diff --git a/content/docs/af-ZA/contributing/pr-guidelines.mdx b/content/docs/af-ZA/contributing/pr-guidelines.mdx
index 7a251032..c226da04 100644
--- a/content/docs/af-ZA/contributing/pr-guidelines.mdx
+++ b/content/docs/af-ZA/contributing/pr-guidelines.mdx
@@ -19,6 +19,8 @@ To ensure a smooth and efficient review process, both contributors and reviewers
 4. **Code Quality**
    - Ensure your code follows the project's coding standards and best practices.
    - Include comments where necessary to explain complex logic.
+   - Always test your changes locally before submitting the PR to catch any issues early.
+   - Format your code using `bun format` to maintain consistency across the codebase.
 5. **Testing**
    - Test your changes thoroughly before submitting the PR.
    - If applicable, include unit tests or integration tests to verify your changes.
diff --git a/content/docs/af-ZA/contributing/translate.mdx b/content/docs/af-ZA/contributing/translate.mdx
new file mode 100644
index 00000000..c62ffdde
--- /dev/null
+++ b/content/docs/af-ZA/contributing/translate.mdx
@@ -0,0 +1,74 @@
+---
+title: Translate
+description: How to translate HytaleModding to your language
+---
+
+# Translating HytaleModding
+
+HytaleModding is translated with the help of the community using **Crowdin**. If you want to help translate or improve existing translations, this is the right place.
+
+## Steps to Translate
+
+All translations are managed **via Crowdin**.
+
+1. Visit [our Crowdin project](https://crowdin.com/project/hytalemodding) and log in if required.
+2. Click on your language.
+3. Click on the file/article you wish to translate. We recommend starting with Official Documentation, and then Server Plugin Documentation.
+4. Start translating!
+5. Approved translations will appear on the website.
+
+### Video Guide
+
+<iframe src="https://www.youtube.com/embed/NHiG1rDRgks" allowFullScreen />
+
+## How to discuss
+
+You can always report issues or discuss specific topics directly on Crowdin, but we recommend using Discord instead of the Crowdin comment system to keep everything organized in one place.
+
+1. Join [our Discord](https://discord.gg/hytalemodding)
+2. Open `#translations` channel. Here you can discuss or ask questions that are not related to a specific language.
+3. If you want to join a thread, you are required to run `/translator <your-language>` command here. The bot will add you to the thread for your language.
+
+## Translation Guidelines
+
+- You need to be confident in what you are translating. You should be able to read the text you just translated and understand the meaning of it very easily.
+- It should use the simplest form of language possible. Use English words if the translation is unknown to the majority in your country.
+- Use your imagination, trust yourself. Feel free to change any context as you wish as long as it can still get the same point across and is understandable.
+- These guidelines are more important than language-specific guidelines, but less important than Hytale terminology and rules.
+
+## What not to translate
+
+We request you all to not translate these specific sections of the website:
+
+### Callout types
+
+Callouts are the boxes that contain important information. We request you to not translate the types as they only work in English.
+
+**Example:**
+
+```mdx
+<Callout type="warning" title="Translate this title!">
+Translate the text inside the callout!
+</Callout>
+```
+
+In this example, please don't translate the word warning, the rest you can translate.
+
+### Icons
+
+Icon names must not be translated.
+They are technical identifiers mapped directly to existing icons. Translating them will break the icon rendering.
+
+```mdx
+icon: Globe
+```
+
+---
+
+{/* 
+For translators who will edit this page:
+
+- You are required to translate the Guidelines as they change.
+- General guidelines should be translated but not edited.
+- Learn how to use Markdown from writing_guides.mdx
+*/}
diff --git a/content/docs/af-ZA/established-information/server/content-categories/art-assets.mdx b/content/docs/af-ZA/established-information/server/content-categories/art-assets.mdx
index 39c2ed37..1e926874 100644
--- a/content/docs/af-ZA/established-information/server/content-categories/art-assets.mdx
+++ b/content/docs/af-ZA/established-information/server/content-categories/art-assets.mdx
@@ -14,7 +14,7 @@ Hytale provides comprehensive support for 3D modeling and texture art creation,
 Hytale uses **Blockbench** as the primary tool for 3D modeling and animation:
 
 * **Official support**: Used for "creating Hytale models, textures, and animations"
-* **Special plugin**: Hytale will have a dedicated Blockbench plugin, to be released ASAP
+* **Special plugin**: Hytale has a dedicated [Blockbench Plugin](https://www.blockbench.net/plugins/hytale_plugin).
 * **Direct compatibility**: The plugin allows creators to "create Hytale-compatible models, textures, and animations directly in Blockbench"
 * **Replaces legacy tools**: Fully replaces the old Hytale Model Maker to better support established creative workflows in the community
 * **Safety features**: Only allows you to add things compatible with the engine, so no need to worry about breaking anything
diff --git a/content/docs/af-ZA/guides/ecs/block-components.mdx b/content/docs/af-ZA/guides/ecs/block-components.mdx
new file mode 100644
index 00000000..ca68b38a
--- /dev/null
+++ b/content/docs/af-ZA/guides/ecs/block-components.mdx
@@ -0,0 +1,247 @@
+---
+title: Block Components
+description: Learn how to use the block components.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+  - name: oskarscot
+    link: https://oskar.scot
+---
+
+# Overview
+
+In this guide, you'll learn how to use block components to create a ticking block.
+
+<Callout>
+  For a more complete reference, you may also want to review FarmingSystems.Ticking, as much of the underlying logic is based on its implementation.
+</Callout>
+
+## Steps
+
+### 1. ExampleBlock - holds block behavior
+
+```java
+public class ExampleBlock implements Component<ChunkStore> {
+
+    public static final BuilderCodec CODEC = BuilderCodec.builder(ExampleBlock.class, ExampleBlock::new).build();
+
+    // Components usually require a copy constructor as well but since we don't actually hold any data in this component this is not neccessary
+    public ExampleBlock() { }
+
+    public static ComponentType getComponentType() {
+        return ExamplePlugin.get().getExampleBlockComponentType();
+    }
+
+    @Nullable
+    public Component<ChunkStore> clone() {
+        return new ExampleBlock();
+    }
+}
+```
+
+ExampleBlock is a custom component that stores the behavior and data for your ticking block. Here, it simply places an Ice Block at x + 1 relative to its current position when it ticks.
+
+---
+
+### 2. ExampleInitializer - marks blocks as ticking when placed
+
+```java
+public class ExampleInitializer extends RefSystem {
+
+    @Override
+    public void onEntityAdded(@Nonnull Ref ref, @Nonnull AddReason reason, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+        BlockModule.BlockStateInfo info = (BlockModule.BlockStateInfo) commandBuffer.getComponent(ref, BlockModule.BlockStateInfo.getComponentType());
+        if (info == null) return;
+
+        ExampleBlock generator = (ExampleBlock) commandBuffer.getComponent(ref, ExamplePlugin.get().getExampleBlockComponentType());
+        if (generator != null) {
+            int x = ChunkUtil.xFromBlockInColumn(info.getIndex());
+            int y = ChunkUtil.yFromBlockInColumn(info.getIndex());
+            int z = ChunkUtil.zFromBlockInColumn(info.getIndex());
+
+            WorldChunk worldChunk = (WorldChunk) commandBuffer.getComponent(info.getChunkRef(), WorldChunk.getComponentType());
+            if (worldChunk != null) {
+				worldChunk.setTicking(x, y, z, true);
+            }
+        }
+    }
+
+    @Override
+    public void onEntityRemove(@Nonnull Ref ref, @Nonnull RemoveReason reason, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+    }
+
+    @Override
+    public Query getQuery() {
+        return Query.and(BlockModule.BlockStateInfo.getComponentType(), ExamplePlugin.get().getExampleBlockComponentType());
+    }
+}
+```
+
+ExampleInitializer is a RefSystem that reacts when block entities with the ExampleBlock component are added or removed. This is crucial for marking blocks as ticking when they're first placed.
+
+**Key Points:**
+
+- Tells the game that this block should tick, allowing `ExampleSystem` to process it.
+
+```java
+worldChunk.setTicking(x, y, z, true);
+```
+
+---
+
+### 3. ExampleSystem - handles ticking
+
+```java
+public class ExampleSystem extends EntityTickingSystem {
+
+    public void tick(float dt, int index, @Nonnull ArchetypeChunk archetypeChunk, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+        BlockSection blocks = (BlockSection) archetypeChunk.getComponent(index, BlockSection.getComponentType());
+
+        assert blocks != null;
+
+        if (blocks.getTickingBlocksCountCopy() != 0) {
+            ChunkSection section = (ChunkSection) archetypeChunk.getComponent(index, ChunkSection.getComponentType());
+
+            assert section != null;
+
+            BlockComponentChunk blockComponentChunk = (BlockComponentChunk) commandBuffer.getComponent(section.getChunkColumnReference(), BlockComponentChunk.getComponentType());
+
+            assert blockComponentChunk != null;
+
+            blocks.forEachTicking(blockComponentChunk, commandBuffer, section.getY(), (blockComponentChunk1, commandBuffer1, localX, localY, localZ, blockId) -> {
+                Ref<ChunkStore> blockRef = blockComponentChunk.getEntityReference(ChunkUtil.indexBlockInColumn(localX, localY, localZ));
+                if (blockRef == null) {
+                    return BlockTickStrategy.IGNORED;
+                } else {
+                    ExampleBlock exampleBlock = (ExampleBlock) commandBuffer1.getComponent(blockRef, ExampleBlock.getComponentType());
+                    if (exampleBlock != null) {
+                        WorldChunk worldChunk = (WorldChunk) commandBuffer.getComponent(section.getChunkColumnReference(), WorldChunk.getComponentType());
+                        World world = worldChunk.getWorld();
+
+                        int globalX = localX + (worldChunk.getX() * 32);
+                        int globalZ = localZ + (worldChunk.getZ() * 32);
+
+                        // We need to execute setBlock on the world thread as you cannot call store functions from a system
+                        // This is because of the architecture of the server, depending on your needs you can also use the CommandBuffer
+                        world.execute(() -> {
+                            world.setBlock(globalX + 1, localY, globalZ, "Rock_Ice");
+                        });
+
+                        return BlockTickStrategy.CONTINUE;
+
+                    } else {
+                        return BlockTickStrategy.IGNORED;
+                    }
+                }
+            });
+        }
+    }
+
+    @Nullable
+    public Query getQuery() {
+        return Query.and(BlockSection.getComponentType(), ChunkSection.getComponentType());;
+    }
+}
+```
+
+ExampleSystem is an EntityTickingSystem that runs every tick to execute the logic for all ticking blocks with the ExampleBlock component.
+
+**Key Points:**
+
+- **Get the block component**
+
+```java
+ExampleBlock exampleBlock = (ExampleBlock) commandBuffer.getComponent(blockRef, ExampleBlock.getComponentType());
+```
+
+- **Convert local chunk coordinates to world coordinates**
+
+```java
+int globalX = localX + (worldChunk.getX() * 32);
+int globalZ = localZ + (worldChunk.getZ() * 32);
+```
+
+- **Run the block logic**
+
+```java
+exampleBlock.runBlockAction(globalX, localY, globalZ, worldChunk.getWorld());
+```
+
+- **Keep the block ticking in the next tick**
+
+```java
+return BlockTickStrategy.CONTINUE;
+```
+
+---
+
+### 4. ExamplePlugin - registers components and systems
+
+```java
+public class ExamplePlugin extends JavaPlugin {
+    protected static ExamplePlugin instance;
+    private static final HytaleLogger LOGGER = HytaleLogger.forEnclosingClass();
+    private ComponentType exampleBlockComponentType;
+
+    public static ExamplePlugin get() {
+        return instance;
+    }
+
+    public ExamplePlugin(@Nonnull JavaPluginInit init) {
+        super(init);
+        LOGGER.atInfo().log("Hello from " + this.getName() + " version " + this.getManifest().getVersion().toString());
+    }
+
+    @Override
+    protected void setup() {
+        instance = this;
+        LOGGER.atInfo().log("Setting up plugin " + this.getName());
+        this.exampleBlockComponentType = this.getChunkStoreRegistry().registerComponent(ExampleBlock.class, "ExampleBlock", ExampleBlock.CODEC);
+    }
+	
+	@Override
+	protected void start() {
+		this.getChunkStoreRegistry().registerSystem(new ExampleSystem());
+		this.getChunkStoreRegistry().registerSystem(new ExampleInitializer());
+	}
+
+    public ComponentType getExampleBlockComponentType() {
+        return this.exampleBlockComponentType;
+    }
+}
+```
+
+---
+
+### 5. Configure In-Game
+
+![block-component-1](/assets/guides/block-component-1.png)
+
+![block-component-2](/assets/guides/block-component-2.png)
+
+With this logic, the block will now continuously place an Ice Block at the coordinates x + 1 relative to its current position every time it ticks.
+
+---
+
+## Common Issues
+
+### NullPointerException on Startup
+
+**Error message:**
+
+```java
+java.lang.NullPointerException: Cannot invoke "com.hypixel.hytale.component.query.Query.validateRegistry(com.hypixel.hytale.component.ComponentRegistry)" because "query" is null
+```
+
+**Cause:**
+This error occurs when your module is loaded **before** the required Hytale modules.
+
+**Fix:**
+Add `EntityModule` and `BlockModule` as dependencies in your `manifest.json` to ensure proper load order.
+
+```json
+"Dependencies": {
+  "Hytale:EntityModule": "*",
+  "Hytale:BlockModule": "*"
+}
+```
diff --git a/content/docs/af-ZA/guides/ecs/hytale-ecs-theory.mdx b/content/docs/af-ZA/guides/ecs/hytale-ecs-theory.mdx
index 20c3a94d..52d8b1f5 100644
--- a/content/docs/af-ZA/guides/ecs/hytale-ecs-theory.mdx
+++ b/content/docs/af-ZA/guides/ecs/hytale-ecs-theory.mdx
@@ -29,7 +29,7 @@ for now this is the basic understanding for the `ChunkStore`. You can use it to
 
 ## Holder
 
-A Holder is essentially a blueprint for an entity. Before an entity exists in the Store (and thus in the world), is exists as a `Holder`. It collects and holds all the necessary components (data). You can compare it analogous to shopping cart. You grab all components you need and once you have everything, check out at the store which will take your cart and create a valid entity ID and hand you back a receipt (a Ref).
+A Holder is essentially a blueprint for an entity. Before an entity exists in the Store (and thus in the world), it exists as a `Holder`. It collects and holds all the necessary components (data). You can compare it analogous to shopping cart. You grab all components you need and once you have everything, check out at the store which will take your cart and create a valid entity ID and hand you back a receipt (a Ref).
 
 Let's take a look at an example: initializing players. In `Universe`, the `addPlayer` method demonstrates it perfectly.
 When a player connects, we don't immediately throw them into the ECS. We first construct their data in a Holder.
@@ -167,7 +167,7 @@ MyComponent comp = commandBuffer.getComponent(ref, componentType);
 
 Codecs handle serialization and deserialization of components. Hytale uses them to save and load entity data to and from disk as well as sending component data over the network. When creating a custom component, you must also create a corresponding Codec.
 
-There are mutliple Codec types already implemented in the default Codec Interface:
+There are multiple Codec types already implemented in the default Codec Interface:
 
 - Codec.STRING
 - Codec.BOOLEAN
@@ -215,7 +215,7 @@ This might seem tedious at first but it ensures that your component can be corre
   KeyedCodec<Integer> exampleInt = new KeyedCodec<Integer>("ExampleIntIdForCodec", Codec.INTEGER);
   ```
 
-- **Setter Function**: This is a lambda function that takes an instance of your component and returns the value of the field you want to serialize. For example, if you have a field called `myCustomField` in your custom component, your getter function would look like this:
+- **Setter Function**: This is a lambda function that takes an instance of your component + the value to set and sets the field value on the component. For example, if you have a field called `myCustomField` in your custom component, your setter function would look like this:
   ```java
   (data, value) -> data.myCustomField = value
   ```
@@ -276,7 +276,7 @@ public class PoisonComponent implements Component<EntityStore> {
 
 You can also add validators to your Codec fields to ensure that the data being serialized/deserialized meets certain criteria. For example, if you want to ensure that the `damagePerTick` field is always non-negative or the poison name is never null, you can add a validator like this:
 
-````java
+```java
 .append(
     new KeyedCodec<Float>("DamagePerTick", Codec.FLOAT),
     (data, value) -> data.damagePerTick = value,
@@ -292,14 +292,15 @@ You can also add validators to your Codec fields to ensure that the data being s
 )
 .addValidator(Validators.nonNull())
 .add()
+```
 
 ### Complex Codec Examples
 
-If you want to have a map inside your component, you can use the MapCodec class to build a KeyedCoded for it. Here's an example of how to create a Codec for a Map field:
+If you want to have a map inside your component, you can use the MapCodec class to build a KeyedCodec for it. Here's an example of how to create a Codec for a Map field:
 
 ```java
 var damagePerTick = new KeyedCodec<>("DamagePerTick", new MapCodec<>(Codec.FLOAT, HashMap<String, Float>::new));
-````
+```
 
 <Callout type="info">
   This also works with custom Objects as long as you have a Codec defined for the Object type.
diff --git a/content/docs/af-ZA/guides/java-basics/00-introduction.mdx b/content/docs/af-ZA/guides/java-basics/00-introduction.mdx
index a03ad638..b0130d74 100644
--- a/content/docs/af-ZA/guides/java-basics/00-introduction.mdx
+++ b/content/docs/af-ZA/guides/java-basics/00-introduction.mdx
@@ -7,7 +7,7 @@ Welcome to your journey into Java Programming! This guide is designed to introdu
 
 ## What is Java?
 
-Java is a powerful, object-oriented programming language created in 1995. It's one of the most popular programming languages in the world and is used for everything from mobile apps to enterprise software. Most importantly for us, it's the language Hytale uses for it's servers & modding API.
+Java is a powerful, object-oriented programming language created in 1995. It's one of the most popular programming languages in the world and is used for everything from mobile apps to enterprise software. Most importantly for us, it's the language Hytale uses for its servers & modding API.
 
 ## What You'll Learn
 
diff --git a/content/docs/af-ZA/guides/java-basics/02-operators.mdx b/content/docs/af-ZA/guides/java-basics/02-operators.mdx
index a132b1c0..18634665 100644
--- a/content/docs/af-ZA/guides/java-basics/02-operators.mdx
+++ b/content/docs/af-ZA/guides/java-basics/02-operators.mdx
@@ -119,7 +119,7 @@ String greetingWithName = "Hello, " + name + "!"; // "Hello, Alice!"
 
 ## Operator Precedence
 
-Operator Precendence means which operator gets evaluated first in an line of code. Think of it like BODMAS/PEMDAS in math!
+Operator Precedence means which operator gets evaluated first in an line of code. Think of it like BODMAS/PEMDAS in math!
 
 ```java
 int result = 10 + 5 * 2; // result is 20, not 30
diff --git a/content/docs/af-ZA/guides/java-basics/03-control-flow-if.mdx b/content/docs/af-ZA/guides/java-basics/03-control-flow-if.mdx
index b9d6c479..af2d1c22 100644
--- a/content/docs/af-ZA/guides/java-basics/03-control-flow-if.mdx
+++ b/content/docs/af-ZA/guides/java-basics/03-control-flow-if.mdx
@@ -7,7 +7,7 @@ Programs need to make decisions. If statements let your code choose different pa
 
 ## Basic If Statement
 
-The simplest form checks one condition;
+The simplest form checks one condition:
 
 ```java
 int health = 20;
diff --git a/content/docs/af-ZA/guides/java-basics/08-access-modifiers.mdx b/content/docs/af-ZA/guides/java-basics/08-access-modifiers.mdx
index af560932..da2bf33b 100644
--- a/content/docs/af-ZA/guides/java-basics/08-access-modifiers.mdx
+++ b/content/docs/af-ZA/guides/java-basics/08-access-modifiers.mdx
@@ -484,7 +484,7 @@ class Data {
     // Static member:
     // cannot access to non-static variables
     public static void bar() {
-        x = 100; // Error: non-static variable x cannot be renference from a static context
+        x = 100; // Error: non-static variable x cannot be referenced from a static context
         y = 100; // OK
     }
 }
@@ -504,7 +504,7 @@ Data.x = 1000; // Error: cannot access instanced variables in a static context
 
 ### Static Fields
 
-A static field represents a data member owned by the class type rather then the object. Static fields are also stored in a specific memory location that's been shared between all the object instances that are created.
+A static field represents a data member owned by the class type rather than the object. Static fields are also stored in a specific memory location that's been shared between all the object instances that are created.
 
 It is declared as following:
 
diff --git a/content/docs/af-ZA/guides/plugin/animated-block-textures.mdx b/content/docs/af-ZA/guides/plugin/animated-block-textures.mdx
new file mode 100644
index 00000000..42bfa51f
--- /dev/null
+++ b/content/docs/af-ZA/guides/plugin/animated-block-textures.mdx
@@ -0,0 +1,101 @@
+---
+title: Animated Block Textures
+description: Learn how to attach a .blockyanim to a block
+authors:
+  - name: Burkino
+---
+
+import { File, Folder, Files } from 'fumadocs-ui/components/files';
+
+So, you want to make your blocks feel more alive through animations, do you?\
+Now for the most part this is the exact same as [Creating custom blocks](./creating-block).
+![blue fire gif](/assets/guides/blue_fire.gif)
+
+## Prerequisites
+
+This is NOT a guide on animating or texturing or even using BlockBench, why? Because I don't know how to do that.\
+The only thing we will be doing is taking the fire texture, changing the color, and applying it to our new fire block.
+
+## Setup
+
+To start, you're obviously going to want to grab the `Common/VFX/Fire/Fire.png` file. How you do it is up to you, in the Asset Editor you'll need to switch to the Common tab.\
+I'll assume you know how colorize or change the hue of an image, so go ahead and do that now and save it as `Blue_Fire.png`.
+
+The other assets used in this guide are `Common/VFX/Fire/Fire.blockymodel` and `Common/Blocks/Animations/Fire/Fire_Burn.blockyanim` (both renamed to `Blue_Fire`) but since we won't be changing them it's probably fine to leave them. I will reference the `Blue_Fire` versions as a way to point out what should be custom assets.\
+I will also duplicate `Server/Item/Item/Deco/Deco_Fire.json` and call it `Deco_Blue_Fire.json`.
+
+## Applying the changes
+
+The `Deco_Blue_Fire` block is actually just a particle emitter, however we will not be using particles, so lets start by removing them in `Block > Particles`.\
+Next we want to set the Block Model (called `CustomModel` in JSON) to `VFX/Blue_Fire/Blue_Fire.blockymodel` and Block Model Textures (`CustomModelTexture` in JSON) to
+
+```json
+[
+    {
+        "Texture": "VFX/Blue_Fire/Blue_Fire.png",
+        "Weight": 1
+    }
+]
+```
+
+Finally, we will apply the .blockyanim to our model, this is done through the Block Model Animation property (`CustomModelAnimation` in JSON) and the value should be `Blocks/Animations/Blue_Fire/Blue_Fire_Burn.blockyanim`.
+
+## Final Code
+
+With that your new blue fire should be done. Here is the minimal JSON for our blue fire.\
+There is an additional `Looping` and `RequiresAlphaBlending` property that I have not gone over, however I hope it is self-explanatory.
+
+```json
+{
+  "BlockType": {
+    "DrawType": "Model",
+    "CustomModel": "VFX/Blue_Fire/Blue_Fire.blockymodel",
+    "CustomModelAnimation": "Blocks/Animations/Blue_Fire/Blue_Fire_Burn.blockyanim",
+    "CustomModelTexture": [
+      {
+        "Texture": "VFX/Blue_Fire/Blue_Fire.png",
+        "Weight": 1
+      }
+    ],
+    "Looping": true,
+    "RequiresAlphaBlending": false
+  },
+  "PlayerAnimationsId": "Block"
+}
+```
+
+<Files>
+  <Folder name="resources" defaultOpen>
+    <Folder name="Server" defaultOpen>
+      <Folder name="Item" defaultOpen>
+        <Folder name="Items" defaultOpen>
+          <Folder name="Deco" defaultOpen>
+            <File name="Deco_Blue_Fire.json" />
+          </Folder>
+        </Folder>
+      </Folder>
+    </Folder>
+
+    <Folder name="Common" defaultOpen>
+      <Folder name="Blocks" defaultOpen>
+        <Folder name="Animations" defaultOpen>
+          <Folder name="Blue_Fire" defaultOpen>
+            <File name="Blue_Fire_Burn.blockyanim" />
+          </Folder>
+        </Folder>
+      </Folder>
+
+      <Folder name="VFX" defaultOpen>
+        <Folder name="Blue_Fire" defaultOpen>
+          <File name="Blue_Fire.blockymodel" />
+
+          <File name="Blue_Fire.png" />
+        </Folder>
+      </Folder>
+    </Folder>
+  </Folder>
+</Files>
+
+## Next steps
+
+Now that you know how to attach an animation to a block, try adding it to a block state.
diff --git a/content/docs/af-ZA/guides/plugin/build-and-test.mdx b/content/docs/af-ZA/guides/plugin/build-and-test.mdx
index 0e7fe7eb..f37534c3 100644
--- a/content/docs/af-ZA/guides/plugin/build-and-test.mdx
+++ b/content/docs/af-ZA/guides/plugin/build-and-test.mdx
@@ -9,18 +9,18 @@ If you followed along with the [Setting Up Your Development Environment](./setti
 
 ## Building Your Mod
 
-In our case, we've **Maven** as the build system. Maven is a powerful build automation tool that manages dependencies, compiles your code, and packages everything into a distributable JAR file.
+In our case, we've **Gradle** as the build system. Gradle is a powerful build automation tool that manages dependencies, compiles your code, and packages everything into a distributable JAR file.
 
-### Understanding Maven
+### Understanding Gradle
 
-Maven uses a `pom.xml` file (Project Object Model) to define your project's configuration, dependencies, and build settings. You can learn more about Maven at the [official Apache Maven website](https://maven.apache.org/).
+Gradle can use a `build.gradle.kts` file (Kotlin DSL) to define your project's configuration, dependencies, and build settings. You can learn more about Gradle at the [official Gradle website](https://gradle.org/).
 
-### Building with Maven
+### Building with Gradle
 
 To build your mod, open a terminal in your project directory and run:
 
 ```bash
-mvn package
+./gradlew build
 ```
 
 This command will:
@@ -29,16 +29,35 @@ This command will:
 2. Run any tests (if present)
 3. Package everything into a JAR file
 
+<Callout type="info">
+  If you are using the plugin template from the [Setting Up Your Development Environment](./setting-up-env) guide, then the build script is already set up for you. It includes paths to your Hytale game library and handles the packaging of your mod, managing hytale dependencies and manifest changes.
+
+  If you have a different path to your Hytale installation, you may receive the following error:
+
+  ```bash
+  FAILURE: Build failed with an exception.
+
+  * What went wrong:
+  Failed to find Hytale at the expected location. Please make sure you have installed the game. The expected location can be changed using the hytale.home_path property. Currently looking in 'C:\Path\To\Hytale'
+  ```
+
+  You can change the path by adding a property to your `gradle.properties` file (if it doesn't exist, create it in the root of your project):
+
+  ```properties
+  hytale.home_path=C:\Correct\Path\To\Hytale
+  ```
+</Callout>
+
 ### Build Output
 
-Once the build completes successfully, your mod will be located in the `target` directory and named:
+Once the build completes successfully, your mod will be located in the `build/libs` directory and named:
 
 ```
-ExamplePlugin-1.0-SNAPSHOT.jar
+ExamplePlugin-1.0.jar
 ```
 
 <Callout type="info">
-  The exact name may vary depending on what you configured in your `pom.xml` file. Check the `artifactId` and `version` fields to see what your JAR will be named.
+  The exact name may vary depending on what you configured in your `build.gradle.kts` and `settings.gradle.kts` file. Check the `rootProject.name` and `version` fields to see what your JAR will be named.
 </Callout>
 
 ## Testing Your Mod
@@ -49,11 +68,11 @@ Now that you've built your mod, it's time to test it in Hytale!
 
 First, you need to find Hytale's mods directory:
 
-1. Press **Win + R** on your keyboard
-2. Type `%appdata%` and press Enter
-3. Navigate to: `Hytale\UserData\Mods`
+1. Go to your Hytale installation directory (The default location is usually in your AppData folder)
+   > On Windows, you can access it by clicking `windows + R` and typing `%appdata%`.
+2. Navigate to: `/UserData/Mods`
 
-The full path should look like:
+The default path would look like:
 
 ```
 C:\Users\YourUsername\AppData\Roaming\Hytale\UserData\Mods
@@ -65,7 +84,7 @@ C:\Users\YourUsername\AppData\Roaming\Hytale\UserData\Mods
 
 ### 2. Copy Your Mod
 
-Copy the `ExamplePlugin-1.0-SNAPSHOT.jar` file from your project's `target` directory into the `Mods` folder you just located.
+Copy the `ExamplePlugin-1.0.jar` file from your project's `build/libs` directory into the `Mods` folder you just located.
 
 ### 3. Launch Hytale and Verify
 
@@ -84,7 +103,7 @@ If your mod doesn't appear in the mods list:
 - Make sure the JAR file is in the correct `Mods` folder
 - Check that your `manifest.json` file is properly configured
 - Look for any error messages in the Hytale logs
-- Verify that you're using the correct version of Java and Maven
+- Verify that you're using the correct version of Java and Gradle
 
 ## Next Steps
 
diff --git a/content/docs/af-ZA/guides/plugin/creating-commands.mdx b/content/docs/af-ZA/guides/plugin/creating-commands.mdx
index d33597f3..08572f16 100644
--- a/content/docs/af-ZA/guides/plugin/creating-commands.mdx
+++ b/content/docs/af-ZA/guides/plugin/creating-commands.mdx
@@ -8,6 +8,8 @@ authors:
     url: https://oskar.scot
   - name: jacobwojoski
     url: https://github.com/jacobwojoski
+  - name: Marcel-TO
+    url: https://marcel-to.net
 ---
 
 In this guide, you will learn how to create custom commands for your Hytale mod.
@@ -36,7 +38,7 @@ The most basic command is an `AbstractAsyncCommand`. It has very minimal data av
   `AbstractAsyncCommand` runs on its own background thread. This means its execute is not tied to any world instance and because of this it can not edit any **Stores** or **Refs** without getting the desired world first. To access this data any of the other command types would be preferred and are likely what you will want to use instead.
 </Callout>
 
-The main purpose for a command like this would be for something that can happen everywhere and is not tied to a specific world. For example a `serverRules` command to tell the user thats running the command in chat what the servers rules are nomatter what world they are in.
+The main purpose for a command like this would be for something that can happen everywhere and is not tied to a specific world. For example a `serverRules` command to tell the user that's running the command in chat what the server's rules are no matter what world they are in.
 
 ```java
 // Command that can be run that lists the server rules in chat to the player
@@ -49,7 +51,7 @@ public class ServerRulesCommand extends AbstractAsyncCommand {
     }
 
     // Run the command
-    // conetext - info about who ran the command. Server console?, Some player?
+    // context - info about who ran the command. Server console?, Some player?
     @Override
     protected CompletableFuture<Void> executeAsync(@Nonnull CommandContext context) {
         context.sendMessage(Message.raw("The only rule is there are no rules."));
@@ -134,7 +136,7 @@ Uses a Ray to see what the player is looking at and tries to run the command on
 
 ## Adding Arguments
 
-Arguments are additional fields that the user can input when running a command. The different types of arguments along with small snipits and a large example can be seen below.
+Arguments are additional fields that the user can input when running a command. The different types of arguments along with small snippets and a large example can be seen below.
 
 ### Command Argument Types
 
@@ -163,14 +165,14 @@ this.messageArg = this.withOptionalArg("message", "Message to print while healin
 
 ### Default Arguments
 
-Adding a default argument has two additional arguemnt for the default value and default value description. You need to use `withDefaultArg` method.
+Adding a default argument has two additional argument for the default value and default value description. You need to use `withDefaultArg` method.
 
 ```java
 // args <Command String> <Description> <Default Value> <Desc of default value>
 this.healthArg = this.withDefaultArg("health", "Amount to heal player", ArgTypes.FLOAT, (float)100, "Desc of Default: 100");
 ```
 
-### Flag Arguemnts
+### Flag Arguments
 
 Similar as above but the flags return is either true if it exists or false if it does not. You need to use `withFlagArg` method.
 
@@ -181,20 +183,13 @@ this.debugArg = this.withFlagArg("debug", "Add debug logs");
 
 ### ArgTypes
 
-The following ArgTypes are available (only lists common types):
-
-- `ArgTypes.STRING`
-- `ArgTypes.INTEGER`
-- `ArgTypes.BOOLEAN`
-- `ArgTypes.FLOAT`
-- `ArgTypes.DOUBLE`
-- `ArgTypes.UUID`
+You can find all the available argument types on the [ArgTypes](../../argtypes) page.
 
 ### Example Command Arg Types
 
-Shows all Command arguemnt types with different various input types.
+Shows all Command argument types with different various input types.
 
-**NOTE:** When getting the value of an argument during execute you need to pass the context with `someArg.get(commandContext)`. Where `commandContext` is the first variable in the execute funtion.
+**NOTE:** When getting the value of an argument during execute you need to pass the context with `someArg.get(commandContext)`. Where `commandContext` is the first variable in the execute function.
 
 ```java
 // Example usage: /healplayer --health 50 --message "Feels Good" --debug
@@ -204,7 +199,7 @@ public class HealPlayerCommand extends AbstractTargetPlayerCommand {
     private final FlagArg debugArg;
 
     public HealPlayerCommand() {
-        super("healplayer", "Healing a player for an <input> ammount of HP (default: 100)");
+        super("healplayer", "Healing a player for an <input> amount of HP (default: 100)");
 
         // Abstract TargetPlayerCommand passes the player that ran the command by default and implements
         // the use of `--player <value>` to specify someone else
@@ -213,10 +208,10 @@ public class HealPlayerCommand extends AbstractTargetPlayerCommand {
         this.healthArg = this.withDefaultArg("health", "Amount to heal player", ArgTypes.FLOAT, (float)100, "Desc of Default: 100");
 
         // Or you could do the following making the health value required instead of with a default.
-        //    You would need to change the decleration to RequiredArg<Float>
+        //    You would need to change the declaration to RequiredArg<Float>
         // this.healthArg = this.withRequiredArg("health", "Amount to heal player", ArgTypes.FLOAT);
 
-        // Optional args reguare the user the input `--<key> <value>` so the following would require `--message "Good Luck"`
+// Optional args require the user the input `--<key> <value>` so the following would require `--message "Good Luck"`
         this.messageArg = this.withOptionalArg("message", "Message to print while healing", ArgTypes.STRING);
 
         // No type needed due to being a bool
@@ -230,7 +225,7 @@ public class HealPlayerCommand extends AbstractTargetPlayerCommand {
             commandContext.sendMessage(Message.raw("We are debugging"));
         }
 
-        // Health is stored in a generic stat map to allowing mods/future contect to easily add more stats if desired.
+        // Health is stored in a generic stat map to allowing mods/future content to easily add more stats if desired.
         EntityStatMap stats = store.getComponent(ref, EntityStatMap.getComponentType());
         int healthIdx = DefaultEntityStatTypes.getHealth();
         EntityStatValue health = stats.get(healthIdx);
@@ -252,7 +247,7 @@ public class HealPlayerCommand extends AbstractTargetPlayerCommand {
 
 ## Argument Validators
 
-Argument validators are a way to check the command before the command gets executed. They are added with the `addValidator` method on an argument when calling `withXxxArg`. They provide a nice output to the user when an input value is invalid.
+Argument validators are a way to check the command before the command gets executed. They are added with the `addValidator` method on an argument when calling `withXxxArg`. They provide a nice output to the user when an input value is invalid. There are some common validators provided in the `Validators` class such as `greaterThan`, `lessThan`, and `or`, `max`, `range`, etc.
 
 ```java
 ...
@@ -260,18 +255,59 @@ Argument validators are a way to check the command before the command gets execu
     OptionalArg<Integer> healAmount = withOptionalArg("amount", "Heal Amount", ArgTypes.INTEGER)
         .addValidator(Validators.greaterThan(0))
         .addValidator(Validators.lessThan(1000));
-
-    // Custom check example
-    OptionalArg<Integer> healAmount = withOptionalArg("amount", "Heal Amount", ArgTypes.INTEGER)
-            .addValidator( value -> {
-                if (value != null && value <= 0) {
-                    return ValidationResult.error("ammount argument must be a positive number");
-                }
-                return ValidationResult.success();
-            });
 ...
 ```
 
+### Custom Validators
+
+You can also create custom validators by implementing the `com.hypixel.hytale.codec.validation.Validator` interface. The interfaces forces you to implement the `accept` and `updateSchema` method. The `accept` method takes in the argument value and validates it. If the validation fails, you can use the `fail` method of the `com.hypixel.hytale.codec.validation.ValidationResults` class to return an error message.
+The `updateSchema` method is used to update the schema of the command argument. This is used for commands that have dynamic schemas based on the input value. For example, if you have a command that takes in a player name as an argument, you can use the `updateSchema` method to update the schema to include a list of online players for validation.
+
+Here is an example of a custom validator that checks if a string value is equal to a banned word. In this example, the banned word is "badword". If the input value is "badword", the validator will fail and return an error message.
+
+```java
+import com.hypixel.hytale.codec.schema.SchemaContext;
+import com.hypixel.hytale.codec.schema.config.Schema;
+import com.hypixel.hytale.codec.validation.ValidationResults;
+import com.hypixel.hytale.codec.validation.Validator;
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+
+public class MyCustomValidator implements Validator<String> {
+    @Nonnull
+    private final String value;
+
+    public MyCustomValidator(@Nonnull String value) {
+        this.value = value;
+    }
+
+    @Override
+    public void accept(@Nullable String input, @Nonnull ValidationResults results) {
+        if (this.value.equalsIgnoreCase(input)) {
+            results.fail("The given role has been banned.");
+        }
+    }
+
+    @Override
+    public void updateSchema(SchemaContext context, @Nonnull Schema target) {
+        // This method can be used to update the schema of the command argument. This is useful for commands that have dynamic schemas based on the input value. For example, if you have a command that takes in a player name as an argument, you can use the `updateSchema` method to update the schema to include a list of online players for validation.
+        throw new UnsupportedOperationException("Not implemented yet.");
+    }
+}
+```
+
+After the custom validator is created, you can add it to an argument like the following example. In this example, we add the `MyCustomValidator` to a string argument called "role". If the user inputs "badword" as the role, the command will fail and return the error message defined in the `MyCustomValidator`.
+
+```java
+    ...
+    // Custom validator example
+    String bannedRole = "badword";
+
+    OptionalArg<String> roleArg = withOptionalArg("role", "Role to assign", ArgTypes.STRING)
+        .addValidator(new MyCustomValidator(bannedRole));
+    ...
+```
+
 ---
 
 ## Permissions
@@ -312,7 +348,7 @@ This allows the server to control who has access to specific commands. You add t
 
 If you want variants of the same command without doing argument parsing you can instead use `addUsageVariant(new OtherCommandClass())` in the original commands constructor.
 
-The only difference is in the `OtherCommandClass()` constrcutor you don't pass the command name to the super class.
+The only difference is in the `OtherCommandClass()` constructor you don't pass the command name to the super class.
 
 <Callout type="info">
   You can also use `addAliases("some_alias", "some_other_alias")` as a way to add shorthand or other ways to write the same command.
@@ -387,7 +423,7 @@ public class AdminCommand extends AbstractCommandCollection {
     public AdminCommand () {
         super("admin", "Admin commands");
         addSubCommand(new UserCommandCollection());
-        addSybCommand(new ServerCommandCollection);
+        addSubCommand(new ServerCommandCollection);
     }
 }
 ```
@@ -417,5 +453,5 @@ public class MyPlugin extends JavaPlugin {
 
 ## Video Link
 
-_Special Thanks to [TroubleDev](https://www.youtube.com/@TroubleDEV) for his excelent video guide on all of these features._
+_Special Thanks to [TroubleDev](https://www.youtube.com/@TroubleDEV) for his excellent video guide on all of these features._
 _Video Link: [TroubleDev - Hytale's Command API Explained](https://www.youtube.com/watch?v=KnmhG9MDMgo)_
diff --git a/content/docs/af-ZA/guides/plugin/creating-events.mdx b/content/docs/af-ZA/guides/plugin/creating-events.mdx
index 95863990..d3f0925d 100644
--- a/content/docs/af-ZA/guides/plugin/creating-events.mdx
+++ b/content/docs/af-ZA/guides/plugin/creating-events.mdx
@@ -1,6 +1,6 @@
 ---
-title: Creating Events
-description: Learn how to create custom events for your Hytale mod.
+title: Creating Events Listeners
+description: Learn how to create event listeners for your Hytale mod.
 authors:
   - name: Neil Revin
     url: https://itsneil.dev
@@ -10,7 +10,7 @@ authors:
 
 ## Event Class
 
-You can import a Event class and create a function with the Event as a argument. [Click here](../../server/events) to look at all available events.
+You can import an Event class and create a function with the Event as an argument. [Click here](../../server/events) to look at all available events.
 
 Example plugin when a player is ready (joins a server):
 
diff --git a/content/docs/af-ZA/guides/plugin/item-registry.mdx b/content/docs/af-ZA/guides/plugin/item-registry.mdx
new file mode 100644
index 00000000..9a0fd53a
--- /dev/null
+++ b/content/docs/af-ZA/guides/plugin/item-registry.mdx
@@ -0,0 +1,95 @@
+---
+title: Working with the Item Registry
+description: Learn how to access and query the game's item registry to list all items, check if items exist, and retrieve item properties.
+authors:
+  - name: Denis
+---
+
+In this guide, you'll learn how to work with Hytale's Item Registry system. This is useful when you need to programmatically list all available items, validate item IDs, or retrieve item properties at runtime.
+
+## Prerequisites
+
+Before diving in, you should be familiar with:
+
+- [Setting up your development environment](./setting-up-env)
+- [Creating commands](./creating-commands) (optional, for testing)
+
+## Required Imports
+
+To work with the Item Registry, you'll need the following imports:
+
+```java
+import com.hypixel.hytale.assetstore.map.DefaultAssetMap;
+import com.hypixel.hytale.server.core.asset.type.item.config.Item;
+```
+
+## Getting the Item Registry
+
+The Item Registry is accessed through the `Item.getAssetMap()` method, which returns a `DefaultAssetMap<String, Item>` containing all registered items in the game:
+
+```java
+DefaultAssetMap<String, Item> itemMap = Item.getAssetMap();
+```
+
+## Listing All Items
+
+To iterate through all items in the registry, you can get the underlying map and loop through its entries:
+
+```java
+DefaultAssetMap<String, Item> itemMap = Item.getAssetMap();
+var map = itemMap.getAssetMap();
+
+for (var entry : map.entrySet()) {
+    String itemId = String.valueOf(entry.getKey());
+    Item item = entry.getValue();
+    
+    // Do something with the item
+    LOGGER.atInfo().log("Item ID: " + itemId);
+}
+```
+
+You can also get the total count of registered items:
+
+```java
+int totalItems = map.size();
+```
+
+## Checking if an Item Exists
+
+To check if a specific item exists in the registry, use `getAsset()` and verify the result:
+
+```java
+public boolean itemExists(String itemId) {
+    var assetMap = Item.getAssetMap();
+    if (assetMap != null) {
+        Item item = assetMap.getAsset(itemId);
+        return item != null && item != Item.UNKNOWN;
+    }
+    return false;
+}
+```
+
+<Callout type="info">
+  The `Item.UNKNOWN` constant represents an invalid or unrecognized item. Always check for both `null` and `Item.UNKNOWN` when validating items.
+</Callout>
+
+## Accessing Item Properties
+
+Once you have an `Item` instance, you can access various properties:
+
+```java
+var assetMap = Item.getAssetMap();
+Item item = assetMap.getAsset("Soil_Grass");
+
+if (item != null && item != Item.UNKNOWN) {
+    String id = item.getId(); // Soil_Grass
+    int maxStack = item.getMaxStack(); // 100
+    boolean isBlock = item.hasBlockType(); // true
+    boolean isConsumable = item.isConsumable(); // false
+}
+```
+
+## Related Guides
+
+- [Inventory Management](./inventory-management) - Learn how to add and remove items from player inventories
+- [Create Custom Item and Interaction](./item-interaction) - Learn how to create your own custom items
diff --git a/content/docs/af-ZA/guides/plugin/permission-management.mdx b/content/docs/af-ZA/guides/plugin/permission-management.mdx
index 6b7cfd46..55f06101 100644
--- a/content/docs/af-ZA/guides/plugin/permission-management.mdx
+++ b/content/docs/af-ZA/guides/plugin/permission-management.mdx
@@ -10,132 +10,569 @@ authors:
     link: https://discord.com/users/292656109939064833
   - name: Ivan
     link: https://discord.com/users/505770451218333717
+  - name: ZenithDevHQ
+    link: https://github.com/ZenithDevHQ
 ---
 
-In this guide, you'll learn how to manage permission nodes and groups in your Hytale plugin.
+In this guide, you'll learn how to manage permission nodes and groups in your Hytale plugin. Permissions control what actions players can perform on your server, from basic commands to advanced administrative functions.
 
-## The `PermissionsModule` class
+## What Are Permissions?
 
-The `PermissionsModule` class is responsible for managing permission nodes and groups in your plugin. It provides methods to check, grant and revoke permissions and groups for players. It allows the following operations
+Permissions are string identifiers that control access to features and commands. When a player tries to perform an action (like using a command), the server checks if they have the required permission.
 
-- Add permissions to user
-- Remove permissions from user
-- Add permissions to group (this also creates the group if it doesn't exist)
-- Remove permissions from group
-- Add user to group
-- Remove user from group
-- List all groups for a user
-- Check if a user has a permission (it checks both user and group permissions for the given player UUID)
+**Example permission nodes:**
 
-With this class you cannot:
+- `hytale.command.gamemode` - Permission to use the gamemode command
+- `hytale.editor.brush.use` - Permission to use brush tools
+- `myplugin.teleport.home` - A custom permission for your plugin
 
-- List all defined groups
-- Remove a group
+Permissions follow a hierarchical naming pattern: `namespace.category.action`
 
-### Adding Permission Nodes
+## Key Concepts
 
-You need a `Set<String>` containing all the permission nodes you want to add, these are added on top of the already existing permission nodes the user may have, it is not a replacement.
+Before diving into code, let's understand the core concepts:
+
+| Concept             | Description                                                                |
+| ------------------- | -------------------------------------------------------------------------- |
+| **Permission Node** | A string like `myplugin.feature.use` that represents a specific permission |
+| **Group**           | A named collection of permissions (e.g., "Admin", "VIP", "Default")        |
+| **Provider**        | The backend that stores and retrieves permissions                          |
+| **Wildcard**        | A pattern like `*` or `myplugin.*` that matches multiple permissions       |
+
+### How Permissions Are Checked
+
+When checking if a player has a permission, Hytale follows this order:
+
+1. **User's direct permissions** - Permissions granted directly to the player
+2. **Group permissions** - Permissions from groups the player belongs to
+3. **Virtual groups** - Game-mode-based permissions (e.g., Creative mode grants builder tools)
+4. **Default value** - Falls back to `false` if no match found
+
+<Callout type="info">
+  The first definitive match wins. If a player has a permission granted at the user level, group permissions won't override it.
+</Callout>
+
+---
+
+## The `PermissionsModule` Class
+
+The `PermissionsModule` class is the central hub for managing permissions. Access it using the singleton pattern:
 
 ```java
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.addUserPermission(playerUUID, permissions);
 ```
 
-### Removing Permission Nodes
+### Available Operations
+
+The module supports these operations:
+
+| Operation                     | Method                                          |
+| ----------------------------- | ----------------------------------------------- |
+| Add permissions to user       | `addUserPermission(uuid, permissions)`          |
+| Remove permissions from user  | `removeUserPermission(uuid, permissions)`       |
+| Add permissions to group      | `addGroupPermission(groupName, permissions)`    |
+| Remove permissions from group | `removeGroupPermission(groupName, permissions)` |
+| Add user to group             | `addUserToGroup(uuid, groupName)`               |
+| Remove user from group        | `removeUserFromGroup(uuid, groupName)`          |
+| Get user's groups             | `getGroupsForUser(uuid)`                        |
+| Check permission              | `hasPermission(uuid, permissionNode)`           |
+
+<Callout type="warning">
+  The module does **not** support:
+
+  - Listing all defined groups
+  - Deleting a group entirely
+
+  Groups are implicitly created when you first add permissions to them.
+</Callout>
+
+---
 
-Same as above, we just use the `removeUserPermission` method instead to remove permission nodes.
+## Checking Permissions
+
+The most common operation is checking if a player has a permission.
+
+### Basic Permission Check
+
+```java
+// Returns true if player has the permission, false otherwise
+boolean canUse = PermissionsModule.get().hasPermission(playerUUID, "myplugin.feature.use");
+
+if (canUse) {
+    // Player has permission, allow the action
+} else {
+    // Player lacks permission, deny or show error
+}
+```
+
+### Permission Check with Default Value
+
+You can specify what to return when no permission is explicitly set:
+
+```java
+// Returns true by default if no explicit permission is found
+boolean canUse = PermissionsModule.get().hasPermission(playerUUID, "myplugin.feature.use", true);
+```
+
+This is useful for features that should be enabled by default but can be revoked.
+
+### Using PermissionHolder Interface
+
+Players and command senders implement `PermissionHolder`, allowing direct checks:
+
+```java
+// In a command or event handler where you have access to the player
+if (player.hasPermission("myplugin.admin.manage")) {
+    // Player has admin permission
+}
+```
+
+---
+
+## Managing User Permissions
+
+### Adding Permissions to a User
+
+Permissions are additive - new permissions are added on top of existing ones, not replaced.
+
+```java
+PermissionsModule perms = PermissionsModule.get();
+
+// Add a single permission
+perms.addUserPermission(playerUUID, Set.of("myplugin.vip.chat"));
+
+// Add multiple permissions at once
+Set<String> newPerms = Set.of(
+    "myplugin.vip.chat",
+    "myplugin.vip.fly",
+    "myplugin.vip.kit"
+);
+perms.addUserPermission(playerUUID, newPerms);
+```
+
+### Removing Permissions from a User
 
 ```java
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.removeUserPermission(playerUUID, permissions);
+
+// Remove specific permissions
+Set<String> toRemove = Set.of("myplugin.vip.fly");
+perms.removeUserPermission(playerUUID, toRemove);
 ```
 
-### Add permissions to group
+---
+
+## Managing Groups
+
+Groups let you assign a collection of permissions to multiple players. This is more manageable than assigning permissions individually.
+
+### Adding Permissions to a Group
+
+If the group doesn't exist, it will be created automatically.
 
 ```java
-String groupName = "testGroup";
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.addGroupPermission(groupName, permissions);
+
+// Create/update the "VIP" group with permissions
+Set<String> vipPerms = Set.of(
+    "myplugin.vip.chat",
+    "myplugin.vip.fly",
+    "myplugin.vip.kit"
+);
+perms.addGroupPermission("VIP", vipPerms);
 ```
 
-### Remove permissions from group
+### Removing Permissions from a Group
 
 ```java
-String groupName = "testGroup";
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.removeGroupPermission(groupName, permissions);
+
+// Remove specific permissions from the group
+Set<String> toRemove = Set.of("myplugin.vip.fly");
+perms.removeGroupPermission("VIP", toRemove);
 ```
 
-### Add user to group
+### Adding a User to a Group
 
 ```java
-String groupName = "testGroup";
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.addUserToGroup(playerUUID, groupName);
+
+// Add player to the VIP group - they now have all VIP permissions
+perms.addUserToGroup(playerUUID, "VIP");
 ```
 
-### Remove user from group
+### Removing a User from a Group
 
 ```java
-String groupName = "testGroup";
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.removeUserFromGroup(playerUUID, groupName);
+
+// Remove player from VIP group
+perms.removeUserFromGroup(playerUUID, "VIP");
 ```
 
-### List all groups for a user
+### Getting a User's Groups
 
 ```java
 PermissionsModule perms = PermissionsModule.get();
-perms.getGroupsForUser(playerUUID);
+
+// Get all groups the player belongs to
+Set<String> groups = perms.getGroupsForUser(playerUUID);
+
+for (String group : groups) {
+    System.out.println("Player is in group: " + group);
+}
 ```
 
-### Check Permission Nodes
+---
+
+## Built-in Groups
+
+Hytale includes two default groups:
+
+| Group     | Default Permissions   | Purpose                           |
+| --------- | --------------------- | --------------------------------- |
+| `OP`      | `*` (all permissions) | Server operators with full access |
+| `Default` | None                  | Base group for all players        |
+
+Players without any explicit group assignment are automatically part of the `Default` group.
 
-To check if a player has a specific permission node, you can use the `hasPermission` method.
+---
+
+## Wildcards
+
+Wildcards let you grant or deny multiple permissions with a single pattern.
+
+### Wildcard Patterns
+
+| Pattern             | Meaning                                          |
+| ------------------- | ------------------------------------------------ |
+| `*`                 | Grants **all** permissions                       |
+| `myplugin.*`        | Grants all permissions starting with `myplugin.` |
+| `-*`                | Denies **all** permissions                       |
+| `-myplugin.admin.*` | Denies all admin permissions in your plugin      |
+
+### Example: Admin Group with Wildcards
 
 ```java
-boolean hasPermission = PermissionsModule.hasPermission(playerUUID, "permission.node");
+// Grant all permissions to admins
+perms.addGroupPermission("Admin", Set.of("*"));
+
+// Grant all plugin permissions to moderators
+perms.addGroupPermission("Moderator", Set.of("myplugin.*"));
+
+// Grant all permissions except admin commands
+perms.addGroupPermission("Helper", Set.of(
+    "*",
+    "-myplugin.admin.*"  // Deny admin permissions
+));
 ```
 
-## Additional: Defining your own provider for permissions and groups
+<Callout type="warning">
+  Negation permissions (starting with `-`) take precedence at each level. Use them carefully to avoid accidentally blocking permissions.
+</Callout>
+
+---
+
+## Built-in Permission Nodes
+
+Hytale provides constants for common permissions in the `HytalePermissions` class:
+
+### Command Permissions
+
+```java
+// Generate permission for a command
+String perm = HytalePermissions.fromCommand("gamemode");
+// Result: "hytale.command.gamemode"
+
+// Generate permission for a subcommand
+String perm = HytalePermissions.fromCommand("gamemode", "creative");
+// Result: "hytale.command.gamemode.creative"
+```
+
+### Common Permission Nodes
+
+| Permission                    | Description                  |
+| ----------------------------- | ---------------------------- |
+| `hytale.command.op.add`       | Add players to OP group      |
+| `hytale.command.op.remove`    | Remove players from OP group |
+| `hytale.editor.brush.use`     | Use brush tools              |
+| `hytale.editor.prefab.use`    | Use prefabs                  |
+| `hytale.editor.selection.use` | Use selection tools          |
+| `hytale.editor.history`       | Undo/redo operations         |
+| `hytale.camera.flycam`        | Use fly camera mode          |
+
+---
+
+## Listening to Permission Events
+
+You can react to permission changes using Hytale's event system.
+
+### Available Events
+
+| Event                                            | Triggered When                   |
+| ------------------------------------------------ | -------------------------------- |
+| `PlayerPermissionChangeEvent.PermissionsAdded`   | Permissions added to a user      |
+| `PlayerPermissionChangeEvent.PermissionsRemoved` | Permissions removed from a user  |
+| `PlayerGroupEvent.Added`                         | User added to a group            |
+| `PlayerGroupEvent.Removed`                       | User removed from a group        |
+| `GroupPermissionChangeEvent.Added`               | Permissions added to a group     |
+| `GroupPermissionChangeEvent.Removed`             | Permissions removed from a group |
 
-The PermissionsModule also enables us to define our own PermissionProvider's, this can be useful for:
+### Example: Reacting to Permission Changes
 
-- Cross server permission systems
-- Implementing features missing in the `HytalePermissionsProvider` like permission expiry
+```java
+public class PermissionListener {
+
+    public static void onPermissionsAdded(PlayerPermissionChangeEvent.PermissionsAdded event) {
+        UUID playerUUID = event.getPlayerUuid();
+        Set<String> added = event.getAddedPermissions();
+
+        System.out.println("Permissions added to " + playerUUID + ": " + added);
 
-To implement our PermissionProvider, first we need to define a provider class that implements PermissionProvider:
+        // Maybe notify the player or update cached data
+    }
+
+    public static void onGroupAdded(PlayerGroupEvent.Added event) {
+        UUID playerUUID = event.getPlayerUuid();
+        String groupName = event.getGroupName();
+
+        System.out.println("Player " + playerUUID + " joined group: " + groupName);
+    }
+}
+```
+
+### Registering the Events
 
 ```java
-public class DatabasePermissionProvider implements PermissionProvider
+public class MyPlugin extends JavaPlugin {
+
+    @Override
+    public void setup() {
+        EventRegistry events = this.getEventRegistry();
+
+        events.registerGlobal(
+            PlayerPermissionChangeEvent.PermissionsAdded.class,
+            PermissionListener::onPermissionsAdded
+        );
+
+        events.registerGlobal(
+            PlayerGroupEvent.Added.class,
+            PermissionListener::onGroupAdded
+        );
+    }
+}
 ```
 
-Then we just implement the required methods using a database implementation.
+---
+
+## Creating a Custom Permission Provider
+
+For advanced use cases, you can create your own permission provider. This is useful for:
+
+- Database-backed permissions (MySQL, MongoDB, etc.)
+- Cross-server permission synchronization
+- Custom features like permission expiry or contexts
+
+### Implementing PermissionProvider
+
+```java
+public class DatabasePermissionProvider implements PermissionProvider {
+
+    @Nonnull
+    @Override
+    public String getName() {
+        return "DatabasePermissionProvider";
+    }
+
+    // User permission methods
+    @Override
+    public void addUserPermissions(@Nonnull UUID uuid, @Nonnull Set<String> permissions) {
+        // Save to your database
+    }
+
+    @Override
+    public void removeUserPermissions(@Nonnull UUID uuid, @Nonnull Set<String> permissions) {
+        // Remove from your database
+    }
+
+    @Override
+    public Set<String> getUserPermissions(@Nonnull UUID uuid) {
+        // Query your database
+        return Set.of();
+    }
+
+    // Group permission methods
+    @Override
+    public void addGroupPermissions(@Nonnull String group, @Nonnull Set<String> permissions) {
+        // Save to your database
+    }
+
+    @Override
+    public void removeGroupPermissions(@Nonnull String group, @Nonnull Set<String> permissions) {
+        // Remove from your database
+    }
+
+    @Override
+    public Set<String> getGroupPermissions(@Nonnull String group) {
+        // Query your database
+        return Set.of();
+    }
+
+    // User-group membership methods
+    @Override
+    public void addUserToGroup(@Nonnull UUID uuid, @Nonnull String group) {
+        // Save to your database
+    }
+
+    @Override
+    public void removeUserFromGroup(@Nonnull UUID uuid, @Nonnull String group) {
+        // Remove from your database
+    }
+
+    @Override
+    public Set<String> getGroupsForUser(@Nonnull UUID uuid) {
+        // Query your database
+        return Set.of("Default");
+    }
+}
+```
 
 <Callout type="warning">
-  Hytale will try to use the first available permissions provider to add/remove gamemode groups (i.e. `Creative`, `Adventure`).
+  Hytale automatically assigns players to game-mode groups (like `Creative` or `Adventure`) using the first available provider.
+
+  If your provider throws an error when the group doesn't exist, the player will be disconnected! Always handle missing groups gracefully.
+</Callout>
+
+### Registering Your Provider
 
-  If your provider throws an error (for instance, if the group does not exist) when the server is preparing the player, the player will be disconnected.
+```java
+public class MyPlugin extends JavaPlugin {
+
+    @Override
+    public void setup() {
+        // Add your provider alongside the default one
+        PermissionsModule.get().addProvider(new DatabasePermissionProvider());
+    }
+}
+```
+
+The `PermissionsModule` aggregates permissions from all registered providers. This means:
+
+- Permission checks query all providers
+- Write operations (add/remove) use the **first** provider
+
+### Replacing the Default Provider
+
+If you want full control, you can remove the default provider:
+
+```java
+public class MyPlugin extends JavaPlugin {
+
+    @Override
+    public void setup() {
+        PermissionsModule perms = PermissionsModule.get();
+
+        // Remove the default provider FIRST
+        perms.removeProvider(perms.getFirstPermissionProvider());
+
+        // Then add your provider
+        perms.addProvider(new DatabasePermissionProvider());
+    }
+}
+```
+
+<Callout type="info">
+  When you remove the default provider, the `/op self` command will stop working since it checks for provider tampering.
 </Callout>
 
-We can then register the provider using the built-in permission module:
+---
+
+## Best Practices
+
+### Permission Naming Conventions
+
+Follow the pattern: `namespace.category.action`
 
 ```java
-PermissionsModule.get().addProvider(new DatabasePermissionProvider());
+// Good - clear hierarchy
+"myplugin.admin.ban"
+"myplugin.user.teleport.home"
+"myplugin.vip.chat.color"
+
+// Bad - unclear structure
+"myplugin_ban"
+"teleport"
+"vipChatColor"
 ```
 
-Please note that the `HytalePermissionsProvider` will still be enabled alongside your provider.
-The `PermissionsModule` will aggregate groups and permissions from all available providers.
+### Use Constants for Permissions
 
-If you want to disable the default `HytalePermissionsProvider`, you can use:
+Define your permissions as constants to avoid typos:
 
 ```java
-// put this **before** you add your provider
-PermissionsModule.get().removeProvider(PermissionsModule.get().getFirstPermissionProvider());
+public final class MyPermissions {
+    public static final String ADMIN_BAN = "myplugin.admin.ban";
+    public static final String ADMIN_KICK = "myplugin.admin.kick";
+    public static final String USER_HOME = "myplugin.user.home";
+    public static final String VIP_FLY = "myplugin.vip.fly";
+}
+
+// Usage
+if (player.hasPermission(MyPermissions.ADMIN_BAN)) {
+    // ...
+}
 ```
+
+### Don't Over-Permission
+
+Only create permissions for actions that genuinely need access control. Not everything needs a permission check.
+
+### Thread Safety
+
+If you create a custom provider, ensure it's thread-safe. Permission checks can occur from multiple threads simultaneously. Use `ReadWriteLock` or `ConcurrentHashMap` for your data structures.
+
+---
+
+## In-Game Commands
+
+Hytale provides built-in commands for managing permissions:
+
+### `/op` Command
+
+| Command               | Description                                                        |
+| --------------------- | ------------------------------------------------------------------ |
+| `/op self`            | Toggle your own OP status (singleplayer or with `--allow-op` flag) |
+| `/op add <player>`    | Add a player to the OP group                                       |
+| `/op remove <player>` | Remove a player from the OP group                                  |
+
+### `/perm` Command
+
+Use `/perm --help` in-game for full usage. Common operations:
+
+| Command                                  | Description                   |
+| ---------------------------------------- | ----------------------------- |
+| `/perm user list <uuid>`                 | List user's permissions       |
+| `/perm user add <uuid> <perm>`           | Add permission to user        |
+| `/perm user remove <uuid> <perm>`        | Remove permission from user   |
+| `/perm user group list <uuid>`           | List user's groups            |
+| `/perm user group add <uuid> <group>`    | Add user to group             |
+| `/perm user group remove <uuid> <group>` | Remove user from group        |
+| `/perm group list <group>`               | List group's permissions      |
+| `/perm group add <group> <perm>`         | Add permission to group       |
+| `/perm group remove <group> <perm>`      | Remove permission from group  |
+| `/perm test <perm>`                      | Test if you have a permission |
+
+---
+
+## Summary
+
+You've learned how to:
+
+- **Check permissions** using `PermissionsModule.hasPermission()`
+- **Manage user permissions** with `addUserPermission()` and `removeUserPermission()`
+- **Work with groups** using `addGroupPermission()`, `addUserToGroup()`, etc.
+- **Use wildcards** like `*` and `myplugin.*` for bulk permissions
+- **Listen to events** for permission changes
+- **Create custom providers** for database-backed permissions
+
+For more advanced permission systems with features like inheritance, expiry, and contexts, we're looking into expanding this guide with advanced permission management techniques in the future.
diff --git a/content/docs/af-ZA/guides/plugin/setting-up-env.mdx b/content/docs/af-ZA/guides/plugin/setting-up-env.mdx
index d2718098..5be5e9e0 100644
--- a/content/docs/af-ZA/guides/plugin/setting-up-env.mdx
+++ b/content/docs/af-ZA/guides/plugin/setting-up-env.mdx
@@ -4,6 +4,10 @@ description: Learn how to set up your development environment for modding Hytale
 authors:
   - name: Neil Revin
     link: https://itsneil.dev
+  - name: Marcel-TO
+    url: https://marcel-to.net
+  - name: Ádám Liszkai
+    link: https://adaliszk.dev
 ---
 
 This guide will walk you through setting up a complete development environment for Hytale modding, including all necessary tools and dependencies.
@@ -19,24 +23,73 @@ Before we begin, make sure you have:
 
 ## Required Software
 
-### 1. Java Development Kit (JDK)
+### Integrated Development Environment (IDE)
 
+We recommend IntelliJ IDEA Community Edition for Hytale modding. If you use IntelliJ IDEA, **almost everything is built-in**. You can clone a template, open a new project, and start working right away!
+
+1. Download from [JetBrains website](https://www.jetbrains.com/idea/download/)
+2. Install with default settings
+3. Launch and complete the initial setup wizard
+
+When opening a project, wait for indexing to finish, then start coding.
+Now, IDEA may say "No JDK configured" at the top of the source file you have.
+In that case, you can click Download JDK and choose JetBrains JDK 25.
+
+<Callout type="success">
+  If IDEA opened the project without errors, your environment is ready.
+</Callout>
+
+More details by [JetBrains](https://www.jetbrains.com/help/idea/2026.1/run-for-the-first-time.html)
+help page, where we recommend that you also check the
+[SDK configuration](https://www.jetbrains.com/help/idea/2026.1/sdk.html) guide.
+
+<Callout type="info">
+  We recommened following
+  [TheNullicorn's](https://gist.github.com/TheNullicorn/90a619796c40f20ae1fcf13094c1a57d) guide to ensure
+  you are using the correct `Nonnull` in your projects.
+</Callout>
+
+#### What the IDE Does for You
+
+When opened in IntelliJ IDEA, the project automatically:
+
+- Detects and configures Gradle or Maven
+- Downloads all dependencies
+- Sets up project structure and classpaths
+- Configures run/build tasks
+
+You do **not** need to manually install or configure Maven or Gradle if you stay inside the IDE.
+
+Skip to the [Setting Up Your Workspace](#setting-up-your-workspace).
+
+### Manual Setup: Java Development Kit (JDK)
+
+For any other setup, you will need to install and configure your system to have and load Java.
 Hytale modding requires Java 25 or later. We recommend using OpenJDK.
 
-#### Windows
+#### Windows via Installer
 
 1. Download OpenJDK 25 from [Adoptium](https://adoptium.net/)
 2. Run the installer with default settings
+   - Optionally enable feature `Set or Override JAVA_HOME variable` to resolve version related build issues with your project.
 3. Verify installation by opening Command Prompt and running:
 
+#### Windows via Scoop
+
+1. Install Scoop via PowerShell using [scoop.sh](https://scoop.sh/)
+2. Install OpenJDK 25:
+
 ```bash
-java -version
+scoop bucket add java
+scoop install java/openjdk25
 ```
 
 #### macOS
 
+1. Install Brew via Terminal using [brew.sh](https://brew.sh)
+2. Install JDK via Homebrew:
+
 ```bash
-# Using Homebrew
 brew install openjdk@25
 ```
 
@@ -51,22 +104,41 @@ brew install openjdk@25
 
 #### Linux (Ubuntu/Debian)
 
+1. Install JDK via the built-in package repository:
+
 ```bash
 sudo apt update
 sudo apt install openjdk-25-jdk
 ```
 
-### 2. Integrated Development Environment (IDE)
+### Verify installation:
 
-We recommend IntelliJ IDEA Community Edition for Hytale modding.
+Run the following command to see what version of Java you have:
 
-1. Download from [JetBrains website](https://www.jetbrains.com/idea/download/)
-2. Install with default settings
-3. Launch and complete the initial setup wizard
+```bash
+java -version
+```
+
+### Java Build Tool (Optional)
+
+We recommend using a Gradle Wrapper for managing dependencies and building your Hytale plugins. It provides benefits by eliminating the need for a system-wide Gradle installation and ensuring consistent Gradle versions across different environments. (Alternatively you can use Maven, but this guide focuses on Gradle since it is the default for our plugin template.)
+
+The plugin template in the following sections includes a Gradle Wrapper, so you can skip this step if you plan to use the template.
+
+#### Choosing Gradle (if not using the template)
+
+If you prefer to install Gradle manually, follow these steps:
 
-### 3) Java Build Tool
+1. Visit the official website: https://gradle.org/releases/
+2. Download the newest gradle binary: `gradle-9.3.1-bin.zip` (Binary zip archive)
+3. Unzip it
+4. Add the `gradle-9.3.1/bin/` folder to your PATH
+
+You can now try the command `gradle -version` to verify Gradle is installed correctly. Make sure to do this in a fresh new terminal instead of one you had opened from before!
+
+#### Choosing Maven (if not using the template)
 
-We recommend using Apache Maven for managing dependencies and building your Hytale plugins. (Alternatively you can use Gradle, but this guide focuses on Maven.)
+If you prefer to use Maven instead of Gradle, follow these steps to install Maven:
 
 1. Visit the official website: https://maven.apache.org/download.cgi
 2. Download this file: `apache-maven-3.9.12-bin.zip` (Binary zip archive)
@@ -89,22 +161,61 @@ cd MyFirstMod
 
 If you don't have Git installed, you can download the ZIP file from the repository page and extract it to a folder named `MyFirstMod`.
 
-### 2. Open Plugin in your IDEA
+### 2. Open Plugin in your IDE
 
-1. Open IntelliJ IDEA
+1. Open Your IDE (e.g., IntelliJ IDEA)
 2. Click "Open" and navigate to your `MyFirstMod` directory
-3. IntelliJ will automatically detect it as a Maven project
+3. Most IDEs like IntelliJ will automatically detect it as a Gradle project
 4. Wait for the project to index and dependencies to download
 
-<Callout type="info">
-  We recommened following [this](https://gist.github.com/TheNullicorn/90a619796c40f20ae1fcf13094c1a57d) guide to ensure you are using the correct `Nonnull` in your projects.
-</Callout>
+## Alternate Approach: Hytale Dependency
+
+If you prefer to set up your project from scratch without using the template and importing the hytale dependencies manually, ensure your build configuration includes the Hytale repositories and dependencies:
+
+For Gradle, add the following to your `build.gradle.kts`:
+
+```kotlin
+repositories {
+    mavenCentral()
+    maven {
+        name = "hytale"
+        url = uri("https://maven.hytale.com/release") // Or "hytale-pre-release" for pre-release versions
+    }
+}
+dependencies {
+    // + here means the latest version, but you can hard-wire any known version!
+    implementation("com.hypixel.hytale:Server:+")
+}
+```
+
+For Maven, add the following to your `pom.xml`:
+
+```xml
+<project>
+    <repositories>
+        <repository>
+            <id>hytale-release</id> <!-- Or "hytale-pre-release" for pre-release versions -->
+            <url>https://maven.hytale.com/release</url> <!-- Or "https://maven.hytale.com/pre-release" -->
+        </repository>
+    </repositories>
+
+    <dependencies>
+        <dependency>
+            <groupId>com.hypixel.hytale</groupId>
+            <artifactId>Server</artifactId>
+            <!-- Replace with latest version, Hytale provides jars for the last five releases -->
+            <version>LATEST_VERSION_HERE</version>
+            <scope>provided</scope>
+        </dependency>
+    </dependencies>
+</project>
+```
 
 ## Next Steps
 
 Now that you have your development environment set up with the plugin template:
 
-1. **Customize the template** - Edit the `pom.xml` and `manifest.json` file to change your mod's name and details
+1. **Customize the template** - Edit the `settings.gradle.kts`, `build.gradle.kts` and `manifest.json` file to change your mod's name and details
 2. **Explore the code structure** - Familiarize yourself with the template's organization
 3. **Start modding** - Begin writing your first Hytale plugin!
 
diff --git a/content/docs/af-ZA/guides/plugin/spawning-entities.mdx b/content/docs/af-ZA/guides/plugin/spawning-entities.mdx
index e12c0aea..15be2fb3 100644
--- a/content/docs/af-ZA/guides/plugin/spawning-entities.mdx
+++ b/content/docs/af-ZA/guides/plugin/spawning-entities.mdx
@@ -36,7 +36,7 @@ Store<EntityStore> store = world.getEntityStore().getStore();
 
 ## Creating Entities
 
-Once you have the `EntityStore` instance, you can start to create a entity and give it components. Entities are just instances of `Holder<EntityStore>` with several components attached to them.
+Once you have the `EntityStore` instance, you can start to create an entity and give it components. Entities are just instances of `Holder<EntityStore>` with several components attached to them.
 
 <Callout type="warning">
   To interact with the `World` instance, some methods require you to run the code inside the world's execution context.
@@ -118,3 +118,48 @@ Finally, we can add the entity to the world by calling the `addEntity` method on
 ```java
 store.addEntity(holder, AddReason.SPAWN);
 ```
+
+## Making the entity persist
+
+Hytale automatically saves all entities, but the `NetworkId` component (required for players to be able to see the entity) needs to be manually added every time the entity is loaded.
+
+### Using a system
+
+If you have a component that is unique to your entities, this can be done by creating and registering a custom system as follows:
+
+```java
+public class AddNetworkIdToMyEntitySystem extends HolderSystem<EntityStore> {
+    private final ComponentType<EntityStore, MyEntityComponent> myEntityComponentType = MyEntityComponent.getComponentType();
+    private final ComponentType<EntityStore, NetworkId> networkIdComponentType = NetworkId.getComponentType();
+    private final Query<EntityStore> query = Query.and(this.myEntityComponentType, Query.not(this.networkIdComponentType));
+
+    @Override
+    public void onEntityAdd(@NotNull Holder<EntityStore> holder, @NotNull AddReason reason, @NotNull Store<EntityStore> store) {
+        if (!holder.getArchetype().contains(NetworkId.getComponentType())) {
+            holder.addComponent(NetworkId.getComponentType(), new NetworkId(store.getExternalData().takeNextNetworkId()));
+        }
+    }
+
+    @Override
+    public void onEntityRemoved(@NotNull Holder<EntityStore> holder, @NotNull RemoveReason reason, @NotNull Store<EntityStore> store) {}
+
+    @Override
+    public @Nullable Query<EntityStore> getQuery() {
+        return query;
+    }
+}
+```
+
+In your plugin's `setup()` function
+
+```java
+this.getEntityStoreRegistry().registerSystem(new AddNetworkIdToMyEntitySystem())
+```
+
+### Using PropComponent
+
+Alternatively you can add `PropComponent` to your entity. Hytale adds `PropComponent` to entities spawned with the Entity Tool, and such entities automatically get `NetworkId` and `PrefabCopyableComponent` (which makes the entity work with prefabs).
+
+<Callout type="warning">
+  There is no guarantee, that Hytale will not add some other behavior to this component in the future, which may break your entity, so be careful if you decide to rely on it.
+</Callout>
diff --git a/content/docs/af-ZA/guides/plugin/store-persistent-data.mdx b/content/docs/af-ZA/guides/plugin/store-persistent-data.mdx
new file mode 100644
index 00000000..1071dff3
--- /dev/null
+++ b/content/docs/af-ZA/guides/plugin/store-persistent-data.mdx
@@ -0,0 +1,171 @@
+---
+title: Storing Persistent Data on the Player
+description: Learn how to save and load persistent data using Components
+authors:
+  - name: Neil Revin
+    url: https://itsneil.dev/
+  - name: ArcticDev
+    url: https://github.com/ArcticRaven
+  - name: oskarscot
+    url: https://oskar.scot
+  - name: JammingEng
+    url: https://github.com/JammingEnd
+---
+
+Here is how to store persistent data using a custom component on a Player.
+
+## Build your Component Class
+
+Creating a custom component class leverages the Component system made with the ECS architecture in mind. For more information on Components, check out the [ECS Guide](../ecs/hytale-ecs-theory#components).
+
+Start by creating your custom component class. This will be extremely similar to how regular components are created, however we'll setup a custom Codec so the server can translate this data to BSON, or the server's internal json encoder.
+
+<Callout type="info">
+  Each variable you want to store in your component must have its own Codec field defined in the BuilderCodec.
+  For more information on how to create custom Codecs, check out the [ECS Codec Guide](../ecs/hytale-ecs-theory#codec).
+</Callout>
+
+```java
+public class YourPlayerData implements Component<EntityStore> {
+
+    // define some vars!
+    private int someInteger;
+    private String someString;
+    private Map<String, String> someMap;
+
+    public static final BuilderCodec<YourPlayerData> CODEC =
+            BuilderCodec.builder(YourPlayerData.class, YourPlayerData::new)
+            .append(new KeyedCodec<>("SomeInteger", Codec.INTEGER),
+                    (data, value) -> data.someInteger = value, // setter
+                    data -> data.someInteger) // getter
+            .addValidator(Validators.nonNull())
+            .add()
+            .append(new KeyedCodec<>("SomeString", Codec.STRING),
+                    (data, value) -> data.someString = value, // setter
+                    data -> data.someString) // getter
+            .add()
+            .append(new KeyedCodec<>("SomeMap",
+                            new MapCodec<>(Codec.STRING, HashMap::new, false)),
+                    (data, value) -> data.someMap = value, // setter
+                    data -> data.someMap) // getter
+            .add()
+            .build();
+
+
+
+    // Getters and Setters are for the purpose of this example omitted.
+
+    // constructor
+    public YourPlayerData() {
+        this.someInteger = 0;
+        this.someString = "";
+        this.someMap = new HashMap<>();
+    }
+
+    // copy constructor for cloning
+    public YourPlayerData(YourPlayerData clone) {
+        this.someInteger = clone.someInteger;
+        this.someString = clone.someString;
+        this.someMap = clone.someMap;
+    }
+
+    @Nonnull
+    @Override
+    public Component<EntityStore> clone() {
+        return new YourPlayerData(this);
+    }
+}
+```
+
+## Register your Component
+
+Inside your main class's `setup()` method, register your new Component.
+
+```java
+public class YourPlugin extends JavaPlugin {
+
+    private ComponentType<EntityStore, YourPlayerData> yourPlayerDataComponent;
+
+    public YourPlugin(@Nonnull JavaPluginInit init) {
+        super(init);
+    }
+
+    @Override
+    protected void setup(){
+        this.yourPlayerDataComponent = this.getEntityStoreRegistry().registerComponent(
+            YourPlayerData.class,
+            "YourPlayerDataComponent",
+            YourPlayerData.CODEC
+        );
+    }
+
+    public ComponentType<EntityStore, YourPlayerData> getYourPlayerDataComponent() {
+        return this.yourPlayerDataComponent;
+    }
+}
+```
+
+## Using your Component
+
+To use your newly created component, you can add the Component to a player using the `addComponent` method, although this only adds it temporarily, meaning when the player/entity leaves the world, the component is removed. You can use `putComponent` to ensure the component persists between sessions.
+
+```java
+// You will need the Ref and Store to apply components
+private void someEntryMethod(@Nonnull Ref<EntityStore> ref, @Nonnull Store<EntityStore> store)
+{
+       // Any entity will work, for now we will use the player
+      Player player = (Player) store.getComponent(ref, Player.getComponentType());
+
+      // since we're using putComponent, it could be useful to check if it already exists on the player in case we want to update it
+     if(store.getComponent(ref, YourPlugin.instance().getYourPlayerDataComponent()) != null)
+     {
+          // here we implement logic that updates the component
+         var comp = store.getComponent(ref, YourPlugin.instance().getYourPlayerDataComponent())
+         // declare public fields or methods in the component class
+         comp.SomeString = "An Updated Field";
+     } else {
+          // Here we put the component
+          var myCustomComp = new CustomComponent();
+          // declare public fields or methods in the component class
+          myCustomComp.SomeString = "Edited String";
+
+          // putComponent allows you to insert declared objects
+          store.putComponent(ref, YourPlugin.instance().getYourPlayerDataComponent(), myCustomComp);
+     }
+}
+```
+
+## Using your Data
+
+Your component will be stored within the `Store<EntityStore>` when added to the player. In the provided example,
+we'll fetch this data off the player using the `ensureAndGetComponent()` method, which will add the component to
+the player if it does not exist with the default values.
+
+```java
+public class IncompleteCustomCommand extends AbstractPlayerCommand {
+
+    public IncompleteCustomCommand() {
+        super("nope", "don't use this command");
+    }
+
+    @Override
+    protected void execute(
+        @NonNullDecl CommandContext commandContext,
+        @NonNullDecl Store<EntityStore> store,
+        @NonNullDecl Ref<EntityStore> ref,
+        @NonNullDecl PlayerRef playerRef,
+        @NonNullDecl World world
+    ) {
+        YourPlayerData customData = store.ensureAndGetComponent(ref, YourPlugin.instance().getYourPlayerDataComponent());
+        // ensureAndGetComponent adds the component to the ref, with the default values defined inside your component.
+ 		// use your data
+    }
+}
+```
+
+And that's it! Your data will now be saved and loaded automatically with the player.
+
+Using custom components to store persistent data on players is a powerful way to maintain state across sessions.
+By following the steps outlined above, you can easily create, register, and utilize your own data structures within the Hytale ECS framework.
+This approach ensures that your data is seamlessly integrated with the game's existing systems.
+For more information about Hytale's Entity Component System visit the [Hytale ECS Theory](https://hytalemodding.dev/en/docs/guides/ecs/hytale-ecs-theory) guide.
diff --git a/content/docs/af-ZA/guides/plugin/teleporting-players.mdx b/content/docs/af-ZA/guides/plugin/teleporting-players.mdx
index 57cee77f..32ce0435 100644
--- a/content/docs/af-ZA/guides/plugin/teleporting-players.mdx
+++ b/content/docs/af-ZA/guides/plugin/teleporting-players.mdx
@@ -1,26 +1,32 @@
 ---
 title: Teleporting the player
 description: Learn how to teleport the player.
+authors:
+  - name: oskarscot
+    url: https://oskar.scot
 ---
 
-To teleport players in Hytale, you will need to get a `World` object so we can safely run the teleport on the world thread. The world thread manages all entity updates, so modifying entities off-thread can crash the server or cause inconsistent state.
-Next, we get the entity store and make a `Teleport` object.
-We add a `Teleport` component to the player’s entity reference in the entity store. This triggers the teleportation logic for that player.
+Teleporting players in Hytale works by simply attaching a `Teleport` component to a player with the desired world and transform.
+You can only trigger teleports from a world where the player is currently present.
+Teleport itself is a component but it also provides factory methods to configure the Teleport. Just as with any entity component, an EntityStore and a Ref to the EntityStore is required
+
+We can create a simple teleport utility like this:
 
 ```java
-public static void teleportPlayer(Player player, int x, int y, int z) {
-        World world = player.getWorld();
-        if (world == null) return;
-        world.execute(() -> {
-            if (player.getReference() == null) return;
-            Store<EntityStore> store = player.getReference().getStore();
-            Teleport teleport = Teleport.createForPlayer(world,
-                new Vector3d(x ,y, z), // Target position
-                new Vector3f(0, 0, 0)  // Target rotation (pitch, yaw, roll)
-            );
+public static void teleportPlayer(Ref<EntityStore> ref, Store<EntityStore> store, World targetWorld, double x, double y, double z) {                                                                                       
+    Transform transform = new Transform(x, y, z);                                                                                                                           
+    Teleport teleport = Teleport.createForPlayer(targetWorld, transform);                                                                                                   
+    store.addComponent(ref, Teleport.getComponentType(), teleport);                                                                                                         
+}  
+```
 
-            store.addComponent(player.getReference(), Teleport.getComponentType(), teleport);
-        });
+A `Transform` is a representation of a position Vector3d and rotation Vector3f which works in the following way:
 
-}
+```java
+Transform transform = new Transform(
+    new Vector3d(x, y, z),      // Position
+    new Rotation(yaw, pitch, 0) // Rotation, last value seems to always be 0
+);
+Teleport teleport = Teleport.createForPlayer(targetWorld, transform);
+store.addComponent(ref, Teleport.getComponentType(), teleport);
 ```
diff --git a/content/docs/af-ZA/guides/plugin/tracking-mod-analytics-with-hstats.mdx b/content/docs/af-ZA/guides/plugin/tracking-mod-analytics-with-hstats.mdx
new file mode 100644
index 00000000..45c022e0
--- /dev/null
+++ b/content/docs/af-ZA/guides/plugin/tracking-mod-analytics-with-hstats.mdx
@@ -0,0 +1,65 @@
+---
+title: Tracking Mod Analytics with HStats
+description: Learn how you can track Analytics for your Hytale Mod for Free using hstats.dev
+authors:
+  - name: Al3x
+    url: https://hstats.dev
+---
+
+In this guide, you will learn how to integrate HStats into your Plugin/Mod which will allow you to track how many Servers are using it along with other stats.
+
+<Callout type="info">
+  HStats is a third-party tool and is not affiliated with HytaleModding or Hypixel Studios
+</Callout>
+
+# Step 1: Register your Mod to HStats
+
+Before you touch any code, you will need to add your mod to the HStats website which will give you a UUID for your mod.
+
+- Create or Login to an Account on https://hstats.dev
+- Navigate to the dashboard page (https://hstats.dev/dashboard)
+- On the left, type in your mod's name and click "Add Mod"
+- Keep note of the UUID generated for later.
+
+# Step 2: Add the HStats Class to Your Project
+
+To keep things simple, HStats uses a single Java class file that handles everything for you.
+
+- Download / Copy the File from the GitHub page (https://github.com/hstats-dev/HStatsExamplePlugin/blob/main/src/main/java/com/al3x/HStats.java)
+- Paste into your Project. You should now have a HStats.java file somewhere in your projects directory.
+- Update the package name from com.al3x to whatever fits your project.
+
+# Step 3: Initialize HStats in your code
+
+You only need to add one line of code to your mod's setup method in your main class to start tracking.
+
+`new HStats("YOUR-MOD-UUID", "1.0.0");`
+
+Replace `YOUR-MOD-UUID` with the Mod UUID we made note of earlier and change the `1.0.0` version to whatever version your mod is currently on.
+
+Your setup method should now look something like this:
+
+```java
+@Override
+protected void setup() {
+  super.setup();
+  new HStats("c34a2b2a-afd8-4d6a-821e-7a63e12c5ea6", "1.0.0");
+}
+```
+
+# Extras
+
+Your done! Your mod should now be listed under the Mods page (https://hstats.dev/mods) as well as under your dashboard.
+
+Servers using your mod should now post updates about every minute to HStats which you can view in the Dashboard.
+
+### Embeds
+
+HStats allows you to generate an Embed Card that you can place on your CurseForge or GitHub page. This is useful for server owners to be able to see how many other servers are using your mod.
+
+- In your dashboard, scroll down to the Embed Card section.
+- Customize the appearance (Light/Dark mode, layout, etc).
+- Copy the generated URL to display your "Active Servers" and "Players Online" live on your mod's description page
+
+Heres an example of what they look like:
+![HStats Example](https://api.hstats.dev/api/embed/d52fa672-6966-47b2-b501-1a11bddebac3/card.svg?theme=light\&layout=compact\&size=md\&show_id=true\&dark=false)
diff --git a/content/docs/af-ZA/guides/plugin/world-gen.mdx b/content/docs/af-ZA/guides/plugin/world-gen.mdx
index 4c23b0c9..7b193ffd 100644
--- a/content/docs/af-ZA/guides/plugin/world-gen.mdx
+++ b/content/docs/af-ZA/guides/plugin/world-gen.mdx
@@ -100,7 +100,7 @@ Biome biome = biomeGen.generateBiomeAt(zoneResult, seed, x, z);
 
 ### Zone & Cave Integration
 
-Each zone defines it's own cave patterns:
+Each zone defines its own cave patterns:
 
 ```java
 Zone zone = /* ... */;
diff --git a/content/docs/af-ZA/guides/prefabs.mdx b/content/docs/af-ZA/guides/prefabs.mdx
index 08404b30..b1a55109 100644
--- a/content/docs/af-ZA/guides/prefabs.mdx
+++ b/content/docs/af-ZA/guides/prefabs.mdx
@@ -14,7 +14,7 @@ Prefabs are Hytale's way of creating reusable structures.
 There are a few fundamental concepts to understand about prefabs:
 
 - Users interact with prefabs via a prefab editing world.
-- Prefabs the physical structures in the game world, and are saved as JSON files.
+- Prefabs are the physical structures in the game world, and are saved as JSON files.
 
 ## How to Create a Prefab
 
diff --git a/content/docs/af-ZA/official-documentation/custom-ui/common-styling.mdx b/content/docs/af-ZA/official-documentation/custom-ui/common-styling.mdx
new file mode 100644
index 00000000..c36e3e3a
--- /dev/null
+++ b/content/docs/af-ZA/official-documentation/custom-ui/common-styling.mdx
@@ -0,0 +1,50 @@
+---
+title: Common Styling
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# Common Styling
+
+## Common UI Styling Library
+
+This document describes the shared UI components and styles defined in `Common.ui`.
+
+---
+
+### Styles
+
+We are providing some styles that can be re-used in any custom UI that, provide a cohesive UI experience with the core game UI. These styles are available in the `Common.ui` file.
+
+You can find a list of all the styles defined with live examples by running the `/ui-gallery` command ingame.
+
+<Callout type="warning">
+  This command is not available yet, but will be in a future patch.
+</Callout>
+
+![Gallery](/assets/official-documentation/ui/gallery.png)
+
+### Importing
+
+To use these styles in your UI file:
+
+```
+$Common = "Common.ui";
+
+// Then reference styles and components:
+$Common.@TextButton { @Text = "My Button"; }
+$Common.@Container { ... }
+```
+
+<Callout type="info">
+  The `Common.ui` file is at `Common/UI/Custom/Common.ui` within the Hytale pack. If your custom ui document is in a subfolder of `Common/UI/Custom/`, reference it via relative path traversal:
+
+  ```
+  $Common = "../Common.ui";
+  ```
+
+  You can find more info about paths [here](markup#path).
+</Callout>
diff --git a/content/docs/af-ZA/official-documentation/custom-ui/index.mdx b/content/docs/af-ZA/official-documentation/custom-ui/index.mdx
new file mode 100644
index 00000000..f94c4e88
--- /dev/null
+++ b/content/docs/af-ZA/official-documentation/custom-ui/index.mdx
@@ -0,0 +1,125 @@
+---
+title: Custom UI
+icon: LayoutDashboard
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# Custom UI
+
+## What is Custom UI?
+
+Custom UI is Hytale's framework for creating **custom user interfaces** controlled by the game server. Unlike the built-in Client UI (which is part of the game client and cannot be modified), Server UI allows you to create interactive screens and HUD overlays through Java plugins and asset packs.
+
+As a modder, Custom UI gives you the power to:
+
+- **Create custom interactive pages** - Shop interfaces, quest dialogs, server settings menus, admin panels
+- **Add custom HUD overlays** - Quest trackers, status displays, custom health bars, server information
+- **Design with markup** - Use `.ui` files to define reusable UI templates
+- **Handle user interactions** - Respond to button clicks, form submissions, and other events
+- **Localize your UI** - Support multiple languages using the game's translation system
+
+## How Custom UI Fits Into Hytale's UI
+
+Hytale's user interface is divided into two main categories:
+
+### Client UI (Not Moddable)
+
+Built-in interfaces controlled by the C# game client:
+
+- Main menu and settings
+- Character creation
+- Built-in HUD (health, hotbar, chat)
+- Inventory and crafting screens
+- Development tools
+
+**You cannot modify these** - they are part of the core game client.
+
+### In-Game UI (Moddable via Server)
+
+Server-controlled interfaces that you can create and customize:
+
+#### Custom Pages
+
+Full-screen interactive overlays that appear during gameplay:
+
+- Can be dismissed by the player (ESC key)
+- Capture all input (keyboard and mouse)
+- Support loading states while waiting for server responses
+- Perfect for: shops, dialogs, menus, configuration screens
+
+#### Custom HUDs
+
+Persistent overlay elements drawn on top of the game world:
+
+- Display-only (no user interaction)
+- Always visible during gameplay
+- Lightweight and non-intrusive
+- Perfect for: quest objectives, status indicators, server info panels
+
+## Architecture Overview
+
+Server UI uses a **command-based architecture**:
+
+```
+┌─────────────────────┐         ┌──────────────────────┐
+│   Java Server       │         │    C# Client         │
+│   (Your Plugin)     │         │    (Game)            │
+├─────────────────────┤         ├──────────────────────┤
+│                     │         │                      │
+│ InteractiveCustomUI │         │   CustomPage or      │
+│ Page                │         │   CustomHud          │
+│   ↓ build()         ├────────→│     ↓ Apply          │
+│ UICommandBuilder    │         │   Element Tree       │
+│   - append()        │         │     ↓ Layout         │
+│   - set()           │         │   Rendered UI        │
+│   - clear()         │         │                      │
+│                     │         │                      │
+│ ↓ handleDataEvent() │← Events │   User Interaction   │
+│   Process input     │         │   (click, type, etc) │
+│   sendUpdate()      │         │                      │
+└─────────────────────┘         └──────────────────────┘
+```
+
+**The flow:**
+
+1. Your Java code builds UI using `UICommandBuilder`
+2. Commands are sent to the client as data
+3. Client parses `.ui` markup files and creates visual elements
+4. User interacts with the UI
+5. Events are sent back to your Java code
+6. You process events and send updates back
+
+## Key Principles
+
+### Declarative, Not Imperative
+
+You don't create UI objects directly. Instead, you send **commands** that describe what you want:
+
+- "Append this button template to that container"
+- "Set this label's text to 'Hello World'"
+- "Clear all children from this list"
+
+### Asset-Driven
+
+UI structure is defined in `.ui` markup files (assets), not hardcoded in Java. This enables:
+
+- Designers to modify layouts without touching code
+- Reusable UI components
+- Consistent visual language
+
+### Event-Driven
+
+User interactions trigger events that flow back to your server code. You register event bindings and handle them in `handleDataEvent()`.
+
+### Selector-Based
+
+You target specific UI elements using **selectors:**
+
+- `#MyButton` - Element with ID "MyButton"
+- `#List[0]` - First child of element "List"
+- `#List[0] #Title` - Element with ID "Title" in the first child of element "List"
+- `#Label.TextColor` - The TextColor property of element "Label"
diff --git a/content/docs/af-ZA/official-documentation/custom-ui/layout.mdx b/content/docs/af-ZA/official-documentation/custom-ui/layout.mdx
new file mode 100644
index 00000000..0a24ca09
--- /dev/null
+++ b/content/docs/af-ZA/official-documentation/custom-ui/layout.mdx
@@ -0,0 +1,492 @@
+---
+title: Layout
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# Layout
+
+The layout system determines how UI elements are positioned and sized on screen. Understanding layout is crucial for creating well-structured, responsive interfaces.
+
+## Layout Fundamentals
+
+Every UI element has:
+
+- **Container Rectangle** - The space allocated by the parent
+- **Anchor** - How the element positions/sizes itself within the container
+- **Padding** - Inner spacing that affects child layout
+- **LayoutMode** - How the element arranges its children (if it's a container)
+
+```
+┌─────────────────────────────────────┐
+│  Container Rectangle (from parent)  │
+│  ┌───────────────────────────────┐  │
+│  │  Anchored Rectangle           │  │
+│  │  ┌─────────────────────────┐  │  │
+│  │  │ Padding                 │  │  │
+│  │  │  ┌───────────────────┐  │  │  │
+│  │  │  │  Content Area     │  │  │  │
+│  │  │  └───────────────────┘  │  │  │
+│  │  └─────────────────────────┘  │  │
+│  └───────────────────────────────┘  │
+└─────────────────────────────────────┘
+```
+
+## Anchor
+
+`Anchor` controls how an element positions and sizes itself within its container rectangle.
+
+### Fixed Size
+
+```
+Button {
+    Anchor: (Width: 200, Height: 40);
+}
+```
+
+Creates a 200×40 pixel button.
+
+### Positioning
+
+```
+Label {
+    Anchor: (Top: 10, Left: 20, Width: 100, Height: 30);
+}
+```
+
+- **Top**: 10 pixels from container's top edge
+- **Left**: 20 pixels from container's left edge
+- **Width**: 100 pixels wide
+- **Height**: 30 pixels tall
+
+### Anchoring to Edges
+
+```
+Button {
+    Anchor: (Bottom: 10, Right: 10, Width: 100, Height: 30);
+}
+```
+
+Anchors the button to the bottom-right corner, 10 pixels from each edge.
+
+### Stretching
+
+```
+Group {
+    Anchor: (Top: 0, Bottom: 0, Left: 0, Right: 0);
+}
+```
+
+Stretches to fill the entire container (all edges at 0 pixels).
+
+**Shorthand:**
+
+```
+Group {
+    Anchor: (Full: 0);
+}
+```
+
+### Mixed Anchoring
+
+```
+Panel {
+    Anchor: (Top: 10, Bottom: 10, Left: 20, Width: 300);
+}
+```
+
+- Fixed width of 300 pixels
+- Stretches vertically between top and bottom edges
+- 10 pixels from top and bottom
+- 20 pixels from left
+
+## Padding
+
+`Padding` creates inner spacing, affecting where children are positioned.
+
+### Uniform Padding
+
+```
+Group {
+    Padding: (Full: 20);
+}
+```
+
+20 pixels of padding on all sides.
+
+### Directional Padding
+
+```
+Group {
+    Padding: (Top: 10, Bottom: 20, Left: 15, Right: 15);
+}
+```
+
+Different padding per edge.
+
+### Shorthand
+
+```
+// Horizontal and vertical
+Group {
+    Padding: (Horizontal: 20, Vertical: 10);
+}
+
+// Equivalent to:
+// Top: 10, Bottom: 10, Left: 20, Right: 20
+```
+
+### Effect on Children
+
+```
+Group {
+    Anchor: (Width: 200, Height: 100);
+    Padding: (Full: 10);
+
+    Label {
+        Anchor: (Full: 0);
+    }
+}
+```
+
+The label fills the group, but there's a 10-pixel gap on all sides due to padding.
+
+```
+┌──────────────────────┐
+│ Group (200×100)      │
+│  ┌────────────────┐  │
+│  │ Label          │  │ ← 10px padding all around
+│  │                │  │
+│  └────────────────┘  │
+└──────────────────────┘
+```
+
+## LayoutMode
+
+`LayoutMode` determines how a container arranges its children.
+
+### Top (Vertical Stack)
+
+```
+Group {
+    LayoutMode: Top;
+
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+}
+```
+
+Children stack vertically from top to bottom:
+
+```
+┌──────────┐
+│ Button 1 │
+├──────────┤
+│ Button 2 │
+├──────────┤
+│ Button 3 │
+└──────────┘
+
+
+```
+
+Each child's `Anchor.Bottom` adds spacing between elements:
+
+```
+Button { Anchor: (Height: 30, Bottom: 10); }  // 10px gap after this button
+```
+
+### Bottom (Vertical Stack)
+
+```
+Group {
+    LayoutMode: Bottom;
+
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+}
+```
+
+Children stack vertically from top to bottom but aligned to the bottom edge of the parent:
+
+```
+
+
+
+┌──────────┐
+│ Button 1 │
+├──────────┤
+│ Button 2 │
+├──────────┤
+│ Button 3 │
+└──────────┘
+```
+
+### Left (Horizontal Stack)
+
+```
+Group {
+    LayoutMode: Left;
+
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+}
+```
+
+Children arrange horizontally from left to right:
+
+```
+┌────────┬────────┬────────┐
+│ Button │ Button │ Button │
+│   1    │   2    │   3    │
+└────────┴────────┴────────┘
+```
+
+Use `Anchor.Right` for spacing between elements.
+
+### Right (Horizontal Stack)
+
+```
+Group {
+    LayoutMode: Right;
+
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+}
+```
+
+Children arrange horizontally from left to right but aligned to the right side of the parent:
+
+```
+                                                                 ┌────────┬────────┬────────┐
+                                                                 │ Button │ Button │ Button │
+                                                                 │   1    │   2    │   3    │
+                                                                 └────────┴────────┴────────┘
+```
+
+### Center
+
+```
+Group {
+    LayoutMode: Center;
+
+    Group #Dialog {
+        Anchor: (Width: 400, Height: 300);
+    }
+}
+```
+
+Centers the children horizontally.
+
+### Middle
+
+```
+Group {
+    LayoutMode: Middle;
+
+    Group #Dialog {
+        Anchor: (Width: 400, Height: 300);
+    }
+}
+```
+
+Centers the children vertically.
+
+### CenterMiddle (Horizontal Stack, Fully Centered)
+
+```
+Group {
+    LayoutMode: CenterMiddle;
+
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+}
+```
+
+Children stack horizontally from left to right, centered both horizontally and vertically within the parent:
+
+```
+┌────────────────────────────────────────────┐
+│                                            │
+│                                            │
+│         ┌──────┐ ┌──────┐ ┌──────┐         │
+│         │  B1  │ │  B2  │ │  B3  │         │
+│         └──────┘ └──────┘ └──────┘         │
+│                                            │
+│                                            │
+└────────────────────────────────────────────┘
+```
+
+---
+
+### MiddleCenter (Vertical Stack, Fully Centered)
+
+```
+Group {
+    LayoutMode: MiddleCenter;
+
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+}
+```
+
+Children stack vertically from top to bottom, centered both horizontally and vertically within the parent:
+
+```
+┌────────────────────────────────────────────┐
+│                                            │
+│              ┌──────────┐                  │
+│              │ Button 1 │                  │
+│              ├──────────┤                  │
+│              │ Button 2 │                  │
+│              ├──────────┤                  │
+│              │ Button 3 │                  │
+│              └──────────┘                  │
+│                                            │
+└────────────────────────────────────────────┘
+```
+
+---
+
+### Full
+
+```
+Group {
+    LayoutMode: Full;
+
+    Label {
+        Anchor: (Top: 20, Left: 20, Width: 100, Height: 30);
+    }
+}
+```
+
+Children use absolute positioning via their `Anchor` properties.
+
+### TopScrolling
+
+```
+Group {
+    LayoutMode: TopScrolling;
+    ScrollbarStyle: $Common.@DefaultScrollbar;
+
+    // ... many children
+}
+```
+
+Like `Top`, but adds a scrollbar if content exceeds container height.
+
+Or use `BottomScrolling` for bottom-aligned content.
+
+### LeftScrolling
+
+```
+Group {
+    LayoutMode: LeftScrolling;
+    ScrollbarStyle: $Common.@DefaultScrollbar;
+
+    // ... many children
+}
+```
+
+Like `Left`, but adds a scrollbar for horizontal scrolling.
+
+Or use `RightScrolling` for right-aligned content.
+
+### LeftCenterWrap (Wrapping Horizontal Stack, Horizontally Centered)
+
+```
+Group {
+    LayoutMode: LeftCenterWrap;
+
+    Button { Anchor: (Width: 80, Height: 30); }
+    Button { Anchor: (Width: 80, Height: 30); }
+    Button { Anchor: (Width: 80, Height: 30); }
+    Button { Anchor: (Width: 80, Height: 30); }
+    Button { Anchor: (Width: 80, Height: 30); }
+}
+```
+
+Children flow left to right. When there's no more horizontal space, they wrap to the next row. Each row is horizontally centered within the parent:
+
+```
+┌────────────────────────────────────────────┐
+│                                            │
+│       ┌──────┐ ┌──────┐ ┌──────┐           │
+│       │  B1  │ │  B2  │ │  B3  │           │
+│       └──────┘ └──────┘ └──────┘           │
+│            ┌──────┐ ┌──────┐               │
+│            │  B4  │ │  B5  │               │
+│            └──────┘ └──────┘               │
+│                                            │
+└────────────────────────────────────────────┘
+```
+
+## FlexWeight
+
+`FlexWeight` distributes remaining space among children.
+
+```
+Group {
+    LayoutMode: Left;
+    Anchor: (Width: 400);
+
+    Button {
+        Anchor: (Width: 100);
+    }
+
+    Group {
+        FlexWeight: 1;  // Takes all remaining space
+    }
+
+    Button {
+        Anchor: (Width: 100);
+    }
+}
+```
+
+Result:
+
+- First button: 100px
+- Middle group: 200px (400 - 100 - 100 = 200)
+- Last button: 100px
+
+### Multiple FlexWeights
+
+```
+Group {
+    LayoutMode: Left;
+    Anchor: (Width: 600);
+
+    Group { FlexWeight: 1; }
+    Group { FlexWeight: 2; }
+    Group { FlexWeight: 1; }
+}
+```
+
+Remaining space (600px) is split:
+
+- First group: 600 × (1/4) = 150px
+- Second group: 600 × (2/4) = 300px
+- Third group: 600 × (1/4) = 150px
+
+## Visibility
+
+```
+Button #HiddenButton {
+    Visible: false;
+}
+```
+
+**Effect:**
+
+- Element and its children are not displayed
+- Element is **not included in layout** (doesn't take up space)
diff --git a/content/docs/af-ZA/official-documentation/custom-ui/markup.mdx b/content/docs/af-ZA/official-documentation/custom-ui/markup.mdx
new file mode 100644
index 00000000..564110ed
--- /dev/null
+++ b/content/docs/af-ZA/official-documentation/custom-ui/markup.mdx
@@ -0,0 +1,226 @@
+---
+title: Markup
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# Markup
+
+## Markup
+
+An element is the basic building block of a user interface. There are various types of elements with different properties, which are documented below.
+
+Here's what the syntax looks like:
+
+```
+// Basic declaration of an element
+// with its Anchor property set to attach on all sides of its parent
+// with 10 pixels of margin
+Group { Anchor: (Left: 10, Top: 10, Right: 10, Bottom: 10); }
+
+Group { Anchor: (Full: 10); } // More concise version
+
+// Declaration of a Label with a name
+// (can be used to access the element from game code)
+Label #MyLabel {
+  Style: LabelStyle(FontSize: 16); // or just Style: (FontSize: 16), type can be inferred.
+  Text: "Hi! I am text.";
+}
+
+// Declaration of a Group containing 2 children
+// You can use FlexWeight to distribute any left-over space after explicit widths/heights have been subtracted
+Group {
+  LayoutMode: Left;
+  Label { Text: "Child 1"; FlexWeight: 2; }
+  Label { Text: "Child 2"; FlexWeight: 1; }
+}
+```
+
+### Documents
+
+A UI document (_.ui_ file) contains trees of elements. There can be multiple root elements.
+
+### Named Expressions
+
+Named expressions can be declared at any level of a document (including at the root) and will be scoped to that subtree, though they need to be declared at the top of the block.
+
+```
+// Example of named expressions, declared and used with @ prefix
+@Title = "Hytale";
+@ExtraSpacing = 5;
+
+Label {
+  Text: @Title;
+  Style: (LetterSpacing: 2 + @ExtraSpacing);
+}
+```
+
+You can use the spread operator `...` to reuse a named expression while overriding some of its fields:
+
+```
+@MyBaseStyle = LabelStyle(FontSize: 24, LetterSpacing: 2);
+
+Label {
+  Style: (...@MyBaseStyle, FontSize: 36);
+}
+```
+
+You can even layer multiple named expressions like so:
+
+```
+@TitleStyle = LabelStyle(FontSize: 24, HorizontalAlignment: Center);
+@SpacedTextStyle = LabelStyle(LetterSpacing: 2);
+
+Label {
+  Style: (...@BigTextStyle, ...@SpacedTextStyle);
+}
+```
+
+#### Document references
+
+A document can reference another document and access its named expressions.
+
+```
+// Document references are defined with $ prefix
+$Common = "../Common.ui";
+
+TextButton {
+  Style: $Common.@DefaultButtonStyle;
+}
+```
+
+### Templates
+
+You can declare a reusable bit of interface as a named expression and then instantiate it as many times as you want in the tree while customizing it.
+
+You can override local named expressions as well as insert additional children at any point in the template tree. However, local named expressions must be defined at the very top of the block, before properties and child elements.
+
+```
+// This is the template
+@Row = Group {
+  Anchor: (Height: 50);
+  Label #Label { Anchor: (Left: 0, Width: 100); Text: @LabelText; }
+  Group #Content { Anchor: (Left: 100); }
+};
+
+// Here we'll be using it twice in the document tree
+Group #Rows {
+  LayoutMode: TopScrolling;
+
+  @Row #MyFirstRow {
+    @LabelText = "First row";
+    #Content { TextInput {} }
+  }
+
+  @Row #MySecondRow {
+    @LabelText = "Second row";
+  }
+}
+```
+
+### Property Types
+
+#### Basic Types
+
+- **Boolean**
+  - `Visible: false;`
+  - `Visible: true;`
+- **Int**
+  - `Height: 20;`
+- **Float, Double, Decimal**
+  - `Min: 0.2;`
+- **String**
+  - `Text: "Hi!";`
+- **Char**
+  - `PasswordChar: "*";`
+  - _Note: The syntax is the same as a string, however a value of this type cannot contain more than one character!_
+- **Color**
+  - `Background: #ffffff;`&#x20;
+- **Objects**
+  - `Style: (Background: #ffffff)`
+- **Array**&#x20;
+  - `TextSpans: [(Text: "Hi", IsBold: true)]`
+
+#### Translations
+
+Translation keys can be referenced anywhere in markup where you can provide a string, and they are then converted to a string when an element gets instantiated.
+
+**Example:**
+
+```
+Label {
+  Text: %ui.general.cancel;
+}
+```
+
+#### Colors
+
+A color literal can be written as follows:
+
+- `#rrggbb`: 6-digit hexadecimal representation for red, green, blue (fully opaque)
+- `#rrggbb(a.a)`: 6-digit hexadecimal representation for red, green, blue with alpha between 0 and 1
+- `#rrggbbaa`: 8-digit hexadecimal representation for red, green, blue and alpha
+
+```
+Group {
+  Background: #000000(0.3);
+}
+```
+
+<Callout>
+  The `#rrggbb(a.a)` format is prefered over the `#rrggbbaa` format for
+  readability reasons.
+</Callout>
+
+#### Font Name
+
+Font names can be referenced directly by their string ID. Internally this is using a custom type called `UIFontName`, however strings will be converted automatically to this type in markup.
+
+```
+Label {
+  Text: "Hi";
+  Style: (FontName: "Secondary");
+}
+```
+
+**Available Font Names**
+
+- _Default_ - This is the default font that is used for most text and is always used unless a different option has been specified
+- _Secondary_ - This font is mostly used for headlines or elements that are supposed to stick out
+- _Mono_ - This is only used for development; For things such as profiling or error overlays.
+
+#### Path
+
+We can reference other UI assets with the `UIPath` type. Similar to `UIFontName`_,_ Strings are automatically converted to a `UIPath`. Paths are always relative to the file where they have been declared in. Looking up _MyButton.png_ in _Menu/MyAwesomeMenu.ui_ will result in _Menu/MyButton.png_. If you want to reference a file that is in a parent folder you can go back one directory by writing two dots (_../MyButton.png_).
+
+The markup syntax of a `UIPath` is the same as a String. (e.g. `Path: "Test.png"`)
+
+Here are some more examples:
+
+| UIPath             | .ui File                              | Resulting Path    |
+| ------------------ | ------------------------------------- | ----------------- |
+| MyButton.png       | Menu/MyAwesomeMenu.ui                 | Menu/MyButton.png |
+| ../MyButton.png    | Menu/MyAwesomeMenu.ui                 | MyButton.png      |
+| ../../MyButton.png | Menu/Popup/Templates/MyAwesomeMenu.ui | Menu/MyButton.png |
+
+#### Objects
+
+Objects contain a set of properties. In this example we are assigning an Anchor object to the _Anchor_ property:
+
+```
+Group {
+  Anchor: (
+   Height: 10,
+   Width: 20
+ );
+}
+```
+
+You can find all objects that can be used in markup [here](type-documentation#elements).
+
+## Visual Studio Code Extension
+
+There is an official extension for Visual Studio Code which adds syntax highlighting for .ui files. You can find it [here](https://marketplace.visualstudio.com/items?itemName=HypixelStudiosCanadaInc.vscode-hytaleui).
diff --git a/content/docs/af-ZA/official-documentation/custom-ui/type-documentation/index.mdx b/content/docs/af-ZA/official-documentation/custom-ui/type-documentation/index.mdx
new file mode 100644
index 00000000..69cea406
--- /dev/null
+++ b/content/docs/af-ZA/official-documentation/custom-ui/type-documentation/index.mdx
@@ -0,0 +1,127 @@
+---
+title: Type Documentation
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# Type Documentation
+
+This is a generated list of UI elements accessible by markup. More information about the User Interface framework can be found in the main documentation.
+
+## Elements
+
+- [ActionButton](type-documentation/elements/actionbutton)
+- [AssetImage](type-documentation/elements/assetimage)
+- [BackButton](type-documentation/elements/backbutton)
+- [BlockSelector](type-documentation/elements/blockselector)
+- [Button](type-documentation/elements/button)
+- [CharacterPreviewComponent](type-documentation/elements/characterpreviewcomponent)
+- [CheckBox](type-documentation/elements/checkbox)
+- [CheckBoxContainer](type-documentation/elements/checkboxcontainer)
+- [CircularProgressBar](type-documentation/elements/circularprogressbar)
+- [CodeEditor](type-documentation/elements/codeeditor)
+- [ColorOptionGrid](type-documentation/elements/coloroptiongrid)
+- [ColorPicker](type-documentation/lements/colorpicker)
+- [ColorPickerDropdownBox](type-documentation/elements/colorpickerdropdownbox)
+- [CompactTextField](type-documentation/elements/compacttextfield)
+- [DropdownBox](type-documentation/elements/dropdownbox)
+- [DropdownEntry](type-documentation/elements/dropdownentry)
+- [DynamicPane](type-documentation/elements/dynamicpane)
+- [DynamicPaneContainer](type-documentation/elements/dynamicpanecontainer)
+- [FloatSlider](type-documentation/elements/floatslider)
+- [FloatSliderNumberField](type-documentation/elements/floatslidernumberfield)
+- [Group](type-documentation/elements/group)
+- [HotkeyLabel](type-documentation/elements/hotkeylabel)
+- [ItemGrid](type-documentation/elements/itemgrid)
+- [ItemIcon](type-documentation/elements/itemicon)
+- [ItemPreviewComponent](type-documentation/elements/itempreviewcomponent)
+- [ItemSlot](type-documentation/elements/itemslot)
+- [ItemSlotButton](type-documentation/elements/itemslotbutton)
+- [Label](type-documentation/elements/label)
+- [LabeledCheckBox](type-documentation/elements/labeledcheckbox)
+- [MenuItem](type-documentation/elements/menuitem)
+- [MultilineTextField](type-documentation/elements/multilinetextfield)
+- [NumberField](type-documentation/elements/numberfield)
+- [Panel](type-documentation/elements/panel)
+- [ProgressBar](type-documentation/elements/progressbar)
+- [ReorderableList](type-documentation/elements/reorderablelist)
+- [ReorderableListGrip](type-documentation/elements/reorderablelistgrip)
+- [SceneBlur](type-documentation/elements/sceneblur)
+- [Slider](type-documentation/elements/slider)
+- [SliderNumberField](type-documentation/elements/slidernumberfield)
+- [Sprite](type-documentation/elements/sprite)
+- [TabButton](type-documentation/elements/tabbutton)
+- [TabNavigation](type-documentation/elements/tabnavigation)
+- [TextButton](type-documentation/elements/textbutton)
+- [TextField](type-documentation/elements/textfield)
+- [TimerLabel](type-documentation/elements/timerlabel)
+- [ToggleButton](type-documentation/elements/togglebutton)
+
+## Property Types
+
+- [Anchor](type-documentation/property-types/anchor)
+- [BlockSelectorStyle](type-documentation/property-types/blockselectorstyle)
+- [ButtonSounds](type-documentation/property-types/buttonsounds)
+- [ButtonStyle](type-documentation/property-types/buttonstyle)
+- [ButtonStyleState](type-documentation/property-types/buttonstylestate)
+- [CheckBoxStyle](type-documentation/property-types/checkboxstyle)
+- [CheckBoxStyleState](type-documentation/property-types/checkboxstylestate)
+- [ClientItemStack](type-documentation/property-types/clientitemstack)
+- [ColorOptionGridStyle](type-documentation/property-types/coloroptiongridstyle)
+- [ColorPickerDropdownBoxStateBackground](type-documentation/property-types/colorpickerdropdownboxstatebackground)
+- [ColorPickerDropdownBoxStyle](type-documentation/property-types/colorpickerdropdownboxstyle)
+- [ColorPickerStyle](type-documentation/property-types/colorpickerstyle)
+- [DropdownBoxSearchInputStyle](type-documentation/property-types/dropdownboxsearchinputstyle)
+- [DropdownBoxSounds](type-documentation/property-types/dropdownboxsounds)
+- [DropdownBoxStyle](type-documentation/property-types/dropdownboxstyle)
+- [InputFieldButtonStyle](type-documentation/property-types/inputfieldbuttonstyle)
+- [InputFieldDecorationStyle](type-documentation/property-types/inputfielddecorationstyle)
+- [InputFieldDecorationStyleState](type-documentation/property-types/inputfielddecorationstylestate)
+- [InputFieldIcon](type-documentation/property-types/inputfieldicon)
+- [InputFieldStyle](type-documentation/property-types/inputfieldstyle)
+- [ItemGridSlot](type-documentation/property-types/itemgridslot)
+- [ItemGridStyle](type-documentation/property-types/itemgridstyle)
+- [LabeledCheckBoxStyle](type-documentation/property-types/labeledcheckboxstyle)
+- [LabeledCheckBoxStyleState](type-documentation/property-types/labeledcheckboxstylestate)
+- [LabelSpan](type-documentation/property-types/labelspan)
+- [LabelStyle](type-documentation/property-types/labelstyle)
+- [NumberFieldFormat](type-documentation/property-types/numberfieldformat)
+- [Padding](type-documentation/property-types/padding)
+- [PatchStyle](type-documentation/property-types/patchstyle)
+- [PopupStyle](type-documentation/property-types/popupstyle)
+- [ScrollbarStyle](type-documentation/property-types/scrollbarstyle)
+- [SliderStyle](type-documentation/property-types/sliderstyle)
+- [SoundStyle](type-documentation/property-types/soundstyle)
+- [SpriteFrame](type-documentation/property-types/spriteframe)
+- [SubMenuItemStyle](type-documentation/property-types/submenuitemstyle)
+- [SubMenuItemStyleState](type-documentation/property-types/submenuitemstylestate)
+- [Tab](type-documentation/property-types/tab)
+- [TabNavigationStyle](type-documentation/property-types/tabnavigationstyle)
+- [TabStyle](type-documentation/property-types/tabstyle)
+- [TabStyleState](type-documentation/property-types/tabstylestate)
+- [TextButtonStyle](type-documentation/property-types/textbuttonstyle)
+- [TextButtonStyleState](type-documentation/property-types/textbuttonstylestate)
+- [TextTooltipStyle](type-documentation/property-types/texttooltipstyle)
+- [ToggleButtonStyle](type-documentation/property-types/togglebuttonstyle)
+- [ToggleButtonStyleState](type-documentation/property-types/togglebuttonstylestate)
+
+## Enums
+
+- [ActionButtonAlignment](type-documentation/enums/actionbuttonalignment)
+- [CodeEditorLanguage](type-documentation/enums/codeeditorlanguage)
+- [ColorFormat](type-documentation/enums/colorformat)
+- [DropdownBoxAlign](type-documentation/enums/dropdownboxalign)
+- [InputFieldButtonSide](type-documentation/enums/inputfieldbuttonside)
+- [InputFieldIconSide](type-documentation/enums/inputfieldiconside)
+- [ItemGridInfoDisplayMode](type-documentation/enums/itemgridinfodisplaymode)
+- [LabelAlignment](type-documentation/enums/labelalignment)
+- [LayoutMode](type-documentation/enums/layoutmode)
+- [MouseWheelScrollBehaviourType](type-documentation/enums/mousewheelscrollbehaviourtype)
+- [ProgressBarAlignment](type-documentation/enums/progressbaralignment)
+- [ProgressBarDirection](type-documentation/enums/progressbardirection)
+- [ResizeType](type-documentation/enums/resizetype)
+- [TimerDirection](type-documentation/enums/timerdirection)
+- [TooltipAlignment](type-documentation/enums/tooltipalignment)
diff --git a/content/docs/af-ZA/official-documentation/npc/2-getting-started-with-templates.mdx b/content/docs/af-ZA/official-documentation/npc/2-getting-started-with-templates.mdx
index 91081ca1..99d078e0 100644
--- a/content/docs/af-ZA/official-documentation/npc/2-getting-started-with-templates.mdx
+++ b/content/docs/af-ZA/official-documentation/npc/2-getting-started-with-templates.mdx
@@ -9,7 +9,7 @@ authors:
 
 There are no hard and fast rules for making a start on a template. I like to duplicate **BlankTemplate** and start from there because it already provides the basic structure of the file.
 
-This leaves me with the following template (`Template_Goblin_Ogre.json`): (note: the file could be looking different in the current version of the game)
+This leaves me with the following template (`Template_Goblin_Ogre.json`): (**note: the file could be looking different in the current version of the game**)
 
 ```json
 {
@@ -33,7 +33,7 @@ This leaves me with the following template (`Template_Goblin_Ogre.json`): (note:
     }
   },
   "Appearance": { "Compute": "Appearance" },
-  "DropList": { "Compute": "Droplist" },
+  "DropList": { "Compute": "DropList" },
   "MaxHealth": { "Compute": "MaxHealth" },
   "MotionControllerList": [
     {
@@ -65,10 +65,10 @@ And the following variant (`Goblin_Ogre.json`) next to the template. There's a t
   "Type": "Variant",
   "Reference": "Template_Goblin_Ogre",
   "Modify": {
-    "Appearance": "Goblin_Ogre",
+    "Appearance": "Goblin",
     "MaxHealth": 124
   }
 }
 ```
 
-Our artists have defined the `Goblin_Ogre` appearance already so I'm going to use that.
+Our artists have not yet finished animations for the `Goblin_Ogre`, for that sake of the tutorial I am going to use appearance `Goblin`, because it offers a more complete set of animations that we will need.
diff --git a/content/docs/af-ZA/official-documentation/worldgen/pack-tutorial/asset-packs.mdx b/content/docs/af-ZA/official-documentation/worldgen/pack-tutorial/asset-packs.mdx
index 38809fad..dcf1f3b9 100644
--- a/content/docs/af-ZA/official-documentation/worldgen/pack-tutorial/asset-packs.mdx
+++ b/content/docs/af-ZA/official-documentation/worldgen/pack-tutorial/asset-packs.mdx
@@ -9,13 +9,13 @@ authors:
 
 <OfficialDocumentationNotice />
 
-# How to modify Hytale
+# How to modify Hytale?
 
-## What's an Asset Pack
+## What's an Asset Pack?
 
-Hytales gameplay is driven by assets in the game that can be modified by creators. Asset Packs are our solution to let you override or add features to the base game with your own work. These can in the form of zip files of folders, which contain a custom set of assets. This is not the only way for a creator to change Hytale but this is the most accessible form.;
+Hytales gameplay is driven by assets in the game that can be modified by creators. Asset Packs are our solution to let you override or add features to the base game with your own work. These can be the form of zip files of folders, which contain a custom set of assets. This is not the only way for a creator to change Hytale but this is the most accessible form.;
 
-### How do I make an Asset Pack
+### How do I make an Asset Pack?
 
 <video controls className="my-6 aspect-video w-full rounded-lg border">
   <source src="https://cdn.internal.hytalemodding.dev/guides/official/how-to-asset-pack.mp4" type="video/mp4" />
@@ -48,7 +48,7 @@ An asset pack is typically a zip or folder, with a `manifest.json` inside. This
 }
 ```
 
-### Where are they stored
+### Where are they stored?
 
 Asset Packs are stored with other mods in the Mods folder.
 
@@ -76,7 +76,7 @@ C:\Users\<user>\AppData\Roaming\Hytale\UserData\Saves\New World 5\mods
 
 When you have Asset Packs or Mods installed, these will appear in the New World menu under the Options menu.;
 
-### How do I change an existing asset
+### How do I change an existing asset?
 
 <video controls className="my-6 aspect-video w-full rounded-lg border">
   <source src="https://cdn.internal.hytalemodding.dev/guides/official/how-to-asset.mp4" type="video/mp4" />
diff --git a/content/docs/af-ZA/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx b/content/docs/af-ZA/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx
index 44528376..24e628b5 100644
--- a/content/docs/af-ZA/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx
+++ b/content/docs/af-ZA/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx
@@ -106,7 +106,7 @@ If a BaseHeight is provided, the TopY and BottomY values are relative to the Bas
 
 Applies a Material Provider slot on a set of horizontal stripes of blocks of varying thickness and position. Below is an example image of basalt stripes into a stone cliff.
 
-{/* ![](https://540086904-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F7KAmBkOg6d13nZCkf9ku%2Fuploads%2FbcxO9LpArn8gPCaBwFg5%2Funknown.png?alt=media&token=1c72b67a-8253-4d03-8c64-1ad5f6830050) */}
+![Example of basalt stripes](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/basalt-stripes-example.png)
 
 #### Parameters:
 
diff --git a/content/docs/af-ZA/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx b/content/docs/af-ZA/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx
index 5e34acd4..a4418473 100644
--- a/content/docs/af-ZA/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx
+++ b/content/docs/af-ZA/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx
@@ -294,7 +294,7 @@ Combines all the positions into a single Positioins field.
 
 ---
 
-### SimpleHoritontal
+### SimpleHorizontal
 
 Keeps only the positions that are within the provided range.
 
diff --git a/content/docs/af-ZA/official-documentation/worldgen/worldgen-tutorial/README.mdx b/content/docs/af-ZA/official-documentation/worldgen/worldgen-tutorial/README.mdx
new file mode 100644
index 00000000..5f66d245
--- /dev/null
+++ b/content/docs/af-ZA/official-documentation/worldgen/worldgen-tutorial/README.mdx
@@ -0,0 +1,166 @@
+---
+title: How to edit and create Biomes
+description: Explores where world generation assets can be found and how to edit them.
+---
+
+### Where are the Assets
+
+World generation assets are kept in the HytaleGenerator directory within the assets.
+
+```
+/Server/HytaleGenerator/
+```
+
+<div className="flex flex-row rounded-lg border p-4">
+  <div className="flex-1/2 border-r pr-4">
+    ```
+    /Biomes
+    ```
+
+    Biome assets, with content configurations.
+  </div>
+
+  <div className="flex-1/2 pl-4">
+    ```
+    /WorldStructure
+    ```
+
+    Generator files that define which biomes spawn together.
+  </div>
+</div>
+
+<div className="flex flex-row rounded-lg border p-4">
+  <div className="flex-1/2 border-r pr-4">
+    ```
+    /Density
+    ```
+
+    Density assets that can be referenced by any other assets.
+  </div>
+
+  <div className="flex-1/2 pl-4">
+    ```
+    /Assignments
+    ```
+
+    Prop assets that can be referenced by any Biome assets.
+  </div>
+</div>
+
+***
+
+An example of this structure can be found bellow, packed in an asset pack with the instance configuration.
+
+[https://drive.google.com/file/d/1sIz_CluANIIe3n8vNiOi-4PQdeqCO0qY/view?usp=drive_link](https://drive.google.com/file/d/1sIz_CluANIIe3n8vNiOi-4PQdeqCO0qY/view?usp=drive_link)
+
+<Callout>
+  Ensure you place your asset pack in the correct directory, under Mods.
+</Callout>
+
+### How to visit our worlds
+
+https://drive.google.com/file/d/1BJurxyj-taE-PXWm04bk7Dl6X7ZHTH92/view?usp=sharing
+
+#### Requirements
+
+- You must be an **Operator** in the world.
+  - To do this, run <mark style="color:$danger;">`/op self`</mark>
+- You must be in **Creative mode**.
+  - Press the <mark style="color:$danger;">`O`</mark> key, O for Orange.&#x20;
+
+The generation assets define a set of generators but on their own you cannot visit these. Currently you require an Instance with a generator that will allow you to visit your work.
+
+```
+/Server/Instances/
+```
+
+Instances are separate worlds that players can join using the `/instances` command. Each instance has an `Instance.bson` configuration asset that specifies which generator to use, among other worldly settings.
+
+```json
+{
+  "WorldGen": {
+    "Type": "HytaleGenerator",
+    "WorldStructure": "Basic",
+    "playerSpawn" : {
+      "X" : 123,
+      "Y" : 480,
+      "Z" : 10000,
+      "Pitch" : 0,
+      "Yaw" : 0,
+      "Roll" : 0
+    }
+  }
+}
+```
+
+<Callout>
+  You can create custom instances for different world structures and biomes as you need them.
+</Callout>
+
+### How to edit Biomes
+
+<video>
+  <source src="https://cdn.internal.hytalemodding.dev/guides/official/How-to-edit-Biomes.mp4" type="video/mp4" />
+</video>
+
+We currently use the Hytale Node Editor when editing world generation assets. This can be accessed while in-game from the Content Creation menu when pressing B. The node editor is then found under the asset editor dropdown on the upper left.&#x20;
+
+![Node Editor 1](/assets/official-documentation/worldgen/worldgen-tutorial/biomes/node-editor-1.png)
+
+Once you have the Hytale Node Editor open, through the file menu you can open Biomes by navigating to the Biomes directory and selecting one from your pack.&#x20;
+
+```
+/Server/HytaleGenerator/Biomes/
+```
+
+### Biome Asset Structure
+
+Every Biome has a root Biome node, this node splits into 5 structures. This is covered briefly but more information on each field can be found on the World Generation Concepts page.
+
+![Node Editor 2](/assets/official-documentation/worldgen/worldgen-tutorial/biomes/node-editor-2.png)
+
+<Callout>
+  Each biome is for the most part self contained, meaning it has control over what appears with the biome. The only exception to this are Base Heights.
+</Callout>
+
+<Tabs>
+  <Tab value="Terrain">
+    Mathematical function nodes that calculate the physical shape of the Biome's terrain.
+  </Tab>
+
+  <Tab value="Materials">
+    Logical nodes that determine what materials (blocks) make up a Biome's terrain.
+  </Tab>
+
+  <Tab value="Props">
+    Function nodes that add objects like prefabs and decorations to the terrain.
+  </Tab>
+
+  <Tab value="Environments">
+    Logical nodes that determine the environment asset at a given coordinate within the biome. This asset determines things like weather, NPC spawns, and sounds.
+  </Tab>
+
+  <Tab value="Tints">
+    Logical function nodes that determine a colour code that can be used by certain blocks in the world. Typically this will be grasses and soils.
+  </Tab>
+</Tabs>
+
+### How to preview your work
+
+[https://drive.google.com/file/d/1mNcHn9LhFnWDF0DzWFH6_YllmKAUvUry/view?t=6](https://drive.google.com/file/d/1mNcHn9LhFnWDF0DzWFH6_YllmKAUvUry/view?t=6)
+
+Once you are in an Instance world with the Hytale Generator active you will only be able to see your work by generating new chunks. There are a few ways to do this.
+
+The viewport command selects an area around the Player that will live reload as you make changes to the generator.&#x20;
+
+```
+/viewport --radius 5 
+```
+
+You can also create a new world to show your changes.&#x20;
+
+```
+/instances spawn <instance> 
+```
+
+The last option is to simply fly south, new chunks will generate with the changes made.
diff --git a/content/docs/af-ZA/quick-start.mdx b/content/docs/af-ZA/quick-start.mdx
index 653644f4..249d803a 100644
--- a/content/docs/af-ZA/quick-start.mdx
+++ b/content/docs/af-ZA/quick-start.mdx
@@ -9,3 +9,8 @@ Welcome to the Hytale modding documentation! Here you'll find everything you nee
 * [Setting up your dev environment](./guides/plugin/setting-up-env)
 * [Entity Component System (ECS)](./guides/ecs/entity-component-system)
 * [Publishing your mod](./publishing)
+
+### Useful Links
+
+* [Kaupenjoe's Modding Videos](https://www.youtube.com/@ModdingByKaupenjoe)
+* [TroubleDEV's Modding Videos](https://www.youtube.com/@TroubleDEV)
diff --git a/content/docs/af-ZA/server/argtypes.mdx b/content/docs/af-ZA/server/argtypes.mdx
new file mode 100644
index 00000000..e54a442e
--- /dev/null
+++ b/content/docs/af-ZA/server/argtypes.mdx
@@ -0,0 +1,61 @@
+---
+title: ArgTypes
+description: Available ArgTypes
+icon: List
+full: true
+authors:
+  - name: Valeena
+---
+
+| Name                        | Target Class                           | Description                                                                                                                               |   |
+| :-------------------------- | :------------------------------------- | :---------------------------------------------------------------------------------------------------------------------------------------- | - |
+| Boolean                     | java.lang.Boolean                      | A 'true' or 'false' input                                                                                                                 |   |
+| Integer                     | java.lang.Integer                      | A whole number                                                                                                                            |   |
+| String                      | java.lang.String                       | Words, text, numbers, letters. To input more than one word at a time, you may need to wrap it with double quotes (`"my fancy sentence"`). |   |
+| Float                       | java.lang.Float                        | A floating-pointer number                                                                                                                 |   |
+| Double                      | java.lang.Double                       | A decimal number                                                                                                                          |   |
+| UUID                        | java.util.UUID                         | A UUID (Universally Unique IDentifier)                                                                                                    |   |
+| Player_UUID                 | java.util.UUID                         | A UUID or an online player username                                                                                                       |   |
+| Game_Profile_Lookup_Async   | ProfileServiceClient.PublicGameProfile | A player UUID or username. If not found locally, performs a remote lookup via the Profile Service.                                        |   |
+| Relative_Double_Coord       | Coord                                  | An x, y, or z coordinate as a decimal, optionally relative by specifying a tilde (~) in front of the number                               |   |
+| Relative_Int_Coord          | IntCoord                               | An x, y, or z coordinate as a whole number, optionally relative by specifying a tilde (~) in front of the number                          |   |
+| Relative_Integer            | RelativeInteger                        | A tilde to mark an integer relative to a base                                                                                             |   |
+| Relative_Float              | RelativeFloat                          | A tilde to mark a float relative to a base                                                                                                |   |
+| Player_Ref                  | PlayerRef                              | A UUID or an online player's username                                                                                                     |   |
+| World                       | World                                  | A world folder name                                                                                                                       |   |
+| Model_Asset                 | ModelAsset                             | A reference to an Asset of type Model                                                                                                     |   |
+| Weather_Asset               | Weather                                | A reference to an Asset of type Weather                                                                                                   |   |
+| Interaction_Asset           | Interaction                            | A reference to an Asset of type Interaction                                                                                               |   |
+| Root_Interaction_Asset      | RootInteraction                        | A reference to an Asset of type Root Interaction                                                                                          |   |
+| Effect_Asset                | EntityEffect                           | A refernece to an Asset of type EntityEffect                                                                                              |   |
+| Environment_Asset           | Environment                            | A reference to an Asset of type Environment                                                                                               |   |
+| Item_Asset                  | Item                                   | A reference to an Asset of type Item                                                                                                      |   |
+| Block_Type_Asset            | BlockType                              | A reference to an Asset of type BlockType                                                                                                 |   |
+| Particle_System             | ParticleSystem                         | A reference to an Asset of type ParticleSystem                                                                                            |   |
+| Hitbox_Collision_Config     | HitboxCollisionConfig                  | A reference to an Asset of type HitboxCollisionConfig                                                                                     |   |
+| Repulsion_Config            | RepulsionConfig                        | A reference to an Asset of type RepulsionConfig                                                                                           |   |
+| Sound_Event_Asset           | SoundEvent                             | A reference to an Asset of type SoundEvent                                                                                                |   |
+| Ambiance_Fx_Asset           | AmbianceFX                             | A reference to an Asset of type AmbianceFX                                                                                                |   |
+| Sound_Category              | SoundCategory                          | A sound category (sfx, music, ambient, ui)                                                                                                |   |
+| Entity_ID                   | `ArgWrapper<EntityWrappedArg, UUID>`   | A UUID representing an entity id                                                                                                          |   |
+| Integer_Comparison_Operator | IntegerComparisonOperator              | A mathematical sign for integer comparison                                                                                                |   |
+| Integer_Operation           | IntegerOperation                       | A mathematical sign for performing an operation                                                                                           |   |
+| Int_Range                   | `Pair<Integer, Integer>`               | Two integers representing a minimum and maximum of a range                                                                                |   |
+| Relative_Int_Range          | RelativeIntRange                       | Two integers representing a minimum and maximum of a range                                                                                |   |
+| Vector2I                    | Vector2i                               | Two integers, generally corresponding to x/z axis                                                                                         |   |
+| Vector3I                    | Vector3i                               | Three integers, generally corresponding to x/y/z axis                                                                                     |   |
+| Relative_Vector3I           | RelativeVector3i                       | Three optionally relative integers, generally corresponding to x/y/z axis                                                                 |   |
+| Relative_Block_Position     | RelativeIntPosition                    | A position with three integer coordinates, representing a block's location in world space.                                                |   |
+| Relative_Position           | Relative                               | A position with three decimal coordinates, representing a location in world space.                                                        |   |
+| Relative_Chunk_Position     | RealtiveChunkPosition                  | A position with two integer coordinates (x, z), representing a chunk's location.                                                          |   |
+| Rotation                    | Vector3f                               | A rotation with three coordinates, representing the pitch, yaw, and roll respectively                                                     |   |
+| Block_Type_Key              | String                                 | A block type                                                                                                                              |   |
+| Block_ID                    | Integer                                | A block type, converted to an int id                                                                                                      |   |
+| Color                       | Integer                                | A color value in hex format, hex integer, or decimal integer                                                                              |   |
+| Weighted_Block_Type         | `Pair<Integer, String>`                | A weight corresponding to a blocktype                                                                                                     |   |
+| Weighted_Block_Entry        | String                                 | A block with optional weight prefix                                                                                                       |   |
+| Block_Pattern               | BlockPattern                           | A list of blocks with optional weights                                                                                                    |   |
+| Individual_Block_Mask       | BlockMask                              | Create a block mask using symbols and block names                                                                                         |   |
+| Block_Mask                  | BlockMask                              | A tick rate value (e.g., 30tps, 33ms, or 30)                                                                                              |   |
+| Tick_Rate                   | Integer                                | A list of block masks that combine together                                                                                               |   |
+| Game_Mode                   | GameMode                               | GameMode                                                                                                                                  |   |
diff --git a/content/docs/af-ZA/server/interaction-reference.mdx b/content/docs/af-ZA/server/interaction-reference.mdx
new file mode 100644
index 00000000..6c0d01b3
--- /dev/null
+++ b/content/docs/af-ZA/server/interaction-reference.mdx
@@ -0,0 +1,1586 @@
+---
+title: Interactions
+description: A list of most Interaction types provided by Hypixel, along with the meaning of their fields, and how they fit together.
+icon: List
+authors:
+  - name: Stephen Baynham
+    url: https://github.com/cannibalvox
+---
+
+### The Interaction Base Type
+
+All interactions of every type below are inherited from Interaction and have these fields.
+
+**Interaction Fields**
+
+| Field Name                | Type                                                                 | Required? | Notes                                                                                                                                                                                                                       |
+| ------------------------- | -------------------------------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| ViewDistance              | `Double`<br />(Default: 96.0)                                        | **No**    | Distance in blocks at which other players can see the effects from this interaction.                                                                                                                                        |
+| Effects                   | `InteractionEffects`                                                 | **No**    | Sound, animations, and particle effects that should trigger when this interaction begins executing.                                                                                                                         |
+| HorizontalSpeedMultiplier | `Float`<br />(Default: 1.0)                                          | **No**    | Multiplier applied to the User entity's movement speed while this interaction is executing                                                                                                                                  |
+| RunTime                   | `Float`                                                              | **No**    | If provided, this interaction will continue executing for at least this long before the interaction chain moves onto the next interaction.                                                                                  |
+| CancelOnItemChange        | `Boolean`<br />(Default: true)                                       | **No**    | If true, this interaction will be cancelled if the User entity's held item changes during execution. This can happen either due to the selected hotbar slot changing or the contents of the item's inventory slot changing. |
+| Rules                     | `InteractionRules`                                                   | **Yes**   | If provided, adds additional limitations and cancellation conditions to this interaction.                                                                                                                                   |
+| Settings                  | `Map`<br />(Key Type: `GameMode`, Value Type: `InteractionSettings`) | **No**    | If provided, adds additional per-GameMode settings to the interaction.                                                                                                                                                      |
+| Camera                    | `InteractionCameraSettings`                                          | **No**    | Arrays of camera motion keyframes for cutscenes and reveals.                                                                                                                                                                |
+
+**GameMode Values**
+
+- `Creative`: The game is currently in Creative Mode
+- `Adventure`: The game is currently in Adventure Mode
+
+**InteractionEffects Fields**
+
+| Field Name               | Type                                              | Required? | Notes                                                                                                                                                 |
+| ------------------------ | ------------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Particles                | `Array`<br />(Element Type: `ModelParticle`)      | **No**    | Particle systems to activate when this interaction begins if the player is in third-person mode.                                                      |
+| FirstPersonParticles     | `Array`<br />(Element Type: `ModelParticle`)      | **No**    | Particle systems to activate when this interaction begins if the player is in first-person mode.                                                      |
+| WorldSoundEventId        | `Asset`<br />(Asset Type: `SoundEvent`)           | **No**    | A sound to play in the world at the User entity's location when this interaction begins.<br />**The SoundEvent must be single-channel (mono) sound.** |
+| LocalSoundEventId        | `Asset`<br />(Asset Type: `SoundEvent`)           | **No**    | A 2D sound to play for the User entity when this interaction begins. Ignored if the User entity is not a player.                                      |
+| Trails                   | `Array`<br />(Element Type: `ModelTrail`)         | **No**    | Trail effects to activate on the User entity when this interaction begins.                                                                            |
+| WaitForAnimationToFinish | `Boolean`<br />(Default: false)                   | **No**    | If true, this interaction will continue executing for at least the length of any animations in this InteractionEffects object.                        |
+| ItemPlayerAnimationsId   | `Asset`<br />(Asset Type: `ItemPlayerAnimations`) | **No**    | If provided, the User entity will use this ItemPlayerAnimations set while this interaction is executing.                                              |
+| ItemAnimationId          | `String`                                          | **No**    | Id of an animation to trigger when this interaction begins executing.<br />**This animation id is not validated on server start.**                    |
+| ClearAnimationOnFinish   | `Boolean`<br />(Default: false)                   | **No**    | If true, animations triggered by this interaction will be halted when the interaction completes.                                                      |
+| ClearSoundEventOnFinish  | `Boolean`<br />(Default: false)                   | **No**    | If true, sounds triggered by this interaction will be halted when the interaction completes.                                                          |
+| CameraEffect             | `Asset`<br />(Asset Type: `CameraEffect` )        | **No**    | If provided, the CameraEffect will be applied while this interaction is executing.                                                                    |
+| MovementEffects          | `MovementEffects`                                 | **No**    | If provided, apply the movement effects to the User entity while this interaction is executing.                                                       |
+| StartDelay               | `Float`<br />(Default: 0.0f)                      | **No**    | The interaction will wait this many seconds before triggering the effects in this object.                                                             |
+
+**InteractionRules Fields**
+
+| Field Name          | Type                                                                                                | Required? | Notes                                                                                                                                                                                                                                     |
+| ------------------- | --------------------------------------------------------------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| BlockedBy           | `Array`<br />(Element Type: `InteractionType`)<br />(Default: Based on the chain's InteractionType) | **No**    | If provided, this RootInteraction cannot be executed while interaction chains of the provided types are executing.<br />**This field only functions for rules attached to a RootInteraction. It has no effect on an Interaction.**        |
+| Blocking            | `Array`<br />(Element Type: `InteractionType`)                                                      | **No**    | If provided, interaction chains with the specified InteractionTypes cannot be executed while this interaction is executing.                                                                                                               |
+| InterruptedBy       | `Array`<br />(Element Type: `InteractionType`)                                                      | **No**    | If provided, interaction chains with the specified InteractionTypes will cancel this interaction chain when they execute.<br />**This field only functions for rules attached to a RootInteraction. It has no effect on an Interaction.** |
+| Interrupting        | `Array`<br />(Element Type: `InteractionType`)                                                      | **No**    | If provided, interaction chains with the specified InteractionTypes will be canceled when this interaction begins.                                                                                                                        |
+| BlockedByBypass     | `String`                                                                                            | **No**    | If provided, this RootInteraction cannot be blocked by interaction chains whose RootInteraction has this value as an asset tag.                                                                                                           |
+| BlockingBypass      | `String`                                                                                            | **No**    | If provided, this interaction will not block RootInteractions that have the this value as an asset tag.                                                                                                                                   |
+| InterruptedByBypass | `String`                                                                                            | **No**    | If provided, this RootInteraction cannot be canceled by RootInteractions that have this value as an asset tag.                                                                                                                            |
+| InterruptingBypass  | `String`                                                                                            | **No**    | If provided, this interaction will not cancel interaction chains whose RootInteraction has this value as an asset tag.                                                                                                                    |
+
+**InteractionType Values**
+
+- `Primary`
+- `Secondary`
+- `Ability1`
+- `Ability2`
+- `Ability3`
+- `Use`
+- `Pick`
+- `Pickup`
+- `CollisionEnter`
+- `CollisionLeave`
+- `Collision`
+- `EntityStatEffect`
+- `SwapTo`
+- `SwapFrom`
+- `Death`
+- `Wielding`
+- `ProjectileSpawn`
+- `ProjectileHit`
+- `ProjectileMiss`
+- `ProjectileBounce`
+- `Held`
+- `HeldOffhand`
+- `Equipped`
+- `Dodge`
+- `GameModeSwap`
+
+**InteractionSettings Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                        |
+| ---------------- | ------------------------------- | --------- | -------------------------------------------------------------------------------------------- |
+| AllowSkipOnClick | `Boolean`<br />(Default: false) | **No**    | If true, the user will be able to skip this interaction by clicking shortly after it starts. |
+
+**InteractionCameraSettings Fields**
+
+| Field Name  | Type                                             | Required? | Notes                                                                                                                                                           |
+| ----------- | ------------------------------------------------ | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| FirstPerson | `Array`<br />(Element Type: `InteractionCamera`) | **No**    | A list of camera keyframes to be played if the player is in first-person.<br />**The time of each keyframe must be after the keyframe before it in the array.** |
+| ThirdPerson | `Array`<br />(Element Type: `InteractionCamera`) | **No**    | A list of camera keyframes to be played if the player is in third-person.<br />**The time of each keyframe must be after the keyframe before it in the array.** |
+
+**InteractionCamera Fields**
+
+| Field Name | Type                         | Required? | Notes                                                                                                                                       |
+| ---------- | ---------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------- |
+| Time       | `Float`<br />(Default: 0.1f) | **No**    | How long after the interaction begins executing that the camera should arrive at this keyframe.<br />**Cannot be less than or equal to 0.** |
+| Position   | `Vector3`                    | **Yes**   | Where the camera should be located when it arrives at this keyframe.                                                                        |
+| Rotation   | `Direction`                  | **Yes**   | Where the camera should be pointing when it arrives at this keyframe.                                                                       |
+
+### SimpleInteraction
+
+Most interaction types below are inherited from SimpleInteraction and have these
+fields.  If a type does not have these fields, the documentation will mention it.
+
+The purpose of SimpleInteraction is to facilitate Interaction chaining by taking different paths
+based on whether the Interaction succeeded or failed.  The circumstances under which
+a given Interaction fails are generally type-specific (and described in the documentation
+below), but all interactions will be marked failed if they are cancelled via one of the
+many, many mechanisms for doing so.
+
+It is valid to create an interaction asset of type "Simple", which can be valuable when you want to use the
+interaction fields with no additional functionality.
+
+**SimpleInteraction Fields**
+
+| Field Name | Type                                     | Required? | Notes                                                                                          |
+| ---------- | ---------------------------------------- | --------- | ---------------------------------------------------------------------------------------------- |
+| Next       | `Asset`<br />(Asset Type: `Interaction`) | **No**    | After this Interaction has finished, "Next" will be executed if this Interaction did not fail. |
+| Failed     | `Asset`<br />(Asset Type: `Interaction`) | **No**    | After this Interaction has finished, "Failed" will be executed if this Interaction failed.     |
+
+## Flow Control
+
+These are interaction types used to control the flow of an interaction chain and allow interactions
+to be composed into more complex behaviors.  These interaction types generally do not pertain to
+the game and instead pertain to the interaction system itself.
+
+### Condition
+
+This interaction will fail if one of the fields is provided but does not match the current state.
+
+**Condition Fields**
+
+| Field Name       | Type       | Required? | Notes                                                                                                                                                                                    |
+| ---------------- | ---------- | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| RequiredGameMode | `GameMode` | **No**    | If provided, the interaction will fail if the current GameMode does not match the provided value.                                                                                        |
+| Jumping          | `Boolean`  | **No**    | If provided, the interaction will fail if the player's Jumping state does not match the provided value. (i.e. if True, the player must be jumping, if False, the player must not be)     |
+| Swimming         | `Boolean`  | **No**    | If provided, the interaction will fail if the player's Swimming state does not match the provided value. (i.e. if True, the player must be swimming, if False, the player must not be)   |
+| Crouching        | `Boolean`  | **No**    | If provided, the interaction will fail if the player's Crouching state does not match the provided value. (i.e. if True, the player must be crouching, if False, the player must not be) |
+| Running          | `Boolean`  | **No**    | If provided, the interaction will fail if the player's Running state does not match the provided value. (i.e. if True, the player must be running, if False, the player must not be)     |
+| Flying           | `Boolean`  | **No**    | If provided, the interaction will fail if the player's Flying state does not match the provided value. (i.e. if True, the player must be flying, if False, the player must not be)       |
+
+**GameMode Values**
+
+- `Creative`: The game is currently in Creative Mode
+- `Adventure`: The game is currently in Adventure Mode
+
+### FirstClick
+
+This interaction does not inherit from SimpleInteraction and therefore has no Next or Failed fields.
+
+This interaction has two fields that each contain a reference to an Interaction: Click and Hold.  If the root interaction
+of the chain was initiated by a client button/key press (or simulated NPC input) and the input was a tap, then
+the Click interaction is run. if it was a longer press, then the Hold interaction is run.
+
+As a minor implementation detail, this interaction is internally marked as failed when the Hold path is followed.
+This generally shouldn't matter.  If the interaction was not initiated by a key press at all, the Click path will be followed,
+but it seems risky to rely on that behavior.
+
+**FirstClick Fields**
+
+| Field Name | Type                                     | Required? | Notes                                                                                                                                                    |
+| ---------- | ---------------------------------------- | --------- | -------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Click      | `Asset`<br />(Asset Type: `Interaction`) | **No**    | If provided and the root interaction of the chain was initiated by button/key press, this interaction is executed next if the press was a quick tap.     |
+| Hold       | `Asset`<br />(Asset Type: `Interaction`) | **No**    | If provided and the root interaction of the chain was initiated by a button/key press, this interaction is executed next if the press was a longer hold. |
+
+### Interrupt
+
+This interaction can be used to cancel one or more running interaction chains on an entity and **all forked interaction
+chains those chains have spawned that are still currently running**.  All interaction chains canceled in this manner will be marked as
+Failed, which may have additional implications if the canceled chains are themselves forked from
+other chains that are still running.
+
+**Interrupt Fields**
+
+| Field Name     | Type                                           | Required? | Notes                                                                                                                                                                                               |
+| -------------- | ---------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Entity         | `InteractionTarget`<br />(Default: User)       | **Yes**   | The entity that is the owner of the target interaction chains.  This field can indicate the Owner, User, or Target of this interaction chain.                                                       |
+| InterruptTypes | `Array`<br />(Element Type: `InteractionType`) | **No**    | A set of InteractionTypes that are to be interrupted. Only interactions of these types are affected. If null, all types will be interrupted.<br />**(Note: An empty set will interrupt NO TYPES.)** |
+| RequiredTag    | `String`                                       | **No**    | An asset tag that, if provided, the RootInteraction of the interaction chain must have in order to be canceled.                                                                                     |
+| ExcludedTag    | `String`                                       | **No**    | An asset tag that, if provided, the RootInteraction of the interaction chain must not have in order to be canceled.                                                                                 |
+
+**InteractionTarget Values**
+
+- `User` - The user of this interaction chain. The entity whose actions caused this interaction chain to be executed. This is usually the same as the Owner.
+- `Owner` - The owner of this interaction chain. The entity upon whom this interaction chain is executing.
+- `Target` - The entity target of this interaction chain, if any.  This value is mutable (and can therefore come from many places) but most commonly, it is an entity the User was targeting when this interaction chain began executing.
+
+**InteractionType Values**
+
+- `Primary`
+- `Secondary`
+- `Ability1`
+- `Ability2`
+- `Ability3`
+- `Use`
+- `Pick`
+- `Pickup`
+- `CollisionEnter`
+- `CollisionLeave`
+- `Collision`
+- `EntityStatEffect`
+- `SwapTo`
+- `SwapFrom`
+- `Death`
+- `Wielding`
+- `ProjectileSpawn`
+- `ProjectileHit`
+- `ProjectileMiss`
+- `ProjectileBounce`
+- `Held`
+- `HeldOffhand`
+- `Equipped`
+- `Dodge`
+- `GameModeSwap`
+
+### Parallel
+
+This interaction does not inherit from SimpleInteraction and therefore has no Next or Failed fields.
+
+This interaction has a field `Interactions` that is an array of RootInteraction assets. The list must contain at least
+two RootInteractions.  This interaction will fork all of its children except for the first into their
+own interaction chains and immediately complete. After this interaction completes, this interaction chain will
+execute the first RootInteraction in the `Interactions` list.
+
+This interaction does not have any failure conditions and is indifferent to the fate of the forked interaction chains.
+
+**Parallel Fields**
+
+| Field Name   | Type                                                | Required? | Notes                                                         |
+| ------------ | --------------------------------------------------- | --------- | ------------------------------------------------------------- |
+| Interactions | `AssetArray`<br />(Element Type: `RootInteraction`) | **Yes**   | An array of RootInteractions that will be forked or executed. |
+
+### Repeat
+
+This interaction has a field `ForkInteractions` that is an asset of type RootInteraction. This interaction will fork that
+RootInteraction into its own interaction chain and then wait for it to complete. If the RootInteraction fails, this
+interaction will complete immediately and be marked failed. Otherwise, the RootInteraction will be forked and run again,
+up to a specified total number of times.
+
+**Repeat Fields**
+
+| Field Name       | Type                                                                                   | Required? | Notes                                                                                                                                                                                                              |
+| ---------------- | -------------------------------------------------------------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| ForkInteractions | `Asset`<br />(Asset Type: `RootInteraction`)                                           | **Yes**   | A RootInteraction that will be forked.                                                                                                                                                                             |
+| Repeat           | `Integer`<br />(Default: 1)<br />**Must be -1 or a positive integer. 0 is not valid.** | **No**    | The total number of times to fork ForkInteractions. If -1 is provided, ForkInteractions will continue being forked and executed indefinitely, until this interaction is cancelled or until ForkInteractions fails. |
+
+### Replace
+
+This interaction does not inherit from SimpleInteraction and therefore has no Next or Failed fields.
+
+This interaction uses the InteractionVars system that is avaiable for items. InteractionVars are RootInteractions that
+can be attached to an Item asset with a name.
+
+This interaction specifies a var name, and if this interaction chain was executed through
+an item and that item has an InteractionVar of the same name, then this interaction will immediately execute
+the RootInteraction on the var.  Otherwise, it will execute the default RootInteraction specified in this interaction.
+If no default is specified, then this interaction will be marked as failed.
+
+**Replace Fields**
+
+| Field Name   | Type                                         | Required? | Notes                                                                                                                                                                                                           |
+| ------------ | -------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Var          | `String`                                     | **Yes**   | The name of the InteractionVar to execute.                                                                                                                                                                      |
+| DefaultValue | `Asset`<br />(Asset Type: `RootInteraction`) | **No**    | The RootInteraction to execute if the owning item does not have an InteractionVar by the specified name. If not provided, the interaction will be marked as failed instead.                                     |
+| DefaultOk    | `Boolean`<br />(Default: false)              | **No**    | If false, then an angry message will be printed to the server logs if the owning item does not have an InteractionVar by the specified name.  The functioning of this interaction will be otherwise unaffected. |
+
+### RunRootInteraction
+
+This interaction immediately executes the provided RootInteraction as part of this interaction chain. This interaction
+does not have any failure conditions.
+
+**RunRootInteraction Fields**
+
+| Field Name      | Type                                         | Required? | Notes                           |
+| --------------- | -------------------------------------------- | --------- | ------------------------------- |
+| RootInteraction | `Asset`<br />(Asset Type: `RootInteraction`) | **Yes**   | The RootInteraction to execute. |
+
+### Selector
+
+This interaction will execute a Selector to find entities and/or blocks (depending on the Selector) and fork off an
+interaction chain for each located entity or block. This interaction will not wait for those interaction chains
+to complete and is indifferent to their fate. The forked interaction chains will use the located entity/block as
+their target entity/target block. Each entity or block will only fork one interaction chain over the life of this
+interaction.  The Selector is guaranteed to run once for each execution of this interaction, but some Selectors
+are intended to be run over a period of time and sweep across an area to locate targets. In order to use those Selectors
+properly, you will need to extend the execution time of this interaction using `RunTime` or `WaitForAnimationToFinish`.
+The Selector will be executed repeatedly over the lifetime of the interaction.
+
+If the Selector is configured to locate entities, you can add additional sets of entity matching rules. If a located entity
+matches one of the rules, the matching RootInteraction will be forked instead of the standard `HitEntity` RootInteraction.
+
+Entities located by the Selector will be ignored if they do not have a NetworkId, if they are dead, or if they are invulnerable.
+The only exception to this rule is that players in Creative Mode that are marked to receive hits will not be ignored.
+
+This interaction's failure conditions are configurable via the `FailOn` field. You can configure this interaction to never
+fail, to fail if the Selector does not locate any blocks before this interaction finishes executing, to fail if the
+Selector does not locate any entities before this interaction finishes executing, or to fail in either case.
+
+**Selector Fields**
+
+| Field Name     | Type                                         | Required? | Notes                                                                                                                                                                                                                                     |
+| -------------- | -------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Selector       | `Selector`                                   | **Yes**   | The Selector is executed at least once and may be executed repeatedly to locate blocks and/or entities in an area.                                                                                                                        |
+| HitEntity      | `Asset`<br />(Asset Type: `RootInteraction`) | **No**    | If included and the `Selector` locates an entity that does not match any `HitEntityRules`, this RootInteraction will be forked into a new interaction chain with the located entity as the target entity.                                 |
+| HitEntityRules | `Array`<br />(Element Type: `HitEntity`)     | **No**    | If included, these rules will be matched against any entity located by the `Selector`. If an entity matches a set of rules, the RootInteraction associated with the rules will be forked instead of the standard `HitEntity` interaction. |
+| HitBlock       | `Asset`<br />(Asset Type: `RootInteraction`) | **No**    | If included and the `Selector` locates a block, this RootInteraction will be forked into a new interaction chain with the located block as the block target.                                                                              |
+| FailOn         | `FailOnType`<br />(Default: `Neither`)       | **No**    | Defines under what circumstances this interaction will fail.  It can be marked to fail when it completes without locating any blocks, it can be marked to fail when it completes without locating any entities, both, or neither.         |
+| IgnoreOwner    | `Boolean`<br />(Default: true)               | **No**    | If true, the Selector will not locate the User entity of this interaction.                                                                                                                                                                |
+
+**HitEntity Fields**
+
+| Field Name | Type                                         | Required? | Notes                                                                                                 |
+| ---------- | -------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------- |
+| Matchers   | `Array`<br />(Element Type: `EntityMatcher`) | **Yes**   | A set of rules that an entity must match. An entity must successful match all rules to be considered. |
+| Next       | `Asset`<br />(Asset Type: `RootInteraction`) | **Yes**   | The RootInteraction to fork if an entity matches all rules.                                           |
+
+**EntityMatcher Fields**
+
+| Field Name | Type                            | Required? | Notes                                                                                                     |
+| ---------- | ------------------------------- | --------- | --------------------------------------------------------------------------------------------------------- |
+| Type       | `String`                        | **Yes**   | If provided, specifies a type of EntityMatcher to use. Each matcher type may come with additional fields. |
+| Invert     | `Boolean`<br />(Default: false) | **No**    | If true, an entity must fail this rule for it to be marked as succeeded.                                  |
+
+**EntityMatcher Type: Player**
+
+This EntityMatcher will succesfully match the entity only if they are a player.
+
+**EntityMatcher Type: Vulnerable**
+
+This Entitymatcher will successfully match the entity only if they are not marked as invulnerable.
+
+**FailOnType Values**
+
+- `Neither`
+- `Entity`
+- `Block`
+- `Either`
+
+### Serial
+
+This interaction does not inherit from SimpleInteraction and therefore has no Next or Failed fields.
+
+This interaction has a field `Interactions` which is a list of Interaction assets. This interaction immediately
+completes and the interaction chain continues by executing the interactions in the list one at a time. This
+interaction does not have any failure conditions.
+
+**Serial Fields**
+
+| Field Name   | Type                                            | Required? | Notes                                      |
+| ------------ | ----------------------------------------------- | --------- | ------------------------------------------ |
+| Interactions | `AssetArray`<br />(Element Type: `Interaction`) | **Yes**   | An array of Interaction assets to execute. |
+
+## Cooldowns
+
+RootInteractions interface with a complex cooldown system that can be used for a variety of purposes. Aside from simply
+adding an important aspect of resource management to your game design, cooldowns can be used to ensure that click-activated
+interaction chains don't repeatedly spam if the player holds down the input.
+
+By default, every RootInteraction has a cooldown timer that is keyed to the RootInteraction name, and by default, it
+will launch a cooldown of 0.35 seconds when activated by client input.  Otherwise, no cooldown will be activated.  However,
+by configuring your RootInteraction, you can change the key for the cooldown (so that multiple RootInteractions can share
+a single cooldown), set the cooldown timer to whatever you like, and configure multiple charges that can build up over time
+to allow the entity to activate the RootInteraction multiple times before being forced to pause.
+
+One important concept to keep in mind is the difference between **cooldown** and **charge time**.  The cooldown, if any,
+is activated each time a RootInteraction triggers, even if the player has more available charges. If the RootInteraction
+is configured to use charges, then they will gradually build up over time. In order for a RootInteraction to be activated,
+the cooldown (if any) must be expired, and the RootInteraction must have at least one charge (if it has been
+configured to use charges).
+
+Bear in mind that the entire Cooldown configuration is shared between different RootInteractions with the same cooldown id.
+If you activate an ability with 5 charges and a short cooldown and then another ability with a much longer cooldown and no
+charges, the second ability will use the cooldown properties of the first ability until/unless the first ability finishes
+charging and is cleared from the system.  You should generally only have multiple RootInteractions share a cooldown id
+if they have the same configuration.
+
+The interactions below interact with the cooldown system to allow you to manipulate cooldowns via the interaction system. By
+using these interactions, you can have several interaction chains with different cooldown configurations share cooldowns
+that are checked and activated as part of the interaction chain itself, or have some components of an interaction change
+use a second cooldown separate from the main one.
+
+### CooldownCondition
+
+**CooldownCondition Fields**
+
+This interaction will fail if the specified cooldown id is on cooldown for the User entity.  This interaction will only
+function for players- the interaction will always succeed for NPCs.  In order for this interaction to succeed, the
+cooldown, if any, must have expired and at least one charge, if any, must have filled.
+
+| Field Name | Type     | Required? | Notes                     |
+| ---------- | -------- | --------- | ------------------------- |
+| Id         | `String` | **Yes**   | The cooldown id to check. |
+
+### IncrementCooldown
+
+**IncrementCooldown Fields**
+
+This interaction will modify a cooldown that is currently active on the User entity, allowing charges and remaining
+cooldown to be modified.
+Despite its name, this interaction can be used to reduce a cooldown as well as increase it. If the cooldown is not
+currently active, this interaction will have no effect. The interaction has no special failure conditions.
+
+| Field Name        | Type                        | Required? | Notes                                                                                                                                                                                                                                                                                     |
+| ----------------- | --------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Id                | `String`                    | **No**    | If provided, the cooldown id of the cooldown to be manipulated. If not provided, the cooldown id of the current chain's RootInteraction will be used.                                                                                                                                     |
+| Time              | `Float`<br />(Default: 0.0) | **No**    | The amount to increase the remaining cooldown by. Can be negative. The remaining cooldown time will not be reduced below zero or increased above the maximum cooldown time.                                                                                                               |
+| ChargeTime        | `Float`<br />(Default: 0.0) | **No**    | The amount to increase the remaining time until the next charge is filled by. Can be negative. The remaining charge time cannot be reduced below zero or increased above the maximum cooldown time. **This will not work on abilities that have a maximum of 1 charge, for some reason.** |
+| Charge            | `Integer`<br />(Default: 0) | **No**    | The amount to increase the number of charges by. Can be negative. The number of charges cannot be reduced below 0 or increased above the maximum.                                                                                                                                         |
+| InterruptRecharge | `Boolean`(Default: false)   | **No**    | If true and `Charge` is not 0, will reset the remaining time to the next charge to the maximum value after changing the charge count.                                                                                                                                                     |
+
+### ResetCooldown
+
+This interaction will trigger a cooldown on the User entity with a specified configuration. The charges will be refilled
+but the cooldown will be immediately triggered.  The mechanisms for deciding on the configuration are a little bit complicated.
+You may specify a cooldown configuration via the `Cooldown` field. If you do not include an `Id` field, then the
+interaction chain's RootInteraction will be used for any field not specified in the configuration. If there is an active
+cooldown under the specified `Id` (or under the RootInteraction's cooldown id if none is specified) then the fields
+from that active cooldown will overwrite data in the RootInteraction's cooldown, but not data in your `Cooldown` field.
+
+**ResetCooldown Fields**
+
+| Field Name | Type                  | Required? | Notes                                                        |
+| ---------- | --------------------- | --------- | ------------------------------------------------------------ |
+| Cooldown   | `InteractionCooldown` | **No**    | A cooldown configuration to use for the new, reset cooldown. |
+
+**InteractionCooldown Fields**
+
+| Field Name        | Type                                 | Required? | Notes                                                                                                                                                                                                 |
+| ----------------- | ------------------------------------ | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Id                | `String`                             | **No**    | The cooldown id to use for this cooldown. If not provided, the RootInteraction's cooldown id will be used, if any.                                                                                    |
+| Cooldown          | `Float`<br />(Default: 0.0)          | **No**    | The duration of the cooldown, in seconds.                                                                                                                                                             |
+| Charges           | `Array`<br />(Element Type: `Float`) | **No**    | If provided, a list of how many charges this cooldown can build, and how long each charge takes to build, in seconds.                                                                                 |
+| InterruptRecharge | `Boolean`<br />(Default: false)      | **No**    | If true, the charge time will be reset when the number of charges changes.                                                                                                                            |
+| ClickBypass       | `Boolean`<br />(Default: false)      | **No**    | If true, RootInteractions keyed to this cooldown can still be activated when it is on cooldown provided that the RootInteraction was triggered by a distinct key or mouse button press on the client. |
+
+### TriggerCooldown
+
+This interaction is similar to ResetCooldown, except instead of refilling the cooldown's charges, one charge will be deducted
+as normal.
+
+**TriggerCooldown Fields**
+
+| Field Name | Type                  | Required? | Notes                                                        |
+| ---------- | --------------------- | --------- | ------------------------------------------------------------ |
+| Cooldown   | `InteractionCooldown` | **No**    | A cooldown configuration to use for the new, reset cooldown. |
+
+**InteractionCooldown Fields**
+
+| Field Name        | Type                                 | Required? | Notes                                                                                                                                                                                                 |
+| ----------------- | ------------------------------------ | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Id                | `String`                             | **No**    | The cooldown id to use for this cooldown. If not provided, the RootInteraction's cooldown id will be used, if any.                                                                                    |
+| Cooldown          | `Float`<br />(Default: 0.0)          | **No**    | The duration of the cooldown, in seconds.                                                                                                                                                             |
+| Charges           | `Array`<br />(Element Type: `Float`) | **No**    | If provided, a list of how many charges this cooldown can build, and how long each charge takes to build, in seconds.                                                                                 |
+| InterruptRecharge | `Boolean`<br />(Default: false)      | **No**    | If true, the charge time will be reset when the number of charges changes.                                                                                                                            |
+| ClickBypass       | `Boolean`<br />(Default: false)      | **No**    | If true, RootInteractions keyed to this cooldown can still be activated when it is on cooldown provided that the RootInteraction was triggered by a distinct key or mouse button press on the client. |
+
+## Combo Chains
+
+Hytale additionally comes with a rich "combo chaining" system, which allows several inputs in a row to result in different
+attacks and special moves.  Rather than being attached to the RootInteraction like the cooldown system, these are
+primarily driven by the `Chaining` interaction.
+
+### Chaining
+
+This interaction does not inherit from SimpleInteraction and therefore has no Failed field. Its Next field works differently
+from most interaction types.
+
+Chaining is a type of flow control interaction- each time a Chaining interaction with the same `ChainId` is called, a single
+interaction in the `Next` list is chosen and the others are ignored. The first time the `ChainId` is used, the first
+interaction in the list is chosen, the next time the second, etc. Once the end of the list is reached, the first
+interaction will be chosen again.
+
+Bear in mind: the progress through the Next list is based on the **ChainId**, not the interaction!  That means that two
+different Chaining interactions can share a single combo chain. You could have a pair of daggers that attacks with
+the left when the left mouse button is clicked and with the right when the right mouse button is clicked.  You could give
+both interaction chains a Chaining interaction with the same `ChainId` and three `Next` entries that do a light-light-heavy
+combo.  Each specific hit would occur with either the left or the right knife based on which button you clicked, but
+the combo would be otherwise identical regardless of which you chose.
+
+The Chaining interaction also has a concept called "flags".  It is possible to attach named flags to a `ChainId` by using
+the ChainFlag interaction.  Then, you specify the flag name in Chaining's `Flags` field. If a Flag is active when the
+Chaining interaction is run, the Flag's interaction will be run instead of the appropriate interaction in `Next`.
+Bear in mind: the entity's progress through the `Next` list still advances, the resulting `Next` interaction is just not
+run.  Only one flag can be active at a time.
+
+Lastly, it is possible to cancel the entity's progress through the combo chain and reset them to the first interaction in
+the list. This can be done with the CancelChain interaction, but it will also happen automatically if the player does
+not trigger an interaction with the ChainId for the specified ChainingAllowance.  When either of these happen, all flags will be
+canceled as well.
+
+All of these effects are triggered on the User entity only. Non-players can use the chaining system, but Flags do not currently
+work for non-players.  This interaction has no special failure conditions.
+
+**Chaining Fields**
+
+| Field Name        | Type                                                       | Required? | Notes                                                                                                                                                                                                                       |
+| ----------------- | ---------------------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| ChainId           | `String`                                                   | **No**    | If provided, acts as a key that multiple Chaining interactions can use to share combo chain progress and flags. If not provided, a unique ChainId will be generated for this interaction.                                   |
+| ChainingAllowance | `Double`<br />(Default: 0.0)                               | **No**    | If, at the time this interaction is triggered, it has been this long in seconds since the last time a Chaining interaction with the same ChainId was executed, all state for this ChainId will be cleared before execution. |
+| Next              | `AssetArray`<br />(Element Type: `Interaction`)            | **Yes**   | A list of interactions to cycle between each time this interaction is run.                                                                                                                                                  |
+| Flags             | `Map`<br />(Key Type: `String`, Value Type: `Interaction`) | **No**    | A map of flag names to interactions to run if the flag is active when this interaction executes.                                                                                                                            |
+
+### CancelChain
+
+This interaction resets all progress and flag data on the User entity for the provided `ChainId`.  The next time a Chaining
+interaction is called for the provided `ChainId`, it will begin at the first interaction in the `Next` list. This
+interaction has no special failure conditions.
+
+**CancelChain Fields**
+
+| Field Name | Type     | Required? | Notes                                 |
+| ---------- | -------- | --------- | ------------------------------------- |
+| ChainId    | `String` | **Yes**   | A ChainId whose data should be reset. |
+
+### ChainFlag
+
+This interaction activates a flag on the User entity for the provided `ChainId`, which can be used to change behavior the
+next time a Chaining interaction with this `ChainId` is run. This will overwrite any flag that has
+already been raised. This interaction will have no effect for non-players. This interaction has no special failure
+conditions.
+
+| Field Name | Type     | Required? | Notes                                        |
+| ---------- | -------- | --------- | -------------------------------------------- |
+| ChainId    | `String` | **Yes**   | A ChainId on whom the flag should be raised. |
+| Flag       | `String` | **Yes**   | The name of the flag to raise.               |
+
+## Charging
+
+A unique flow-control interaction that is frequently used is the Charging interaction.  It is a flow-control interaction
+that delays while the input button used to trigger the interaction chain is held.  When it is released (or the interaction
+is forced to end), the interaction chain can continue with a different interaction based on how long the input was held
+for.
+
+These interactions are all related by either being the Charging interaction, or other interaction types that inherit the
+Charging interaction's behavior.
+
+### Charging
+
+This interaction does not inherit from SimpleInteraction and therefore its Next field works different from most interactions.
+This interaction adds its own Failed field which works the same way that SimpleInteraction's does.
+
+This interaction only works properly when its interaction chain was triggered by a client key or button press (or
+NPC-simulated equivalent). This interaction will continue executing for as long as the key or button press is held (with
+some exceptions, covered below) by the User entity.  Like other interactions, it has a `Next` field indicating which interaction to execute
+after this one, but the field is a map from `Float` values to `Interaction` assets. When this interaction ends, either
+due to the input being released or the charge duration completing, this interaction will determine the largest `Float` key that is less
+than the amount of time in seconds that the interaction was executing for.  The Interaction mapped to that key will be
+executed next.
+
+The interaction includes some cancellation conditions that are specific to this interaction. For instance, the interaction
+has a `CancelOnOtherClick` field that matches the field on RootInteraction. If it is active on this interaction but not
+the RootInteraction, then clicking while charging will cancel this interaction (and execute the `Failed` interaction rather
+than any of the `Next` interactions) but otherwise continue the interaction chain.
+
+Another valuable feature Charging has is the `Forks` field.  For input-triggered interactions that are triggered while the
+Charging interaction is executing, you can add an entry for the relevant InteractionType to this field and instead of
+triggering the usual interaction chain based on held item, targeted block, etc. the RootInteraction specified in the
+`Forks` field will be triggered.  This can unlock rich attack modes and behaviors. For instance, having a shield bash attack
+triggered off left click while blocking, or a special attack that triggers when both mouse buttons are pressed at the
+same time.
+
+There are two modes of operation for the Charging interaction. One is to have the ability charge for as long
+as the input is held and only end execution when the entity releases the input.  Bows in the main Hytale game work
+that way.  That is accomplished by setting `AllowIndefiniteHold` to true.  Another mode of operation is to have the
+interaction complete execution when the execution time has surpassed the largest key value in the `Next` field and
+immediately begin executing the Interaction mapped to that key.  Food in the main Hytale game work like this.  It
+is accomplished by setting `AllowIndefiniteHold` to false.
+
+One pitfall to be careful of when setting `AllowIndefiniteHold` to false is the way it interacts with cooldowns.\
+Normally, input-initiated interaction chains start a 0.35s cooldown on the triggered RootInteraction that prevents
+holding the mouse button from immediately spamming a new interaction when the first one completes.  However, if the
+duration of a Charging interaction is longer than 0.35s, then the cooldown will have already completed when the
+interaction chain finishes, which will often result in a new execution beginning immediately before the player can
+stop pressing the mouse button.  One solution for this problem is to add a `Simple` interaction to the end of your
+interaction chain with a `RunTime` of 0.35s to simulate the cooldown.  Alternatively, you can add a longer cooldown
+(the maximum duration of your Charging interaction plus 0.35s) to the RootInteraction. However, the longer cooldown is
+not always desirable, as the interaction may have ended prematurely, resulting in an unusually long lockout between
+executions.
+
+**Charging Fields**
+
+| Field Name                         | Type                                                                    | Required? | Notes                                                                                                                                                                                                                                                                                                                                                                                       |
+| ---------------------------------- | ----------------------------------------------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| FailOnDamage                       | `Boolean`<br />(Default: false)                                         | **No**    | If true, this interaction will fail and end immediately if the User entity takes any damage while it is executing.                                                                                                                                                                                                                                                                          |
+| CancelOnOtherClick                 | `Boolean`<br />(Default: true)                                          | **No**    | If true, this interaction will fail and end immediately if the User entity sends another button or key press while it is executing.                                                                                                                                                                                                                                                         |
+| Forks                              | `Map`<br />(Key Type: `InteractionType`, Value Type: `RootInteraction`) | **No**    | A map of InteractionType to RootInteraction. If entity input triggers the InteractionType while this interaction is executing, the mapped RootInteraction will be forked into its own interaction chain. This will happen instead of the usual handling for that InteractionType.  This fork will occur even if `CancelOnOtherClick` is set to true.                                        |
+| Failed                             | `Asset`<br />(Asset Type: `Interaction`)                                | **No**    | After this Interaction has finished, "Failed" will be executed if this Interaction failed.                                                                                                                                                                                                                                                                                                  |
+| AllowIndefiniteHold                | `Boolean`<br />(Default: false)                                         | **No**    | If true, this interaction will continue executing for as long as the User entity continues to hold the input. If false, execution will end as soon as the execution time in seconds reaches the largest key value in the `Next` map.                                                                                                                                                        |
+| DisplayProgress                    | `Boolean`<br />(Default: true)                                          | **No**    | If true, players executing this interaction will see a progress bar will be displayed below their cursor indicating how close to reaching the highest key value in `Next` they are.                                                                                                                                                                                                         |
+| Next                               | `Map`<br />(Key Type: `Float`, Value Type: `Interaction`)               | **No**    | A map from `Float` to `Interaction`.  When this interaction successfully finishes executing (either because the input was released or because the maximum duration was reached), this interaction will find the `Float` value with the largest duration in seconds that is less than the amount of time this interaction executed for. That key's mapped Interaction will then be executed. |
+| MouseSensitivityAdjustmentTarget   | `Float`<br />(Default: 1.0)                                             | **No**    | While charging, this mouse sensitivity multiplier will gradually be applied.                                                                                                                                                                                                                                                                                                                |
+| MouseSensitivityAdjustmentDuration | `Float`<br />(Default: 1.0)                                             | **No**    | Duration in seconds. After this many seconds, `MouseSensitivityAdjustmentTarget` will be fully applied to the mouse sensitivity.                                                                                                                                                                                                                                                            |
+| Delay                              | `ChargingDelay`                                                         | **No**    | Settings that allow charging progress to be pushed back when the User entity takes damage.                                                                                                                                                                                                                                                                                                  |
+
+**ChargingDelay Fields**
+
+| Field Name    | Type                        | Required? | Notes                                                                                                                                                                                                                                                                     |
+| ------------- | --------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| MinHealth     | `Float`<br />(Default: 0.0) | **No**    | Damage taken as a percentage of entity health (0.0-1.0). If a hit deals less than this much damage, no pushback will be applied.  If a hit deals exactly this much damage, `MinDelay` seconds worth of pushback will be applied.                                          |
+| MaxHealth     | `Float`<br />(Default: 0.0) | **No**    | Damage taken as a percentage of entity health (0.0-1.0). If a hit deals at least this much damage, `MaxDelay` seconds worth of pushback will be applied.                                                                                                                  |
+| MinDelay      | `Float`<br />(Default: 0)   | **No**    | The amount of pushback, in seconds, to apply if the entity takes a hit that deals `MinHealth` damage. The amount of pushback applied by a hit is a gradiant between `MinDelay` and `MaxDelay` based on the amount of damage between `MinHealth` and `MaxHealth`.          |
+| MaxDelay      | `Float`<br />(Default: 0)   | **No**    | The amount of pushback, in seconds, to apply if the entity takes a hit that deals at least `MaxHealth` damage. The amount of pushback applied by a hit is a gradiant between `MinDelay` and `MaxDelay` based on the amount of damage between `MinHealth` and `MaxHealth`. |
+| MaxTotalDelay | `Float`<br />(Deault: 0)    | **No**    | The maximum amount of pushback the entity can receive over the course of a single charge, regardless of how many times they are hit.                                                                                                                                      |
+
+**InteractionType Values**
+
+- `Primary`
+- `Secondary`
+- `Ability1`
+- `Ability2`
+- `Ability3`
+- `Use`
+- `Pick`
+- `Pickup`
+- `CollisionEnter`
+- `CollisionLeave`
+- `Collision`
+- `EntityStatEffect`
+- `SwapTo`
+- `SwapFrom`
+- `Death`
+- `Wielding`
+- `ProjectileSpawn`
+- `ProjectileHit`
+- `ProjectileMiss`
+- `ProjectileBounce`
+- `Held`
+- `HeldOffhand`
+- `Equipped`
+- `Dodge`
+- `GameModeSwap`
+
+### Wielding
+
+This interaction is inherited from Charging rather than SimpleInteraction.  However, its `Failed` and `Next` fields function
+identically to SimpleInteraction.  It does not inherit all fields from Charging, so be sure to pay close attention to
+the field list below.
+
+This interaction drives most blocking behavior in the game. While this interaction is executing, attacks made against
+the Owner entity will (conditionally) trigger effects defined in this interaction.  Unlike the Charging interaction,
+this interaction can always execute indefinitely and will only end when it fails or when the input is released.
+
+One option available in Wielding is `AngledWielding`, which allows damage and knockback modifiers to only be applied
+depending on the direction the attack against the Owner entity is coming from.  The AngledWielding type has a
+field `Angle` which determines which direction the protection points relative to the player (0 is the player's
+front), and `AngleDistance` which determines how wide the cone of protection extends around the player.  Block effects
+from this interaction (such as `BlockedEffects`, `BlockedInteractions`, and `StaminaCost`) will only apply if
+the DamageCause matches `DamageModifiers` OR if the DamageCause matches `AngledWielding.DamageModifiers` and
+the source of the damage matches `Angle` and `AngleDistance`.  It is possible for damage and knockback multipliers
+specified on both this interaction's modifier fields and `AngledWielding`'s modifier fields to stack, if both
+have entries for the same DamageCause.
+
+This interaction will only have an effect on damage taken by one of the DamageCause entries in `DamageModifiers` or
+`AngledWielding.DamageModifiers`.  If a DamageCause is in `DamageModifiers`, then the block effect will be triggered
+and the damage modifier applied regardless of what direction the Owner entity is attacked from.  If a DamageCause is in
+`AngledWielding.DamageModifiers`, then the damage modifier is only applied if the
+
+\*\* Wielding Fields\*\*
+
+| Field Name          | Type                                                                    | Required? | Notes                                                                                                                                                                                                                                                                                                                                                                                                      |
+| ------------------- | ----------------------------------------------------------------------- | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| FailOnDamage        | `Boolean`<br />(Default: false)                                         | **No**    | If true, this interaction will fail and end immediately if the User entity takes any damage while it is executing.                                                                                                                                                                                                                                                                                         |
+| CancelOnOtherClick  | `Boolean`<br />(Default: true)                                          | **No**    | If true, this interaction will fail and end immediately if the User entity sends another button or key press while it is executing.                                                                                                                                                                                                                                                                        |
+| Forks               | `Map`<br />(Key Type: `InteractionType`, Value Type: `RootInteraction`) | **No**    | A map of InteractionType to RootInteraction. If entity input triggers the InteractionType while this interaction is executing, the mapped RootInteraction will be forked into its own interaction chain. This will happen instead of the usual handling for that InteractionType.  This fork will occur even if `CancelOnOtherClick` is set to true (after which this interaction chain will be canceled). |
+| Next                | `Asset`<br />(Asset Type: `Interaction`)                                | **No**    | After this interaction has finished, "Next" will be executed if this interaction did not fail.                                                                                                                                                                                                                                                                                                             |
+| Failed              | `Asset`<br />(Asset Type: `Interaction`)                                | **No**    | After this interaction has finished, "Failed" will be executed if this interaction failed.                                                                                                                                                                                                                                                                                                                 |
+| DamageModifiers     | `Map`<br />(Key Type: `DamageCause`, Value Type: `Float`)               | **No**    | A map from DamageCause to Float, where the Float is multiplied against any damage received from the mapped DamageCause while this interaction is executing.                                                                                                                                                                                                                                                |
+| KnockbackModifiers  | `Map`<br />(Key Type: `DamageCause`, Value Type: `Float`)               | **No**    | A map from DamageCause to Float, where the Float is multiplied against any knockback force received from the mapped DamageCause while this interaction is executing.                                                                                                                                                                                                                                       |
+| AngledWielding      | `AngledWielding`                                                        | **No**    | Configuration to only trigger block effects from certain angles.                                                                                                                                                                                                                                                                                                                                           |
+| StaminaCost         | `StaminaCost`                                                           | **No**    | If the Owner entity receives damage that matches `DamageModifiers` or `AngledWielding` while this interaction is executing, then the entity's stamina will be deducted according to this configuration.                                                                                                                                                                                                    |
+| BlockedEffects      | `DamageEffects`                                                         | **No**    | If the Owner entity receives damage that matches `DamageModifiers` or `AngledWielding` while this interaction is executing, then these effects will be applied to the instance of damage.                                                                                                                                                                                                                  |
+| BlockedInteractions | `Asset`<br />(Asset Type: `RootInteraction`)                            | **No**    | If the Owner entity receives damage that matches `DamageModifiers` or `AngledWielding` while this interaction is executing, then this RootInteraction will be launched as a brand new interaction chain with the Owner entity as both Owner and User, and the attacker as the Target entity.  This new interaction chain is, notably, brand new, **not** forked from the current one.                      |
+
+**AngledWielding Fields**
+
+| Field Name         | Type                                                      | Required? | Notes                                                                                                                                                                                                            |
+| ------------------ | --------------------------------------------------------- | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Angle              | `Float`<br />(Default: 0.0)                               | **No**    | Angle in degrees relative to the Owner entity where the angled protection is centered. 0.0 means pointed towards the front of the Owner entity.                                                                  |
+| AngleDistance      | `Float`<br />(Default: 0.0)                               | **No**    | Angle in degrees indicating how wide the cone of protection is.                                                                                                                                                  |
+| DamageModifiers    | `Map`<br />(Key Type: `DamageCause`, Value Type: `Float`) | **No**    | A map from DamageCause to Float, where the Float is multiplied against any damage received from the mapped DamageCause received from within the cone of protection while this interaction is executing.          |
+| KnockbackModifiers | `Map`<br />(Key Type: `DamageCause`, Value Type: `Float`) | **No**    | A map from DamageCause to Float, where the Float is multiplied against any knockback force received from the mapped DamageCause received from within the cone of protection while this interaction is executing. |
+
+**StaminaCost Fields**
+
+| Field Name | Type                                             | Required? | Notes                                                                                                                                                                                                                                                |
+| ---------- | ------------------------------------------------ | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| CostType   | `CostType`<br />(Default: `MaxHealthPercentage`) | **No**    | How to calculate stamina consumed by blocking from the raw pre-block damage. If `Damage`, then the stamina consumed will be `rawDamage / Value`. If `MaxHealthPercentage`, then the stamina consumed will be `rawDamage / (EntityMaxHealth * Value)` |
+| Value      | `Float`<br />(Default: 0.04)                     | **No**    | The value to use in the `CostType` formula.                                                                                                                                                                                                          |
+
+**DamageEffects Fields**
+
+| Field Name             | Type                                         | Required? | Notes                                                                           |
+| ---------------------- | -------------------------------------------- | --------- | ------------------------------------------------------------------------------- |
+| ModelParticles         | `Array`<br />(Element Type: `ModelParticle`) | **No**    | Particle systems to trigger in the first-person view.                           |
+| WorldParticles         | `Array`<br />(Element Type: `WorldParticle`) | **No**    | Particle systems to trigger in the third-person view.                           |
+| LocalSoundEventId      | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | 2D sound to play locally to the attacking entity if they are a player.          |
+| WorldSoundEventId      | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | Sound to play in the world at the Owner entity's location.                      |
+| PlayerSoundEventId     | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | 2D sound to play locally to the Owner entity if they are a player.              |
+| ViewDistance           | `Double`<br />(Default: 75.0)                | **No**    | Distance at which these effects should play for other players.                  |
+| Knockback              | `Knockback`                                  | **No**    | The properties of the knockback that will be applied.                           |
+| CameraEffect           | `Asset`<br />(Asset Type: `CameraEffect`)    | **No**    | CameraEffect to briefly apply locally to the Owner entity if they are a player. |
+| StaminaDrainMultiplier | `Float`<br />(Default: 1.0)                  | **No**    | This multiplier is applied to the `StaminaCost`, if any.                        |
+
+**Knockback Fields**
+
+| Field Name     | Type                                       | Required? | Notes                                                                                                                      |
+| -------------- | ------------------------------------------ | --------- | -------------------------------------------------------------------------------------------------------------------------- |
+| Type           | `String`                                   | **No**    | If provided, specifies a type of knockback to use. Each knockback type may come with additional fields.                    |
+| Force          | `Double`<br />(Default: 0.0)               | **No**    | The amount of force to apply to the Owner entity.                                                                          |
+| Duration       | `Double`<br />(Default: 0.0)               | **No**    | If 0.0, apply the force as a single impulse.  If more, continuously apply the force over a period of time.                 |
+| VelocityType   | `ChangeVelocityType`<br />(Default: `Add`) | **No**    | How to apply the force, either adding it to the entity's current velocity, or setting the velocity to the knockback force. |
+| VelocityConfig | `VelocityConfig`                           | **No**    | Characteristics of friction as the Owner entity is thrown by this knockback.                                               |
+
+**Knockback Type: Force**
+
+Apply the calculated knockback force along the provided direction.
+
+| Field Name | Type                         | Required? | Notes                                                                                |
+| ---------- | ---------------------------- | --------- | ------------------------------------------------------------------------------------ |
+| Direction  | `Vector3`<br />(Default: Up) | **No**    | Which direction the player should be flung, relative to the direction of the attack. |
+
+**Knockback Type: Point**
+
+Apply the calculated knockback force laterally along the XZ plane, plus provided Y velocity.
+
+| Field Name | Type                        | Required? | Notes                                                                                                   |
+| ---------- | --------------------------- | --------- | ------------------------------------------------------------------------------------------------------- |
+| OffsetX    | `Integer`<br />(Default: 0) | **No**    | Offset the source position of the knockback left or right perpendicular to the direction of the attack. |
+| OffsetZ    | `Integer`<br />(Default: 0) | **No**    | Offset the source position of the knockback, forward or backward along the directon of the attack.      |
+| RotateY    | `Integer`<br />(Default: 0) | **No**    | Rotate the knockback direction around the Y axis, where 0 is the default attack direction.              |
+| VelocityY  | `Float`<br />(Default: 0.0) | **No**    | Add vertical velocity to the knockback force after the direction and force has been calculated.         |
+
+**Knockback Type: Directional**
+
+Apply the calculated knockback force along the attack direction, removing any vertical component and replacing it with a provided Y velocity.
+
+| Field Name | Type                      | Required? | Notes                                                                                                                                            |
+| ---------- | ------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------ |
+| RelativeX  | `Float`<br />(Default: 0) | **No**    | Apply additional force left or right perpendicular to the direction of the attack. The additional force is multiplied by the knockback strength. |
+| RelativeZ  | `Float`<br />(Default: 0) | **No**    | Apply additional force forward or backward along the attack direction. The additional force is multiplied by the knockback strength.             |
+| VelocityY  | `Float`<br />(Default: 0) | **No**    | Replace the vertical velocity of the knockback with this value.  This value is not multiplied by knockback strength.                             |
+
+**VelocityConfig Fields**
+
+| Field Name          | Type                                              | Required? | Notes                                                                                                                                                                                           |
+| ------------------- | ------------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| GroundResistance    | `Float`<br />(Default: 0.82)                      | **No**    | The minimum amount of friction applied when the entity is in contact with the ground.  1.0 = no friction, 0.0 = total friction                                                                  |
+| GroundResistanceMax | `Float`<br />(Default: 0.0)                       | **No**    | The maximum amount of friction applied when the entity is in contact with the ground.  1.0 = no friction, 0.0 = total friction                                                                  |
+| AirResistance       | `Float`<br />(Default: 0.96)                      | **No**    | The minimum amount of friction applied when the entity is in the air. 1.0 = no friction, 0.0 = total friction                                                                                   |
+| AirResistanceMax    | `Float`<br />(Default: 0.0)                       | **No**    | The maximum amount of friction applied when the entity is in the air. 1.0 = no friction, 0.0 = total friction                                                                                   |
+| Threshold           | `Float`<br />(Default: 1.0)                       | **No**    | The speed at which the maximum amount of friction will be applied to the entity. The amount of friction applied will increase from minimum to maximum as the entity moves from 0 to this speed. |
+| Style               | `VelocityThresholdStyle`<br />(Default: `Linear`) | **No**    | The curve that friction follows as the entity's speed increases toward the `Threshold`.                                                                                                         |
+
+**CostType Values**
+
+- `MaxHealthPercentage`
+- `Damage`
+
+**ChangeVelocityType Values**
+
+- `Add`
+- `Set`
+
+**VelocityThresholdStyle Values**
+
+- `Linear`
+- `Exp`
+
+## Blocks
+
+These are interaction types meant to reason about and modify blocks in the world.  The most important concept unique
+to these interactions is the Block Target.  Like the Entity Target, it is mutable and can come from many places.
+However, for interaction chains initiated by the client, the block target will initially be the block that the player's cursor was
+over, if any.
+
+Additionally, for interaction chains initiated by the client, the client will send along which face of the block is targeted,
+which is used by a few block-related interactions.
+It is left up to each interaction type that cares about block faces as to how to handle this behavior for simulated input
+(i.e. NPCs initiating chains that are normally initated by the client).  At the time of this writing, all block-related
+interactions choose the top face where relevant in simulated input.
+
+### BlockCondition
+
+This interaction has a field `Matchers` which specifies certain conditions, such as block type, state, etc.  This
+interaction fails if the current target block does not match all of them.
+
+**BlockCondition Fields**
+
+| Field Name       | Type                                        | Required? | Notes                                                                                                                                                                                                                                                                                                                                   |
+| ---------------- | ------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false)             | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction.                                                                                                                                                                                                       |
+| Matchers         | `Array`<br />(Element Type: `BlockMatcher`) | **Yes**   | A list of conditions that the target block must match or this condition will fail.<br />**Note: This field is technically not required but there is a bug that makes it dangerous to not provide at the time of this writing.**<br />**Note: If no conditions are added to this array, the interaction will fail, counterintuitively.** |
+
+**BlockMatcher Fields**
+
+| Field Name | Type                       | Required? | Notes                                                                          |
+| ---------- | -------------------------- | --------- | ------------------------------------------------------------------------------ |
+| Block      | `BlockIdMatcher`           | **No**    | If provided, requires the block itself match some set of conditions.           |
+| Face       | `BlockFace`                | **No**    | If provided and not 'None', requires a specific block face be targeted.        |
+| StaticFace | `Boolean` (Default: false) | **No**    | If false, the face condition will be adjusted by the block's current rotation. |
+
+**BlockFace Values**
+
+- `Up`
+- `Down`
+- `North`
+- `South`
+- `East`
+- `West`
+- `None`
+
+**BlockIdMatcher Fields**
+
+| Field Name | Type                                   | Required? | Notes                                                                      |
+| ---------- | -------------------------------------- | --------- | -------------------------------------------------------------------------- |
+| Id         | `Asset`<br />(Asset Type: `BlockType`) | **No**    | If provided, the block must match the specified `BlockType`.               |
+| State      | `String`                               | **No**    | If provided, the block's current state must match the provided state name. |
+| Tag        | `String`                               | **No**    | If provided, the block type's asset tags must contain the provided tag.    |
+
+### DestroyCondition
+
+This interaction fails if the current User entity cannot destroy the current target blcok.
+
+**DestroyCondition Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+
+### PlacementCountCondition
+
+This interaction accepts the name of a BlockType that has the TrackedPlacement BlockEntity. The interaction will fail if the number of
+blocks of the provided BlockType in the world do not match the provided condition.
+
+**PlacementCountCondition Fields**
+
+| Field Name | Type                           | Required? | Notes                                                                                                                                                                                                                                                           |
+| ---------- | ------------------------------ | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Block      | `String`                       | **Yes**   | The BlockType to examine. The number of instances of the BlockType in the world will be compared to Value.<br />**Note: The specified BlockType must have the TrackedPlacement BlockEntity. Otherwise, the number of blocks in the world will always be zero.** |
+| Value      | `Integer`<br />(Default: 0)    | **No**    | The value to compare the number of blocks in the world with.                                                                                                                                                                                                    |
+| LessThan   | \`Boolean<br />(Default: true) | **No**    | If true, the interaction will fail if the number of blocks in the world is greater than or equal to Value. If false, the interaction will fail if the number of blocks in the world is less than or equal to Value.                                             |
+
+### BreakBlock
+
+This interaction attempts to break the target block while acting as the User entity. The User entity must be a player. It
+is not guaranteed to work, depending on world settings and the User entity's current state, it may not work.  If it
+fails, it will fail the interaction under some circumstances, but not others.
+
+**Note: In particular, if `Harvest`=false and the player is in Survival mode, the player will simply execute a damage operation
+against the block. Even when the Tool field is specified, the player's currently-held item can impact the results in unintuitive
+ways.**
+
+This interaction will fail if there is no block target, if `Harvest`=true and the
+block is not harvestable, or if the world settings prevent the Harvest/Break operation.
+It will generally not fail otherwise, even if the block was not broken or damaged.
+The block will generally break every time if `Harvest`=true or the player is in
+Creative mode.
+
+**BreakBlock Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                                                                                                                                                                                                  |
+| ---------------- | ------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction.                                                                                                                                                                      |
+| Harvest          | `Boolean` (Default: false)      | **No**    | If true, harvest the block and deposit the drops in the player's inventory. This operation will generally always succeed.  If false, this interaction will effectively perform whatever action would have occurred if the player had left-clicked the block.                                           |
+| Tool             | `String`                        | **No**    | If `Harvest`=true, the player is in Survival mode, and this field is provided, then the break operation will be performed as though with this tool type.<br />**This field mostly doesn't work.  Your held item will be used for most block damage calculations regardless of this field's contents.** |
+| MatchTool        | `Boolean` (Default: false)      | **No**    | If true, `Harvest`=true, the player is in Survival mode, and `Tool` is provided, block breaking will be prevented unless `Tool` is a valid gathering tool for the target block. The interaction will not be failed, even if block breaking is prevented in this manner.                                |
+
+### ChangeBlock
+
+This interaction requires a mapping from one or more current BlockTypes to one or more target BlockTypes.  If the
+target block is one of the key BlockTypes, then it will be changed to the mapped target BlockType.  If the current
+BlockType of the target block does not appear as a key in the Changes field, then this interaction fails.
+
+**ChangeBlock Fields**
+
+| Field Name        | Type                                                        | Required? | Notes                                                                                                                             |
+| ----------------- | ----------------------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget  | `Boolean`<br />(Default: false)                             | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+| Changes           | `Map`<br />(Key Type: `BlockType`, Value Type: `BlockType`) | **No**    | A list of potential block type changes, with each entry having a current and new BlockType id.                                    |
+| WorldSoundEventId | `Asset`<br />(Asset Type: `SoundEvent`)                     | **No**    | If provided, this SoundEvent is played in the world at the position of the block if the block successfully changes.               |
+| RequireNotBroken  | `Boolean`<br />(Default: false)                             | **No**    | If true, this interaction will fail if the player's held item is broken (durability 0), and the block change will not take place. |
+
+### ChangeState
+
+This interaction requires a mapping from one or more current block state names to one or more state names. If the
+target block is in one of the key block states, then it will be changed to the mapped target blocks tate. If the
+current block state of the target block does nto appear as a key in the Changes field, then this interaction fails.
+
+All blocks start out with a null state by default.  This null state can be referenced by the key "default" and the block
+can be returned to that state with the value "default".
+
+**ChangeState Fields**
+
+| Field Name       | Type                                                  | Required? | Notes                                                                                                                                          |
+| ---------------- | ----------------------------------------------------- | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false)                       | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction.              |
+| Changes          | `Map`<br />(Key Type: `String`, Value Type: `String`) | **No**    | A list of potential block state changes, with each entry having a current and new state name.                                                  |
+| UpdateBlockState | `Boolean`<br />(Default: false)                       | **No**    | If true, performs a full refresh of the block's BlockEntity component and notifies nearby players as though a full block type change occurred. |
+
+### CycleBlockGroup
+
+This interaction will attempt to change the target block to the next block type in one of the BlockGroups it belongs to.
+If the block type belongs to multiple BlockGroups, which one is used is effectively arbitrary. The User entity must be
+a player. If the block cannot be changed for any reason (entity not a player, no block target, block does not belong
+to a BlockGroup, etc.). If the block is the only entry in the BlockGroup, this interaction will succeed and the block
+will be considered changed despite nothing happening.  Unlike most other block-changing interactions, this one will
+fail if the world settings prevent players from breaking blocks.
+
+**This interaction always reduces the player's held item's durability by a single 'hit' worth of damage if the block
+changes. There is no way to prevent it. The block type will change and the interaction will succeed even if the player's
+held item is broken, however.**
+
+**CycleBlockGroup Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+
+### DestroyBlock
+
+This interaction destroys the target block without dropping anything.  It will successfully destroy the block if the
+target block exists and this interaction has no failure conditions.
+
+**This interaction has no additional fields.**
+
+### PickBlock
+
+This interaction is effectively equivalent to using the middle mouse button in creative mode. In survival mode, the
+block's item will be moved to the user's current active hotbar slot if it is in the player's inventory.  This
+interaction is performed entirely on the client and cannot be performed by non-players.  It is unclear if this
+interaction has failure conditions.
+
+**PickBlock Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+
+### PlaceBlock
+
+This interaction is effectively identical to a right clicking while holding a block in their hand, with some
+additional options. For one, it can be executed with any LivingEntity as the User entity. For another, it has some
+useful fields.  For the most part, though, it follows the same behaviors and rules as any ordinary block placement
+by a player.
+
+It's not clear under what circumstances this interaction can fail. The server will not fail the interaction under any
+special circumstances (including when there is no target block, or when `BlockTypeToPlace` is not provided and the
+LivingEntity is not holding a block). However, the client is very involved with the function of this interaction and
+its behavior is unknown.
+
+**PlaceBlock Fields**
+
+| Field Name         | Type                                   | Required? | Notes                                                                                                                                                                                                                                                                                                                                                           |
+| ------------------ | -------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| BlockTypeToPlace   | `Asset`<br />(Asset Type: `BlockType`) | **No**    | If provided, the block placed by this interaction will be the specified BlockType. If not provided, the User entity's held item will be used, instead, if it is a block.                                                                                                                                                                                        |
+| RemoveItemInHand   | `Boolean`<br />(Default: True)         | **No**    | If true and the User entity is not a player in Creative mode, the item in the player's hand must match the block being placed and one quantity will be removed for each block placed. If the item does not match, the block cannot be placed.  If false, the player's hand item is ignored entirely.\*\*                                                        |
+| AllowDragPlacement | `Boolean`<br />(Default: True)         | **No**    | If true and the interaction was triggered on the client by a player, then the player can hold the input that was used to activate this interaction chain and move the mouse around in order to execute this interaction repeatedly and place several blocks. The interaction chain will not move onto the next interaction until the player releases the input. |
+
+### RunOnBlockTypes
+
+This interaction retrieves all blocks within a provided radius of the User entity. For each block that matches any of
+the provided BlockSets, a new interaction chain will be forked that uses the matching block as the target block.
+This interaction will continue executing until all forked interaction chains have completed.  The interaction will fail if no
+blocks within the radius match the provided BlockSets or if all of the forked interaction chains fail.
+
+**RunOnBlockTypes Fields**
+
+| Field Name   | Type                                         | Required?        | Notes                                                                                                                                                                                                                                                                                      |
+| ------------ | -------------------------------------------- | ---------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| Range        | `Integer`                                    | **Yes**          | The spherical radius around the User entity to search for blocks. Must be at least 1.                                                                                                                                                                                                      |
+| BlockSets    | `AssetArray`<br />(Element Type: `BlockSet`) | **No**           | A list of BlockSets to match nearby blocks again. Only blocks that match any of the BlockSets will have interaction chains forked for them.                                                                                                                                                |
+| MaxCount     | `Integer`                                    | **Yes**          | The maximum number of blocks that will be located with the search. Further blocks will be ignored. If there are more matching blocks within the radius than this number, the specific set of blocks that will be found is completely arbitrary and may change from execution to execution. |
+| Interactions | `Asset`<br />(Asset Type: `RootInteraction`) | **No, but yes.** | The RootInteraction that will be forked for each matching block.  This interaction will not fail to validate if it is missing, but every execution of this interaction will fail.                                                                                                          |
+
+### UseBlock
+
+If the target block has an interaction for this interaction chain's interaction type, execute it immediately as part of
+this interaction chain. The execution will be wrapped in UseBlockEvent.Pre and UseBlockEvent.Post events, and cancellations
+of the UserBlockEvent.Pre event are respected. The User entity is considered the triggering entity for both events.
+
+If the target block does not have an interaction for this interaction chain's interaction type, this interaction fails.
+
+**This interaction has no additional fields.**
+
+## Items
+
+These are interactions intended to interface with an entity's inventory. There is no concept of an "item target",
+unfortunately, so these generally either interact with the entity's held item or the entity's inventory at a high level.
+
+### AddItem
+
+Adds a specified quantity of a specified item to the User entity's inventory, preferring to add it to the
+entity's hotbar where possible. This interaction will have no effect on User entities that are not LivingEntities.
+This interaction has no failure states.
+
+**Note: This interaction has a bug in its field validators that will cause interactions that reference items declared
+in the same mod to fail validation on startup.  Additionally, this interaction has a bug that will cause it to
+fail and have no effect if the User entity has no block target. Use ModifyInventory instead.**
+
+**AddItem Fields**
+
+| Field Name       | Type                              | Required? | Notes                                                                                                                             |
+| ---------------- | --------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false)   | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+| ItemId           | `Asset`<br />(Asset Type: `Item`) | **Yes**   | The item id of the item to add to the player's inventory.                                                                         |
+| Quantity         | `Integer`<br />(Default: 0)       | **No**    | The quantity of the item to add to the player's inventory.                                                                        |
+
+### CheckUniqueItemUsage
+
+This interaction will check whether it has run once for the User entity with their currently-held item before. If it hasn't,
+it will succeed. If it has, it will fail. It will also fail if the User entity is not a player. The interaction will record
+the item id of the User entity's currently-held item on success, ensuring it cannot be successfully run with that player
+and item id combination again.
+
+**This interaction has no additional fields.**
+
+### ChangeActiveSlot
+
+This interaction does not inherit from SimpleInteraction and therefore has no Next or Failed fields.  The `CancelOnItemChange`
+field is ignored for this interaction and is always treated as false. This interaction will set the User entity's currently-
+active hotbar slot to the specified slot index. If none is specified, the interaction chain's target slot will be used,
+if any. Otherwise, slot 0 will be used.  If a slot is specified and it is already active, then this interaction will
+have no effect, but if no slot is specified and the interaction chain's target slot is already active, the logic in
+the next paragraph will still be executed. This interaction will also have no effect if the User entity is not a
+LivingEntity.
+
+Once the slot has changed, a new SwapTo interaction chain will be forked off for the selected slot.
+If a target slot was specified, then the interaction chain's current target slot will be set to the specified slot, as will
+the forked SwapTo interaction chain. If this interaction chain was initiated by a player swapping an item into or out of
+an occupied active hotbar slot, then the swap will be executed after the slot is changed and before the SwapTo
+interaction is forked. Not running this interaction in the resulting SwapFrom interaction chain is a way for the server
+to cancel players performing these sorts of swap interactions. The default behavior for these swap interactions is that
+the SwapFrom interaction chain will be initiated with the currently-active-slot as the target slot. As a result, the
+target slot will usually not change when this interaction runs, it merely exists as a signal for the server to continue the
+item swap.
+
+**ChangeActiveSlot Fields**
+
+| Field Name | Type      | Required? | Notes                                                                                                                                                                                                     |
+| ---------- | --------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| TargetSlot | `Integer` | **No**    | If not provided, indicates the slot the player's active hotbar slot should be changed to.  Otherwise, the interaction chain's target slot will be used (which is usually the already-active hotbar slot). |
+
+### EquipItem
+
+This interaction will equip the User entity's currently-held item into the appropriate armor slot, if it is armor. The
+interaction will fail if the item is armor but it cannot be equipped for some reason. The interaction will succeed but
+take no action if the User entity cannot equip armor or if the item is not armor.
+
+**This interaction has no additional fields.**
+
+### IncreaseBackpackCapacity
+
+This interaction will increase the User entity's backpack size by the provided amount.  **It will additionally remove one
+quantity from the player's currently-held item. There is no way to prevent this.**  This interaction will have no effect
+if the User entity is not a player.  This interaction has no special failure conditions, even if the User entity
+is not a player, or the player is not currently holding an item.
+
+| Field Name | Type                        | Required? | Notes                                                                                   |
+| ---------- | --------------------------- | --------- | --------------------------------------------------------------------------------------- |
+| Capacity   | `Integer`<br />(Default: 1) | **No**    | The additional backpack capacity to add to the player. **Must be between 1 and 32767.** |
+
+### ModifyInventory
+
+This interaction attempts to perform one or more inventory-modifying actions against the User entity. The User entity must
+be a player. If they are not, no actions will be performed, but the interaction will not fail. Any item removals performed
+by this interaction, either as a result of `ItemToRemove` or `AdjustHeldItemQuantity`, are both atomic (meaning the entire
+quantity must be removed, or none) and required (meaning that the interaction will fail and no further actions taken if
+the removal fails for any reason).  Item additions performed by this interaction, either as a result of `ItemToAdd` or
+`AdjustHeldItemQuantity` will drop excess items on the ground near the player if necesary and continue on.
+
+This interaction first executes the item removal in `ItemToRemove`, if any, then adjusts the held item as specified by
+`AdjustHeldItemQuantity`, if provided, then executes the item addition in `ItemToAdd`, if any, and then finally executes
+the damage/healing of the held item in `AdjustHeldItemDurability`, if provided.
+
+**ModifyDurability Fields**
+
+| Field Name               | Type                            | Required? | Notes                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
+| ------------------------ | ------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| RequiredGameMode         | `GameMode`                      | **No**    | If provided, only execute the inventory-modifying actions if the player is in the provided GameMode. The interaction will not fail if the GameMode doesn't match.                                                                                                                                                                                                                                                                                                                                                                               |
+| ItemToRemove             | `ItemStack`                     | **No**    | If provided, a matching item will be removed in the provided quantity. If there is no matching item in the player inventory in the required quantity, then the interaction will fail and further actions will not be executed.                                                                                                                                                                                                                                                                                                                  |
+| AdjustHeldItemQuantity   | `Integer`<br />(Default: 0)     | **No**    | The player's held item, if any, will have its quantity will be modified by the provided amount- subtracted from if this number is negative or added to if this item is positive.  If the player has no held item, then this field will have no effect regardless of its value and the interaction will NOT fail.  If the player's inventory does not have sufficient quantity of items to support the removal, this interaction will fail and further actions will not be executed. Excess items will be dropped on the ground near the player. |
+| ItemToAdd                | `ItemStack`                     | **No**    | If provided, the ItemStack will be added to the player's inventory. Excess items will be dropped on the ground near the player.                                                                                                                                                                                                                                                                                                                                                                                                                 |
+| AdjustHeldItemDurability | `Double`<br />(Default: 0.0)    | **No**    | The player's held item, if any, will have its durability adjusted by the specified amount.  The durability cannot go below 0 or raise above the item's maximum durability. Invalid durability values in this field will not cause the interaction to fail. Neither will it fail if the player has no held item.                                                                                                                                                                                                                                 |
+| BrokenItem               | `String`                        | **No**    | This field should contain an ItemId, but it is not validated by the server on startup, so be careful.  This field can have the value of "Empty" to specify no item, or an empty hand. If specified and the `AdjustHeldItemDurability` operation reduces the player's held item to 0 durability, the player's held item is changed to this ItemId. If the inventory replacement fails, this interaction will fail.                                                                                                                               |
+| NotifyOnBreak            | `Boolean`<br />(Default: false) | **No**    | If true and the `AdjustHeldItemDurability` operation reduces the player's held item to 0 durability, this interaction will perform the usual audiovisual feedback of a broken tool. It will play the usual tool breaking sound and send the player a text message in chat that their item has broken.                                                                                                                                                                                                                                           |
+| NotifyOnBreakMessage     | `String`                        | **No**    | If provided, and `NotifyOnBreak` is true, when the player is notified of a broken tool by this interaction, the message sent to their chat will instead be the translation key specified by this field. The translation key supports the templating parameter `{itemName}`. See the translation key `server.general.repair.itemBroken_Hoe` for an example.                                                                                                                                                                                      |
+
+**GameMode Values**
+
+- `Creative`: The game is currently in Creative Mode
+- `Adventure`: The game is currently in Adventure Mode
+
+**ItemStack Fields**
+
+| Field Name                   | Type                              | Required? | Notes                                                                                |
+| ---------------------------- | --------------------------------- | --------- | ------------------------------------------------------------------------------------ |
+| Id                           | `Asset`<br />(Asset Type: `Item`) | **Yes**   | The id of the Item asset this stack contains.                                        |
+| Quantity                     | `Integer`<br />(Default: 1)       | **No**    | The number of items in this stack.<br />**Must be greater than 0.**                  |
+| Durability                   | `Double`<br />(Default: 0.0)      | **No**    | The durability of the item stack.<br />**Cannot be negative.**                       |
+| MaxDurability                | `Double`<br />(Default: 0.0)      | **No**    | The maximum durability of the item this stack contains.<br />**Cannot be negative.** |
+| Metadata                     | `Bson Document`                   | **No**    | If provided, applies the bson to the item stack metadata.                            |
+| OverrideDroppedItemAnimation | `Boolean`\*(Default: false)       | **No**    | ???                                                                                  |
+
+### PickupItem
+
+This interaction will attempt to pick up the User entity's current target entity and add it to their inventory. It will
+fail if the User entity is not a player, if they do not have a target entity, or if the target entity is not an item
+located in the world.  It will not fail if the player simply cannot pick up the item.
+
+**This interaction has no additional fields.**
+
+### RefillContainer
+
+This interaction will fail if the User entity is not a player. The interaction will draw a ray from the player's head
+down their look direction until the edge of the player's held item's interaction range or until the first solid block.
+The nearest fluid block of a type listed in this interaction's `States` map will result in the one of the player's
+currently-held items being converted to the fluid's related item state.  If the `States` map indicates a durability
+for the new item state, then the converted item will use that durability. If the item is already in the fluid's related
+item state, then this interaction will fail if the player's held item is already at maximum durability (unless the
+`States` map indicates a durability value greater than the item's maximum, in which case the interaction will succeed
+but the item will not change).  Otherwise, the durability listed for the fluid in the `States` map will be added to the
+item's current durability.
+
+If the interaction has not failed by this point, the fluid block in the world may be transformed to a different type if one is listed
+in the `States` map.
+
+If any part of this process does not proceed for any reason (for instance, if the player is not holding an item),
+then this interaction will fail.
+
+**RefillContainer Fields**
+
+| Field Name | Type                                                       | Required? | Notes                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| ---------- | ---------------------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| States     | `Map`<br />(Key Type: `String`, Value Type: `RefillState`) | **Yes**   | A map from item state names to `RefillState` objects, which contain information such as acceptable fluid block types, durability increases, and what fluid type to convert the targeted fluid block to after refill, if any. If the player targets a fluid block that matches one of the fluid types in the `RefillState`, the item will be converted to the keyed item state and the `RefillState` will be used to decide what happens next. |
+
+**RefillState Fields**
+
+| Field Name     | Type                                  | Required? | Notes                                                                                                                                                                                                                                                                                                                           |
+| -------------- | ------------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| AllowedFluids  | `Array`<br />(Element Type: `String`) | **Yes**   | If any of these fluids are targeted by the player, the player's held item will be converted to the keyed item state and `Durability` and `TransformFluid` will be used.                                                                                                                                                         |
+| Durability     | `Double`<br />(Default: -1.0)         | **No**    | If the player's held item changes item states, this value is the new item's durability, unless it is negative, in which case the item will begin at full durability. If the player's held item is already in the item state, and the item is not already at full durability, this value will be added to the item's durability. |
+| TransformFluid | `String`                              | **No**    | If provided, this field is a fluid id that the targeted fluid block should be transformed to if the player's held item is successfully updated.                                                                                                                                                                                 |
+
+## Entities
+
+### DamageEntity
+
+This interaction does not inherit from SimpleInteraction, but adds its own Next and Failed fields that
+work similarly.
+
+This interaction will cause the User entity to damage the Target entity.  It has the capability to apply different
+damage based on the direction of the attack or what body part was targeted by the User entity, with each possibility
+providing different damage calculations, effects, and Next interaction. If multiple entires match the attack, `TargetedDamage`
+(body part damage) takes highest priority, then the first matching `AngledDamage` in the list, then the default
+damage in the base interaction fields.  It is possible for elements of these different damage priorities to be taken peacemeal if higher-priority
+damage fields do not overwrite lower-priority damage fields. For instance,
+damage calculation could be taken from `TargetedDamage`, the damage effects could be taken from the first matching
+`AngledDamage`, and the Next interaction coming from the default damage field.
+
+If all damage dealt by this interaction is cancelled, then this interaction will fail, and the `Failed` interaction
+will be executed next in the chain. If any damage dealt by this interaction is blocked, then this interaction will
+succeed, but the `Blocked` interaction wil lbe executed next in the chain. Otherwise, the highest-precedent matching
+`Next` interaction that you provide will be executed.  For instance, if you provide `Next` interactions for all
+`TargetedDamage` and `AngledDamage` entries, and one in the interaction's `Next` field, then a headshot could result
+in a unique `Next` interaction being executed, even if there is a matching `AngledDamage` entry. However, if you leave
+the `Next` interaction out of your `TargetedDamage` entries, a special `Next` interaction for backstabs could be
+executed.  Otherwise, the `Next` field in the root of the interaction will be executed instead.
+
+DamageEntity has an unusual relationship with `RunTime`. This interaction always ends immediately after its first tick,
+regardless of the status of `RunTime` or `WaitForAnimationToFinish`.  However, if damage dealt by this interaction is
+calculated as `DamageCalculatorType` `Dps`, then the `RunTime` will be used to determine the precise amount of damage to
+deal. If `RunTime` is 0, then no damage will be dealt.
+
+**DamageEntity Fields**
+
+| Field Name       | Type                                                          | Required?                                                                                                                    | Notes                                                                                                                                                                                                                                                                                                                                                                         |
+| ---------------- | ------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| DamageCalculator | `DamageCalculator`                                            | **No**                                                                                                                       | If provided, describes the damage amounts and types to apply to the Target entity.                                                                                                                                                                                                                                                                                            |
+| DamageEffects    | `DamageEffects`                                               | **No**                                                                                                                       | If provided, describes particles, sounds, knockback, etc. to apply to the target entity on damage.                                                                                                                                                                                                                                                                            |
+| Next             | `Asset`<br />(Asset Type: `Interaction`)                      | **No**  After this interaction has finished, "Next" will be executed if damage was dealt to the target and none was blocked. |                                                                                                                                                                                                                                                                                                                                                                               |
+| AngledDamage     | `Array`<br />(Element Type: `AngledDamage`)                   | **No**                                                                                                                       | If provided, allows alternative `DamageCalculator`, `DamageEffects`, and `Next` entries for attacks that approach the target from certain angles.                                                                                                                                                                                                                             |
+| TargetedDamage   | `Map`<br />(Key Type: `String`, Value Type: `TargetedDamage`) | **Yes**                                                                                                                      | This field must be provided, but is not required to have any entries.  This is a map from body part names to `TargetedDamage` values. Hypixel only uses one body part name: `Head`, and it is not clear whether there are others.  If provided, allows alternative `DamageCalculator`, `DamageEffects`, and `Next` entries for attacks that damage specific enemy body parts. |
+| EntityStatsOnHit | `Array`<br />(Element Type: `EntityStatOnHit`)                | **No**                                                                                                                       | If provided, allows this attack to reduce enemy stats other than health.  Each individual damage application dealt by the same ability will apply stat reductions, at diminishing returns. All damage dealt in interaction chains forked by a Selector interaction will share the number of hits across all targets.                                                          |
+| Failed           | `Asset`<br />(Asset Type: `Interaction`)                      | **No**                                                                                                                       | After this interaction has finished, "Failed" will be executed if no damage hits were applied to the player, or if all damage hits were cancelled.                                                                                                                                                                                                                            |
+| Blocked          | `Asset`<br />(Asset Type: `Interaction`)                      | **No**                                                                                                                       | After this interaction has finished, "Blocked" will be executed if any damage hits were blocked by the target.                                                                                                                                                                                                                                                                |
+
+**DamageCalculator Fields**
+
+| Field Name                | Type                                                      | Required? | Notes                                                                                                                                                                                                                                                 |
+| ------------------------- | --------------------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Type                      | `DamageCalculatorType`<br />(Default: Absolute)           | **No**    | Whether the damage being applied is `Absolute` or \`Dps'.                                                                                                                                                                                             |
+| Class                     | `DamageClass`<br />(Default: Unknown)                     | **No**    | The type of attack producing the damage. Some weapon systems apply equipment modifiers based on this value.                                                                                                                                           |
+| BaseDamage                | `Map`<br />(Key Type: `DamageCause`, Value Type: `Float`) | **No**    | A set of DamageCauses and how much base damage is dealt for each.                                                                                                                                                                                     |
+| SequentialModifierStep    | `Float`<br />(Default: 0.0)                               | **No**    | Value between 0.0-1.0. Each additional hit from a single ability will have its damage reduced by this much as a percentage. All damage dealt in interaction chains forked by a Selector interaction will share the number of hits across all targets. |
+| SequentialModifierMinimum | `Float`<br />(Default: 0.0)                               | **No**    | Value between 0.0-1.0. `SequentialModifierStep` cannot reduce damage below this percentage regardless of the number of hits.                                                                                                                          |
+| RandomPercentageModifier  | `Float`<br />(Default: 0.0)                               | **No**    | A random value between +/- this amount multiplied by the base damage will be added to the base damage.                                                                                                                                                |
+
+**DamageEffects Fields**
+
+| Field Name             | Type                                         | Required? | Notes                                                                                   |
+| ---------------------- | -------------------------------------------- | --------- | --------------------------------------------------------------------------------------- |
+| ModelParticles         | `Array`<br />(Element Type: `ModelParticle`) | **No**    | Particle systems to trigger in the first-person view.                                   |
+| WorldParticles         | `Array`<br />(Element Type: `WorldParticle`) | **No**    | Particle systems to trigger in the third-person view.                                   |
+| LocalSoundEventId      | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | 2D sound to play locally to the attacking entity if they are a player.                  |
+| WorldSoundEventId      | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | Sound to play in the world at the Target entity's location.                             |
+| PlayerSoundEventId     | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | 2D sound to play locally to the Target entity if they are a player.                     |
+| ViewDistance           | `Double`<br />(Default: 75.0)                | **No**    | Distance at which these effects should play for other players.                          |
+| Knockback              | `Knockback`                                  | **No**    | The properties of the knockback that will be applied.                                   |
+| CameraEffect           | `Asset`<br />(Asset Type: `CameraEffect`)    | **No**    | CameraEffect to briefly apply locally to the Target entity if they are a player.        |
+| StaminaDrainMultiplier | `Float`<br />(Default: 1.0)                  | **No**    | This multiplier is applied to the stamina cost incurred by the target blocking, if any. |
+
+**AngledDamage Fields**
+
+| Field Name       | Type                                     | Required? | Notes                                                                                                                                                                                                     |
+| ---------------- | ---------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| AngleDistance    | `Float`<br />(Default: 0)                | **No**    | The width in degrees of the matching arc around the Target entity. If the attack against the Target originates from within the arc, then the properties below will be applied to the attack, if provided. |
+| Angle            | `Float`<br />(Default: 0.0)              | **No**    | The angle in degrees around the Target entity at which the matching arc is centered.                                                                                                                      |
+| DamageCalculator | `DamageCalculator`                       | **No**    | If provided and the attack against the Target entity originates from within the provided arc, this DamageCalculator will override the interaction's `DamageCalculator` field.                             |
+| DamageEffects    | `DamageEffects`                          | **No**    | If provided and the attack against the Target entity originates from within the provided arc, this DamageEffects will override the interaction's `DamageEffects` field.                                   |
+| Next             | `Asset`<br />(Asset Type: `Interaction`) | **No**    | If provided and the attack against the Target entity originates from within the provided arc, this Interaction will override the interaction's `Next` field.                                              |
+
+**TargetedDamage Fields**
+
+| Field Name       | Type                                     | Required? | Notes                                                                                                                                                                                            |
+| ---------------- | ---------------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| DamageCalculator | `DamageCalculator`                       | **No**    | If provided and this TargetedDamage was matched, this DamageCalculator will override the interaction's `DamageCalculator` field and the `DamageCalculator` field of any matching `AngledDamage`. |
+| DamageEffects    | `DamageEffects`                          | **No**    | If provided and this TargetedDamage was matched, this DamageEffects will override the interaction's `DamageEffects` field and the `DamageEffects` field of any matching `AngledDamage`.          |
+| Next             | `Asset`<br />(Asset Type: `Interaction`) | **No**    | If provided and this TargetedDamage was matched, this Interaction will override the interaction's `Next` field and the `Next` field of any matching `AngledDamage`.                              |
+
+**EntityStatOnHit Fields**
+
+| Field Name                  | Type                                                                       | Required? | Notes                                                                                                                                                                                                                                                                                        |
+| --------------------------- | -------------------------------------------------------------------------- | --------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| EntityStatId                | `Asset`<br />(AssetType: `EntityStatType`)                                 | **Yes**   | Which entity stat to affect.                                                                                                                                                                                                                                                                 |
+| Amount                      | `Float`<br />(Default: 0.0)                                                | **No**    | How much of the stat to apply for each damage application. Use negative numbers to reduce stats.                                                                                                                                                                                             |
+| MultipliersPerEntitiesHit   | `Array`<br />(Element Type: `Float`, Default: `[1.0, 0.6, 0.4, 0.2, 0.1]`) | **No**    | The diminishing returns curve to be applied for multiple damage applications by the same ability. Each hit's stat impact will be multiplied by the next value in the list.  If there are more hits than array elements, subsequent hits will be multiplied by `MultiplierPerExtraEntityHit`. |
+| MultiplierPerExtraEntityHit | `Float`<br />(Default: 0.05)                                               | **No**    | If an ability carries out more damage applications than there are elements in the `MultipliersPerEntitiesHit` array, then subsequent stat values will be multiplied by this number.                                                                                                          |
+
+**Knockback Fields**
+
+| Field Name     | Type                                       | Required? | Notes                                                                                                                      |
+| -------------- | ------------------------------------------ | --------- | -------------------------------------------------------------------------------------------------------------------------- |
+| Type           | `String`                                   | **No**    | If provided, specifies a type of knockback to use. Each Target type may come with additional fields.                       |
+| Force          | `Double`<br />(Default: 0.0)               | **No**    | The amount of force to apply to the Owner entity.                                                                          |
+| Duration       | `Double`<br />(Default: 0.0)               | **No**    | If 0.0, apply the force as a single impulse.  If more, continuously apply the force over a period of time.                 |
+| VelocityType   | `ChangeVelocityType`<br />(Default: `Add`) | **No**    | How to apply the force, either adding it to the entity's current velocity, or setting the velocity to the knockback force. |
+| VelocityConfig | `VelocityConfig`                           | **No**    | Characteristics of friction as the Owner entity is thrown by this knockback.                                               |
+
+**Knockback Type: Force**
+
+Apply the calculated knockback force along the provided direction.
+
+| Field Name | Type                         | Required? | Notes                                                                                |
+| ---------- | ---------------------------- | --------- | ------------------------------------------------------------------------------------ |
+| Direction  | `Vector3`<br />(Default: Up) | **No**    | Which direction the entity should be flung, relative to the direction of the attack. |
+
+**Knockback Type: Point**
+
+Apply the calculated knockback force laterally along the XZ plane, plus provided Y velocity.
+
+| Field Name | Type                        | Required? | Notes                                                                                                   |
+| ---------- | --------------------------- | --------- | ------------------------------------------------------------------------------------------------------- |
+| OffsetX    | `Integer`<br />(Default: 0) | **No**    | Offset the source position of the knockback left or right perpendicular to the direction of the attack. |
+| OffsetZ    | `Integer`<br />(Default: 0) | **No**    | Offset the source position of the knockback, forward or backward along the directon of the attack.      |
+| RotateY    | `Integer`<br />(Default: 0) | **No**    | Rotate the knockback direction around the Y axis, where 0 is the default attack direction.              |
+| VelocityY  | `Float`<br />(Default: 0.0) | **No**    | Add vertical velocity to the knockback force after the direction and force has been calculated.         |
+
+**Knockback Type: Directional**
+
+Apply the calculated knockback force along the attack direction, removing any vertical component and replacing it with a provided Y velocity.
+
+| Field Name | Type                      | Required? | Notes                                                                                                                                            |
+| ---------- | ------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------ |
+| RelativeX  | `Float`<br />(Default: 0) | **No**    | Apply additional force left or right perpendicular to the direction of the attack. The additional force is multiplied by the knockback strength. |
+| RelativeZ  | `Float`<br />(Default: 0) | **No**    | Apply additional force forward or backward along the attack direction. The additional force is multiplied by the knockback strength.             |
+| VelocityY  | `Float`<br />(Default: 0) | **No**    | Replace the vertical velocity of the knockback with this value.  This value is not multiplied by knockback strength.                             |
+
+**VelocityConfig Fields**
+
+| Field Name          | Type                                              | Required? | Notes                                                                                                                                                                                           |
+| ------------------- | ------------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| GroundResistance    | `Float`<br />(Default: 0.82)                      | **No**    | The minimum amount of friction applied when the entity is in contact with the ground.  1.0 = no friction, 0.0 = total friction                                                                  |
+| GroundResistanceMax | `Float`<br />(Default: 0.0)                       | **No**    | The maximum amount of friction applied when the entity is in contact with the ground.  1.0 = no friction, 0.0 = total friction                                                                  |
+| AirResistance       | `Float`<br />(Default: 0.96)                      | **No**    | The minimum amount of friction applied when the entity is in the air. 1.0 = no friction, 0.0 = total friction                                                                                   |
+| AirResistanceMax    | `Float`<br />(Default: 0.0)                       | **No**    | The maximum amount of friction applied when the entity is in the air. 1.0 = no friction, 0.0 = total friction                                                                                   |
+| Threshold           | `Float`<br />(Default: 1.0)                       | **No**    | The speed at which the maximum amount of friction will be applied to the entity. The amount of friction applied will increase from minimum to maximum as the entity moves from 0 to this speed. |
+| Style               | `VelocityThresholdStyle`<br />(Default: `Linear`) | **No**    | The curve that friction follows as the entity's speed increases toward the `Threshold`.                                                                                                         |
+
+**DamageCalculatorType Values**
+
+- `Absolute`
+- `Dps`
+
+**DamageClass Values**
+
+- `Unknown`
+- `Light`
+- `Charged`
+- `Signature`
+
+**ChangeVelocityType Values**
+
+- `Add`
+- `Set`
+
+**VelocityThresholdStyle Values**
+
+- `Linear`
+- `Exp`
+
+### LaunchProjectile
+
+This is just a worse version of Projectile and is slated to be removed.  Use Projectile.
+
+### Projectile
+
+This interaction will spawn a new projectile at the User entity's eye position that will travel in its look direction.
+
+| Field Name | Type                                          | Required? | Notes                                                  |
+| ---------- | --------------------------------------------- | --------- | ------------------------------------------------------ |
+| Config     | `Asset`<br />(Asset Type: `ProjectileConfig`) | **No**    | Configuration describing the projectile to be spawned. |
+
+### RemoveEntity
+
+Despawns the specified entity from the world. This interaction will have no effect if the specified entity is a player. This
+interaction has no special failure conditions.
+
+| Field Name | Type                                     | Required? | Notes                  |
+| ---------- | ---------------------------------------- | --------- | ---------------------- |
+| Entity     | `InteractionTarget`<br />(Default: User) | **No**    | The entity to despawn. |
+
+**InteractionTarget Values**
+
+- `User` - The user of this interaction chain. The entity whose actions caused this interaction chain to be executed. This is usually the same as the Owner.
+- `Owner` - The owner of this interaction chain. The entity upon whom this interaction chain is executing.
+- `Target` - The entity target of this interaction chain, if any.  This value is mutable (and can therefore come from many places) but most commonly, it is an entity the User was targeting when this interaction chain began executing.
+
+### SendMessage
+
+This interaction sends a message to the Owner entity if that entity can receive messages.  Otherwise, the message
+is written to the server logs.  If the entity is a player, the message will appear in the player's chat window.
+
+\*\*SendMessage
+
+| Field Name | Type     | Required? | Notes                                                                                                                 |
+| ---------- | -------- | --------- | --------------------------------------------------------------------------------------------------------------------- |
+| Message    | `String` | **No**    | A text message to be sent to the Owner entity.  If this field is not provided, `Key` is used instead.                 |
+| Key        | `String` | **No**    | A translation key for a message to be sent to the Owner entity. If `Message` is provided, then this field is ignored. |
+
+### UseEntity
+
+This interaction is not in use by Hypixel and has some unusual qualities that mean it probably won't do what you want it
+to.  Do not use it.
+
+This interaction will retrieve the entity currently targeted by the client (NOT the interaction chain's current Target
+entity) and execute that entity's RootInteraction for this interaction chain's current interaction type. The
+RootInteraction will be executed as part of this current interaction chain. None of the properties of this interaction
+chain will be modified.
+
+This interaction will fail if the client is not currently targeting an entity, or if no interaction for the current
+interaction type exists on the entity.
+
+## Stats
+
+Hytale's resource system has been written about fairly extensively.  You can use these interactions to modify stats in
+response to actions or use stats as a cost for abilities.
+
+### ChangeStat
+
+This interaction applies a set of raw stat changes to the User entity. It has no special failure conditions.
+
+| Field Name    | Type                                                         | Required? | Notes                                                                                                                                                                                                                      |
+| ------------- | ------------------------------------------------------------ | --------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| StatModifiers | `Map`<br />(Key Type: `EntityStatType`, Value Type: `Float`) | **Yes**   | A set of stats to modify and what value to apply to them.                                                                                                                                                                  |
+| ValueType     | `ValueType`<br />(Default: Absolute)                         | **No**    | Whether the values in the `StatModifiers` map represent flat values to apply to the stat total, or percentages (0.0-100.0). Percentage values are percentage of the difference between the maximum and minimum stat value. |
+| Behaviour     | `ChangeStatBehavior`<br />(Default: Add)                     | **No**    | Whether the values in the `StatModifiers` map represent deltas to add into the User entity's current stat values, or fixed values to set the entity's stats to.                                                            |
+
+**ValueType Values**
+
+- `Absolute`
+- `Percent`
+
+**ChangeStatBehaviour Values**
+
+- `Add`
+- `Set`
+
+### ChangeStatWithModifier
+
+This interaction is like ChangeStat, except an armor stat modifier can be chosen which will apply bonuses and penalties
+to a stat from the User entity's equipped armor before it is applied.
+
+| Field Name            | Type                                                         | Required? | Notes                                                                                                                                                                                                                      |
+| --------------------- | ------------------------------------------------------------ | --------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| StatModifiers         | `Map`<br />(Key Type: `EntityStatType`, Value Type: `Float`) | **Yes**   | A set of stats to modify and what value to apply to them.                                                                                                                                                                  |
+| ValueType             | `ValueType`<br />(Default: Absolute)                         | **No**    | Whether the values in the `StatModifiers` map represent flat values to apply to the stat total, or percentages (0.0-100.0). Percentage values are percentage of the difference between the maximum and minimum stat value. |
+| Behaviour             | `ChangeStatBehavior`<br />(Default: Add)                     | **No**    | Whether the values in the `StatModifiers` map represent deltas to add into the User entity's current stat values, or fixed values to set the entity's stats to.                                                            |
+| InteractionModifierId | `InteractionModifierId`                                      | **Yes**   | The armor interaction modifier to apply bonuses and penalties for.                                                                                                                                                         |
+
+**ValueType Values**
+
+- `Absolute`
+- `Percent`
+
+**ChangeStatBehaviour Values**
+
+- `Add`
+- `Set`
+
+**InteractionModifierId Values**
+
+- `Dodge`
+
+### StatsCondition
+
+This interaction will fail if the User entity cannot afford the specified stats costs, or if it does not have the
+requested stats.
+
+| Field Name | Type                                                         | Required? | Notes                                                                                                                                                                                    |
+| ---------- | ------------------------------------------------------------ | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Costs      | `Map`<br />(Key Type:` EntityStatType`, Value Type: `Float`) | **Yes**   | A set of costs that the User entity needs to be able to afford for this interaction to succeed.                                                                                          |
+| ValueType  | `ValueType`<br />(Default: Absolute)                         | **No**    | Whether the values in the `Costs` map represetn flat values or percentages (0.0-100.0).  Percentage values are percentage of the difference between the maximum and minimum value.       |
+| LessThan   | `Boolean`<br />(Default: false)                              | **No**    | If true, this interaction will fail unless the User entity's current stat values are at or **below** the specified levels.  If false, they must be at or **above** the specified levels. |
+| Lenient    | `Boolean`<br />(Default: false)                              | **No**    | If true and `LessThan` is true, and a player's minimum stat value is below zero, then the player can afford a stat cost if the current value of a stat if above 0.                       |
+
+**ValueType Values**
+
+- `Absolute`
+- `Percent`
+
+### StatsConditionWithModifier
+
+This interaction is like StatsCondition, except an armor stat modifier can be chosen which will apply bonuses and penalties
+to a stat's cost from the User entity's equipped armor before it is compared.
+
+| Field Name            | Type                                                         | Required? | Notes                                                                                                                                                                                    |
+| --------------------- | ------------------------------------------------------------ | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Costs                 | `Map`<br />(Key Type:` EntityStatType`, Value Type: `Float`) | **Yes**   | A set of costs that the User entity needs to be able to afford for this interaction to succeed.                                                                                          |
+| ValueType             | `ValueType`<br />(Default: Absolute)                         | **No**    | Whether the values in the `Costs` map represetn flat values or percentages (0.0-100.0).  Percentage values are percentage of the difference between the maximum and minimum value.       |
+| LessThan              | `Boolean`<br />(Default: false)                              | **No**    | If true, this interaction will fail unless the User entity's current stat values are at or **below** the specified levels.  If false, they must be at or **above** the specified levels. |
+| Lenient               | `Boolean`<br />(Default: false)                              | **No**    | If true and `LessThan` is true, and a player's minimum stat value is below zero, then the player can afford a stat cost if the current value of a stat if above 0.                       |
+| InteractionModifierId | `InteractionModifierId`                                      | **Yes**   | The armor interaction modifier to apply bonuses and penalties for.                                                                                                                       |
+
+**ValueType Values**
+
+- `Absolute`
+- `Percent`
+
+**InteractionModifierId Values**
+
+- `Dodge`
+
+## EntityEffects
+
+EntityEffects are buff or debuff effects that can be applied to a LivingEntity.  These can have a variety of effects from
+movement speed changes to periodic damage.
+
+### EffectCondition
+
+This interaction will fail if the specified entity's EntityEffects do not match the provided conditions.
+
+**EffectCondition Fields**
+
+| Field Name      | Type                                             | Required? | Notes                                                                                                                                                                                                             |
+| --------------- | ------------------------------------------------ | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Entity          | `InteractionTarget`<br />(Default: User)         | **Yes**   | The entity to examine for EntityEffects. This field can indicate the Owner, User, or Target of this interaction chain.                                                                                            |
+| Match           | `Match`<br />(Default: All)                      | **No**    | If `All`, then this interaction will fail if any EntityEffect in the `EntityEffectIds` is not on the specified entity. If `None`, then this interaction will fail if any EntityEffect IS on the specified entity. |
+| EntityEffectIds | `AssetArray`<br />(Element Type: `EntityEffect`) | **Yes**   | The set of EntityEffects to check against the specified entity and `Match`.                                                                                                                                       |
+
+**InteractionTarget Values**
+
+- `User` - The user of this interaction chain. The entity whose actions caused this interaction chain to be executed. This is usually the same as the Owner.
+- `Owner` - The owner of this interaction chain. The entity upon whom this interaction chain is executing.
+- `Target` - The entity target of this interaction chain, if any.  This value is mutable (and can therefore come from many places) but most commonly, it is an entity the User was targeting when this interaction chain began executing.
+
+**Match Values**
+
+- `All` - All EntityEffects must be on the specified entity for this interaction to succeed.
+- `None` - None of the EntityEffects must be on the specified entity for this interaction to succeed.
+
+### ApplyEffect
+
+This interaction will apply the specified EntityEffect to the specified Entity.  It has no special failure conditions.
+
+**ApplyEffect Fields**
+
+| Field Name | Type                                      | Required? | Notes                                                                                                                  |
+| ---------- | ----------------------------------------- | --------- | ---------------------------------------------------------------------------------------------------------------------- |
+| Entity     | `InteractionTarget`<br />(Default: User)  | **Yes**   | The entity to apply the EntityEffect to. This field can indicate the Owner, User, or Target of this interaction chain. |
+| EffectId   | `Asset`<br />(Asset Type: `EntityEffect`) | **Yes**   | The effect to apply.                                                                                                   |
+
+**InteractionTarget Values**
+
+- `User` - The user of this interaction chain. The entity whose actions caused this interaction chain to be executed. This is usually the same as the Owner.
+- `Owner` - The owner of this interaction chain. The entity upon whom this interaction chain is executing.
+- `Target` - The entity target of this interaction chain, if any.  This value is mutable (and can therefore come from many places) but most commonly, it is an entity the User was targeting when this interaction chain began executing.
+
+### ClearEntityEffect
+
+This interaction will remove the specified EntityEffect from the specified Entity. It has no special failure conditions.
+It will not fail if the Entity does not have the EntityEffect.
+
+**ClearEntityEffect Fields**
+
+| Field Name | Type                                      | Required? | Notes                                                                                                                     |
+| ---------- | ----------------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------- |
+| Entity     | `InteractionTarget`<br />(Default: User)  | **Yes**   | The entity to remove the EntityEffect from. This field can indicate the Owner, User, or Target of this interaction chain. |
+| EffectId   | `Asset`<br />(Asset Type: `EntityEffect`) | **Yes**   | The effect to remove.                                                                                                     |
+
+**InteractionTarget Values**
+
+- `User` - The user of this interaction chain. The entity whose actions caused this interaction chain to be executed. This is usually the same as the Owner.
+- `Owner` - The owner of this interaction chain. The entity upon whom this interaction chain is executing.
+- `Target` - The entity target of this interaction chain, if any.  This value is mutable (and can therefore come from many places) but most commonly, it is an entity the User was targeting when this interaction chain began executing.
+
+## Farming
+
+These are interaction types built to support the in-game farming system in Hytale. They are mostly block-related interactions
+with a few exceptions.
+
+### ChangeFarmingStage
+
+If the target block is a farming block, this interaction will attempt to modify the current farming stage in one of
+three ways.  The interaction can optionally specify which StageSet to use for the new stage. If it is not specified,
+the current StageSet will be used. If any part of the the process of changing the growth stage fails, this interaction
+will fail, with the one exception that attempting to set the stage to the crop's existing stage will have no effect but
+still succeed.
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                                                                                                                                                                          |
+| ---------------- | ------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction.                                                                                                                                              |
+| StageSet         | `String`                        | **No**    | If provided, set the block's current stage to one in the provided StageSet. Otherwise, use the crop's current StageSet.                                                                                                                                                        |
+| Increase         | `Integer`                       | **No**    | If provided, increase the current stage by the specified amount. If the specified stage does not exist, the block will be set to the closest extant stage.                                                                                                                     |
+| Decrease         | `Integer`                       | **No**    | If provided and `Increase` is not provided, decrease the current stage by the specified amount. If the specified stage does not exist, the block will be set to the closest extant stage.                                                                                      |
+| Stage            | `Integer`<br />(Default: -1)    | **No**    | If provided and `Increase`/`Decrease` are not provided, set the current stage to the specified stage. If this value is less than 0, set the current stage to the final growth stage. If the specified stage does not exist, the block will be set to the closest extant stage. |
+
+### FertilizeSoil
+
+If the target block is unfertilized tilled soil or a farming block on top of unfertilized tilled soil, fertilizes the soil.
+The interaction will fail otherwise.
+
+**FertilizeSoil Fields**
+
+| Field Name       | Type                                  | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false)       | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+| RefreshModifiers | `Array`<br />(Element Type: `String`) | **No**    | Does nothing.                                                                                                                     |
+
+### HarvestCrop
+
+This interaction will attempt to execute the harvest action on the current block target and add the crop's drops to the User entity's
+inventory.  The block will either be destroyed or set to its post-harvest growth stage, depending on the farming
+configuration of the block.  This will happen (and the player will receive the full harvest drops) regardless of the
+block's current growth stage. This interaction has no special failure conditions, even if the block target isn't a
+farming block or gathering isn't permitted in the current world, but nothing will occur in those cases.
+
+**HarvestCrop Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+
+### UseWateringCan
+
+If the target block is tilled soil or a farming block on top of tilled soil, waters the soil for the specified duration.
+The interaction will fail otherwise.
+
+**UseWateringCan Fields**
+
+| Field Name       | Type                                  | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false)       | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+| Duration         | `Integer`<br />(Default: 0)           | **No**    | The duration in seconds to water the soil for.                                                                                    |
+| RefreshModifiers | `Array`<br />(Element Type: `String`) | **No**    | Does nothing.                                                                                                                     |
diff --git a/content/docs/ar-SA/contributing/pr-guidelines.mdx b/content/docs/ar-SA/contributing/pr-guidelines.mdx
index 7a251032..c226da04 100644
--- a/content/docs/ar-SA/contributing/pr-guidelines.mdx
+++ b/content/docs/ar-SA/contributing/pr-guidelines.mdx
@@ -19,6 +19,8 @@ To ensure a smooth and efficient review process, both contributors and reviewers
 4. **Code Quality**
    - Ensure your code follows the project's coding standards and best practices.
    - Include comments where necessary to explain complex logic.
+   - Always test your changes locally before submitting the PR to catch any issues early.
+   - Format your code using `bun format` to maintain consistency across the codebase.
 5. **Testing**
    - Test your changes thoroughly before submitting the PR.
    - If applicable, include unit tests or integration tests to verify your changes.
diff --git a/content/docs/ar-SA/contributing/translate.mdx b/content/docs/ar-SA/contributing/translate.mdx
new file mode 100644
index 00000000..c62ffdde
--- /dev/null
+++ b/content/docs/ar-SA/contributing/translate.mdx
@@ -0,0 +1,74 @@
+---
+title: Translate
+description: How to translate HytaleModding to your language
+---
+
+# Translating HytaleModding
+
+HytaleModding is translated with the help of the community using **Crowdin**. If you want to help translate or improve existing translations, this is the right place.
+
+## Steps to Translate
+
+All translations are managed **via Crowdin**.
+
+1. Visit [our Crowdin project](https://crowdin.com/project/hytalemodding) and log in if required.
+2. Click on your language.
+3. Click on the file/article you wish to translate. We recommend starting with Official Documentation, and then Server Plugin Documentation.
+4. Start translating!
+5. Approved translations will appear on the website.
+
+### Video Guide
+
+<iframe src="https://www.youtube.com/embed/NHiG1rDRgks" allowFullScreen />
+
+## How to discuss
+
+You can always report issues or discuss specific topics directly on Crowdin, but we recommend using Discord instead of the Crowdin comment system to keep everything organized in one place.
+
+1. Join [our Discord](https://discord.gg/hytalemodding)
+2. Open `#translations` channel. Here you can discuss or ask questions that are not related to a specific language.
+3. If you want to join a thread, you are required to run `/translator <your-language>` command here. The bot will add you to the thread for your language.
+
+## Translation Guidelines
+
+- You need to be confident in what you are translating. You should be able to read the text you just translated and understand the meaning of it very easily.
+- It should use the simplest form of language possible. Use English words if the translation is unknown to the majority in your country.
+- Use your imagination, trust yourself. Feel free to change any context as you wish as long as it can still get the same point across and is understandable.
+- These guidelines are more important than language-specific guidelines, but less important than Hytale terminology and rules.
+
+## What not to translate
+
+We request you all to not translate these specific sections of the website:
+
+### Callout types
+
+Callouts are the boxes that contain important information. We request you to not translate the types as they only work in English.
+
+**Example:**
+
+```mdx
+<Callout type="warning" title="Translate this title!">
+Translate the text inside the callout!
+</Callout>
+```
+
+In this example, please don't translate the word warning, the rest you can translate.
+
+### Icons
+
+Icon names must not be translated.
+They are technical identifiers mapped directly to existing icons. Translating them will break the icon rendering.
+
+```mdx
+icon: Globe
+```
+
+---
+
+{/* 
+For translators who will edit this page:
+
+- You are required to translate the Guidelines as they change.
+- General guidelines should be translated but not edited.
+- Learn how to use Markdown from writing_guides.mdx
+*/}
diff --git a/content/docs/ar-SA/established-information/server/content-categories/art-assets.mdx b/content/docs/ar-SA/established-information/server/content-categories/art-assets.mdx
index 39c2ed37..1e926874 100644
--- a/content/docs/ar-SA/established-information/server/content-categories/art-assets.mdx
+++ b/content/docs/ar-SA/established-information/server/content-categories/art-assets.mdx
@@ -14,7 +14,7 @@ Hytale provides comprehensive support for 3D modeling and texture art creation,
 Hytale uses **Blockbench** as the primary tool for 3D modeling and animation:
 
 * **Official support**: Used for "creating Hytale models, textures, and animations"
-* **Special plugin**: Hytale will have a dedicated Blockbench plugin, to be released ASAP
+* **Special plugin**: Hytale has a dedicated [Blockbench Plugin](https://www.blockbench.net/plugins/hytale_plugin).
 * **Direct compatibility**: The plugin allows creators to "create Hytale-compatible models, textures, and animations directly in Blockbench"
 * **Replaces legacy tools**: Fully replaces the old Hytale Model Maker to better support established creative workflows in the community
 * **Safety features**: Only allows you to add things compatible with the engine, so no need to worry about breaking anything
diff --git a/content/docs/ar-SA/guides/ecs/block-components.mdx b/content/docs/ar-SA/guides/ecs/block-components.mdx
new file mode 100644
index 00000000..ca68b38a
--- /dev/null
+++ b/content/docs/ar-SA/guides/ecs/block-components.mdx
@@ -0,0 +1,247 @@
+---
+title: Block Components
+description: Learn how to use the block components.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+  - name: oskarscot
+    link: https://oskar.scot
+---
+
+# Overview
+
+In this guide, you'll learn how to use block components to create a ticking block.
+
+<Callout>
+  For a more complete reference, you may also want to review FarmingSystems.Ticking, as much of the underlying logic is based on its implementation.
+</Callout>
+
+## Steps
+
+### 1. ExampleBlock - holds block behavior
+
+```java
+public class ExampleBlock implements Component<ChunkStore> {
+
+    public static final BuilderCodec CODEC = BuilderCodec.builder(ExampleBlock.class, ExampleBlock::new).build();
+
+    // Components usually require a copy constructor as well but since we don't actually hold any data in this component this is not neccessary
+    public ExampleBlock() { }
+
+    public static ComponentType getComponentType() {
+        return ExamplePlugin.get().getExampleBlockComponentType();
+    }
+
+    @Nullable
+    public Component<ChunkStore> clone() {
+        return new ExampleBlock();
+    }
+}
+```
+
+ExampleBlock is a custom component that stores the behavior and data for your ticking block. Here, it simply places an Ice Block at x + 1 relative to its current position when it ticks.
+
+---
+
+### 2. ExampleInitializer - marks blocks as ticking when placed
+
+```java
+public class ExampleInitializer extends RefSystem {
+
+    @Override
+    public void onEntityAdded(@Nonnull Ref ref, @Nonnull AddReason reason, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+        BlockModule.BlockStateInfo info = (BlockModule.BlockStateInfo) commandBuffer.getComponent(ref, BlockModule.BlockStateInfo.getComponentType());
+        if (info == null) return;
+
+        ExampleBlock generator = (ExampleBlock) commandBuffer.getComponent(ref, ExamplePlugin.get().getExampleBlockComponentType());
+        if (generator != null) {
+            int x = ChunkUtil.xFromBlockInColumn(info.getIndex());
+            int y = ChunkUtil.yFromBlockInColumn(info.getIndex());
+            int z = ChunkUtil.zFromBlockInColumn(info.getIndex());
+
+            WorldChunk worldChunk = (WorldChunk) commandBuffer.getComponent(info.getChunkRef(), WorldChunk.getComponentType());
+            if (worldChunk != null) {
+				worldChunk.setTicking(x, y, z, true);
+            }
+        }
+    }
+
+    @Override
+    public void onEntityRemove(@Nonnull Ref ref, @Nonnull RemoveReason reason, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+    }
+
+    @Override
+    public Query getQuery() {
+        return Query.and(BlockModule.BlockStateInfo.getComponentType(), ExamplePlugin.get().getExampleBlockComponentType());
+    }
+}
+```
+
+ExampleInitializer is a RefSystem that reacts when block entities with the ExampleBlock component are added or removed. This is crucial for marking blocks as ticking when they're first placed.
+
+**Key Points:**
+
+- Tells the game that this block should tick, allowing `ExampleSystem` to process it.
+
+```java
+worldChunk.setTicking(x, y, z, true);
+```
+
+---
+
+### 3. ExampleSystem - handles ticking
+
+```java
+public class ExampleSystem extends EntityTickingSystem {
+
+    public void tick(float dt, int index, @Nonnull ArchetypeChunk archetypeChunk, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+        BlockSection blocks = (BlockSection) archetypeChunk.getComponent(index, BlockSection.getComponentType());
+
+        assert blocks != null;
+
+        if (blocks.getTickingBlocksCountCopy() != 0) {
+            ChunkSection section = (ChunkSection) archetypeChunk.getComponent(index, ChunkSection.getComponentType());
+
+            assert section != null;
+
+            BlockComponentChunk blockComponentChunk = (BlockComponentChunk) commandBuffer.getComponent(section.getChunkColumnReference(), BlockComponentChunk.getComponentType());
+
+            assert blockComponentChunk != null;
+
+            blocks.forEachTicking(blockComponentChunk, commandBuffer, section.getY(), (blockComponentChunk1, commandBuffer1, localX, localY, localZ, blockId) -> {
+                Ref<ChunkStore> blockRef = blockComponentChunk.getEntityReference(ChunkUtil.indexBlockInColumn(localX, localY, localZ));
+                if (blockRef == null) {
+                    return BlockTickStrategy.IGNORED;
+                } else {
+                    ExampleBlock exampleBlock = (ExampleBlock) commandBuffer1.getComponent(blockRef, ExampleBlock.getComponentType());
+                    if (exampleBlock != null) {
+                        WorldChunk worldChunk = (WorldChunk) commandBuffer.getComponent(section.getChunkColumnReference(), WorldChunk.getComponentType());
+                        World world = worldChunk.getWorld();
+
+                        int globalX = localX + (worldChunk.getX() * 32);
+                        int globalZ = localZ + (worldChunk.getZ() * 32);
+
+                        // We need to execute setBlock on the world thread as you cannot call store functions from a system
+                        // This is because of the architecture of the server, depending on your needs you can also use the CommandBuffer
+                        world.execute(() -> {
+                            world.setBlock(globalX + 1, localY, globalZ, "Rock_Ice");
+                        });
+
+                        return BlockTickStrategy.CONTINUE;
+
+                    } else {
+                        return BlockTickStrategy.IGNORED;
+                    }
+                }
+            });
+        }
+    }
+
+    @Nullable
+    public Query getQuery() {
+        return Query.and(BlockSection.getComponentType(), ChunkSection.getComponentType());;
+    }
+}
+```
+
+ExampleSystem is an EntityTickingSystem that runs every tick to execute the logic for all ticking blocks with the ExampleBlock component.
+
+**Key Points:**
+
+- **Get the block component**
+
+```java
+ExampleBlock exampleBlock = (ExampleBlock) commandBuffer.getComponent(blockRef, ExampleBlock.getComponentType());
+```
+
+- **Convert local chunk coordinates to world coordinates**
+
+```java
+int globalX = localX + (worldChunk.getX() * 32);
+int globalZ = localZ + (worldChunk.getZ() * 32);
+```
+
+- **Run the block logic**
+
+```java
+exampleBlock.runBlockAction(globalX, localY, globalZ, worldChunk.getWorld());
+```
+
+- **Keep the block ticking in the next tick**
+
+```java
+return BlockTickStrategy.CONTINUE;
+```
+
+---
+
+### 4. ExamplePlugin - registers components and systems
+
+```java
+public class ExamplePlugin extends JavaPlugin {
+    protected static ExamplePlugin instance;
+    private static final HytaleLogger LOGGER = HytaleLogger.forEnclosingClass();
+    private ComponentType exampleBlockComponentType;
+
+    public static ExamplePlugin get() {
+        return instance;
+    }
+
+    public ExamplePlugin(@Nonnull JavaPluginInit init) {
+        super(init);
+        LOGGER.atInfo().log("Hello from " + this.getName() + " version " + this.getManifest().getVersion().toString());
+    }
+
+    @Override
+    protected void setup() {
+        instance = this;
+        LOGGER.atInfo().log("Setting up plugin " + this.getName());
+        this.exampleBlockComponentType = this.getChunkStoreRegistry().registerComponent(ExampleBlock.class, "ExampleBlock", ExampleBlock.CODEC);
+    }
+	
+	@Override
+	protected void start() {
+		this.getChunkStoreRegistry().registerSystem(new ExampleSystem());
+		this.getChunkStoreRegistry().registerSystem(new ExampleInitializer());
+	}
+
+    public ComponentType getExampleBlockComponentType() {
+        return this.exampleBlockComponentType;
+    }
+}
+```
+
+---
+
+### 5. Configure In-Game
+
+![block-component-1](/assets/guides/block-component-1.png)
+
+![block-component-2](/assets/guides/block-component-2.png)
+
+With this logic, the block will now continuously place an Ice Block at the coordinates x + 1 relative to its current position every time it ticks.
+
+---
+
+## Common Issues
+
+### NullPointerException on Startup
+
+**Error message:**
+
+```java
+java.lang.NullPointerException: Cannot invoke "com.hypixel.hytale.component.query.Query.validateRegistry(com.hypixel.hytale.component.ComponentRegistry)" because "query" is null
+```
+
+**Cause:**
+This error occurs when your module is loaded **before** the required Hytale modules.
+
+**Fix:**
+Add `EntityModule` and `BlockModule` as dependencies in your `manifest.json` to ensure proper load order.
+
+```json
+"Dependencies": {
+  "Hytale:EntityModule": "*",
+  "Hytale:BlockModule": "*"
+}
+```
diff --git a/content/docs/ar-SA/guides/ecs/hytale-ecs-theory.mdx b/content/docs/ar-SA/guides/ecs/hytale-ecs-theory.mdx
index 20c3a94d..52d8b1f5 100644
--- a/content/docs/ar-SA/guides/ecs/hytale-ecs-theory.mdx
+++ b/content/docs/ar-SA/guides/ecs/hytale-ecs-theory.mdx
@@ -29,7 +29,7 @@ for now this is the basic understanding for the `ChunkStore`. You can use it to
 
 ## Holder
 
-A Holder is essentially a blueprint for an entity. Before an entity exists in the Store (and thus in the world), is exists as a `Holder`. It collects and holds all the necessary components (data). You can compare it analogous to shopping cart. You grab all components you need and once you have everything, check out at the store which will take your cart and create a valid entity ID and hand you back a receipt (a Ref).
+A Holder is essentially a blueprint for an entity. Before an entity exists in the Store (and thus in the world), it exists as a `Holder`. It collects and holds all the necessary components (data). You can compare it analogous to shopping cart. You grab all components you need and once you have everything, check out at the store which will take your cart and create a valid entity ID and hand you back a receipt (a Ref).
 
 Let's take a look at an example: initializing players. In `Universe`, the `addPlayer` method demonstrates it perfectly.
 When a player connects, we don't immediately throw them into the ECS. We first construct their data in a Holder.
@@ -167,7 +167,7 @@ MyComponent comp = commandBuffer.getComponent(ref, componentType);
 
 Codecs handle serialization and deserialization of components. Hytale uses them to save and load entity data to and from disk as well as sending component data over the network. When creating a custom component, you must also create a corresponding Codec.
 
-There are mutliple Codec types already implemented in the default Codec Interface:
+There are multiple Codec types already implemented in the default Codec Interface:
 
 - Codec.STRING
 - Codec.BOOLEAN
@@ -215,7 +215,7 @@ This might seem tedious at first but it ensures that your component can be corre
   KeyedCodec<Integer> exampleInt = new KeyedCodec<Integer>("ExampleIntIdForCodec", Codec.INTEGER);
   ```
 
-- **Setter Function**: This is a lambda function that takes an instance of your component and returns the value of the field you want to serialize. For example, if you have a field called `myCustomField` in your custom component, your getter function would look like this:
+- **Setter Function**: This is a lambda function that takes an instance of your component + the value to set and sets the field value on the component. For example, if you have a field called `myCustomField` in your custom component, your setter function would look like this:
   ```java
   (data, value) -> data.myCustomField = value
   ```
@@ -276,7 +276,7 @@ public class PoisonComponent implements Component<EntityStore> {
 
 You can also add validators to your Codec fields to ensure that the data being serialized/deserialized meets certain criteria. For example, if you want to ensure that the `damagePerTick` field is always non-negative or the poison name is never null, you can add a validator like this:
 
-````java
+```java
 .append(
     new KeyedCodec<Float>("DamagePerTick", Codec.FLOAT),
     (data, value) -> data.damagePerTick = value,
@@ -292,14 +292,15 @@ You can also add validators to your Codec fields to ensure that the data being s
 )
 .addValidator(Validators.nonNull())
 .add()
+```
 
 ### Complex Codec Examples
 
-If you want to have a map inside your component, you can use the MapCodec class to build a KeyedCoded for it. Here's an example of how to create a Codec for a Map field:
+If you want to have a map inside your component, you can use the MapCodec class to build a KeyedCodec for it. Here's an example of how to create a Codec for a Map field:
 
 ```java
 var damagePerTick = new KeyedCodec<>("DamagePerTick", new MapCodec<>(Codec.FLOAT, HashMap<String, Float>::new));
-````
+```
 
 <Callout type="info">
   This also works with custom Objects as long as you have a Codec defined for the Object type.
diff --git a/content/docs/ar-SA/guides/java-basics/00-introduction.mdx b/content/docs/ar-SA/guides/java-basics/00-introduction.mdx
index a03ad638..b0130d74 100644
--- a/content/docs/ar-SA/guides/java-basics/00-introduction.mdx
+++ b/content/docs/ar-SA/guides/java-basics/00-introduction.mdx
@@ -7,7 +7,7 @@ Welcome to your journey into Java Programming! This guide is designed to introdu
 
 ## What is Java?
 
-Java is a powerful, object-oriented programming language created in 1995. It's one of the most popular programming languages in the world and is used for everything from mobile apps to enterprise software. Most importantly for us, it's the language Hytale uses for it's servers & modding API.
+Java is a powerful, object-oriented programming language created in 1995. It's one of the most popular programming languages in the world and is used for everything from mobile apps to enterprise software. Most importantly for us, it's the language Hytale uses for its servers & modding API.
 
 ## What You'll Learn
 
diff --git a/content/docs/ar-SA/guides/java-basics/02-operators.mdx b/content/docs/ar-SA/guides/java-basics/02-operators.mdx
index a132b1c0..18634665 100644
--- a/content/docs/ar-SA/guides/java-basics/02-operators.mdx
+++ b/content/docs/ar-SA/guides/java-basics/02-operators.mdx
@@ -119,7 +119,7 @@ String greetingWithName = "Hello, " + name + "!"; // "Hello, Alice!"
 
 ## Operator Precedence
 
-Operator Precendence means which operator gets evaluated first in an line of code. Think of it like BODMAS/PEMDAS in math!
+Operator Precedence means which operator gets evaluated first in an line of code. Think of it like BODMAS/PEMDAS in math!
 
 ```java
 int result = 10 + 5 * 2; // result is 20, not 30
diff --git a/content/docs/ar-SA/guides/java-basics/03-control-flow-if.mdx b/content/docs/ar-SA/guides/java-basics/03-control-flow-if.mdx
index b9d6c479..af2d1c22 100644
--- a/content/docs/ar-SA/guides/java-basics/03-control-flow-if.mdx
+++ b/content/docs/ar-SA/guides/java-basics/03-control-flow-if.mdx
@@ -7,7 +7,7 @@ Programs need to make decisions. If statements let your code choose different pa
 
 ## Basic If Statement
 
-The simplest form checks one condition;
+The simplest form checks one condition:
 
 ```java
 int health = 20;
diff --git a/content/docs/ar-SA/guides/java-basics/08-access-modifiers.mdx b/content/docs/ar-SA/guides/java-basics/08-access-modifiers.mdx
index af560932..da2bf33b 100644
--- a/content/docs/ar-SA/guides/java-basics/08-access-modifiers.mdx
+++ b/content/docs/ar-SA/guides/java-basics/08-access-modifiers.mdx
@@ -484,7 +484,7 @@ class Data {
     // Static member:
     // cannot access to non-static variables
     public static void bar() {
-        x = 100; // Error: non-static variable x cannot be renference from a static context
+        x = 100; // Error: non-static variable x cannot be referenced from a static context
         y = 100; // OK
     }
 }
@@ -504,7 +504,7 @@ Data.x = 1000; // Error: cannot access instanced variables in a static context
 
 ### Static Fields
 
-A static field represents a data member owned by the class type rather then the object. Static fields are also stored in a specific memory location that's been shared between all the object instances that are created.
+A static field represents a data member owned by the class type rather than the object. Static fields are also stored in a specific memory location that's been shared between all the object instances that are created.
 
 It is declared as following:
 
diff --git a/content/docs/ar-SA/guides/plugin/animated-block-textures.mdx b/content/docs/ar-SA/guides/plugin/animated-block-textures.mdx
new file mode 100644
index 00000000..42bfa51f
--- /dev/null
+++ b/content/docs/ar-SA/guides/plugin/animated-block-textures.mdx
@@ -0,0 +1,101 @@
+---
+title: Animated Block Textures
+description: Learn how to attach a .blockyanim to a block
+authors:
+  - name: Burkino
+---
+
+import { File, Folder, Files } from 'fumadocs-ui/components/files';
+
+So, you want to make your blocks feel more alive through animations, do you?\
+Now for the most part this is the exact same as [Creating custom blocks](./creating-block).
+![blue fire gif](/assets/guides/blue_fire.gif)
+
+## Prerequisites
+
+This is NOT a guide on animating or texturing or even using BlockBench, why? Because I don't know how to do that.\
+The only thing we will be doing is taking the fire texture, changing the color, and applying it to our new fire block.
+
+## Setup
+
+To start, you're obviously going to want to grab the `Common/VFX/Fire/Fire.png` file. How you do it is up to you, in the Asset Editor you'll need to switch to the Common tab.\
+I'll assume you know how colorize or change the hue of an image, so go ahead and do that now and save it as `Blue_Fire.png`.
+
+The other assets used in this guide are `Common/VFX/Fire/Fire.blockymodel` and `Common/Blocks/Animations/Fire/Fire_Burn.blockyanim` (both renamed to `Blue_Fire`) but since we won't be changing them it's probably fine to leave them. I will reference the `Blue_Fire` versions as a way to point out what should be custom assets.\
+I will also duplicate `Server/Item/Item/Deco/Deco_Fire.json` and call it `Deco_Blue_Fire.json`.
+
+## Applying the changes
+
+The `Deco_Blue_Fire` block is actually just a particle emitter, however we will not be using particles, so lets start by removing them in `Block > Particles`.\
+Next we want to set the Block Model (called `CustomModel` in JSON) to `VFX/Blue_Fire/Blue_Fire.blockymodel` and Block Model Textures (`CustomModelTexture` in JSON) to
+
+```json
+[
+    {
+        "Texture": "VFX/Blue_Fire/Blue_Fire.png",
+        "Weight": 1
+    }
+]
+```
+
+Finally, we will apply the .blockyanim to our model, this is done through the Block Model Animation property (`CustomModelAnimation` in JSON) and the value should be `Blocks/Animations/Blue_Fire/Blue_Fire_Burn.blockyanim`.
+
+## Final Code
+
+With that your new blue fire should be done. Here is the minimal JSON for our blue fire.\
+There is an additional `Looping` and `RequiresAlphaBlending` property that I have not gone over, however I hope it is self-explanatory.
+
+```json
+{
+  "BlockType": {
+    "DrawType": "Model",
+    "CustomModel": "VFX/Blue_Fire/Blue_Fire.blockymodel",
+    "CustomModelAnimation": "Blocks/Animations/Blue_Fire/Blue_Fire_Burn.blockyanim",
+    "CustomModelTexture": [
+      {
+        "Texture": "VFX/Blue_Fire/Blue_Fire.png",
+        "Weight": 1
+      }
+    ],
+    "Looping": true,
+    "RequiresAlphaBlending": false
+  },
+  "PlayerAnimationsId": "Block"
+}
+```
+
+<Files>
+  <Folder name="resources" defaultOpen>
+    <Folder name="Server" defaultOpen>
+      <Folder name="Item" defaultOpen>
+        <Folder name="Items" defaultOpen>
+          <Folder name="Deco" defaultOpen>
+            <File name="Deco_Blue_Fire.json" />
+          </Folder>
+        </Folder>
+      </Folder>
+    </Folder>
+
+    <Folder name="Common" defaultOpen>
+      <Folder name="Blocks" defaultOpen>
+        <Folder name="Animations" defaultOpen>
+          <Folder name="Blue_Fire" defaultOpen>
+            <File name="Blue_Fire_Burn.blockyanim" />
+          </Folder>
+        </Folder>
+      </Folder>
+
+      <Folder name="VFX" defaultOpen>
+        <Folder name="Blue_Fire" defaultOpen>
+          <File name="Blue_Fire.blockymodel" />
+
+          <File name="Blue_Fire.png" />
+        </Folder>
+      </Folder>
+    </Folder>
+  </Folder>
+</Files>
+
+## Next steps
+
+Now that you know how to attach an animation to a block, try adding it to a block state.
diff --git a/content/docs/ar-SA/guides/plugin/build-and-test.mdx b/content/docs/ar-SA/guides/plugin/build-and-test.mdx
index 0e7fe7eb..f37534c3 100644
--- a/content/docs/ar-SA/guides/plugin/build-and-test.mdx
+++ b/content/docs/ar-SA/guides/plugin/build-and-test.mdx
@@ -9,18 +9,18 @@ If you followed along with the [Setting Up Your Development Environment](./setti
 
 ## Building Your Mod
 
-In our case, we've **Maven** as the build system. Maven is a powerful build automation tool that manages dependencies, compiles your code, and packages everything into a distributable JAR file.
+In our case, we've **Gradle** as the build system. Gradle is a powerful build automation tool that manages dependencies, compiles your code, and packages everything into a distributable JAR file.
 
-### Understanding Maven
+### Understanding Gradle
 
-Maven uses a `pom.xml` file (Project Object Model) to define your project's configuration, dependencies, and build settings. You can learn more about Maven at the [official Apache Maven website](https://maven.apache.org/).
+Gradle can use a `build.gradle.kts` file (Kotlin DSL) to define your project's configuration, dependencies, and build settings. You can learn more about Gradle at the [official Gradle website](https://gradle.org/).
 
-### Building with Maven
+### Building with Gradle
 
 To build your mod, open a terminal in your project directory and run:
 
 ```bash
-mvn package
+./gradlew build
 ```
 
 This command will:
@@ -29,16 +29,35 @@ This command will:
 2. Run any tests (if present)
 3. Package everything into a JAR file
 
+<Callout type="info">
+  If you are using the plugin template from the [Setting Up Your Development Environment](./setting-up-env) guide, then the build script is already set up for you. It includes paths to your Hytale game library and handles the packaging of your mod, managing hytale dependencies and manifest changes.
+
+  If you have a different path to your Hytale installation, you may receive the following error:
+
+  ```bash
+  FAILURE: Build failed with an exception.
+
+  * What went wrong:
+  Failed to find Hytale at the expected location. Please make sure you have installed the game. The expected location can be changed using the hytale.home_path property. Currently looking in 'C:\Path\To\Hytale'
+  ```
+
+  You can change the path by adding a property to your `gradle.properties` file (if it doesn't exist, create it in the root of your project):
+
+  ```properties
+  hytale.home_path=C:\Correct\Path\To\Hytale
+  ```
+</Callout>
+
 ### Build Output
 
-Once the build completes successfully, your mod will be located in the `target` directory and named:
+Once the build completes successfully, your mod will be located in the `build/libs` directory and named:
 
 ```
-ExamplePlugin-1.0-SNAPSHOT.jar
+ExamplePlugin-1.0.jar
 ```
 
 <Callout type="info">
-  The exact name may vary depending on what you configured in your `pom.xml` file. Check the `artifactId` and `version` fields to see what your JAR will be named.
+  The exact name may vary depending on what you configured in your `build.gradle.kts` and `settings.gradle.kts` file. Check the `rootProject.name` and `version` fields to see what your JAR will be named.
 </Callout>
 
 ## Testing Your Mod
@@ -49,11 +68,11 @@ Now that you've built your mod, it's time to test it in Hytale!
 
 First, you need to find Hytale's mods directory:
 
-1. Press **Win + R** on your keyboard
-2. Type `%appdata%` and press Enter
-3. Navigate to: `Hytale\UserData\Mods`
+1. Go to your Hytale installation directory (The default location is usually in your AppData folder)
+   > On Windows, you can access it by clicking `windows + R` and typing `%appdata%`.
+2. Navigate to: `/UserData/Mods`
 
-The full path should look like:
+The default path would look like:
 
 ```
 C:\Users\YourUsername\AppData\Roaming\Hytale\UserData\Mods
@@ -65,7 +84,7 @@ C:\Users\YourUsername\AppData\Roaming\Hytale\UserData\Mods
 
 ### 2. Copy Your Mod
 
-Copy the `ExamplePlugin-1.0-SNAPSHOT.jar` file from your project's `target` directory into the `Mods` folder you just located.
+Copy the `ExamplePlugin-1.0.jar` file from your project's `build/libs` directory into the `Mods` folder you just located.
 
 ### 3. Launch Hytale and Verify
 
@@ -84,7 +103,7 @@ If your mod doesn't appear in the mods list:
 - Make sure the JAR file is in the correct `Mods` folder
 - Check that your `manifest.json` file is properly configured
 - Look for any error messages in the Hytale logs
-- Verify that you're using the correct version of Java and Maven
+- Verify that you're using the correct version of Java and Gradle
 
 ## Next Steps
 
diff --git a/content/docs/ar-SA/guides/plugin/creating-commands.mdx b/content/docs/ar-SA/guides/plugin/creating-commands.mdx
index d33597f3..08572f16 100644
--- a/content/docs/ar-SA/guides/plugin/creating-commands.mdx
+++ b/content/docs/ar-SA/guides/plugin/creating-commands.mdx
@@ -8,6 +8,8 @@ authors:
     url: https://oskar.scot
   - name: jacobwojoski
     url: https://github.com/jacobwojoski
+  - name: Marcel-TO
+    url: https://marcel-to.net
 ---
 
 In this guide, you will learn how to create custom commands for your Hytale mod.
@@ -36,7 +38,7 @@ The most basic command is an `AbstractAsyncCommand`. It has very minimal data av
   `AbstractAsyncCommand` runs on its own background thread. This means its execute is not tied to any world instance and because of this it can not edit any **Stores** or **Refs** without getting the desired world first. To access this data any of the other command types would be preferred and are likely what you will want to use instead.
 </Callout>
 
-The main purpose for a command like this would be for something that can happen everywhere and is not tied to a specific world. For example a `serverRules` command to tell the user thats running the command in chat what the servers rules are nomatter what world they are in.
+The main purpose for a command like this would be for something that can happen everywhere and is not tied to a specific world. For example a `serverRules` command to tell the user that's running the command in chat what the server's rules are no matter what world they are in.
 
 ```java
 // Command that can be run that lists the server rules in chat to the player
@@ -49,7 +51,7 @@ public class ServerRulesCommand extends AbstractAsyncCommand {
     }
 
     // Run the command
-    // conetext - info about who ran the command. Server console?, Some player?
+    // context - info about who ran the command. Server console?, Some player?
     @Override
     protected CompletableFuture<Void> executeAsync(@Nonnull CommandContext context) {
         context.sendMessage(Message.raw("The only rule is there are no rules."));
@@ -134,7 +136,7 @@ Uses a Ray to see what the player is looking at and tries to run the command on
 
 ## Adding Arguments
 
-Arguments are additional fields that the user can input when running a command. The different types of arguments along with small snipits and a large example can be seen below.
+Arguments are additional fields that the user can input when running a command. The different types of arguments along with small snippets and a large example can be seen below.
 
 ### Command Argument Types
 
@@ -163,14 +165,14 @@ this.messageArg = this.withOptionalArg("message", "Message to print while healin
 
 ### Default Arguments
 
-Adding a default argument has two additional arguemnt for the default value and default value description. You need to use `withDefaultArg` method.
+Adding a default argument has two additional argument for the default value and default value description. You need to use `withDefaultArg` method.
 
 ```java
 // args <Command String> <Description> <Default Value> <Desc of default value>
 this.healthArg = this.withDefaultArg("health", "Amount to heal player", ArgTypes.FLOAT, (float)100, "Desc of Default: 100");
 ```
 
-### Flag Arguemnts
+### Flag Arguments
 
 Similar as above but the flags return is either true if it exists or false if it does not. You need to use `withFlagArg` method.
 
@@ -181,20 +183,13 @@ this.debugArg = this.withFlagArg("debug", "Add debug logs");
 
 ### ArgTypes
 
-The following ArgTypes are available (only lists common types):
-
-- `ArgTypes.STRING`
-- `ArgTypes.INTEGER`
-- `ArgTypes.BOOLEAN`
-- `ArgTypes.FLOAT`
-- `ArgTypes.DOUBLE`
-- `ArgTypes.UUID`
+You can find all the available argument types on the [ArgTypes](../../argtypes) page.
 
 ### Example Command Arg Types
 
-Shows all Command arguemnt types with different various input types.
+Shows all Command argument types with different various input types.
 
-**NOTE:** When getting the value of an argument during execute you need to pass the context with `someArg.get(commandContext)`. Where `commandContext` is the first variable in the execute funtion.
+**NOTE:** When getting the value of an argument during execute you need to pass the context with `someArg.get(commandContext)`. Where `commandContext` is the first variable in the execute function.
 
 ```java
 // Example usage: /healplayer --health 50 --message "Feels Good" --debug
@@ -204,7 +199,7 @@ public class HealPlayerCommand extends AbstractTargetPlayerCommand {
     private final FlagArg debugArg;
 
     public HealPlayerCommand() {
-        super("healplayer", "Healing a player for an <input> ammount of HP (default: 100)");
+        super("healplayer", "Healing a player for an <input> amount of HP (default: 100)");
 
         // Abstract TargetPlayerCommand passes the player that ran the command by default and implements
         // the use of `--player <value>` to specify someone else
@@ -213,10 +208,10 @@ public class HealPlayerCommand extends AbstractTargetPlayerCommand {
         this.healthArg = this.withDefaultArg("health", "Amount to heal player", ArgTypes.FLOAT, (float)100, "Desc of Default: 100");
 
         // Or you could do the following making the health value required instead of with a default.
-        //    You would need to change the decleration to RequiredArg<Float>
+        //    You would need to change the declaration to RequiredArg<Float>
         // this.healthArg = this.withRequiredArg("health", "Amount to heal player", ArgTypes.FLOAT);
 
-        // Optional args reguare the user the input `--<key> <value>` so the following would require `--message "Good Luck"`
+// Optional args require the user the input `--<key> <value>` so the following would require `--message "Good Luck"`
         this.messageArg = this.withOptionalArg("message", "Message to print while healing", ArgTypes.STRING);
 
         // No type needed due to being a bool
@@ -230,7 +225,7 @@ public class HealPlayerCommand extends AbstractTargetPlayerCommand {
             commandContext.sendMessage(Message.raw("We are debugging"));
         }
 
-        // Health is stored in a generic stat map to allowing mods/future contect to easily add more stats if desired.
+        // Health is stored in a generic stat map to allowing mods/future content to easily add more stats if desired.
         EntityStatMap stats = store.getComponent(ref, EntityStatMap.getComponentType());
         int healthIdx = DefaultEntityStatTypes.getHealth();
         EntityStatValue health = stats.get(healthIdx);
@@ -252,7 +247,7 @@ public class HealPlayerCommand extends AbstractTargetPlayerCommand {
 
 ## Argument Validators
 
-Argument validators are a way to check the command before the command gets executed. They are added with the `addValidator` method on an argument when calling `withXxxArg`. They provide a nice output to the user when an input value is invalid.
+Argument validators are a way to check the command before the command gets executed. They are added with the `addValidator` method on an argument when calling `withXxxArg`. They provide a nice output to the user when an input value is invalid. There are some common validators provided in the `Validators` class such as `greaterThan`, `lessThan`, and `or`, `max`, `range`, etc.
 
 ```java
 ...
@@ -260,18 +255,59 @@ Argument validators are a way to check the command before the command gets execu
     OptionalArg<Integer> healAmount = withOptionalArg("amount", "Heal Amount", ArgTypes.INTEGER)
         .addValidator(Validators.greaterThan(0))
         .addValidator(Validators.lessThan(1000));
-
-    // Custom check example
-    OptionalArg<Integer> healAmount = withOptionalArg("amount", "Heal Amount", ArgTypes.INTEGER)
-            .addValidator( value -> {
-                if (value != null && value <= 0) {
-                    return ValidationResult.error("ammount argument must be a positive number");
-                }
-                return ValidationResult.success();
-            });
 ...
 ```
 
+### Custom Validators
+
+You can also create custom validators by implementing the `com.hypixel.hytale.codec.validation.Validator` interface. The interfaces forces you to implement the `accept` and `updateSchema` method. The `accept` method takes in the argument value and validates it. If the validation fails, you can use the `fail` method of the `com.hypixel.hytale.codec.validation.ValidationResults` class to return an error message.
+The `updateSchema` method is used to update the schema of the command argument. This is used for commands that have dynamic schemas based on the input value. For example, if you have a command that takes in a player name as an argument, you can use the `updateSchema` method to update the schema to include a list of online players for validation.
+
+Here is an example of a custom validator that checks if a string value is equal to a banned word. In this example, the banned word is "badword". If the input value is "badword", the validator will fail and return an error message.
+
+```java
+import com.hypixel.hytale.codec.schema.SchemaContext;
+import com.hypixel.hytale.codec.schema.config.Schema;
+import com.hypixel.hytale.codec.validation.ValidationResults;
+import com.hypixel.hytale.codec.validation.Validator;
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+
+public class MyCustomValidator implements Validator<String> {
+    @Nonnull
+    private final String value;
+
+    public MyCustomValidator(@Nonnull String value) {
+        this.value = value;
+    }
+
+    @Override
+    public void accept(@Nullable String input, @Nonnull ValidationResults results) {
+        if (this.value.equalsIgnoreCase(input)) {
+            results.fail("The given role has been banned.");
+        }
+    }
+
+    @Override
+    public void updateSchema(SchemaContext context, @Nonnull Schema target) {
+        // This method can be used to update the schema of the command argument. This is useful for commands that have dynamic schemas based on the input value. For example, if you have a command that takes in a player name as an argument, you can use the `updateSchema` method to update the schema to include a list of online players for validation.
+        throw new UnsupportedOperationException("Not implemented yet.");
+    }
+}
+```
+
+After the custom validator is created, you can add it to an argument like the following example. In this example, we add the `MyCustomValidator` to a string argument called "role". If the user inputs "badword" as the role, the command will fail and return the error message defined in the `MyCustomValidator`.
+
+```java
+    ...
+    // Custom validator example
+    String bannedRole = "badword";
+
+    OptionalArg<String> roleArg = withOptionalArg("role", "Role to assign", ArgTypes.STRING)
+        .addValidator(new MyCustomValidator(bannedRole));
+    ...
+```
+
 ---
 
 ## Permissions
@@ -312,7 +348,7 @@ This allows the server to control who has access to specific commands. You add t
 
 If you want variants of the same command without doing argument parsing you can instead use `addUsageVariant(new OtherCommandClass())` in the original commands constructor.
 
-The only difference is in the `OtherCommandClass()` constrcutor you don't pass the command name to the super class.
+The only difference is in the `OtherCommandClass()` constructor you don't pass the command name to the super class.
 
 <Callout type="info">
   You can also use `addAliases("some_alias", "some_other_alias")` as a way to add shorthand or other ways to write the same command.
@@ -387,7 +423,7 @@ public class AdminCommand extends AbstractCommandCollection {
     public AdminCommand () {
         super("admin", "Admin commands");
         addSubCommand(new UserCommandCollection());
-        addSybCommand(new ServerCommandCollection);
+        addSubCommand(new ServerCommandCollection);
     }
 }
 ```
@@ -417,5 +453,5 @@ public class MyPlugin extends JavaPlugin {
 
 ## Video Link
 
-_Special Thanks to [TroubleDev](https://www.youtube.com/@TroubleDEV) for his excelent video guide on all of these features._
+_Special Thanks to [TroubleDev](https://www.youtube.com/@TroubleDEV) for his excellent video guide on all of these features._
 _Video Link: [TroubleDev - Hytale's Command API Explained](https://www.youtube.com/watch?v=KnmhG9MDMgo)_
diff --git a/content/docs/ar-SA/guides/plugin/creating-events.mdx b/content/docs/ar-SA/guides/plugin/creating-events.mdx
index 95863990..d3f0925d 100644
--- a/content/docs/ar-SA/guides/plugin/creating-events.mdx
+++ b/content/docs/ar-SA/guides/plugin/creating-events.mdx
@@ -1,6 +1,6 @@
 ---
-title: Creating Events
-description: Learn how to create custom events for your Hytale mod.
+title: Creating Events Listeners
+description: Learn how to create event listeners for your Hytale mod.
 authors:
   - name: Neil Revin
     url: https://itsneil.dev
@@ -10,7 +10,7 @@ authors:
 
 ## Event Class
 
-You can import a Event class and create a function with the Event as a argument. [Click here](../../server/events) to look at all available events.
+You can import an Event class and create a function with the Event as an argument. [Click here](../../server/events) to look at all available events.
 
 Example plugin when a player is ready (joins a server):
 
diff --git a/content/docs/ar-SA/guides/plugin/item-registry.mdx b/content/docs/ar-SA/guides/plugin/item-registry.mdx
new file mode 100644
index 00000000..9a0fd53a
--- /dev/null
+++ b/content/docs/ar-SA/guides/plugin/item-registry.mdx
@@ -0,0 +1,95 @@
+---
+title: Working with the Item Registry
+description: Learn how to access and query the game's item registry to list all items, check if items exist, and retrieve item properties.
+authors:
+  - name: Denis
+---
+
+In this guide, you'll learn how to work with Hytale's Item Registry system. This is useful when you need to programmatically list all available items, validate item IDs, or retrieve item properties at runtime.
+
+## Prerequisites
+
+Before diving in, you should be familiar with:
+
+- [Setting up your development environment](./setting-up-env)
+- [Creating commands](./creating-commands) (optional, for testing)
+
+## Required Imports
+
+To work with the Item Registry, you'll need the following imports:
+
+```java
+import com.hypixel.hytale.assetstore.map.DefaultAssetMap;
+import com.hypixel.hytale.server.core.asset.type.item.config.Item;
+```
+
+## Getting the Item Registry
+
+The Item Registry is accessed through the `Item.getAssetMap()` method, which returns a `DefaultAssetMap<String, Item>` containing all registered items in the game:
+
+```java
+DefaultAssetMap<String, Item> itemMap = Item.getAssetMap();
+```
+
+## Listing All Items
+
+To iterate through all items in the registry, you can get the underlying map and loop through its entries:
+
+```java
+DefaultAssetMap<String, Item> itemMap = Item.getAssetMap();
+var map = itemMap.getAssetMap();
+
+for (var entry : map.entrySet()) {
+    String itemId = String.valueOf(entry.getKey());
+    Item item = entry.getValue();
+    
+    // Do something with the item
+    LOGGER.atInfo().log("Item ID: " + itemId);
+}
+```
+
+You can also get the total count of registered items:
+
+```java
+int totalItems = map.size();
+```
+
+## Checking if an Item Exists
+
+To check if a specific item exists in the registry, use `getAsset()` and verify the result:
+
+```java
+public boolean itemExists(String itemId) {
+    var assetMap = Item.getAssetMap();
+    if (assetMap != null) {
+        Item item = assetMap.getAsset(itemId);
+        return item != null && item != Item.UNKNOWN;
+    }
+    return false;
+}
+```
+
+<Callout type="info">
+  The `Item.UNKNOWN` constant represents an invalid or unrecognized item. Always check for both `null` and `Item.UNKNOWN` when validating items.
+</Callout>
+
+## Accessing Item Properties
+
+Once you have an `Item` instance, you can access various properties:
+
+```java
+var assetMap = Item.getAssetMap();
+Item item = assetMap.getAsset("Soil_Grass");
+
+if (item != null && item != Item.UNKNOWN) {
+    String id = item.getId(); // Soil_Grass
+    int maxStack = item.getMaxStack(); // 100
+    boolean isBlock = item.hasBlockType(); // true
+    boolean isConsumable = item.isConsumable(); // false
+}
+```
+
+## Related Guides
+
+- [Inventory Management](./inventory-management) - Learn how to add and remove items from player inventories
+- [Create Custom Item and Interaction](./item-interaction) - Learn how to create your own custom items
diff --git a/content/docs/ar-SA/guides/plugin/permission-management.mdx b/content/docs/ar-SA/guides/plugin/permission-management.mdx
index 6b7cfd46..55f06101 100644
--- a/content/docs/ar-SA/guides/plugin/permission-management.mdx
+++ b/content/docs/ar-SA/guides/plugin/permission-management.mdx
@@ -10,132 +10,569 @@ authors:
     link: https://discord.com/users/292656109939064833
   - name: Ivan
     link: https://discord.com/users/505770451218333717
+  - name: ZenithDevHQ
+    link: https://github.com/ZenithDevHQ
 ---
 
-In this guide, you'll learn how to manage permission nodes and groups in your Hytale plugin.
+In this guide, you'll learn how to manage permission nodes and groups in your Hytale plugin. Permissions control what actions players can perform on your server, from basic commands to advanced administrative functions.
 
-## The `PermissionsModule` class
+## What Are Permissions?
 
-The `PermissionsModule` class is responsible for managing permission nodes and groups in your plugin. It provides methods to check, grant and revoke permissions and groups for players. It allows the following operations
+Permissions are string identifiers that control access to features and commands. When a player tries to perform an action (like using a command), the server checks if they have the required permission.
 
-- Add permissions to user
-- Remove permissions from user
-- Add permissions to group (this also creates the group if it doesn't exist)
-- Remove permissions from group
-- Add user to group
-- Remove user from group
-- List all groups for a user
-- Check if a user has a permission (it checks both user and group permissions for the given player UUID)
+**Example permission nodes:**
 
-With this class you cannot:
+- `hytale.command.gamemode` - Permission to use the gamemode command
+- `hytale.editor.brush.use` - Permission to use brush tools
+- `myplugin.teleport.home` - A custom permission for your plugin
 
-- List all defined groups
-- Remove a group
+Permissions follow a hierarchical naming pattern: `namespace.category.action`
 
-### Adding Permission Nodes
+## Key Concepts
 
-You need a `Set<String>` containing all the permission nodes you want to add, these are added on top of the already existing permission nodes the user may have, it is not a replacement.
+Before diving into code, let's understand the core concepts:
+
+| Concept             | Description                                                                |
+| ------------------- | -------------------------------------------------------------------------- |
+| **Permission Node** | A string like `myplugin.feature.use` that represents a specific permission |
+| **Group**           | A named collection of permissions (e.g., "Admin", "VIP", "Default")        |
+| **Provider**        | The backend that stores and retrieves permissions                          |
+| **Wildcard**        | A pattern like `*` or `myplugin.*` that matches multiple permissions       |
+
+### How Permissions Are Checked
+
+When checking if a player has a permission, Hytale follows this order:
+
+1. **User's direct permissions** - Permissions granted directly to the player
+2. **Group permissions** - Permissions from groups the player belongs to
+3. **Virtual groups** - Game-mode-based permissions (e.g., Creative mode grants builder tools)
+4. **Default value** - Falls back to `false` if no match found
+
+<Callout type="info">
+  The first definitive match wins. If a player has a permission granted at the user level, group permissions won't override it.
+</Callout>
+
+---
+
+## The `PermissionsModule` Class
+
+The `PermissionsModule` class is the central hub for managing permissions. Access it using the singleton pattern:
 
 ```java
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.addUserPermission(playerUUID, permissions);
 ```
 
-### Removing Permission Nodes
+### Available Operations
+
+The module supports these operations:
+
+| Operation                     | Method                                          |
+| ----------------------------- | ----------------------------------------------- |
+| Add permissions to user       | `addUserPermission(uuid, permissions)`          |
+| Remove permissions from user  | `removeUserPermission(uuid, permissions)`       |
+| Add permissions to group      | `addGroupPermission(groupName, permissions)`    |
+| Remove permissions from group | `removeGroupPermission(groupName, permissions)` |
+| Add user to group             | `addUserToGroup(uuid, groupName)`               |
+| Remove user from group        | `removeUserFromGroup(uuid, groupName)`          |
+| Get user's groups             | `getGroupsForUser(uuid)`                        |
+| Check permission              | `hasPermission(uuid, permissionNode)`           |
+
+<Callout type="warning">
+  The module does **not** support:
+
+  - Listing all defined groups
+  - Deleting a group entirely
+
+  Groups are implicitly created when you first add permissions to them.
+</Callout>
+
+---
 
-Same as above, we just use the `removeUserPermission` method instead to remove permission nodes.
+## Checking Permissions
+
+The most common operation is checking if a player has a permission.
+
+### Basic Permission Check
+
+```java
+// Returns true if player has the permission, false otherwise
+boolean canUse = PermissionsModule.get().hasPermission(playerUUID, "myplugin.feature.use");
+
+if (canUse) {
+    // Player has permission, allow the action
+} else {
+    // Player lacks permission, deny or show error
+}
+```
+
+### Permission Check with Default Value
+
+You can specify what to return when no permission is explicitly set:
+
+```java
+// Returns true by default if no explicit permission is found
+boolean canUse = PermissionsModule.get().hasPermission(playerUUID, "myplugin.feature.use", true);
+```
+
+This is useful for features that should be enabled by default but can be revoked.
+
+### Using PermissionHolder Interface
+
+Players and command senders implement `PermissionHolder`, allowing direct checks:
+
+```java
+// In a command or event handler where you have access to the player
+if (player.hasPermission("myplugin.admin.manage")) {
+    // Player has admin permission
+}
+```
+
+---
+
+## Managing User Permissions
+
+### Adding Permissions to a User
+
+Permissions are additive - new permissions are added on top of existing ones, not replaced.
+
+```java
+PermissionsModule perms = PermissionsModule.get();
+
+// Add a single permission
+perms.addUserPermission(playerUUID, Set.of("myplugin.vip.chat"));
+
+// Add multiple permissions at once
+Set<String> newPerms = Set.of(
+    "myplugin.vip.chat",
+    "myplugin.vip.fly",
+    "myplugin.vip.kit"
+);
+perms.addUserPermission(playerUUID, newPerms);
+```
+
+### Removing Permissions from a User
 
 ```java
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.removeUserPermission(playerUUID, permissions);
+
+// Remove specific permissions
+Set<String> toRemove = Set.of("myplugin.vip.fly");
+perms.removeUserPermission(playerUUID, toRemove);
 ```
 
-### Add permissions to group
+---
+
+## Managing Groups
+
+Groups let you assign a collection of permissions to multiple players. This is more manageable than assigning permissions individually.
+
+### Adding Permissions to a Group
+
+If the group doesn't exist, it will be created automatically.
 
 ```java
-String groupName = "testGroup";
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.addGroupPermission(groupName, permissions);
+
+// Create/update the "VIP" group with permissions
+Set<String> vipPerms = Set.of(
+    "myplugin.vip.chat",
+    "myplugin.vip.fly",
+    "myplugin.vip.kit"
+);
+perms.addGroupPermission("VIP", vipPerms);
 ```
 
-### Remove permissions from group
+### Removing Permissions from a Group
 
 ```java
-String groupName = "testGroup";
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.removeGroupPermission(groupName, permissions);
+
+// Remove specific permissions from the group
+Set<String> toRemove = Set.of("myplugin.vip.fly");
+perms.removeGroupPermission("VIP", toRemove);
 ```
 
-### Add user to group
+### Adding a User to a Group
 
 ```java
-String groupName = "testGroup";
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.addUserToGroup(playerUUID, groupName);
+
+// Add player to the VIP group - they now have all VIP permissions
+perms.addUserToGroup(playerUUID, "VIP");
 ```
 
-### Remove user from group
+### Removing a User from a Group
 
 ```java
-String groupName = "testGroup";
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.removeUserFromGroup(playerUUID, groupName);
+
+// Remove player from VIP group
+perms.removeUserFromGroup(playerUUID, "VIP");
 ```
 
-### List all groups for a user
+### Getting a User's Groups
 
 ```java
 PermissionsModule perms = PermissionsModule.get();
-perms.getGroupsForUser(playerUUID);
+
+// Get all groups the player belongs to
+Set<String> groups = perms.getGroupsForUser(playerUUID);
+
+for (String group : groups) {
+    System.out.println("Player is in group: " + group);
+}
 ```
 
-### Check Permission Nodes
+---
+
+## Built-in Groups
+
+Hytale includes two default groups:
+
+| Group     | Default Permissions   | Purpose                           |
+| --------- | --------------------- | --------------------------------- |
+| `OP`      | `*` (all permissions) | Server operators with full access |
+| `Default` | None                  | Base group for all players        |
+
+Players without any explicit group assignment are automatically part of the `Default` group.
 
-To check if a player has a specific permission node, you can use the `hasPermission` method.
+---
+
+## Wildcards
+
+Wildcards let you grant or deny multiple permissions with a single pattern.
+
+### Wildcard Patterns
+
+| Pattern             | Meaning                                          |
+| ------------------- | ------------------------------------------------ |
+| `*`                 | Grants **all** permissions                       |
+| `myplugin.*`        | Grants all permissions starting with `myplugin.` |
+| `-*`                | Denies **all** permissions                       |
+| `-myplugin.admin.*` | Denies all admin permissions in your plugin      |
+
+### Example: Admin Group with Wildcards
 
 ```java
-boolean hasPermission = PermissionsModule.hasPermission(playerUUID, "permission.node");
+// Grant all permissions to admins
+perms.addGroupPermission("Admin", Set.of("*"));
+
+// Grant all plugin permissions to moderators
+perms.addGroupPermission("Moderator", Set.of("myplugin.*"));
+
+// Grant all permissions except admin commands
+perms.addGroupPermission("Helper", Set.of(
+    "*",
+    "-myplugin.admin.*"  // Deny admin permissions
+));
 ```
 
-## Additional: Defining your own provider for permissions and groups
+<Callout type="warning">
+  Negation permissions (starting with `-`) take precedence at each level. Use them carefully to avoid accidentally blocking permissions.
+</Callout>
+
+---
+
+## Built-in Permission Nodes
+
+Hytale provides constants for common permissions in the `HytalePermissions` class:
+
+### Command Permissions
+
+```java
+// Generate permission for a command
+String perm = HytalePermissions.fromCommand("gamemode");
+// Result: "hytale.command.gamemode"
+
+// Generate permission for a subcommand
+String perm = HytalePermissions.fromCommand("gamemode", "creative");
+// Result: "hytale.command.gamemode.creative"
+```
+
+### Common Permission Nodes
+
+| Permission                    | Description                  |
+| ----------------------------- | ---------------------------- |
+| `hytale.command.op.add`       | Add players to OP group      |
+| `hytale.command.op.remove`    | Remove players from OP group |
+| `hytale.editor.brush.use`     | Use brush tools              |
+| `hytale.editor.prefab.use`    | Use prefabs                  |
+| `hytale.editor.selection.use` | Use selection tools          |
+| `hytale.editor.history`       | Undo/redo operations         |
+| `hytale.camera.flycam`        | Use fly camera mode          |
+
+---
+
+## Listening to Permission Events
+
+You can react to permission changes using Hytale's event system.
+
+### Available Events
+
+| Event                                            | Triggered When                   |
+| ------------------------------------------------ | -------------------------------- |
+| `PlayerPermissionChangeEvent.PermissionsAdded`   | Permissions added to a user      |
+| `PlayerPermissionChangeEvent.PermissionsRemoved` | Permissions removed from a user  |
+| `PlayerGroupEvent.Added`                         | User added to a group            |
+| `PlayerGroupEvent.Removed`                       | User removed from a group        |
+| `GroupPermissionChangeEvent.Added`               | Permissions added to a group     |
+| `GroupPermissionChangeEvent.Removed`             | Permissions removed from a group |
 
-The PermissionsModule also enables us to define our own PermissionProvider's, this can be useful for:
+### Example: Reacting to Permission Changes
 
-- Cross server permission systems
-- Implementing features missing in the `HytalePermissionsProvider` like permission expiry
+```java
+public class PermissionListener {
+
+    public static void onPermissionsAdded(PlayerPermissionChangeEvent.PermissionsAdded event) {
+        UUID playerUUID = event.getPlayerUuid();
+        Set<String> added = event.getAddedPermissions();
+
+        System.out.println("Permissions added to " + playerUUID + ": " + added);
 
-To implement our PermissionProvider, first we need to define a provider class that implements PermissionProvider:
+        // Maybe notify the player or update cached data
+    }
+
+    public static void onGroupAdded(PlayerGroupEvent.Added event) {
+        UUID playerUUID = event.getPlayerUuid();
+        String groupName = event.getGroupName();
+
+        System.out.println("Player " + playerUUID + " joined group: " + groupName);
+    }
+}
+```
+
+### Registering the Events
 
 ```java
-public class DatabasePermissionProvider implements PermissionProvider
+public class MyPlugin extends JavaPlugin {
+
+    @Override
+    public void setup() {
+        EventRegistry events = this.getEventRegistry();
+
+        events.registerGlobal(
+            PlayerPermissionChangeEvent.PermissionsAdded.class,
+            PermissionListener::onPermissionsAdded
+        );
+
+        events.registerGlobal(
+            PlayerGroupEvent.Added.class,
+            PermissionListener::onGroupAdded
+        );
+    }
+}
 ```
 
-Then we just implement the required methods using a database implementation.
+---
+
+## Creating a Custom Permission Provider
+
+For advanced use cases, you can create your own permission provider. This is useful for:
+
+- Database-backed permissions (MySQL, MongoDB, etc.)
+- Cross-server permission synchronization
+- Custom features like permission expiry or contexts
+
+### Implementing PermissionProvider
+
+```java
+public class DatabasePermissionProvider implements PermissionProvider {
+
+    @Nonnull
+    @Override
+    public String getName() {
+        return "DatabasePermissionProvider";
+    }
+
+    // User permission methods
+    @Override
+    public void addUserPermissions(@Nonnull UUID uuid, @Nonnull Set<String> permissions) {
+        // Save to your database
+    }
+
+    @Override
+    public void removeUserPermissions(@Nonnull UUID uuid, @Nonnull Set<String> permissions) {
+        // Remove from your database
+    }
+
+    @Override
+    public Set<String> getUserPermissions(@Nonnull UUID uuid) {
+        // Query your database
+        return Set.of();
+    }
+
+    // Group permission methods
+    @Override
+    public void addGroupPermissions(@Nonnull String group, @Nonnull Set<String> permissions) {
+        // Save to your database
+    }
+
+    @Override
+    public void removeGroupPermissions(@Nonnull String group, @Nonnull Set<String> permissions) {
+        // Remove from your database
+    }
+
+    @Override
+    public Set<String> getGroupPermissions(@Nonnull String group) {
+        // Query your database
+        return Set.of();
+    }
+
+    // User-group membership methods
+    @Override
+    public void addUserToGroup(@Nonnull UUID uuid, @Nonnull String group) {
+        // Save to your database
+    }
+
+    @Override
+    public void removeUserFromGroup(@Nonnull UUID uuid, @Nonnull String group) {
+        // Remove from your database
+    }
+
+    @Override
+    public Set<String> getGroupsForUser(@Nonnull UUID uuid) {
+        // Query your database
+        return Set.of("Default");
+    }
+}
+```
 
 <Callout type="warning">
-  Hytale will try to use the first available permissions provider to add/remove gamemode groups (i.e. `Creative`, `Adventure`).
+  Hytale automatically assigns players to game-mode groups (like `Creative` or `Adventure`) using the first available provider.
+
+  If your provider throws an error when the group doesn't exist, the player will be disconnected! Always handle missing groups gracefully.
+</Callout>
+
+### Registering Your Provider
 
-  If your provider throws an error (for instance, if the group does not exist) when the server is preparing the player, the player will be disconnected.
+```java
+public class MyPlugin extends JavaPlugin {
+
+    @Override
+    public void setup() {
+        // Add your provider alongside the default one
+        PermissionsModule.get().addProvider(new DatabasePermissionProvider());
+    }
+}
+```
+
+The `PermissionsModule` aggregates permissions from all registered providers. This means:
+
+- Permission checks query all providers
+- Write operations (add/remove) use the **first** provider
+
+### Replacing the Default Provider
+
+If you want full control, you can remove the default provider:
+
+```java
+public class MyPlugin extends JavaPlugin {
+
+    @Override
+    public void setup() {
+        PermissionsModule perms = PermissionsModule.get();
+
+        // Remove the default provider FIRST
+        perms.removeProvider(perms.getFirstPermissionProvider());
+
+        // Then add your provider
+        perms.addProvider(new DatabasePermissionProvider());
+    }
+}
+```
+
+<Callout type="info">
+  When you remove the default provider, the `/op self` command will stop working since it checks for provider tampering.
 </Callout>
 
-We can then register the provider using the built-in permission module:
+---
+
+## Best Practices
+
+### Permission Naming Conventions
+
+Follow the pattern: `namespace.category.action`
 
 ```java
-PermissionsModule.get().addProvider(new DatabasePermissionProvider());
+// Good - clear hierarchy
+"myplugin.admin.ban"
+"myplugin.user.teleport.home"
+"myplugin.vip.chat.color"
+
+// Bad - unclear structure
+"myplugin_ban"
+"teleport"
+"vipChatColor"
 ```
 
-Please note that the `HytalePermissionsProvider` will still be enabled alongside your provider.
-The `PermissionsModule` will aggregate groups and permissions from all available providers.
+### Use Constants for Permissions
 
-If you want to disable the default `HytalePermissionsProvider`, you can use:
+Define your permissions as constants to avoid typos:
 
 ```java
-// put this **before** you add your provider
-PermissionsModule.get().removeProvider(PermissionsModule.get().getFirstPermissionProvider());
+public final class MyPermissions {
+    public static final String ADMIN_BAN = "myplugin.admin.ban";
+    public static final String ADMIN_KICK = "myplugin.admin.kick";
+    public static final String USER_HOME = "myplugin.user.home";
+    public static final String VIP_FLY = "myplugin.vip.fly";
+}
+
+// Usage
+if (player.hasPermission(MyPermissions.ADMIN_BAN)) {
+    // ...
+}
 ```
+
+### Don't Over-Permission
+
+Only create permissions for actions that genuinely need access control. Not everything needs a permission check.
+
+### Thread Safety
+
+If you create a custom provider, ensure it's thread-safe. Permission checks can occur from multiple threads simultaneously. Use `ReadWriteLock` or `ConcurrentHashMap` for your data structures.
+
+---
+
+## In-Game Commands
+
+Hytale provides built-in commands for managing permissions:
+
+### `/op` Command
+
+| Command               | Description                                                        |
+| --------------------- | ------------------------------------------------------------------ |
+| `/op self`            | Toggle your own OP status (singleplayer or with `--allow-op` flag) |
+| `/op add <player>`    | Add a player to the OP group                                       |
+| `/op remove <player>` | Remove a player from the OP group                                  |
+
+### `/perm` Command
+
+Use `/perm --help` in-game for full usage. Common operations:
+
+| Command                                  | Description                   |
+| ---------------------------------------- | ----------------------------- |
+| `/perm user list <uuid>`                 | List user's permissions       |
+| `/perm user add <uuid> <perm>`           | Add permission to user        |
+| `/perm user remove <uuid> <perm>`        | Remove permission from user   |
+| `/perm user group list <uuid>`           | List user's groups            |
+| `/perm user group add <uuid> <group>`    | Add user to group             |
+| `/perm user group remove <uuid> <group>` | Remove user from group        |
+| `/perm group list <group>`               | List group's permissions      |
+| `/perm group add <group> <perm>`         | Add permission to group       |
+| `/perm group remove <group> <perm>`      | Remove permission from group  |
+| `/perm test <perm>`                      | Test if you have a permission |
+
+---
+
+## Summary
+
+You've learned how to:
+
+- **Check permissions** using `PermissionsModule.hasPermission()`
+- **Manage user permissions** with `addUserPermission()` and `removeUserPermission()`
+- **Work with groups** using `addGroupPermission()`, `addUserToGroup()`, etc.
+- **Use wildcards** like `*` and `myplugin.*` for bulk permissions
+- **Listen to events** for permission changes
+- **Create custom providers** for database-backed permissions
+
+For more advanced permission systems with features like inheritance, expiry, and contexts, we're looking into expanding this guide with advanced permission management techniques in the future.
diff --git a/content/docs/ar-SA/guides/plugin/setting-up-env.mdx b/content/docs/ar-SA/guides/plugin/setting-up-env.mdx
index d2718098..5be5e9e0 100644
--- a/content/docs/ar-SA/guides/plugin/setting-up-env.mdx
+++ b/content/docs/ar-SA/guides/plugin/setting-up-env.mdx
@@ -4,6 +4,10 @@ description: Learn how to set up your development environment for modding Hytale
 authors:
   - name: Neil Revin
     link: https://itsneil.dev
+  - name: Marcel-TO
+    url: https://marcel-to.net
+  - name: Ádám Liszkai
+    link: https://adaliszk.dev
 ---
 
 This guide will walk you through setting up a complete development environment for Hytale modding, including all necessary tools and dependencies.
@@ -19,24 +23,73 @@ Before we begin, make sure you have:
 
 ## Required Software
 
-### 1. Java Development Kit (JDK)
+### Integrated Development Environment (IDE)
 
+We recommend IntelliJ IDEA Community Edition for Hytale modding. If you use IntelliJ IDEA, **almost everything is built-in**. You can clone a template, open a new project, and start working right away!
+
+1. Download from [JetBrains website](https://www.jetbrains.com/idea/download/)
+2. Install with default settings
+3. Launch and complete the initial setup wizard
+
+When opening a project, wait for indexing to finish, then start coding.
+Now, IDEA may say "No JDK configured" at the top of the source file you have.
+In that case, you can click Download JDK and choose JetBrains JDK 25.
+
+<Callout type="success">
+  If IDEA opened the project without errors, your environment is ready.
+</Callout>
+
+More details by [JetBrains](https://www.jetbrains.com/help/idea/2026.1/run-for-the-first-time.html)
+help page, where we recommend that you also check the
+[SDK configuration](https://www.jetbrains.com/help/idea/2026.1/sdk.html) guide.
+
+<Callout type="info">
+  We recommened following
+  [TheNullicorn's](https://gist.github.com/TheNullicorn/90a619796c40f20ae1fcf13094c1a57d) guide to ensure
+  you are using the correct `Nonnull` in your projects.
+</Callout>
+
+#### What the IDE Does for You
+
+When opened in IntelliJ IDEA, the project automatically:
+
+- Detects and configures Gradle or Maven
+- Downloads all dependencies
+- Sets up project structure and classpaths
+- Configures run/build tasks
+
+You do **not** need to manually install or configure Maven or Gradle if you stay inside the IDE.
+
+Skip to the [Setting Up Your Workspace](#setting-up-your-workspace).
+
+### Manual Setup: Java Development Kit (JDK)
+
+For any other setup, you will need to install and configure your system to have and load Java.
 Hytale modding requires Java 25 or later. We recommend using OpenJDK.
 
-#### Windows
+#### Windows via Installer
 
 1. Download OpenJDK 25 from [Adoptium](https://adoptium.net/)
 2. Run the installer with default settings
+   - Optionally enable feature `Set or Override JAVA_HOME variable` to resolve version related build issues with your project.
 3. Verify installation by opening Command Prompt and running:
 
+#### Windows via Scoop
+
+1. Install Scoop via PowerShell using [scoop.sh](https://scoop.sh/)
+2. Install OpenJDK 25:
+
 ```bash
-java -version
+scoop bucket add java
+scoop install java/openjdk25
 ```
 
 #### macOS
 
+1. Install Brew via Terminal using [brew.sh](https://brew.sh)
+2. Install JDK via Homebrew:
+
 ```bash
-# Using Homebrew
 brew install openjdk@25
 ```
 
@@ -51,22 +104,41 @@ brew install openjdk@25
 
 #### Linux (Ubuntu/Debian)
 
+1. Install JDK via the built-in package repository:
+
 ```bash
 sudo apt update
 sudo apt install openjdk-25-jdk
 ```
 
-### 2. Integrated Development Environment (IDE)
+### Verify installation:
 
-We recommend IntelliJ IDEA Community Edition for Hytale modding.
+Run the following command to see what version of Java you have:
 
-1. Download from [JetBrains website](https://www.jetbrains.com/idea/download/)
-2. Install with default settings
-3. Launch and complete the initial setup wizard
+```bash
+java -version
+```
+
+### Java Build Tool (Optional)
+
+We recommend using a Gradle Wrapper for managing dependencies and building your Hytale plugins. It provides benefits by eliminating the need for a system-wide Gradle installation and ensuring consistent Gradle versions across different environments. (Alternatively you can use Maven, but this guide focuses on Gradle since it is the default for our plugin template.)
+
+The plugin template in the following sections includes a Gradle Wrapper, so you can skip this step if you plan to use the template.
+
+#### Choosing Gradle (if not using the template)
+
+If you prefer to install Gradle manually, follow these steps:
 
-### 3) Java Build Tool
+1. Visit the official website: https://gradle.org/releases/
+2. Download the newest gradle binary: `gradle-9.3.1-bin.zip` (Binary zip archive)
+3. Unzip it
+4. Add the `gradle-9.3.1/bin/` folder to your PATH
+
+You can now try the command `gradle -version` to verify Gradle is installed correctly. Make sure to do this in a fresh new terminal instead of one you had opened from before!
+
+#### Choosing Maven (if not using the template)
 
-We recommend using Apache Maven for managing dependencies and building your Hytale plugins. (Alternatively you can use Gradle, but this guide focuses on Maven.)
+If you prefer to use Maven instead of Gradle, follow these steps to install Maven:
 
 1. Visit the official website: https://maven.apache.org/download.cgi
 2. Download this file: `apache-maven-3.9.12-bin.zip` (Binary zip archive)
@@ -89,22 +161,61 @@ cd MyFirstMod
 
 If you don't have Git installed, you can download the ZIP file from the repository page and extract it to a folder named `MyFirstMod`.
 
-### 2. Open Plugin in your IDEA
+### 2. Open Plugin in your IDE
 
-1. Open IntelliJ IDEA
+1. Open Your IDE (e.g., IntelliJ IDEA)
 2. Click "Open" and navigate to your `MyFirstMod` directory
-3. IntelliJ will automatically detect it as a Maven project
+3. Most IDEs like IntelliJ will automatically detect it as a Gradle project
 4. Wait for the project to index and dependencies to download
 
-<Callout type="info">
-  We recommened following [this](https://gist.github.com/TheNullicorn/90a619796c40f20ae1fcf13094c1a57d) guide to ensure you are using the correct `Nonnull` in your projects.
-</Callout>
+## Alternate Approach: Hytale Dependency
+
+If you prefer to set up your project from scratch without using the template and importing the hytale dependencies manually, ensure your build configuration includes the Hytale repositories and dependencies:
+
+For Gradle, add the following to your `build.gradle.kts`:
+
+```kotlin
+repositories {
+    mavenCentral()
+    maven {
+        name = "hytale"
+        url = uri("https://maven.hytale.com/release") // Or "hytale-pre-release" for pre-release versions
+    }
+}
+dependencies {
+    // + here means the latest version, but you can hard-wire any known version!
+    implementation("com.hypixel.hytale:Server:+")
+}
+```
+
+For Maven, add the following to your `pom.xml`:
+
+```xml
+<project>
+    <repositories>
+        <repository>
+            <id>hytale-release</id> <!-- Or "hytale-pre-release" for pre-release versions -->
+            <url>https://maven.hytale.com/release</url> <!-- Or "https://maven.hytale.com/pre-release" -->
+        </repository>
+    </repositories>
+
+    <dependencies>
+        <dependency>
+            <groupId>com.hypixel.hytale</groupId>
+            <artifactId>Server</artifactId>
+            <!-- Replace with latest version, Hytale provides jars for the last five releases -->
+            <version>LATEST_VERSION_HERE</version>
+            <scope>provided</scope>
+        </dependency>
+    </dependencies>
+</project>
+```
 
 ## Next Steps
 
 Now that you have your development environment set up with the plugin template:
 
-1. **Customize the template** - Edit the `pom.xml` and `manifest.json` file to change your mod's name and details
+1. **Customize the template** - Edit the `settings.gradle.kts`, `build.gradle.kts` and `manifest.json` file to change your mod's name and details
 2. **Explore the code structure** - Familiarize yourself with the template's organization
 3. **Start modding** - Begin writing your first Hytale plugin!
 
diff --git a/content/docs/ar-SA/guides/plugin/spawning-entities.mdx b/content/docs/ar-SA/guides/plugin/spawning-entities.mdx
index e12c0aea..15be2fb3 100644
--- a/content/docs/ar-SA/guides/plugin/spawning-entities.mdx
+++ b/content/docs/ar-SA/guides/plugin/spawning-entities.mdx
@@ -36,7 +36,7 @@ Store<EntityStore> store = world.getEntityStore().getStore();
 
 ## Creating Entities
 
-Once you have the `EntityStore` instance, you can start to create a entity and give it components. Entities are just instances of `Holder<EntityStore>` with several components attached to them.
+Once you have the `EntityStore` instance, you can start to create an entity and give it components. Entities are just instances of `Holder<EntityStore>` with several components attached to them.
 
 <Callout type="warning">
   To interact with the `World` instance, some methods require you to run the code inside the world's execution context.
@@ -118,3 +118,48 @@ Finally, we can add the entity to the world by calling the `addEntity` method on
 ```java
 store.addEntity(holder, AddReason.SPAWN);
 ```
+
+## Making the entity persist
+
+Hytale automatically saves all entities, but the `NetworkId` component (required for players to be able to see the entity) needs to be manually added every time the entity is loaded.
+
+### Using a system
+
+If you have a component that is unique to your entities, this can be done by creating and registering a custom system as follows:
+
+```java
+public class AddNetworkIdToMyEntitySystem extends HolderSystem<EntityStore> {
+    private final ComponentType<EntityStore, MyEntityComponent> myEntityComponentType = MyEntityComponent.getComponentType();
+    private final ComponentType<EntityStore, NetworkId> networkIdComponentType = NetworkId.getComponentType();
+    private final Query<EntityStore> query = Query.and(this.myEntityComponentType, Query.not(this.networkIdComponentType));
+
+    @Override
+    public void onEntityAdd(@NotNull Holder<EntityStore> holder, @NotNull AddReason reason, @NotNull Store<EntityStore> store) {
+        if (!holder.getArchetype().contains(NetworkId.getComponentType())) {
+            holder.addComponent(NetworkId.getComponentType(), new NetworkId(store.getExternalData().takeNextNetworkId()));
+        }
+    }
+
+    @Override
+    public void onEntityRemoved(@NotNull Holder<EntityStore> holder, @NotNull RemoveReason reason, @NotNull Store<EntityStore> store) {}
+
+    @Override
+    public @Nullable Query<EntityStore> getQuery() {
+        return query;
+    }
+}
+```
+
+In your plugin's `setup()` function
+
+```java
+this.getEntityStoreRegistry().registerSystem(new AddNetworkIdToMyEntitySystem())
+```
+
+### Using PropComponent
+
+Alternatively you can add `PropComponent` to your entity. Hytale adds `PropComponent` to entities spawned with the Entity Tool, and such entities automatically get `NetworkId` and `PrefabCopyableComponent` (which makes the entity work with prefabs).
+
+<Callout type="warning">
+  There is no guarantee, that Hytale will not add some other behavior to this component in the future, which may break your entity, so be careful if you decide to rely on it.
+</Callout>
diff --git a/content/docs/ar-SA/guides/plugin/store-persistent-data.mdx b/content/docs/ar-SA/guides/plugin/store-persistent-data.mdx
new file mode 100644
index 00000000..1071dff3
--- /dev/null
+++ b/content/docs/ar-SA/guides/plugin/store-persistent-data.mdx
@@ -0,0 +1,171 @@
+---
+title: Storing Persistent Data on the Player
+description: Learn how to save and load persistent data using Components
+authors:
+  - name: Neil Revin
+    url: https://itsneil.dev/
+  - name: ArcticDev
+    url: https://github.com/ArcticRaven
+  - name: oskarscot
+    url: https://oskar.scot
+  - name: JammingEng
+    url: https://github.com/JammingEnd
+---
+
+Here is how to store persistent data using a custom component on a Player.
+
+## Build your Component Class
+
+Creating a custom component class leverages the Component system made with the ECS architecture in mind. For more information on Components, check out the [ECS Guide](../ecs/hytale-ecs-theory#components).
+
+Start by creating your custom component class. This will be extremely similar to how regular components are created, however we'll setup a custom Codec so the server can translate this data to BSON, or the server's internal json encoder.
+
+<Callout type="info">
+  Each variable you want to store in your component must have its own Codec field defined in the BuilderCodec.
+  For more information on how to create custom Codecs, check out the [ECS Codec Guide](../ecs/hytale-ecs-theory#codec).
+</Callout>
+
+```java
+public class YourPlayerData implements Component<EntityStore> {
+
+    // define some vars!
+    private int someInteger;
+    private String someString;
+    private Map<String, String> someMap;
+
+    public static final BuilderCodec<YourPlayerData> CODEC =
+            BuilderCodec.builder(YourPlayerData.class, YourPlayerData::new)
+            .append(new KeyedCodec<>("SomeInteger", Codec.INTEGER),
+                    (data, value) -> data.someInteger = value, // setter
+                    data -> data.someInteger) // getter
+            .addValidator(Validators.nonNull())
+            .add()
+            .append(new KeyedCodec<>("SomeString", Codec.STRING),
+                    (data, value) -> data.someString = value, // setter
+                    data -> data.someString) // getter
+            .add()
+            .append(new KeyedCodec<>("SomeMap",
+                            new MapCodec<>(Codec.STRING, HashMap::new, false)),
+                    (data, value) -> data.someMap = value, // setter
+                    data -> data.someMap) // getter
+            .add()
+            .build();
+
+
+
+    // Getters and Setters are for the purpose of this example omitted.
+
+    // constructor
+    public YourPlayerData() {
+        this.someInteger = 0;
+        this.someString = "";
+        this.someMap = new HashMap<>();
+    }
+
+    // copy constructor for cloning
+    public YourPlayerData(YourPlayerData clone) {
+        this.someInteger = clone.someInteger;
+        this.someString = clone.someString;
+        this.someMap = clone.someMap;
+    }
+
+    @Nonnull
+    @Override
+    public Component<EntityStore> clone() {
+        return new YourPlayerData(this);
+    }
+}
+```
+
+## Register your Component
+
+Inside your main class's `setup()` method, register your new Component.
+
+```java
+public class YourPlugin extends JavaPlugin {
+
+    private ComponentType<EntityStore, YourPlayerData> yourPlayerDataComponent;
+
+    public YourPlugin(@Nonnull JavaPluginInit init) {
+        super(init);
+    }
+
+    @Override
+    protected void setup(){
+        this.yourPlayerDataComponent = this.getEntityStoreRegistry().registerComponent(
+            YourPlayerData.class,
+            "YourPlayerDataComponent",
+            YourPlayerData.CODEC
+        );
+    }
+
+    public ComponentType<EntityStore, YourPlayerData> getYourPlayerDataComponent() {
+        return this.yourPlayerDataComponent;
+    }
+}
+```
+
+## Using your Component
+
+To use your newly created component, you can add the Component to a player using the `addComponent` method, although this only adds it temporarily, meaning when the player/entity leaves the world, the component is removed. You can use `putComponent` to ensure the component persists between sessions.
+
+```java
+// You will need the Ref and Store to apply components
+private void someEntryMethod(@Nonnull Ref<EntityStore> ref, @Nonnull Store<EntityStore> store)
+{
+       // Any entity will work, for now we will use the player
+      Player player = (Player) store.getComponent(ref, Player.getComponentType());
+
+      // since we're using putComponent, it could be useful to check if it already exists on the player in case we want to update it
+     if(store.getComponent(ref, YourPlugin.instance().getYourPlayerDataComponent()) != null)
+     {
+          // here we implement logic that updates the component
+         var comp = store.getComponent(ref, YourPlugin.instance().getYourPlayerDataComponent())
+         // declare public fields or methods in the component class
+         comp.SomeString = "An Updated Field";
+     } else {
+          // Here we put the component
+          var myCustomComp = new CustomComponent();
+          // declare public fields or methods in the component class
+          myCustomComp.SomeString = "Edited String";
+
+          // putComponent allows you to insert declared objects
+          store.putComponent(ref, YourPlugin.instance().getYourPlayerDataComponent(), myCustomComp);
+     }
+}
+```
+
+## Using your Data
+
+Your component will be stored within the `Store<EntityStore>` when added to the player. In the provided example,
+we'll fetch this data off the player using the `ensureAndGetComponent()` method, which will add the component to
+the player if it does not exist with the default values.
+
+```java
+public class IncompleteCustomCommand extends AbstractPlayerCommand {
+
+    public IncompleteCustomCommand() {
+        super("nope", "don't use this command");
+    }
+
+    @Override
+    protected void execute(
+        @NonNullDecl CommandContext commandContext,
+        @NonNullDecl Store<EntityStore> store,
+        @NonNullDecl Ref<EntityStore> ref,
+        @NonNullDecl PlayerRef playerRef,
+        @NonNullDecl World world
+    ) {
+        YourPlayerData customData = store.ensureAndGetComponent(ref, YourPlugin.instance().getYourPlayerDataComponent());
+        // ensureAndGetComponent adds the component to the ref, with the default values defined inside your component.
+ 		// use your data
+    }
+}
+```
+
+And that's it! Your data will now be saved and loaded automatically with the player.
+
+Using custom components to store persistent data on players is a powerful way to maintain state across sessions.
+By following the steps outlined above, you can easily create, register, and utilize your own data structures within the Hytale ECS framework.
+This approach ensures that your data is seamlessly integrated with the game's existing systems.
+For more information about Hytale's Entity Component System visit the [Hytale ECS Theory](https://hytalemodding.dev/en/docs/guides/ecs/hytale-ecs-theory) guide.
diff --git a/content/docs/ar-SA/guides/plugin/teleporting-players.mdx b/content/docs/ar-SA/guides/plugin/teleporting-players.mdx
index 57cee77f..32ce0435 100644
--- a/content/docs/ar-SA/guides/plugin/teleporting-players.mdx
+++ b/content/docs/ar-SA/guides/plugin/teleporting-players.mdx
@@ -1,26 +1,32 @@
 ---
 title: Teleporting the player
 description: Learn how to teleport the player.
+authors:
+  - name: oskarscot
+    url: https://oskar.scot
 ---
 
-To teleport players in Hytale, you will need to get a `World` object so we can safely run the teleport on the world thread. The world thread manages all entity updates, so modifying entities off-thread can crash the server or cause inconsistent state.
-Next, we get the entity store and make a `Teleport` object.
-We add a `Teleport` component to the player’s entity reference in the entity store. This triggers the teleportation logic for that player.
+Teleporting players in Hytale works by simply attaching a `Teleport` component to a player with the desired world and transform.
+You can only trigger teleports from a world where the player is currently present.
+Teleport itself is a component but it also provides factory methods to configure the Teleport. Just as with any entity component, an EntityStore and a Ref to the EntityStore is required
+
+We can create a simple teleport utility like this:
 
 ```java
-public static void teleportPlayer(Player player, int x, int y, int z) {
-        World world = player.getWorld();
-        if (world == null) return;
-        world.execute(() -> {
-            if (player.getReference() == null) return;
-            Store<EntityStore> store = player.getReference().getStore();
-            Teleport teleport = Teleport.createForPlayer(world,
-                new Vector3d(x ,y, z), // Target position
-                new Vector3f(0, 0, 0)  // Target rotation (pitch, yaw, roll)
-            );
+public static void teleportPlayer(Ref<EntityStore> ref, Store<EntityStore> store, World targetWorld, double x, double y, double z) {                                                                                       
+    Transform transform = new Transform(x, y, z);                                                                                                                           
+    Teleport teleport = Teleport.createForPlayer(targetWorld, transform);                                                                                                   
+    store.addComponent(ref, Teleport.getComponentType(), teleport);                                                                                                         
+}  
+```
 
-            store.addComponent(player.getReference(), Teleport.getComponentType(), teleport);
-        });
+A `Transform` is a representation of a position Vector3d and rotation Vector3f which works in the following way:
 
-}
+```java
+Transform transform = new Transform(
+    new Vector3d(x, y, z),      // Position
+    new Rotation(yaw, pitch, 0) // Rotation, last value seems to always be 0
+);
+Teleport teleport = Teleport.createForPlayer(targetWorld, transform);
+store.addComponent(ref, Teleport.getComponentType(), teleport);
 ```
diff --git a/content/docs/ar-SA/guides/plugin/tracking-mod-analytics-with-hstats.mdx b/content/docs/ar-SA/guides/plugin/tracking-mod-analytics-with-hstats.mdx
new file mode 100644
index 00000000..45c022e0
--- /dev/null
+++ b/content/docs/ar-SA/guides/plugin/tracking-mod-analytics-with-hstats.mdx
@@ -0,0 +1,65 @@
+---
+title: Tracking Mod Analytics with HStats
+description: Learn how you can track Analytics for your Hytale Mod for Free using hstats.dev
+authors:
+  - name: Al3x
+    url: https://hstats.dev
+---
+
+In this guide, you will learn how to integrate HStats into your Plugin/Mod which will allow you to track how many Servers are using it along with other stats.
+
+<Callout type="info">
+  HStats is a third-party tool and is not affiliated with HytaleModding or Hypixel Studios
+</Callout>
+
+# Step 1: Register your Mod to HStats
+
+Before you touch any code, you will need to add your mod to the HStats website which will give you a UUID for your mod.
+
+- Create or Login to an Account on https://hstats.dev
+- Navigate to the dashboard page (https://hstats.dev/dashboard)
+- On the left, type in your mod's name and click "Add Mod"
+- Keep note of the UUID generated for later.
+
+# Step 2: Add the HStats Class to Your Project
+
+To keep things simple, HStats uses a single Java class file that handles everything for you.
+
+- Download / Copy the File from the GitHub page (https://github.com/hstats-dev/HStatsExamplePlugin/blob/main/src/main/java/com/al3x/HStats.java)
+- Paste into your Project. You should now have a HStats.java file somewhere in your projects directory.
+- Update the package name from com.al3x to whatever fits your project.
+
+# Step 3: Initialize HStats in your code
+
+You only need to add one line of code to your mod's setup method in your main class to start tracking.
+
+`new HStats("YOUR-MOD-UUID", "1.0.0");`
+
+Replace `YOUR-MOD-UUID` with the Mod UUID we made note of earlier and change the `1.0.0` version to whatever version your mod is currently on.
+
+Your setup method should now look something like this:
+
+```java
+@Override
+protected void setup() {
+  super.setup();
+  new HStats("c34a2b2a-afd8-4d6a-821e-7a63e12c5ea6", "1.0.0");
+}
+```
+
+# Extras
+
+Your done! Your mod should now be listed under the Mods page (https://hstats.dev/mods) as well as under your dashboard.
+
+Servers using your mod should now post updates about every minute to HStats which you can view in the Dashboard.
+
+### Embeds
+
+HStats allows you to generate an Embed Card that you can place on your CurseForge or GitHub page. This is useful for server owners to be able to see how many other servers are using your mod.
+
+- In your dashboard, scroll down to the Embed Card section.
+- Customize the appearance (Light/Dark mode, layout, etc).
+- Copy the generated URL to display your "Active Servers" and "Players Online" live on your mod's description page
+
+Heres an example of what they look like:
+![HStats Example](https://api.hstats.dev/api/embed/d52fa672-6966-47b2-b501-1a11bddebac3/card.svg?theme=light\&layout=compact\&size=md\&show_id=true\&dark=false)
diff --git a/content/docs/ar-SA/guides/plugin/world-gen.mdx b/content/docs/ar-SA/guides/plugin/world-gen.mdx
index 4c23b0c9..7b193ffd 100644
--- a/content/docs/ar-SA/guides/plugin/world-gen.mdx
+++ b/content/docs/ar-SA/guides/plugin/world-gen.mdx
@@ -100,7 +100,7 @@ Biome biome = biomeGen.generateBiomeAt(zoneResult, seed, x, z);
 
 ### Zone & Cave Integration
 
-Each zone defines it's own cave patterns:
+Each zone defines its own cave patterns:
 
 ```java
 Zone zone = /* ... */;
diff --git a/content/docs/ar-SA/guides/prefabs.mdx b/content/docs/ar-SA/guides/prefabs.mdx
index 08404b30..b1a55109 100644
--- a/content/docs/ar-SA/guides/prefabs.mdx
+++ b/content/docs/ar-SA/guides/prefabs.mdx
@@ -14,7 +14,7 @@ Prefabs are Hytale's way of creating reusable structures.
 There are a few fundamental concepts to understand about prefabs:
 
 - Users interact with prefabs via a prefab editing world.
-- Prefabs the physical structures in the game world, and are saved as JSON files.
+- Prefabs are the physical structures in the game world, and are saved as JSON files.
 
 ## How to Create a Prefab
 
diff --git a/content/docs/ar-SA/official-documentation/custom-ui/common-styling.mdx b/content/docs/ar-SA/official-documentation/custom-ui/common-styling.mdx
new file mode 100644
index 00000000..c36e3e3a
--- /dev/null
+++ b/content/docs/ar-SA/official-documentation/custom-ui/common-styling.mdx
@@ -0,0 +1,50 @@
+---
+title: Common Styling
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# Common Styling
+
+## Common UI Styling Library
+
+This document describes the shared UI components and styles defined in `Common.ui`.
+
+---
+
+### Styles
+
+We are providing some styles that can be re-used in any custom UI that, provide a cohesive UI experience with the core game UI. These styles are available in the `Common.ui` file.
+
+You can find a list of all the styles defined with live examples by running the `/ui-gallery` command ingame.
+
+<Callout type="warning">
+  This command is not available yet, but will be in a future patch.
+</Callout>
+
+![Gallery](/assets/official-documentation/ui/gallery.png)
+
+### Importing
+
+To use these styles in your UI file:
+
+```
+$Common = "Common.ui";
+
+// Then reference styles and components:
+$Common.@TextButton { @Text = "My Button"; }
+$Common.@Container { ... }
+```
+
+<Callout type="info">
+  The `Common.ui` file is at `Common/UI/Custom/Common.ui` within the Hytale pack. If your custom ui document is in a subfolder of `Common/UI/Custom/`, reference it via relative path traversal:
+
+  ```
+  $Common = "../Common.ui";
+  ```
+
+  You can find more info about paths [here](markup#path).
+</Callout>
diff --git a/content/docs/ar-SA/official-documentation/custom-ui/index.mdx b/content/docs/ar-SA/official-documentation/custom-ui/index.mdx
new file mode 100644
index 00000000..f94c4e88
--- /dev/null
+++ b/content/docs/ar-SA/official-documentation/custom-ui/index.mdx
@@ -0,0 +1,125 @@
+---
+title: Custom UI
+icon: LayoutDashboard
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# Custom UI
+
+## What is Custom UI?
+
+Custom UI is Hytale's framework for creating **custom user interfaces** controlled by the game server. Unlike the built-in Client UI (which is part of the game client and cannot be modified), Server UI allows you to create interactive screens and HUD overlays through Java plugins and asset packs.
+
+As a modder, Custom UI gives you the power to:
+
+- **Create custom interactive pages** - Shop interfaces, quest dialogs, server settings menus, admin panels
+- **Add custom HUD overlays** - Quest trackers, status displays, custom health bars, server information
+- **Design with markup** - Use `.ui` files to define reusable UI templates
+- **Handle user interactions** - Respond to button clicks, form submissions, and other events
+- **Localize your UI** - Support multiple languages using the game's translation system
+
+## How Custom UI Fits Into Hytale's UI
+
+Hytale's user interface is divided into two main categories:
+
+### Client UI (Not Moddable)
+
+Built-in interfaces controlled by the C# game client:
+
+- Main menu and settings
+- Character creation
+- Built-in HUD (health, hotbar, chat)
+- Inventory and crafting screens
+- Development tools
+
+**You cannot modify these** - they are part of the core game client.
+
+### In-Game UI (Moddable via Server)
+
+Server-controlled interfaces that you can create and customize:
+
+#### Custom Pages
+
+Full-screen interactive overlays that appear during gameplay:
+
+- Can be dismissed by the player (ESC key)
+- Capture all input (keyboard and mouse)
+- Support loading states while waiting for server responses
+- Perfect for: shops, dialogs, menus, configuration screens
+
+#### Custom HUDs
+
+Persistent overlay elements drawn on top of the game world:
+
+- Display-only (no user interaction)
+- Always visible during gameplay
+- Lightweight and non-intrusive
+- Perfect for: quest objectives, status indicators, server info panels
+
+## Architecture Overview
+
+Server UI uses a **command-based architecture**:
+
+```
+┌─────────────────────┐         ┌──────────────────────┐
+│   Java Server       │         │    C# Client         │
+│   (Your Plugin)     │         │    (Game)            │
+├─────────────────────┤         ├──────────────────────┤
+│                     │         │                      │
+│ InteractiveCustomUI │         │   CustomPage or      │
+│ Page                │         │   CustomHud          │
+│   ↓ build()         ├────────→│     ↓ Apply          │
+│ UICommandBuilder    │         │   Element Tree       │
+│   - append()        │         │     ↓ Layout         │
+│   - set()           │         │   Rendered UI        │
+│   - clear()         │         │                      │
+│                     │         │                      │
+│ ↓ handleDataEvent() │← Events │   User Interaction   │
+│   Process input     │         │   (click, type, etc) │
+│   sendUpdate()      │         │                      │
+└─────────────────────┘         └──────────────────────┘
+```
+
+**The flow:**
+
+1. Your Java code builds UI using `UICommandBuilder`
+2. Commands are sent to the client as data
+3. Client parses `.ui` markup files and creates visual elements
+4. User interacts with the UI
+5. Events are sent back to your Java code
+6. You process events and send updates back
+
+## Key Principles
+
+### Declarative, Not Imperative
+
+You don't create UI objects directly. Instead, you send **commands** that describe what you want:
+
+- "Append this button template to that container"
+- "Set this label's text to 'Hello World'"
+- "Clear all children from this list"
+
+### Asset-Driven
+
+UI structure is defined in `.ui` markup files (assets), not hardcoded in Java. This enables:
+
+- Designers to modify layouts without touching code
+- Reusable UI components
+- Consistent visual language
+
+### Event-Driven
+
+User interactions trigger events that flow back to your server code. You register event bindings and handle them in `handleDataEvent()`.
+
+### Selector-Based
+
+You target specific UI elements using **selectors:**
+
+- `#MyButton` - Element with ID "MyButton"
+- `#List[0]` - First child of element "List"
+- `#List[0] #Title` - Element with ID "Title" in the first child of element "List"
+- `#Label.TextColor` - The TextColor property of element "Label"
diff --git a/content/docs/ar-SA/official-documentation/custom-ui/layout.mdx b/content/docs/ar-SA/official-documentation/custom-ui/layout.mdx
new file mode 100644
index 00000000..0a24ca09
--- /dev/null
+++ b/content/docs/ar-SA/official-documentation/custom-ui/layout.mdx
@@ -0,0 +1,492 @@
+---
+title: Layout
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# Layout
+
+The layout system determines how UI elements are positioned and sized on screen. Understanding layout is crucial for creating well-structured, responsive interfaces.
+
+## Layout Fundamentals
+
+Every UI element has:
+
+- **Container Rectangle** - The space allocated by the parent
+- **Anchor** - How the element positions/sizes itself within the container
+- **Padding** - Inner spacing that affects child layout
+- **LayoutMode** - How the element arranges its children (if it's a container)
+
+```
+┌─────────────────────────────────────┐
+│  Container Rectangle (from parent)  │
+│  ┌───────────────────────────────┐  │
+│  │  Anchored Rectangle           │  │
+│  │  ┌─────────────────────────┐  │  │
+│  │  │ Padding                 │  │  │
+│  │  │  ┌───────────────────┐  │  │  │
+│  │  │  │  Content Area     │  │  │  │
+│  │  │  └───────────────────┘  │  │  │
+│  │  └─────────────────────────┘  │  │
+│  └───────────────────────────────┘  │
+└─────────────────────────────────────┘
+```
+
+## Anchor
+
+`Anchor` controls how an element positions and sizes itself within its container rectangle.
+
+### Fixed Size
+
+```
+Button {
+    Anchor: (Width: 200, Height: 40);
+}
+```
+
+Creates a 200×40 pixel button.
+
+### Positioning
+
+```
+Label {
+    Anchor: (Top: 10, Left: 20, Width: 100, Height: 30);
+}
+```
+
+- **Top**: 10 pixels from container's top edge
+- **Left**: 20 pixels from container's left edge
+- **Width**: 100 pixels wide
+- **Height**: 30 pixels tall
+
+### Anchoring to Edges
+
+```
+Button {
+    Anchor: (Bottom: 10, Right: 10, Width: 100, Height: 30);
+}
+```
+
+Anchors the button to the bottom-right corner, 10 pixels from each edge.
+
+### Stretching
+
+```
+Group {
+    Anchor: (Top: 0, Bottom: 0, Left: 0, Right: 0);
+}
+```
+
+Stretches to fill the entire container (all edges at 0 pixels).
+
+**Shorthand:**
+
+```
+Group {
+    Anchor: (Full: 0);
+}
+```
+
+### Mixed Anchoring
+
+```
+Panel {
+    Anchor: (Top: 10, Bottom: 10, Left: 20, Width: 300);
+}
+```
+
+- Fixed width of 300 pixels
+- Stretches vertically between top and bottom edges
+- 10 pixels from top and bottom
+- 20 pixels from left
+
+## Padding
+
+`Padding` creates inner spacing, affecting where children are positioned.
+
+### Uniform Padding
+
+```
+Group {
+    Padding: (Full: 20);
+}
+```
+
+20 pixels of padding on all sides.
+
+### Directional Padding
+
+```
+Group {
+    Padding: (Top: 10, Bottom: 20, Left: 15, Right: 15);
+}
+```
+
+Different padding per edge.
+
+### Shorthand
+
+```
+// Horizontal and vertical
+Group {
+    Padding: (Horizontal: 20, Vertical: 10);
+}
+
+// Equivalent to:
+// Top: 10, Bottom: 10, Left: 20, Right: 20
+```
+
+### Effect on Children
+
+```
+Group {
+    Anchor: (Width: 200, Height: 100);
+    Padding: (Full: 10);
+
+    Label {
+        Anchor: (Full: 0);
+    }
+}
+```
+
+The label fills the group, but there's a 10-pixel gap on all sides due to padding.
+
+```
+┌──────────────────────┐
+│ Group (200×100)      │
+│  ┌────────────────┐  │
+│  │ Label          │  │ ← 10px padding all around
+│  │                │  │
+│  └────────────────┘  │
+└──────────────────────┘
+```
+
+## LayoutMode
+
+`LayoutMode` determines how a container arranges its children.
+
+### Top (Vertical Stack)
+
+```
+Group {
+    LayoutMode: Top;
+
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+}
+```
+
+Children stack vertically from top to bottom:
+
+```
+┌──────────┐
+│ Button 1 │
+├──────────┤
+│ Button 2 │
+├──────────┤
+│ Button 3 │
+└──────────┘
+
+
+```
+
+Each child's `Anchor.Bottom` adds spacing between elements:
+
+```
+Button { Anchor: (Height: 30, Bottom: 10); }  // 10px gap after this button
+```
+
+### Bottom (Vertical Stack)
+
+```
+Group {
+    LayoutMode: Bottom;
+
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+}
+```
+
+Children stack vertically from top to bottom but aligned to the bottom edge of the parent:
+
+```
+
+
+
+┌──────────┐
+│ Button 1 │
+├──────────┤
+│ Button 2 │
+├──────────┤
+│ Button 3 │
+└──────────┘
+```
+
+### Left (Horizontal Stack)
+
+```
+Group {
+    LayoutMode: Left;
+
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+}
+```
+
+Children arrange horizontally from left to right:
+
+```
+┌────────┬────────┬────────┐
+│ Button │ Button │ Button │
+│   1    │   2    │   3    │
+└────────┴────────┴────────┘
+```
+
+Use `Anchor.Right` for spacing between elements.
+
+### Right (Horizontal Stack)
+
+```
+Group {
+    LayoutMode: Right;
+
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+}
+```
+
+Children arrange horizontally from left to right but aligned to the right side of the parent:
+
+```
+                                                                 ┌────────┬────────┬────────┐
+                                                                 │ Button │ Button │ Button │
+                                                                 │   1    │   2    │   3    │
+                                                                 └────────┴────────┴────────┘
+```
+
+### Center
+
+```
+Group {
+    LayoutMode: Center;
+
+    Group #Dialog {
+        Anchor: (Width: 400, Height: 300);
+    }
+}
+```
+
+Centers the children horizontally.
+
+### Middle
+
+```
+Group {
+    LayoutMode: Middle;
+
+    Group #Dialog {
+        Anchor: (Width: 400, Height: 300);
+    }
+}
+```
+
+Centers the children vertically.
+
+### CenterMiddle (Horizontal Stack, Fully Centered)
+
+```
+Group {
+    LayoutMode: CenterMiddle;
+
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+}
+```
+
+Children stack horizontally from left to right, centered both horizontally and vertically within the parent:
+
+```
+┌────────────────────────────────────────────┐
+│                                            │
+│                                            │
+│         ┌──────┐ ┌──────┐ ┌──────┐         │
+│         │  B1  │ │  B2  │ │  B3  │         │
+│         └──────┘ └──────┘ └──────┘         │
+│                                            │
+│                                            │
+└────────────────────────────────────────────┘
+```
+
+---
+
+### MiddleCenter (Vertical Stack, Fully Centered)
+
+```
+Group {
+    LayoutMode: MiddleCenter;
+
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+}
+```
+
+Children stack vertically from top to bottom, centered both horizontally and vertically within the parent:
+
+```
+┌────────────────────────────────────────────┐
+│                                            │
+│              ┌──────────┐                  │
+│              │ Button 1 │                  │
+│              ├──────────┤                  │
+│              │ Button 2 │                  │
+│              ├──────────┤                  │
+│              │ Button 3 │                  │
+│              └──────────┘                  │
+│                                            │
+└────────────────────────────────────────────┘
+```
+
+---
+
+### Full
+
+```
+Group {
+    LayoutMode: Full;
+
+    Label {
+        Anchor: (Top: 20, Left: 20, Width: 100, Height: 30);
+    }
+}
+```
+
+Children use absolute positioning via their `Anchor` properties.
+
+### TopScrolling
+
+```
+Group {
+    LayoutMode: TopScrolling;
+    ScrollbarStyle: $Common.@DefaultScrollbar;
+
+    // ... many children
+}
+```
+
+Like `Top`, but adds a scrollbar if content exceeds container height.
+
+Or use `BottomScrolling` for bottom-aligned content.
+
+### LeftScrolling
+
+```
+Group {
+    LayoutMode: LeftScrolling;
+    ScrollbarStyle: $Common.@DefaultScrollbar;
+
+    // ... many children
+}
+```
+
+Like `Left`, but adds a scrollbar for horizontal scrolling.
+
+Or use `RightScrolling` for right-aligned content.
+
+### LeftCenterWrap (Wrapping Horizontal Stack, Horizontally Centered)
+
+```
+Group {
+    LayoutMode: LeftCenterWrap;
+
+    Button { Anchor: (Width: 80, Height: 30); }
+    Button { Anchor: (Width: 80, Height: 30); }
+    Button { Anchor: (Width: 80, Height: 30); }
+    Button { Anchor: (Width: 80, Height: 30); }
+    Button { Anchor: (Width: 80, Height: 30); }
+}
+```
+
+Children flow left to right. When there's no more horizontal space, they wrap to the next row. Each row is horizontally centered within the parent:
+
+```
+┌────────────────────────────────────────────┐
+│                                            │
+│       ┌──────┐ ┌──────┐ ┌──────┐           │
+│       │  B1  │ │  B2  │ │  B3  │           │
+│       └──────┘ └──────┘ └──────┘           │
+│            ┌──────┐ ┌──────┐               │
+│            │  B4  │ │  B5  │               │
+│            └──────┘ └──────┘               │
+│                                            │
+└────────────────────────────────────────────┘
+```
+
+## FlexWeight
+
+`FlexWeight` distributes remaining space among children.
+
+```
+Group {
+    LayoutMode: Left;
+    Anchor: (Width: 400);
+
+    Button {
+        Anchor: (Width: 100);
+    }
+
+    Group {
+        FlexWeight: 1;  // Takes all remaining space
+    }
+
+    Button {
+        Anchor: (Width: 100);
+    }
+}
+```
+
+Result:
+
+- First button: 100px
+- Middle group: 200px (400 - 100 - 100 = 200)
+- Last button: 100px
+
+### Multiple FlexWeights
+
+```
+Group {
+    LayoutMode: Left;
+    Anchor: (Width: 600);
+
+    Group { FlexWeight: 1; }
+    Group { FlexWeight: 2; }
+    Group { FlexWeight: 1; }
+}
+```
+
+Remaining space (600px) is split:
+
+- First group: 600 × (1/4) = 150px
+- Second group: 600 × (2/4) = 300px
+- Third group: 600 × (1/4) = 150px
+
+## Visibility
+
+```
+Button #HiddenButton {
+    Visible: false;
+}
+```
+
+**Effect:**
+
+- Element and its children are not displayed
+- Element is **not included in layout** (doesn't take up space)
diff --git a/content/docs/ar-SA/official-documentation/custom-ui/markup.mdx b/content/docs/ar-SA/official-documentation/custom-ui/markup.mdx
new file mode 100644
index 00000000..564110ed
--- /dev/null
+++ b/content/docs/ar-SA/official-documentation/custom-ui/markup.mdx
@@ -0,0 +1,226 @@
+---
+title: Markup
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# Markup
+
+## Markup
+
+An element is the basic building block of a user interface. There are various types of elements with different properties, which are documented below.
+
+Here's what the syntax looks like:
+
+```
+// Basic declaration of an element
+// with its Anchor property set to attach on all sides of its parent
+// with 10 pixels of margin
+Group { Anchor: (Left: 10, Top: 10, Right: 10, Bottom: 10); }
+
+Group { Anchor: (Full: 10); } // More concise version
+
+// Declaration of a Label with a name
+// (can be used to access the element from game code)
+Label #MyLabel {
+  Style: LabelStyle(FontSize: 16); // or just Style: (FontSize: 16), type can be inferred.
+  Text: "Hi! I am text.";
+}
+
+// Declaration of a Group containing 2 children
+// You can use FlexWeight to distribute any left-over space after explicit widths/heights have been subtracted
+Group {
+  LayoutMode: Left;
+  Label { Text: "Child 1"; FlexWeight: 2; }
+  Label { Text: "Child 2"; FlexWeight: 1; }
+}
+```
+
+### Documents
+
+A UI document (_.ui_ file) contains trees of elements. There can be multiple root elements.
+
+### Named Expressions
+
+Named expressions can be declared at any level of a document (including at the root) and will be scoped to that subtree, though they need to be declared at the top of the block.
+
+```
+// Example of named expressions, declared and used with @ prefix
+@Title = "Hytale";
+@ExtraSpacing = 5;
+
+Label {
+  Text: @Title;
+  Style: (LetterSpacing: 2 + @ExtraSpacing);
+}
+```
+
+You can use the spread operator `...` to reuse a named expression while overriding some of its fields:
+
+```
+@MyBaseStyle = LabelStyle(FontSize: 24, LetterSpacing: 2);
+
+Label {
+  Style: (...@MyBaseStyle, FontSize: 36);
+}
+```
+
+You can even layer multiple named expressions like so:
+
+```
+@TitleStyle = LabelStyle(FontSize: 24, HorizontalAlignment: Center);
+@SpacedTextStyle = LabelStyle(LetterSpacing: 2);
+
+Label {
+  Style: (...@BigTextStyle, ...@SpacedTextStyle);
+}
+```
+
+#### Document references
+
+A document can reference another document and access its named expressions.
+
+```
+// Document references are defined with $ prefix
+$Common = "../Common.ui";
+
+TextButton {
+  Style: $Common.@DefaultButtonStyle;
+}
+```
+
+### Templates
+
+You can declare a reusable bit of interface as a named expression and then instantiate it as many times as you want in the tree while customizing it.
+
+You can override local named expressions as well as insert additional children at any point in the template tree. However, local named expressions must be defined at the very top of the block, before properties and child elements.
+
+```
+// This is the template
+@Row = Group {
+  Anchor: (Height: 50);
+  Label #Label { Anchor: (Left: 0, Width: 100); Text: @LabelText; }
+  Group #Content { Anchor: (Left: 100); }
+};
+
+// Here we'll be using it twice in the document tree
+Group #Rows {
+  LayoutMode: TopScrolling;
+
+  @Row #MyFirstRow {
+    @LabelText = "First row";
+    #Content { TextInput {} }
+  }
+
+  @Row #MySecondRow {
+    @LabelText = "Second row";
+  }
+}
+```
+
+### Property Types
+
+#### Basic Types
+
+- **Boolean**
+  - `Visible: false;`
+  - `Visible: true;`
+- **Int**
+  - `Height: 20;`
+- **Float, Double, Decimal**
+  - `Min: 0.2;`
+- **String**
+  - `Text: "Hi!";`
+- **Char**
+  - `PasswordChar: "*";`
+  - _Note: The syntax is the same as a string, however a value of this type cannot contain more than one character!_
+- **Color**
+  - `Background: #ffffff;`&#x20;
+- **Objects**
+  - `Style: (Background: #ffffff)`
+- **Array**&#x20;
+  - `TextSpans: [(Text: "Hi", IsBold: true)]`
+
+#### Translations
+
+Translation keys can be referenced anywhere in markup where you can provide a string, and they are then converted to a string when an element gets instantiated.
+
+**Example:**
+
+```
+Label {
+  Text: %ui.general.cancel;
+}
+```
+
+#### Colors
+
+A color literal can be written as follows:
+
+- `#rrggbb`: 6-digit hexadecimal representation for red, green, blue (fully opaque)
+- `#rrggbb(a.a)`: 6-digit hexadecimal representation for red, green, blue with alpha between 0 and 1
+- `#rrggbbaa`: 8-digit hexadecimal representation for red, green, blue and alpha
+
+```
+Group {
+  Background: #000000(0.3);
+}
+```
+
+<Callout>
+  The `#rrggbb(a.a)` format is prefered over the `#rrggbbaa` format for
+  readability reasons.
+</Callout>
+
+#### Font Name
+
+Font names can be referenced directly by their string ID. Internally this is using a custom type called `UIFontName`, however strings will be converted automatically to this type in markup.
+
+```
+Label {
+  Text: "Hi";
+  Style: (FontName: "Secondary");
+}
+```
+
+**Available Font Names**
+
+- _Default_ - This is the default font that is used for most text and is always used unless a different option has been specified
+- _Secondary_ - This font is mostly used for headlines or elements that are supposed to stick out
+- _Mono_ - This is only used for development; For things such as profiling or error overlays.
+
+#### Path
+
+We can reference other UI assets with the `UIPath` type. Similar to `UIFontName`_,_ Strings are automatically converted to a `UIPath`. Paths are always relative to the file where they have been declared in. Looking up _MyButton.png_ in _Menu/MyAwesomeMenu.ui_ will result in _Menu/MyButton.png_. If you want to reference a file that is in a parent folder you can go back one directory by writing two dots (_../MyButton.png_).
+
+The markup syntax of a `UIPath` is the same as a String. (e.g. `Path: "Test.png"`)
+
+Here are some more examples:
+
+| UIPath             | .ui File                              | Resulting Path    |
+| ------------------ | ------------------------------------- | ----------------- |
+| MyButton.png       | Menu/MyAwesomeMenu.ui                 | Menu/MyButton.png |
+| ../MyButton.png    | Menu/MyAwesomeMenu.ui                 | MyButton.png      |
+| ../../MyButton.png | Menu/Popup/Templates/MyAwesomeMenu.ui | Menu/MyButton.png |
+
+#### Objects
+
+Objects contain a set of properties. In this example we are assigning an Anchor object to the _Anchor_ property:
+
+```
+Group {
+  Anchor: (
+   Height: 10,
+   Width: 20
+ );
+}
+```
+
+You can find all objects that can be used in markup [here](type-documentation#elements).
+
+## Visual Studio Code Extension
+
+There is an official extension for Visual Studio Code which adds syntax highlighting for .ui files. You can find it [here](https://marketplace.visualstudio.com/items?itemName=HypixelStudiosCanadaInc.vscode-hytaleui).
diff --git a/content/docs/ar-SA/official-documentation/custom-ui/type-documentation/index.mdx b/content/docs/ar-SA/official-documentation/custom-ui/type-documentation/index.mdx
new file mode 100644
index 00000000..69cea406
--- /dev/null
+++ b/content/docs/ar-SA/official-documentation/custom-ui/type-documentation/index.mdx
@@ -0,0 +1,127 @@
+---
+title: Type Documentation
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# Type Documentation
+
+This is a generated list of UI elements accessible by markup. More information about the User Interface framework can be found in the main documentation.
+
+## Elements
+
+- [ActionButton](type-documentation/elements/actionbutton)
+- [AssetImage](type-documentation/elements/assetimage)
+- [BackButton](type-documentation/elements/backbutton)
+- [BlockSelector](type-documentation/elements/blockselector)
+- [Button](type-documentation/elements/button)
+- [CharacterPreviewComponent](type-documentation/elements/characterpreviewcomponent)
+- [CheckBox](type-documentation/elements/checkbox)
+- [CheckBoxContainer](type-documentation/elements/checkboxcontainer)
+- [CircularProgressBar](type-documentation/elements/circularprogressbar)
+- [CodeEditor](type-documentation/elements/codeeditor)
+- [ColorOptionGrid](type-documentation/elements/coloroptiongrid)
+- [ColorPicker](type-documentation/lements/colorpicker)
+- [ColorPickerDropdownBox](type-documentation/elements/colorpickerdropdownbox)
+- [CompactTextField](type-documentation/elements/compacttextfield)
+- [DropdownBox](type-documentation/elements/dropdownbox)
+- [DropdownEntry](type-documentation/elements/dropdownentry)
+- [DynamicPane](type-documentation/elements/dynamicpane)
+- [DynamicPaneContainer](type-documentation/elements/dynamicpanecontainer)
+- [FloatSlider](type-documentation/elements/floatslider)
+- [FloatSliderNumberField](type-documentation/elements/floatslidernumberfield)
+- [Group](type-documentation/elements/group)
+- [HotkeyLabel](type-documentation/elements/hotkeylabel)
+- [ItemGrid](type-documentation/elements/itemgrid)
+- [ItemIcon](type-documentation/elements/itemicon)
+- [ItemPreviewComponent](type-documentation/elements/itempreviewcomponent)
+- [ItemSlot](type-documentation/elements/itemslot)
+- [ItemSlotButton](type-documentation/elements/itemslotbutton)
+- [Label](type-documentation/elements/label)
+- [LabeledCheckBox](type-documentation/elements/labeledcheckbox)
+- [MenuItem](type-documentation/elements/menuitem)
+- [MultilineTextField](type-documentation/elements/multilinetextfield)
+- [NumberField](type-documentation/elements/numberfield)
+- [Panel](type-documentation/elements/panel)
+- [ProgressBar](type-documentation/elements/progressbar)
+- [ReorderableList](type-documentation/elements/reorderablelist)
+- [ReorderableListGrip](type-documentation/elements/reorderablelistgrip)
+- [SceneBlur](type-documentation/elements/sceneblur)
+- [Slider](type-documentation/elements/slider)
+- [SliderNumberField](type-documentation/elements/slidernumberfield)
+- [Sprite](type-documentation/elements/sprite)
+- [TabButton](type-documentation/elements/tabbutton)
+- [TabNavigation](type-documentation/elements/tabnavigation)
+- [TextButton](type-documentation/elements/textbutton)
+- [TextField](type-documentation/elements/textfield)
+- [TimerLabel](type-documentation/elements/timerlabel)
+- [ToggleButton](type-documentation/elements/togglebutton)
+
+## Property Types
+
+- [Anchor](type-documentation/property-types/anchor)
+- [BlockSelectorStyle](type-documentation/property-types/blockselectorstyle)
+- [ButtonSounds](type-documentation/property-types/buttonsounds)
+- [ButtonStyle](type-documentation/property-types/buttonstyle)
+- [ButtonStyleState](type-documentation/property-types/buttonstylestate)
+- [CheckBoxStyle](type-documentation/property-types/checkboxstyle)
+- [CheckBoxStyleState](type-documentation/property-types/checkboxstylestate)
+- [ClientItemStack](type-documentation/property-types/clientitemstack)
+- [ColorOptionGridStyle](type-documentation/property-types/coloroptiongridstyle)
+- [ColorPickerDropdownBoxStateBackground](type-documentation/property-types/colorpickerdropdownboxstatebackground)
+- [ColorPickerDropdownBoxStyle](type-documentation/property-types/colorpickerdropdownboxstyle)
+- [ColorPickerStyle](type-documentation/property-types/colorpickerstyle)
+- [DropdownBoxSearchInputStyle](type-documentation/property-types/dropdownboxsearchinputstyle)
+- [DropdownBoxSounds](type-documentation/property-types/dropdownboxsounds)
+- [DropdownBoxStyle](type-documentation/property-types/dropdownboxstyle)
+- [InputFieldButtonStyle](type-documentation/property-types/inputfieldbuttonstyle)
+- [InputFieldDecorationStyle](type-documentation/property-types/inputfielddecorationstyle)
+- [InputFieldDecorationStyleState](type-documentation/property-types/inputfielddecorationstylestate)
+- [InputFieldIcon](type-documentation/property-types/inputfieldicon)
+- [InputFieldStyle](type-documentation/property-types/inputfieldstyle)
+- [ItemGridSlot](type-documentation/property-types/itemgridslot)
+- [ItemGridStyle](type-documentation/property-types/itemgridstyle)
+- [LabeledCheckBoxStyle](type-documentation/property-types/labeledcheckboxstyle)
+- [LabeledCheckBoxStyleState](type-documentation/property-types/labeledcheckboxstylestate)
+- [LabelSpan](type-documentation/property-types/labelspan)
+- [LabelStyle](type-documentation/property-types/labelstyle)
+- [NumberFieldFormat](type-documentation/property-types/numberfieldformat)
+- [Padding](type-documentation/property-types/padding)
+- [PatchStyle](type-documentation/property-types/patchstyle)
+- [PopupStyle](type-documentation/property-types/popupstyle)
+- [ScrollbarStyle](type-documentation/property-types/scrollbarstyle)
+- [SliderStyle](type-documentation/property-types/sliderstyle)
+- [SoundStyle](type-documentation/property-types/soundstyle)
+- [SpriteFrame](type-documentation/property-types/spriteframe)
+- [SubMenuItemStyle](type-documentation/property-types/submenuitemstyle)
+- [SubMenuItemStyleState](type-documentation/property-types/submenuitemstylestate)
+- [Tab](type-documentation/property-types/tab)
+- [TabNavigationStyle](type-documentation/property-types/tabnavigationstyle)
+- [TabStyle](type-documentation/property-types/tabstyle)
+- [TabStyleState](type-documentation/property-types/tabstylestate)
+- [TextButtonStyle](type-documentation/property-types/textbuttonstyle)
+- [TextButtonStyleState](type-documentation/property-types/textbuttonstylestate)
+- [TextTooltipStyle](type-documentation/property-types/texttooltipstyle)
+- [ToggleButtonStyle](type-documentation/property-types/togglebuttonstyle)
+- [ToggleButtonStyleState](type-documentation/property-types/togglebuttonstylestate)
+
+## Enums
+
+- [ActionButtonAlignment](type-documentation/enums/actionbuttonalignment)
+- [CodeEditorLanguage](type-documentation/enums/codeeditorlanguage)
+- [ColorFormat](type-documentation/enums/colorformat)
+- [DropdownBoxAlign](type-documentation/enums/dropdownboxalign)
+- [InputFieldButtonSide](type-documentation/enums/inputfieldbuttonside)
+- [InputFieldIconSide](type-documentation/enums/inputfieldiconside)
+- [ItemGridInfoDisplayMode](type-documentation/enums/itemgridinfodisplaymode)
+- [LabelAlignment](type-documentation/enums/labelalignment)
+- [LayoutMode](type-documentation/enums/layoutmode)
+- [MouseWheelScrollBehaviourType](type-documentation/enums/mousewheelscrollbehaviourtype)
+- [ProgressBarAlignment](type-documentation/enums/progressbaralignment)
+- [ProgressBarDirection](type-documentation/enums/progressbardirection)
+- [ResizeType](type-documentation/enums/resizetype)
+- [TimerDirection](type-documentation/enums/timerdirection)
+- [TooltipAlignment](type-documentation/enums/tooltipalignment)
diff --git a/content/docs/ar-SA/official-documentation/npc/2-getting-started-with-templates.mdx b/content/docs/ar-SA/official-documentation/npc/2-getting-started-with-templates.mdx
index 91081ca1..99d078e0 100644
--- a/content/docs/ar-SA/official-documentation/npc/2-getting-started-with-templates.mdx
+++ b/content/docs/ar-SA/official-documentation/npc/2-getting-started-with-templates.mdx
@@ -9,7 +9,7 @@ authors:
 
 There are no hard and fast rules for making a start on a template. I like to duplicate **BlankTemplate** and start from there because it already provides the basic structure of the file.
 
-This leaves me with the following template (`Template_Goblin_Ogre.json`): (note: the file could be looking different in the current version of the game)
+This leaves me with the following template (`Template_Goblin_Ogre.json`): (**note: the file could be looking different in the current version of the game**)
 
 ```json
 {
@@ -33,7 +33,7 @@ This leaves me with the following template (`Template_Goblin_Ogre.json`): (note:
     }
   },
   "Appearance": { "Compute": "Appearance" },
-  "DropList": { "Compute": "Droplist" },
+  "DropList": { "Compute": "DropList" },
   "MaxHealth": { "Compute": "MaxHealth" },
   "MotionControllerList": [
     {
@@ -65,10 +65,10 @@ And the following variant (`Goblin_Ogre.json`) next to the template. There's a t
   "Type": "Variant",
   "Reference": "Template_Goblin_Ogre",
   "Modify": {
-    "Appearance": "Goblin_Ogre",
+    "Appearance": "Goblin",
     "MaxHealth": 124
   }
 }
 ```
 
-Our artists have defined the `Goblin_Ogre` appearance already so I'm going to use that.
+Our artists have not yet finished animations for the `Goblin_Ogre`, for that sake of the tutorial I am going to use appearance `Goblin`, because it offers a more complete set of animations that we will need.
diff --git a/content/docs/ar-SA/official-documentation/worldgen/pack-tutorial/asset-packs.mdx b/content/docs/ar-SA/official-documentation/worldgen/pack-tutorial/asset-packs.mdx
index 38809fad..dcf1f3b9 100644
--- a/content/docs/ar-SA/official-documentation/worldgen/pack-tutorial/asset-packs.mdx
+++ b/content/docs/ar-SA/official-documentation/worldgen/pack-tutorial/asset-packs.mdx
@@ -9,13 +9,13 @@ authors:
 
 <OfficialDocumentationNotice />
 
-# How to modify Hytale
+# How to modify Hytale?
 
-## What's an Asset Pack
+## What's an Asset Pack?
 
-Hytales gameplay is driven by assets in the game that can be modified by creators. Asset Packs are our solution to let you override or add features to the base game with your own work. These can in the form of zip files of folders, which contain a custom set of assets. This is not the only way for a creator to change Hytale but this is the most accessible form.;
+Hytales gameplay is driven by assets in the game that can be modified by creators. Asset Packs are our solution to let you override or add features to the base game with your own work. These can be the form of zip files of folders, which contain a custom set of assets. This is not the only way for a creator to change Hytale but this is the most accessible form.;
 
-### How do I make an Asset Pack
+### How do I make an Asset Pack?
 
 <video controls className="my-6 aspect-video w-full rounded-lg border">
   <source src="https://cdn.internal.hytalemodding.dev/guides/official/how-to-asset-pack.mp4" type="video/mp4" />
@@ -48,7 +48,7 @@ An asset pack is typically a zip or folder, with a `manifest.json` inside. This
 }
 ```
 
-### Where are they stored
+### Where are they stored?
 
 Asset Packs are stored with other mods in the Mods folder.
 
@@ -76,7 +76,7 @@ C:\Users\<user>\AppData\Roaming\Hytale\UserData\Saves\New World 5\mods
 
 When you have Asset Packs or Mods installed, these will appear in the New World menu under the Options menu.;
 
-### How do I change an existing asset
+### How do I change an existing asset?
 
 <video controls className="my-6 aspect-video w-full rounded-lg border">
   <source src="https://cdn.internal.hytalemodding.dev/guides/official/how-to-asset.mp4" type="video/mp4" />
diff --git a/content/docs/ar-SA/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx b/content/docs/ar-SA/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx
index 44528376..24e628b5 100644
--- a/content/docs/ar-SA/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx
+++ b/content/docs/ar-SA/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx
@@ -106,7 +106,7 @@ If a BaseHeight is provided, the TopY and BottomY values are relative to the Bas
 
 Applies a Material Provider slot on a set of horizontal stripes of blocks of varying thickness and position. Below is an example image of basalt stripes into a stone cliff.
 
-{/* ![](https://540086904-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F7KAmBkOg6d13nZCkf9ku%2Fuploads%2FbcxO9LpArn8gPCaBwFg5%2Funknown.png?alt=media&token=1c72b67a-8253-4d03-8c64-1ad5f6830050) */}
+![Example of basalt stripes](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/basalt-stripes-example.png)
 
 #### Parameters:
 
diff --git a/content/docs/ar-SA/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx b/content/docs/ar-SA/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx
index 5e34acd4..a4418473 100644
--- a/content/docs/ar-SA/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx
+++ b/content/docs/ar-SA/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx
@@ -294,7 +294,7 @@ Combines all the positions into a single Positioins field.
 
 ---
 
-### SimpleHoritontal
+### SimpleHorizontal
 
 Keeps only the positions that are within the provided range.
 
diff --git a/content/docs/ar-SA/official-documentation/worldgen/worldgen-tutorial/README.mdx b/content/docs/ar-SA/official-documentation/worldgen/worldgen-tutorial/README.mdx
new file mode 100644
index 00000000..5f66d245
--- /dev/null
+++ b/content/docs/ar-SA/official-documentation/worldgen/worldgen-tutorial/README.mdx
@@ -0,0 +1,166 @@
+---
+title: How to edit and create Biomes
+description: Explores where world generation assets can be found and how to edit them.
+---
+
+### Where are the Assets
+
+World generation assets are kept in the HytaleGenerator directory within the assets.
+
+```
+/Server/HytaleGenerator/
+```
+
+<div className="flex flex-row rounded-lg border p-4">
+  <div className="flex-1/2 border-r pr-4">
+    ```
+    /Biomes
+    ```
+
+    Biome assets, with content configurations.
+  </div>
+
+  <div className="flex-1/2 pl-4">
+    ```
+    /WorldStructure
+    ```
+
+    Generator files that define which biomes spawn together.
+  </div>
+</div>
+
+<div className="flex flex-row rounded-lg border p-4">
+  <div className="flex-1/2 border-r pr-4">
+    ```
+    /Density
+    ```
+
+    Density assets that can be referenced by any other assets.
+  </div>
+
+  <div className="flex-1/2 pl-4">
+    ```
+    /Assignments
+    ```
+
+    Prop assets that can be referenced by any Biome assets.
+  </div>
+</div>
+
+***
+
+An example of this structure can be found bellow, packed in an asset pack with the instance configuration.
+
+[https://drive.google.com/file/d/1sIz_CluANIIe3n8vNiOi-4PQdeqCO0qY/view?usp=drive_link](https://drive.google.com/file/d/1sIz_CluANIIe3n8vNiOi-4PQdeqCO0qY/view?usp=drive_link)
+
+<Callout>
+  Ensure you place your asset pack in the correct directory, under Mods.
+</Callout>
+
+### How to visit our worlds
+
+https://drive.google.com/file/d/1BJurxyj-taE-PXWm04bk7Dl6X7ZHTH92/view?usp=sharing
+
+#### Requirements
+
+- You must be an **Operator** in the world.
+  - To do this, run <mark style="color:$danger;">`/op self`</mark>
+- You must be in **Creative mode**.
+  - Press the <mark style="color:$danger;">`O`</mark> key, O for Orange.&#x20;
+
+The generation assets define a set of generators but on their own you cannot visit these. Currently you require an Instance with a generator that will allow you to visit your work.
+
+```
+/Server/Instances/
+```
+
+Instances are separate worlds that players can join using the `/instances` command. Each instance has an `Instance.bson` configuration asset that specifies which generator to use, among other worldly settings.
+
+```json
+{
+  "WorldGen": {
+    "Type": "HytaleGenerator",
+    "WorldStructure": "Basic",
+    "playerSpawn" : {
+      "X" : 123,
+      "Y" : 480,
+      "Z" : 10000,
+      "Pitch" : 0,
+      "Yaw" : 0,
+      "Roll" : 0
+    }
+  }
+}
+```
+
+<Callout>
+  You can create custom instances for different world structures and biomes as you need them.
+</Callout>
+
+### How to edit Biomes
+
+<video>
+  <source src="https://cdn.internal.hytalemodding.dev/guides/official/How-to-edit-Biomes.mp4" type="video/mp4" />
+</video>
+
+We currently use the Hytale Node Editor when editing world generation assets. This can be accessed while in-game from the Content Creation menu when pressing B. The node editor is then found under the asset editor dropdown on the upper left.&#x20;
+
+![Node Editor 1](/assets/official-documentation/worldgen/worldgen-tutorial/biomes/node-editor-1.png)
+
+Once you have the Hytale Node Editor open, through the file menu you can open Biomes by navigating to the Biomes directory and selecting one from your pack.&#x20;
+
+```
+/Server/HytaleGenerator/Biomes/
+```
+
+### Biome Asset Structure
+
+Every Biome has a root Biome node, this node splits into 5 structures. This is covered briefly but more information on each field can be found on the World Generation Concepts page.
+
+![Node Editor 2](/assets/official-documentation/worldgen/worldgen-tutorial/biomes/node-editor-2.png)
+
+<Callout>
+  Each biome is for the most part self contained, meaning it has control over what appears with the biome. The only exception to this are Base Heights.
+</Callout>
+
+<Tabs>
+  <Tab value="Terrain">
+    Mathematical function nodes that calculate the physical shape of the Biome's terrain.
+  </Tab>
+
+  <Tab value="Materials">
+    Logical nodes that determine what materials (blocks) make up a Biome's terrain.
+  </Tab>
+
+  <Tab value="Props">
+    Function nodes that add objects like prefabs and decorations to the terrain.
+  </Tab>
+
+  <Tab value="Environments">
+    Logical nodes that determine the environment asset at a given coordinate within the biome. This asset determines things like weather, NPC spawns, and sounds.
+  </Tab>
+
+  <Tab value="Tints">
+    Logical function nodes that determine a colour code that can be used by certain blocks in the world. Typically this will be grasses and soils.
+  </Tab>
+</Tabs>
+
+### How to preview your work
+
+[https://drive.google.com/file/d/1mNcHn9LhFnWDF0DzWFH6_YllmKAUvUry/view?t=6](https://drive.google.com/file/d/1mNcHn9LhFnWDF0DzWFH6_YllmKAUvUry/view?t=6)
+
+Once you are in an Instance world with the Hytale Generator active you will only be able to see your work by generating new chunks. There are a few ways to do this.
+
+The viewport command selects an area around the Player that will live reload as you make changes to the generator.&#x20;
+
+```
+/viewport --radius 5 
+```
+
+You can also create a new world to show your changes.&#x20;
+
+```
+/instances spawn <instance> 
+```
+
+The last option is to simply fly south, new chunks will generate with the changes made.
diff --git a/content/docs/ar-SA/quick-start.mdx b/content/docs/ar-SA/quick-start.mdx
index 1bdf3ad0..7db2e537 100644
--- a/content/docs/ar-SA/quick-start.mdx
+++ b/content/docs/ar-SA/quick-start.mdx
@@ -9,3 +9,8 @@ Welcome to the Hytale modding documentation! Here you'll find everything you nee
 * [Setting up your dev environment](./guides/plugin/setting-up-env)
 * [Entity Component System (ECS)](./guides/ecs/entity-component-system)
 * [Publishing your mod](./publishing)
+
+### Useful Links
+
+* [Kaupenjoe's Modding Videos](https://www.youtube.com/@ModdingByKaupenjoe)
+* [TroubleDEV's Modding Videos](https://www.youtube.com/@TroubleDEV)
diff --git a/content/docs/ar-SA/server/argtypes.mdx b/content/docs/ar-SA/server/argtypes.mdx
new file mode 100644
index 00000000..e54a442e
--- /dev/null
+++ b/content/docs/ar-SA/server/argtypes.mdx
@@ -0,0 +1,61 @@
+---
+title: ArgTypes
+description: Available ArgTypes
+icon: List
+full: true
+authors:
+  - name: Valeena
+---
+
+| Name                        | Target Class                           | Description                                                                                                                               |   |
+| :-------------------------- | :------------------------------------- | :---------------------------------------------------------------------------------------------------------------------------------------- | - |
+| Boolean                     | java.lang.Boolean                      | A 'true' or 'false' input                                                                                                                 |   |
+| Integer                     | java.lang.Integer                      | A whole number                                                                                                                            |   |
+| String                      | java.lang.String                       | Words, text, numbers, letters. To input more than one word at a time, you may need to wrap it with double quotes (`"my fancy sentence"`). |   |
+| Float                       | java.lang.Float                        | A floating-pointer number                                                                                                                 |   |
+| Double                      | java.lang.Double                       | A decimal number                                                                                                                          |   |
+| UUID                        | java.util.UUID                         | A UUID (Universally Unique IDentifier)                                                                                                    |   |
+| Player_UUID                 | java.util.UUID                         | A UUID or an online player username                                                                                                       |   |
+| Game_Profile_Lookup_Async   | ProfileServiceClient.PublicGameProfile | A player UUID or username. If not found locally, performs a remote lookup via the Profile Service.                                        |   |
+| Relative_Double_Coord       | Coord                                  | An x, y, or z coordinate as a decimal, optionally relative by specifying a tilde (~) in front of the number                               |   |
+| Relative_Int_Coord          | IntCoord                               | An x, y, or z coordinate as a whole number, optionally relative by specifying a tilde (~) in front of the number                          |   |
+| Relative_Integer            | RelativeInteger                        | A tilde to mark an integer relative to a base                                                                                             |   |
+| Relative_Float              | RelativeFloat                          | A tilde to mark a float relative to a base                                                                                                |   |
+| Player_Ref                  | PlayerRef                              | A UUID or an online player's username                                                                                                     |   |
+| World                       | World                                  | A world folder name                                                                                                                       |   |
+| Model_Asset                 | ModelAsset                             | A reference to an Asset of type Model                                                                                                     |   |
+| Weather_Asset               | Weather                                | A reference to an Asset of type Weather                                                                                                   |   |
+| Interaction_Asset           | Interaction                            | A reference to an Asset of type Interaction                                                                                               |   |
+| Root_Interaction_Asset      | RootInteraction                        | A reference to an Asset of type Root Interaction                                                                                          |   |
+| Effect_Asset                | EntityEffect                           | A refernece to an Asset of type EntityEffect                                                                                              |   |
+| Environment_Asset           | Environment                            | A reference to an Asset of type Environment                                                                                               |   |
+| Item_Asset                  | Item                                   | A reference to an Asset of type Item                                                                                                      |   |
+| Block_Type_Asset            | BlockType                              | A reference to an Asset of type BlockType                                                                                                 |   |
+| Particle_System             | ParticleSystem                         | A reference to an Asset of type ParticleSystem                                                                                            |   |
+| Hitbox_Collision_Config     | HitboxCollisionConfig                  | A reference to an Asset of type HitboxCollisionConfig                                                                                     |   |
+| Repulsion_Config            | RepulsionConfig                        | A reference to an Asset of type RepulsionConfig                                                                                           |   |
+| Sound_Event_Asset           | SoundEvent                             | A reference to an Asset of type SoundEvent                                                                                                |   |
+| Ambiance_Fx_Asset           | AmbianceFX                             | A reference to an Asset of type AmbianceFX                                                                                                |   |
+| Sound_Category              | SoundCategory                          | A sound category (sfx, music, ambient, ui)                                                                                                |   |
+| Entity_ID                   | `ArgWrapper<EntityWrappedArg, UUID>`   | A UUID representing an entity id                                                                                                          |   |
+| Integer_Comparison_Operator | IntegerComparisonOperator              | A mathematical sign for integer comparison                                                                                                |   |
+| Integer_Operation           | IntegerOperation                       | A mathematical sign for performing an operation                                                                                           |   |
+| Int_Range                   | `Pair<Integer, Integer>`               | Two integers representing a minimum and maximum of a range                                                                                |   |
+| Relative_Int_Range          | RelativeIntRange                       | Two integers representing a minimum and maximum of a range                                                                                |   |
+| Vector2I                    | Vector2i                               | Two integers, generally corresponding to x/z axis                                                                                         |   |
+| Vector3I                    | Vector3i                               | Three integers, generally corresponding to x/y/z axis                                                                                     |   |
+| Relative_Vector3I           | RelativeVector3i                       | Three optionally relative integers, generally corresponding to x/y/z axis                                                                 |   |
+| Relative_Block_Position     | RelativeIntPosition                    | A position with three integer coordinates, representing a block's location in world space.                                                |   |
+| Relative_Position           | Relative                               | A position with three decimal coordinates, representing a location in world space.                                                        |   |
+| Relative_Chunk_Position     | RealtiveChunkPosition                  | A position with two integer coordinates (x, z), representing a chunk's location.                                                          |   |
+| Rotation                    | Vector3f                               | A rotation with three coordinates, representing the pitch, yaw, and roll respectively                                                     |   |
+| Block_Type_Key              | String                                 | A block type                                                                                                                              |   |
+| Block_ID                    | Integer                                | A block type, converted to an int id                                                                                                      |   |
+| Color                       | Integer                                | A color value in hex format, hex integer, or decimal integer                                                                              |   |
+| Weighted_Block_Type         | `Pair<Integer, String>`                | A weight corresponding to a blocktype                                                                                                     |   |
+| Weighted_Block_Entry        | String                                 | A block with optional weight prefix                                                                                                       |   |
+| Block_Pattern               | BlockPattern                           | A list of blocks with optional weights                                                                                                    |   |
+| Individual_Block_Mask       | BlockMask                              | Create a block mask using symbols and block names                                                                                         |   |
+| Block_Mask                  | BlockMask                              | A tick rate value (e.g., 30tps, 33ms, or 30)                                                                                              |   |
+| Tick_Rate                   | Integer                                | A list of block masks that combine together                                                                                               |   |
+| Game_Mode                   | GameMode                               | GameMode                                                                                                                                  |   |
diff --git a/content/docs/ar-SA/server/interaction-reference.mdx b/content/docs/ar-SA/server/interaction-reference.mdx
new file mode 100644
index 00000000..6c0d01b3
--- /dev/null
+++ b/content/docs/ar-SA/server/interaction-reference.mdx
@@ -0,0 +1,1586 @@
+---
+title: Interactions
+description: A list of most Interaction types provided by Hypixel, along with the meaning of their fields, and how they fit together.
+icon: List
+authors:
+  - name: Stephen Baynham
+    url: https://github.com/cannibalvox
+---
+
+### The Interaction Base Type
+
+All interactions of every type below are inherited from Interaction and have these fields.
+
+**Interaction Fields**
+
+| Field Name                | Type                                                                 | Required? | Notes                                                                                                                                                                                                                       |
+| ------------------------- | -------------------------------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| ViewDistance              | `Double`<br />(Default: 96.0)                                        | **No**    | Distance in blocks at which other players can see the effects from this interaction.                                                                                                                                        |
+| Effects                   | `InteractionEffects`                                                 | **No**    | Sound, animations, and particle effects that should trigger when this interaction begins executing.                                                                                                                         |
+| HorizontalSpeedMultiplier | `Float`<br />(Default: 1.0)                                          | **No**    | Multiplier applied to the User entity's movement speed while this interaction is executing                                                                                                                                  |
+| RunTime                   | `Float`                                                              | **No**    | If provided, this interaction will continue executing for at least this long before the interaction chain moves onto the next interaction.                                                                                  |
+| CancelOnItemChange        | `Boolean`<br />(Default: true)                                       | **No**    | If true, this interaction will be cancelled if the User entity's held item changes during execution. This can happen either due to the selected hotbar slot changing or the contents of the item's inventory slot changing. |
+| Rules                     | `InteractionRules`                                                   | **Yes**   | If provided, adds additional limitations and cancellation conditions to this interaction.                                                                                                                                   |
+| Settings                  | `Map`<br />(Key Type: `GameMode`, Value Type: `InteractionSettings`) | **No**    | If provided, adds additional per-GameMode settings to the interaction.                                                                                                                                                      |
+| Camera                    | `InteractionCameraSettings`                                          | **No**    | Arrays of camera motion keyframes for cutscenes and reveals.                                                                                                                                                                |
+
+**GameMode Values**
+
+- `Creative`: The game is currently in Creative Mode
+- `Adventure`: The game is currently in Adventure Mode
+
+**InteractionEffects Fields**
+
+| Field Name               | Type                                              | Required? | Notes                                                                                                                                                 |
+| ------------------------ | ------------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Particles                | `Array`<br />(Element Type: `ModelParticle`)      | **No**    | Particle systems to activate when this interaction begins if the player is in third-person mode.                                                      |
+| FirstPersonParticles     | `Array`<br />(Element Type: `ModelParticle`)      | **No**    | Particle systems to activate when this interaction begins if the player is in first-person mode.                                                      |
+| WorldSoundEventId        | `Asset`<br />(Asset Type: `SoundEvent`)           | **No**    | A sound to play in the world at the User entity's location when this interaction begins.<br />**The SoundEvent must be single-channel (mono) sound.** |
+| LocalSoundEventId        | `Asset`<br />(Asset Type: `SoundEvent`)           | **No**    | A 2D sound to play for the User entity when this interaction begins. Ignored if the User entity is not a player.                                      |
+| Trails                   | `Array`<br />(Element Type: `ModelTrail`)         | **No**    | Trail effects to activate on the User entity when this interaction begins.                                                                            |
+| WaitForAnimationToFinish | `Boolean`<br />(Default: false)                   | **No**    | If true, this interaction will continue executing for at least the length of any animations in this InteractionEffects object.                        |
+| ItemPlayerAnimationsId   | `Asset`<br />(Asset Type: `ItemPlayerAnimations`) | **No**    | If provided, the User entity will use this ItemPlayerAnimations set while this interaction is executing.                                              |
+| ItemAnimationId          | `String`                                          | **No**    | Id of an animation to trigger when this interaction begins executing.<br />**This animation id is not validated on server start.**                    |
+| ClearAnimationOnFinish   | `Boolean`<br />(Default: false)                   | **No**    | If true, animations triggered by this interaction will be halted when the interaction completes.                                                      |
+| ClearSoundEventOnFinish  | `Boolean`<br />(Default: false)                   | **No**    | If true, sounds triggered by this interaction will be halted when the interaction completes.                                                          |
+| CameraEffect             | `Asset`<br />(Asset Type: `CameraEffect` )        | **No**    | If provided, the CameraEffect will be applied while this interaction is executing.                                                                    |
+| MovementEffects          | `MovementEffects`                                 | **No**    | If provided, apply the movement effects to the User entity while this interaction is executing.                                                       |
+| StartDelay               | `Float`<br />(Default: 0.0f)                      | **No**    | The interaction will wait this many seconds before triggering the effects in this object.                                                             |
+
+**InteractionRules Fields**
+
+| Field Name          | Type                                                                                                | Required? | Notes                                                                                                                                                                                                                                     |
+| ------------------- | --------------------------------------------------------------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| BlockedBy           | `Array`<br />(Element Type: `InteractionType`)<br />(Default: Based on the chain's InteractionType) | **No**    | If provided, this RootInteraction cannot be executed while interaction chains of the provided types are executing.<br />**This field only functions for rules attached to a RootInteraction. It has no effect on an Interaction.**        |
+| Blocking            | `Array`<br />(Element Type: `InteractionType`)                                                      | **No**    | If provided, interaction chains with the specified InteractionTypes cannot be executed while this interaction is executing.                                                                                                               |
+| InterruptedBy       | `Array`<br />(Element Type: `InteractionType`)                                                      | **No**    | If provided, interaction chains with the specified InteractionTypes will cancel this interaction chain when they execute.<br />**This field only functions for rules attached to a RootInteraction. It has no effect on an Interaction.** |
+| Interrupting        | `Array`<br />(Element Type: `InteractionType`)                                                      | **No**    | If provided, interaction chains with the specified InteractionTypes will be canceled when this interaction begins.                                                                                                                        |
+| BlockedByBypass     | `String`                                                                                            | **No**    | If provided, this RootInteraction cannot be blocked by interaction chains whose RootInteraction has this value as an asset tag.                                                                                                           |
+| BlockingBypass      | `String`                                                                                            | **No**    | If provided, this interaction will not block RootInteractions that have the this value as an asset tag.                                                                                                                                   |
+| InterruptedByBypass | `String`                                                                                            | **No**    | If provided, this RootInteraction cannot be canceled by RootInteractions that have this value as an asset tag.                                                                                                                            |
+| InterruptingBypass  | `String`                                                                                            | **No**    | If provided, this interaction will not cancel interaction chains whose RootInteraction has this value as an asset tag.                                                                                                                    |
+
+**InteractionType Values**
+
+- `Primary`
+- `Secondary`
+- `Ability1`
+- `Ability2`
+- `Ability3`
+- `Use`
+- `Pick`
+- `Pickup`
+- `CollisionEnter`
+- `CollisionLeave`
+- `Collision`
+- `EntityStatEffect`
+- `SwapTo`
+- `SwapFrom`
+- `Death`
+- `Wielding`
+- `ProjectileSpawn`
+- `ProjectileHit`
+- `ProjectileMiss`
+- `ProjectileBounce`
+- `Held`
+- `HeldOffhand`
+- `Equipped`
+- `Dodge`
+- `GameModeSwap`
+
+**InteractionSettings Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                        |
+| ---------------- | ------------------------------- | --------- | -------------------------------------------------------------------------------------------- |
+| AllowSkipOnClick | `Boolean`<br />(Default: false) | **No**    | If true, the user will be able to skip this interaction by clicking shortly after it starts. |
+
+**InteractionCameraSettings Fields**
+
+| Field Name  | Type                                             | Required? | Notes                                                                                                                                                           |
+| ----------- | ------------------------------------------------ | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| FirstPerson | `Array`<br />(Element Type: `InteractionCamera`) | **No**    | A list of camera keyframes to be played if the player is in first-person.<br />**The time of each keyframe must be after the keyframe before it in the array.** |
+| ThirdPerson | `Array`<br />(Element Type: `InteractionCamera`) | **No**    | A list of camera keyframes to be played if the player is in third-person.<br />**The time of each keyframe must be after the keyframe before it in the array.** |
+
+**InteractionCamera Fields**
+
+| Field Name | Type                         | Required? | Notes                                                                                                                                       |
+| ---------- | ---------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------- |
+| Time       | `Float`<br />(Default: 0.1f) | **No**    | How long after the interaction begins executing that the camera should arrive at this keyframe.<br />**Cannot be less than or equal to 0.** |
+| Position   | `Vector3`                    | **Yes**   | Where the camera should be located when it arrives at this keyframe.                                                                        |
+| Rotation   | `Direction`                  | **Yes**   | Where the camera should be pointing when it arrives at this keyframe.                                                                       |
+
+### SimpleInteraction
+
+Most interaction types below are inherited from SimpleInteraction and have these
+fields.  If a type does not have these fields, the documentation will mention it.
+
+The purpose of SimpleInteraction is to facilitate Interaction chaining by taking different paths
+based on whether the Interaction succeeded or failed.  The circumstances under which
+a given Interaction fails are generally type-specific (and described in the documentation
+below), but all interactions will be marked failed if they are cancelled via one of the
+many, many mechanisms for doing so.
+
+It is valid to create an interaction asset of type "Simple", which can be valuable when you want to use the
+interaction fields with no additional functionality.
+
+**SimpleInteraction Fields**
+
+| Field Name | Type                                     | Required? | Notes                                                                                          |
+| ---------- | ---------------------------------------- | --------- | ---------------------------------------------------------------------------------------------- |
+| Next       | `Asset`<br />(Asset Type: `Interaction`) | **No**    | After this Interaction has finished, "Next" will be executed if this Interaction did not fail. |
+| Failed     | `Asset`<br />(Asset Type: `Interaction`) | **No**    | After this Interaction has finished, "Failed" will be executed if this Interaction failed.     |
+
+## Flow Control
+
+These are interaction types used to control the flow of an interaction chain and allow interactions
+to be composed into more complex behaviors.  These interaction types generally do not pertain to
+the game and instead pertain to the interaction system itself.
+
+### Condition
+
+This interaction will fail if one of the fields is provided but does not match the current state.
+
+**Condition Fields**
+
+| Field Name       | Type       | Required? | Notes                                                                                                                                                                                    |
+| ---------------- | ---------- | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| RequiredGameMode | `GameMode` | **No**    | If provided, the interaction will fail if the current GameMode does not match the provided value.                                                                                        |
+| Jumping          | `Boolean`  | **No**    | If provided, the interaction will fail if the player's Jumping state does not match the provided value. (i.e. if True, the player must be jumping, if False, the player must not be)     |
+| Swimming         | `Boolean`  | **No**    | If provided, the interaction will fail if the player's Swimming state does not match the provided value. (i.e. if True, the player must be swimming, if False, the player must not be)   |
+| Crouching        | `Boolean`  | **No**    | If provided, the interaction will fail if the player's Crouching state does not match the provided value. (i.e. if True, the player must be crouching, if False, the player must not be) |
+| Running          | `Boolean`  | **No**    | If provided, the interaction will fail if the player's Running state does not match the provided value. (i.e. if True, the player must be running, if False, the player must not be)     |
+| Flying           | `Boolean`  | **No**    | If provided, the interaction will fail if the player's Flying state does not match the provided value. (i.e. if True, the player must be flying, if False, the player must not be)       |
+
+**GameMode Values**
+
+- `Creative`: The game is currently in Creative Mode
+- `Adventure`: The game is currently in Adventure Mode
+
+### FirstClick
+
+This interaction does not inherit from SimpleInteraction and therefore has no Next or Failed fields.
+
+This interaction has two fields that each contain a reference to an Interaction: Click and Hold.  If the root interaction
+of the chain was initiated by a client button/key press (or simulated NPC input) and the input was a tap, then
+the Click interaction is run. if it was a longer press, then the Hold interaction is run.
+
+As a minor implementation detail, this interaction is internally marked as failed when the Hold path is followed.
+This generally shouldn't matter.  If the interaction was not initiated by a key press at all, the Click path will be followed,
+but it seems risky to rely on that behavior.
+
+**FirstClick Fields**
+
+| Field Name | Type                                     | Required? | Notes                                                                                                                                                    |
+| ---------- | ---------------------------------------- | --------- | -------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Click      | `Asset`<br />(Asset Type: `Interaction`) | **No**    | If provided and the root interaction of the chain was initiated by button/key press, this interaction is executed next if the press was a quick tap.     |
+| Hold       | `Asset`<br />(Asset Type: `Interaction`) | **No**    | If provided and the root interaction of the chain was initiated by a button/key press, this interaction is executed next if the press was a longer hold. |
+
+### Interrupt
+
+This interaction can be used to cancel one or more running interaction chains on an entity and **all forked interaction
+chains those chains have spawned that are still currently running**.  All interaction chains canceled in this manner will be marked as
+Failed, which may have additional implications if the canceled chains are themselves forked from
+other chains that are still running.
+
+**Interrupt Fields**
+
+| Field Name     | Type                                           | Required? | Notes                                                                                                                                                                                               |
+| -------------- | ---------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Entity         | `InteractionTarget`<br />(Default: User)       | **Yes**   | The entity that is the owner of the target interaction chains.  This field can indicate the Owner, User, or Target of this interaction chain.                                                       |
+| InterruptTypes | `Array`<br />(Element Type: `InteractionType`) | **No**    | A set of InteractionTypes that are to be interrupted. Only interactions of these types are affected. If null, all types will be interrupted.<br />**(Note: An empty set will interrupt NO TYPES.)** |
+| RequiredTag    | `String`                                       | **No**    | An asset tag that, if provided, the RootInteraction of the interaction chain must have in order to be canceled.                                                                                     |
+| ExcludedTag    | `String`                                       | **No**    | An asset tag that, if provided, the RootInteraction of the interaction chain must not have in order to be canceled.                                                                                 |
+
+**InteractionTarget Values**
+
+- `User` - The user of this interaction chain. The entity whose actions caused this interaction chain to be executed. This is usually the same as the Owner.
+- `Owner` - The owner of this interaction chain. The entity upon whom this interaction chain is executing.
+- `Target` - The entity target of this interaction chain, if any.  This value is mutable (and can therefore come from many places) but most commonly, it is an entity the User was targeting when this interaction chain began executing.
+
+**InteractionType Values**
+
+- `Primary`
+- `Secondary`
+- `Ability1`
+- `Ability2`
+- `Ability3`
+- `Use`
+- `Pick`
+- `Pickup`
+- `CollisionEnter`
+- `CollisionLeave`
+- `Collision`
+- `EntityStatEffect`
+- `SwapTo`
+- `SwapFrom`
+- `Death`
+- `Wielding`
+- `ProjectileSpawn`
+- `ProjectileHit`
+- `ProjectileMiss`
+- `ProjectileBounce`
+- `Held`
+- `HeldOffhand`
+- `Equipped`
+- `Dodge`
+- `GameModeSwap`
+
+### Parallel
+
+This interaction does not inherit from SimpleInteraction and therefore has no Next or Failed fields.
+
+This interaction has a field `Interactions` that is an array of RootInteraction assets. The list must contain at least
+two RootInteractions.  This interaction will fork all of its children except for the first into their
+own interaction chains and immediately complete. After this interaction completes, this interaction chain will
+execute the first RootInteraction in the `Interactions` list.
+
+This interaction does not have any failure conditions and is indifferent to the fate of the forked interaction chains.
+
+**Parallel Fields**
+
+| Field Name   | Type                                                | Required? | Notes                                                         |
+| ------------ | --------------------------------------------------- | --------- | ------------------------------------------------------------- |
+| Interactions | `AssetArray`<br />(Element Type: `RootInteraction`) | **Yes**   | An array of RootInteractions that will be forked or executed. |
+
+### Repeat
+
+This interaction has a field `ForkInteractions` that is an asset of type RootInteraction. This interaction will fork that
+RootInteraction into its own interaction chain and then wait for it to complete. If the RootInteraction fails, this
+interaction will complete immediately and be marked failed. Otherwise, the RootInteraction will be forked and run again,
+up to a specified total number of times.
+
+**Repeat Fields**
+
+| Field Name       | Type                                                                                   | Required? | Notes                                                                                                                                                                                                              |
+| ---------------- | -------------------------------------------------------------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| ForkInteractions | `Asset`<br />(Asset Type: `RootInteraction`)                                           | **Yes**   | A RootInteraction that will be forked.                                                                                                                                                                             |
+| Repeat           | `Integer`<br />(Default: 1)<br />**Must be -1 or a positive integer. 0 is not valid.** | **No**    | The total number of times to fork ForkInteractions. If -1 is provided, ForkInteractions will continue being forked and executed indefinitely, until this interaction is cancelled or until ForkInteractions fails. |
+
+### Replace
+
+This interaction does not inherit from SimpleInteraction and therefore has no Next or Failed fields.
+
+This interaction uses the InteractionVars system that is avaiable for items. InteractionVars are RootInteractions that
+can be attached to an Item asset with a name.
+
+This interaction specifies a var name, and if this interaction chain was executed through
+an item and that item has an InteractionVar of the same name, then this interaction will immediately execute
+the RootInteraction on the var.  Otherwise, it will execute the default RootInteraction specified in this interaction.
+If no default is specified, then this interaction will be marked as failed.
+
+**Replace Fields**
+
+| Field Name   | Type                                         | Required? | Notes                                                                                                                                                                                                           |
+| ------------ | -------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Var          | `String`                                     | **Yes**   | The name of the InteractionVar to execute.                                                                                                                                                                      |
+| DefaultValue | `Asset`<br />(Asset Type: `RootInteraction`) | **No**    | The RootInteraction to execute if the owning item does not have an InteractionVar by the specified name. If not provided, the interaction will be marked as failed instead.                                     |
+| DefaultOk    | `Boolean`<br />(Default: false)              | **No**    | If false, then an angry message will be printed to the server logs if the owning item does not have an InteractionVar by the specified name.  The functioning of this interaction will be otherwise unaffected. |
+
+### RunRootInteraction
+
+This interaction immediately executes the provided RootInteraction as part of this interaction chain. This interaction
+does not have any failure conditions.
+
+**RunRootInteraction Fields**
+
+| Field Name      | Type                                         | Required? | Notes                           |
+| --------------- | -------------------------------------------- | --------- | ------------------------------- |
+| RootInteraction | `Asset`<br />(Asset Type: `RootInteraction`) | **Yes**   | The RootInteraction to execute. |
+
+### Selector
+
+This interaction will execute a Selector to find entities and/or blocks (depending on the Selector) and fork off an
+interaction chain for each located entity or block. This interaction will not wait for those interaction chains
+to complete and is indifferent to their fate. The forked interaction chains will use the located entity/block as
+their target entity/target block. Each entity or block will only fork one interaction chain over the life of this
+interaction.  The Selector is guaranteed to run once for each execution of this interaction, but some Selectors
+are intended to be run over a period of time and sweep across an area to locate targets. In order to use those Selectors
+properly, you will need to extend the execution time of this interaction using `RunTime` or `WaitForAnimationToFinish`.
+The Selector will be executed repeatedly over the lifetime of the interaction.
+
+If the Selector is configured to locate entities, you can add additional sets of entity matching rules. If a located entity
+matches one of the rules, the matching RootInteraction will be forked instead of the standard `HitEntity` RootInteraction.
+
+Entities located by the Selector will be ignored if they do not have a NetworkId, if they are dead, or if they are invulnerable.
+The only exception to this rule is that players in Creative Mode that are marked to receive hits will not be ignored.
+
+This interaction's failure conditions are configurable via the `FailOn` field. You can configure this interaction to never
+fail, to fail if the Selector does not locate any blocks before this interaction finishes executing, to fail if the
+Selector does not locate any entities before this interaction finishes executing, or to fail in either case.
+
+**Selector Fields**
+
+| Field Name     | Type                                         | Required? | Notes                                                                                                                                                                                                                                     |
+| -------------- | -------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Selector       | `Selector`                                   | **Yes**   | The Selector is executed at least once and may be executed repeatedly to locate blocks and/or entities in an area.                                                                                                                        |
+| HitEntity      | `Asset`<br />(Asset Type: `RootInteraction`) | **No**    | If included and the `Selector` locates an entity that does not match any `HitEntityRules`, this RootInteraction will be forked into a new interaction chain with the located entity as the target entity.                                 |
+| HitEntityRules | `Array`<br />(Element Type: `HitEntity`)     | **No**    | If included, these rules will be matched against any entity located by the `Selector`. If an entity matches a set of rules, the RootInteraction associated with the rules will be forked instead of the standard `HitEntity` interaction. |
+| HitBlock       | `Asset`<br />(Asset Type: `RootInteraction`) | **No**    | If included and the `Selector` locates a block, this RootInteraction will be forked into a new interaction chain with the located block as the block target.                                                                              |
+| FailOn         | `FailOnType`<br />(Default: `Neither`)       | **No**    | Defines under what circumstances this interaction will fail.  It can be marked to fail when it completes without locating any blocks, it can be marked to fail when it completes without locating any entities, both, or neither.         |
+| IgnoreOwner    | `Boolean`<br />(Default: true)               | **No**    | If true, the Selector will not locate the User entity of this interaction.                                                                                                                                                                |
+
+**HitEntity Fields**
+
+| Field Name | Type                                         | Required? | Notes                                                                                                 |
+| ---------- | -------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------- |
+| Matchers   | `Array`<br />(Element Type: `EntityMatcher`) | **Yes**   | A set of rules that an entity must match. An entity must successful match all rules to be considered. |
+| Next       | `Asset`<br />(Asset Type: `RootInteraction`) | **Yes**   | The RootInteraction to fork if an entity matches all rules.                                           |
+
+**EntityMatcher Fields**
+
+| Field Name | Type                            | Required? | Notes                                                                                                     |
+| ---------- | ------------------------------- | --------- | --------------------------------------------------------------------------------------------------------- |
+| Type       | `String`                        | **Yes**   | If provided, specifies a type of EntityMatcher to use. Each matcher type may come with additional fields. |
+| Invert     | `Boolean`<br />(Default: false) | **No**    | If true, an entity must fail this rule for it to be marked as succeeded.                                  |
+
+**EntityMatcher Type: Player**
+
+This EntityMatcher will succesfully match the entity only if they are a player.
+
+**EntityMatcher Type: Vulnerable**
+
+This Entitymatcher will successfully match the entity only if they are not marked as invulnerable.
+
+**FailOnType Values**
+
+- `Neither`
+- `Entity`
+- `Block`
+- `Either`
+
+### Serial
+
+This interaction does not inherit from SimpleInteraction and therefore has no Next or Failed fields.
+
+This interaction has a field `Interactions` which is a list of Interaction assets. This interaction immediately
+completes and the interaction chain continues by executing the interactions in the list one at a time. This
+interaction does not have any failure conditions.
+
+**Serial Fields**
+
+| Field Name   | Type                                            | Required? | Notes                                      |
+| ------------ | ----------------------------------------------- | --------- | ------------------------------------------ |
+| Interactions | `AssetArray`<br />(Element Type: `Interaction`) | **Yes**   | An array of Interaction assets to execute. |
+
+## Cooldowns
+
+RootInteractions interface with a complex cooldown system that can be used for a variety of purposes. Aside from simply
+adding an important aspect of resource management to your game design, cooldowns can be used to ensure that click-activated
+interaction chains don't repeatedly spam if the player holds down the input.
+
+By default, every RootInteraction has a cooldown timer that is keyed to the RootInteraction name, and by default, it
+will launch a cooldown of 0.35 seconds when activated by client input.  Otherwise, no cooldown will be activated.  However,
+by configuring your RootInteraction, you can change the key for the cooldown (so that multiple RootInteractions can share
+a single cooldown), set the cooldown timer to whatever you like, and configure multiple charges that can build up over time
+to allow the entity to activate the RootInteraction multiple times before being forced to pause.
+
+One important concept to keep in mind is the difference between **cooldown** and **charge time**.  The cooldown, if any,
+is activated each time a RootInteraction triggers, even if the player has more available charges. If the RootInteraction
+is configured to use charges, then they will gradually build up over time. In order for a RootInteraction to be activated,
+the cooldown (if any) must be expired, and the RootInteraction must have at least one charge (if it has been
+configured to use charges).
+
+Bear in mind that the entire Cooldown configuration is shared between different RootInteractions with the same cooldown id.
+If you activate an ability with 5 charges and a short cooldown and then another ability with a much longer cooldown and no
+charges, the second ability will use the cooldown properties of the first ability until/unless the first ability finishes
+charging and is cleared from the system.  You should generally only have multiple RootInteractions share a cooldown id
+if they have the same configuration.
+
+The interactions below interact with the cooldown system to allow you to manipulate cooldowns via the interaction system. By
+using these interactions, you can have several interaction chains with different cooldown configurations share cooldowns
+that are checked and activated as part of the interaction chain itself, or have some components of an interaction change
+use a second cooldown separate from the main one.
+
+### CooldownCondition
+
+**CooldownCondition Fields**
+
+This interaction will fail if the specified cooldown id is on cooldown for the User entity.  This interaction will only
+function for players- the interaction will always succeed for NPCs.  In order for this interaction to succeed, the
+cooldown, if any, must have expired and at least one charge, if any, must have filled.
+
+| Field Name | Type     | Required? | Notes                     |
+| ---------- | -------- | --------- | ------------------------- |
+| Id         | `String` | **Yes**   | The cooldown id to check. |
+
+### IncrementCooldown
+
+**IncrementCooldown Fields**
+
+This interaction will modify a cooldown that is currently active on the User entity, allowing charges and remaining
+cooldown to be modified.
+Despite its name, this interaction can be used to reduce a cooldown as well as increase it. If the cooldown is not
+currently active, this interaction will have no effect. The interaction has no special failure conditions.
+
+| Field Name        | Type                        | Required? | Notes                                                                                                                                                                                                                                                                                     |
+| ----------------- | --------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Id                | `String`                    | **No**    | If provided, the cooldown id of the cooldown to be manipulated. If not provided, the cooldown id of the current chain's RootInteraction will be used.                                                                                                                                     |
+| Time              | `Float`<br />(Default: 0.0) | **No**    | The amount to increase the remaining cooldown by. Can be negative. The remaining cooldown time will not be reduced below zero or increased above the maximum cooldown time.                                                                                                               |
+| ChargeTime        | `Float`<br />(Default: 0.0) | **No**    | The amount to increase the remaining time until the next charge is filled by. Can be negative. The remaining charge time cannot be reduced below zero or increased above the maximum cooldown time. **This will not work on abilities that have a maximum of 1 charge, for some reason.** |
+| Charge            | `Integer`<br />(Default: 0) | **No**    | The amount to increase the number of charges by. Can be negative. The number of charges cannot be reduced below 0 or increased above the maximum.                                                                                                                                         |
+| InterruptRecharge | `Boolean`(Default: false)   | **No**    | If true and `Charge` is not 0, will reset the remaining time to the next charge to the maximum value after changing the charge count.                                                                                                                                                     |
+
+### ResetCooldown
+
+This interaction will trigger a cooldown on the User entity with a specified configuration. The charges will be refilled
+but the cooldown will be immediately triggered.  The mechanisms for deciding on the configuration are a little bit complicated.
+You may specify a cooldown configuration via the `Cooldown` field. If you do not include an `Id` field, then the
+interaction chain's RootInteraction will be used for any field not specified in the configuration. If there is an active
+cooldown under the specified `Id` (or under the RootInteraction's cooldown id if none is specified) then the fields
+from that active cooldown will overwrite data in the RootInteraction's cooldown, but not data in your `Cooldown` field.
+
+**ResetCooldown Fields**
+
+| Field Name | Type                  | Required? | Notes                                                        |
+| ---------- | --------------------- | --------- | ------------------------------------------------------------ |
+| Cooldown   | `InteractionCooldown` | **No**    | A cooldown configuration to use for the new, reset cooldown. |
+
+**InteractionCooldown Fields**
+
+| Field Name        | Type                                 | Required? | Notes                                                                                                                                                                                                 |
+| ----------------- | ------------------------------------ | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Id                | `String`                             | **No**    | The cooldown id to use for this cooldown. If not provided, the RootInteraction's cooldown id will be used, if any.                                                                                    |
+| Cooldown          | `Float`<br />(Default: 0.0)          | **No**    | The duration of the cooldown, in seconds.                                                                                                                                                             |
+| Charges           | `Array`<br />(Element Type: `Float`) | **No**    | If provided, a list of how many charges this cooldown can build, and how long each charge takes to build, in seconds.                                                                                 |
+| InterruptRecharge | `Boolean`<br />(Default: false)      | **No**    | If true, the charge time will be reset when the number of charges changes.                                                                                                                            |
+| ClickBypass       | `Boolean`<br />(Default: false)      | **No**    | If true, RootInteractions keyed to this cooldown can still be activated when it is on cooldown provided that the RootInteraction was triggered by a distinct key or mouse button press on the client. |
+
+### TriggerCooldown
+
+This interaction is similar to ResetCooldown, except instead of refilling the cooldown's charges, one charge will be deducted
+as normal.
+
+**TriggerCooldown Fields**
+
+| Field Name | Type                  | Required? | Notes                                                        |
+| ---------- | --------------------- | --------- | ------------------------------------------------------------ |
+| Cooldown   | `InteractionCooldown` | **No**    | A cooldown configuration to use for the new, reset cooldown. |
+
+**InteractionCooldown Fields**
+
+| Field Name        | Type                                 | Required? | Notes                                                                                                                                                                                                 |
+| ----------------- | ------------------------------------ | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Id                | `String`                             | **No**    | The cooldown id to use for this cooldown. If not provided, the RootInteraction's cooldown id will be used, if any.                                                                                    |
+| Cooldown          | `Float`<br />(Default: 0.0)          | **No**    | The duration of the cooldown, in seconds.                                                                                                                                                             |
+| Charges           | `Array`<br />(Element Type: `Float`) | **No**    | If provided, a list of how many charges this cooldown can build, and how long each charge takes to build, in seconds.                                                                                 |
+| InterruptRecharge | `Boolean`<br />(Default: false)      | **No**    | If true, the charge time will be reset when the number of charges changes.                                                                                                                            |
+| ClickBypass       | `Boolean`<br />(Default: false)      | **No**    | If true, RootInteractions keyed to this cooldown can still be activated when it is on cooldown provided that the RootInteraction was triggered by a distinct key or mouse button press on the client. |
+
+## Combo Chains
+
+Hytale additionally comes with a rich "combo chaining" system, which allows several inputs in a row to result in different
+attacks and special moves.  Rather than being attached to the RootInteraction like the cooldown system, these are
+primarily driven by the `Chaining` interaction.
+
+### Chaining
+
+This interaction does not inherit from SimpleInteraction and therefore has no Failed field. Its Next field works differently
+from most interaction types.
+
+Chaining is a type of flow control interaction- each time a Chaining interaction with the same `ChainId` is called, a single
+interaction in the `Next` list is chosen and the others are ignored. The first time the `ChainId` is used, the first
+interaction in the list is chosen, the next time the second, etc. Once the end of the list is reached, the first
+interaction will be chosen again.
+
+Bear in mind: the progress through the Next list is based on the **ChainId**, not the interaction!  That means that two
+different Chaining interactions can share a single combo chain. You could have a pair of daggers that attacks with
+the left when the left mouse button is clicked and with the right when the right mouse button is clicked.  You could give
+both interaction chains a Chaining interaction with the same `ChainId` and three `Next` entries that do a light-light-heavy
+combo.  Each specific hit would occur with either the left or the right knife based on which button you clicked, but
+the combo would be otherwise identical regardless of which you chose.
+
+The Chaining interaction also has a concept called "flags".  It is possible to attach named flags to a `ChainId` by using
+the ChainFlag interaction.  Then, you specify the flag name in Chaining's `Flags` field. If a Flag is active when the
+Chaining interaction is run, the Flag's interaction will be run instead of the appropriate interaction in `Next`.
+Bear in mind: the entity's progress through the `Next` list still advances, the resulting `Next` interaction is just not
+run.  Only one flag can be active at a time.
+
+Lastly, it is possible to cancel the entity's progress through the combo chain and reset them to the first interaction in
+the list. This can be done with the CancelChain interaction, but it will also happen automatically if the player does
+not trigger an interaction with the ChainId for the specified ChainingAllowance.  When either of these happen, all flags will be
+canceled as well.
+
+All of these effects are triggered on the User entity only. Non-players can use the chaining system, but Flags do not currently
+work for non-players.  This interaction has no special failure conditions.
+
+**Chaining Fields**
+
+| Field Name        | Type                                                       | Required? | Notes                                                                                                                                                                                                                       |
+| ----------------- | ---------------------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| ChainId           | `String`                                                   | **No**    | If provided, acts as a key that multiple Chaining interactions can use to share combo chain progress and flags. If not provided, a unique ChainId will be generated for this interaction.                                   |
+| ChainingAllowance | `Double`<br />(Default: 0.0)                               | **No**    | If, at the time this interaction is triggered, it has been this long in seconds since the last time a Chaining interaction with the same ChainId was executed, all state for this ChainId will be cleared before execution. |
+| Next              | `AssetArray`<br />(Element Type: `Interaction`)            | **Yes**   | A list of interactions to cycle between each time this interaction is run.                                                                                                                                                  |
+| Flags             | `Map`<br />(Key Type: `String`, Value Type: `Interaction`) | **No**    | A map of flag names to interactions to run if the flag is active when this interaction executes.                                                                                                                            |
+
+### CancelChain
+
+This interaction resets all progress and flag data on the User entity for the provided `ChainId`.  The next time a Chaining
+interaction is called for the provided `ChainId`, it will begin at the first interaction in the `Next` list. This
+interaction has no special failure conditions.
+
+**CancelChain Fields**
+
+| Field Name | Type     | Required? | Notes                                 |
+| ---------- | -------- | --------- | ------------------------------------- |
+| ChainId    | `String` | **Yes**   | A ChainId whose data should be reset. |
+
+### ChainFlag
+
+This interaction activates a flag on the User entity for the provided `ChainId`, which can be used to change behavior the
+next time a Chaining interaction with this `ChainId` is run. This will overwrite any flag that has
+already been raised. This interaction will have no effect for non-players. This interaction has no special failure
+conditions.
+
+| Field Name | Type     | Required? | Notes                                        |
+| ---------- | -------- | --------- | -------------------------------------------- |
+| ChainId    | `String` | **Yes**   | A ChainId on whom the flag should be raised. |
+| Flag       | `String` | **Yes**   | The name of the flag to raise.               |
+
+## Charging
+
+A unique flow-control interaction that is frequently used is the Charging interaction.  It is a flow-control interaction
+that delays while the input button used to trigger the interaction chain is held.  When it is released (or the interaction
+is forced to end), the interaction chain can continue with a different interaction based on how long the input was held
+for.
+
+These interactions are all related by either being the Charging interaction, or other interaction types that inherit the
+Charging interaction's behavior.
+
+### Charging
+
+This interaction does not inherit from SimpleInteraction and therefore its Next field works different from most interactions.
+This interaction adds its own Failed field which works the same way that SimpleInteraction's does.
+
+This interaction only works properly when its interaction chain was triggered by a client key or button press (or
+NPC-simulated equivalent). This interaction will continue executing for as long as the key or button press is held (with
+some exceptions, covered below) by the User entity.  Like other interactions, it has a `Next` field indicating which interaction to execute
+after this one, but the field is a map from `Float` values to `Interaction` assets. When this interaction ends, either
+due to the input being released or the charge duration completing, this interaction will determine the largest `Float` key that is less
+than the amount of time in seconds that the interaction was executing for.  The Interaction mapped to that key will be
+executed next.
+
+The interaction includes some cancellation conditions that are specific to this interaction. For instance, the interaction
+has a `CancelOnOtherClick` field that matches the field on RootInteraction. If it is active on this interaction but not
+the RootInteraction, then clicking while charging will cancel this interaction (and execute the `Failed` interaction rather
+than any of the `Next` interactions) but otherwise continue the interaction chain.
+
+Another valuable feature Charging has is the `Forks` field.  For input-triggered interactions that are triggered while the
+Charging interaction is executing, you can add an entry for the relevant InteractionType to this field and instead of
+triggering the usual interaction chain based on held item, targeted block, etc. the RootInteraction specified in the
+`Forks` field will be triggered.  This can unlock rich attack modes and behaviors. For instance, having a shield bash attack
+triggered off left click while blocking, or a special attack that triggers when both mouse buttons are pressed at the
+same time.
+
+There are two modes of operation for the Charging interaction. One is to have the ability charge for as long
+as the input is held and only end execution when the entity releases the input.  Bows in the main Hytale game work
+that way.  That is accomplished by setting `AllowIndefiniteHold` to true.  Another mode of operation is to have the
+interaction complete execution when the execution time has surpassed the largest key value in the `Next` field and
+immediately begin executing the Interaction mapped to that key.  Food in the main Hytale game work like this.  It
+is accomplished by setting `AllowIndefiniteHold` to false.
+
+One pitfall to be careful of when setting `AllowIndefiniteHold` to false is the way it interacts with cooldowns.\
+Normally, input-initiated interaction chains start a 0.35s cooldown on the triggered RootInteraction that prevents
+holding the mouse button from immediately spamming a new interaction when the first one completes.  However, if the
+duration of a Charging interaction is longer than 0.35s, then the cooldown will have already completed when the
+interaction chain finishes, which will often result in a new execution beginning immediately before the player can
+stop pressing the mouse button.  One solution for this problem is to add a `Simple` interaction to the end of your
+interaction chain with a `RunTime` of 0.35s to simulate the cooldown.  Alternatively, you can add a longer cooldown
+(the maximum duration of your Charging interaction plus 0.35s) to the RootInteraction. However, the longer cooldown is
+not always desirable, as the interaction may have ended prematurely, resulting in an unusually long lockout between
+executions.
+
+**Charging Fields**
+
+| Field Name                         | Type                                                                    | Required? | Notes                                                                                                                                                                                                                                                                                                                                                                                       |
+| ---------------------------------- | ----------------------------------------------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| FailOnDamage                       | `Boolean`<br />(Default: false)                                         | **No**    | If true, this interaction will fail and end immediately if the User entity takes any damage while it is executing.                                                                                                                                                                                                                                                                          |
+| CancelOnOtherClick                 | `Boolean`<br />(Default: true)                                          | **No**    | If true, this interaction will fail and end immediately if the User entity sends another button or key press while it is executing.                                                                                                                                                                                                                                                         |
+| Forks                              | `Map`<br />(Key Type: `InteractionType`, Value Type: `RootInteraction`) | **No**    | A map of InteractionType to RootInteraction. If entity input triggers the InteractionType while this interaction is executing, the mapped RootInteraction will be forked into its own interaction chain. This will happen instead of the usual handling for that InteractionType.  This fork will occur even if `CancelOnOtherClick` is set to true.                                        |
+| Failed                             | `Asset`<br />(Asset Type: `Interaction`)                                | **No**    | After this Interaction has finished, "Failed" will be executed if this Interaction failed.                                                                                                                                                                                                                                                                                                  |
+| AllowIndefiniteHold                | `Boolean`<br />(Default: false)                                         | **No**    | If true, this interaction will continue executing for as long as the User entity continues to hold the input. If false, execution will end as soon as the execution time in seconds reaches the largest key value in the `Next` map.                                                                                                                                                        |
+| DisplayProgress                    | `Boolean`<br />(Default: true)                                          | **No**    | If true, players executing this interaction will see a progress bar will be displayed below their cursor indicating how close to reaching the highest key value in `Next` they are.                                                                                                                                                                                                         |
+| Next                               | `Map`<br />(Key Type: `Float`, Value Type: `Interaction`)               | **No**    | A map from `Float` to `Interaction`.  When this interaction successfully finishes executing (either because the input was released or because the maximum duration was reached), this interaction will find the `Float` value with the largest duration in seconds that is less than the amount of time this interaction executed for. That key's mapped Interaction will then be executed. |
+| MouseSensitivityAdjustmentTarget   | `Float`<br />(Default: 1.0)                                             | **No**    | While charging, this mouse sensitivity multiplier will gradually be applied.                                                                                                                                                                                                                                                                                                                |
+| MouseSensitivityAdjustmentDuration | `Float`<br />(Default: 1.0)                                             | **No**    | Duration in seconds. After this many seconds, `MouseSensitivityAdjustmentTarget` will be fully applied to the mouse sensitivity.                                                                                                                                                                                                                                                            |
+| Delay                              | `ChargingDelay`                                                         | **No**    | Settings that allow charging progress to be pushed back when the User entity takes damage.                                                                                                                                                                                                                                                                                                  |
+
+**ChargingDelay Fields**
+
+| Field Name    | Type                        | Required? | Notes                                                                                                                                                                                                                                                                     |
+| ------------- | --------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| MinHealth     | `Float`<br />(Default: 0.0) | **No**    | Damage taken as a percentage of entity health (0.0-1.0). If a hit deals less than this much damage, no pushback will be applied.  If a hit deals exactly this much damage, `MinDelay` seconds worth of pushback will be applied.                                          |
+| MaxHealth     | `Float`<br />(Default: 0.0) | **No**    | Damage taken as a percentage of entity health (0.0-1.0). If a hit deals at least this much damage, `MaxDelay` seconds worth of pushback will be applied.                                                                                                                  |
+| MinDelay      | `Float`<br />(Default: 0)   | **No**    | The amount of pushback, in seconds, to apply if the entity takes a hit that deals `MinHealth` damage. The amount of pushback applied by a hit is a gradiant between `MinDelay` and `MaxDelay` based on the amount of damage between `MinHealth` and `MaxHealth`.          |
+| MaxDelay      | `Float`<br />(Default: 0)   | **No**    | The amount of pushback, in seconds, to apply if the entity takes a hit that deals at least `MaxHealth` damage. The amount of pushback applied by a hit is a gradiant between `MinDelay` and `MaxDelay` based on the amount of damage between `MinHealth` and `MaxHealth`. |
+| MaxTotalDelay | `Float`<br />(Deault: 0)    | **No**    | The maximum amount of pushback the entity can receive over the course of a single charge, regardless of how many times they are hit.                                                                                                                                      |
+
+**InteractionType Values**
+
+- `Primary`
+- `Secondary`
+- `Ability1`
+- `Ability2`
+- `Ability3`
+- `Use`
+- `Pick`
+- `Pickup`
+- `CollisionEnter`
+- `CollisionLeave`
+- `Collision`
+- `EntityStatEffect`
+- `SwapTo`
+- `SwapFrom`
+- `Death`
+- `Wielding`
+- `ProjectileSpawn`
+- `ProjectileHit`
+- `ProjectileMiss`
+- `ProjectileBounce`
+- `Held`
+- `HeldOffhand`
+- `Equipped`
+- `Dodge`
+- `GameModeSwap`
+
+### Wielding
+
+This interaction is inherited from Charging rather than SimpleInteraction.  However, its `Failed` and `Next` fields function
+identically to SimpleInteraction.  It does not inherit all fields from Charging, so be sure to pay close attention to
+the field list below.
+
+This interaction drives most blocking behavior in the game. While this interaction is executing, attacks made against
+the Owner entity will (conditionally) trigger effects defined in this interaction.  Unlike the Charging interaction,
+this interaction can always execute indefinitely and will only end when it fails or when the input is released.
+
+One option available in Wielding is `AngledWielding`, which allows damage and knockback modifiers to only be applied
+depending on the direction the attack against the Owner entity is coming from.  The AngledWielding type has a
+field `Angle` which determines which direction the protection points relative to the player (0 is the player's
+front), and `AngleDistance` which determines how wide the cone of protection extends around the player.  Block effects
+from this interaction (such as `BlockedEffects`, `BlockedInteractions`, and `StaminaCost`) will only apply if
+the DamageCause matches `DamageModifiers` OR if the DamageCause matches `AngledWielding.DamageModifiers` and
+the source of the damage matches `Angle` and `AngleDistance`.  It is possible for damage and knockback multipliers
+specified on both this interaction's modifier fields and `AngledWielding`'s modifier fields to stack, if both
+have entries for the same DamageCause.
+
+This interaction will only have an effect on damage taken by one of the DamageCause entries in `DamageModifiers` or
+`AngledWielding.DamageModifiers`.  If a DamageCause is in `DamageModifiers`, then the block effect will be triggered
+and the damage modifier applied regardless of what direction the Owner entity is attacked from.  If a DamageCause is in
+`AngledWielding.DamageModifiers`, then the damage modifier is only applied if the
+
+\*\* Wielding Fields\*\*
+
+| Field Name          | Type                                                                    | Required? | Notes                                                                                                                                                                                                                                                                                                                                                                                                      |
+| ------------------- | ----------------------------------------------------------------------- | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| FailOnDamage        | `Boolean`<br />(Default: false)                                         | **No**    | If true, this interaction will fail and end immediately if the User entity takes any damage while it is executing.                                                                                                                                                                                                                                                                                         |
+| CancelOnOtherClick  | `Boolean`<br />(Default: true)                                          | **No**    | If true, this interaction will fail and end immediately if the User entity sends another button or key press while it is executing.                                                                                                                                                                                                                                                                        |
+| Forks               | `Map`<br />(Key Type: `InteractionType`, Value Type: `RootInteraction`) | **No**    | A map of InteractionType to RootInteraction. If entity input triggers the InteractionType while this interaction is executing, the mapped RootInteraction will be forked into its own interaction chain. This will happen instead of the usual handling for that InteractionType.  This fork will occur even if `CancelOnOtherClick` is set to true (after which this interaction chain will be canceled). |
+| Next                | `Asset`<br />(Asset Type: `Interaction`)                                | **No**    | After this interaction has finished, "Next" will be executed if this interaction did not fail.                                                                                                                                                                                                                                                                                                             |
+| Failed              | `Asset`<br />(Asset Type: `Interaction`)                                | **No**    | After this interaction has finished, "Failed" will be executed if this interaction failed.                                                                                                                                                                                                                                                                                                                 |
+| DamageModifiers     | `Map`<br />(Key Type: `DamageCause`, Value Type: `Float`)               | **No**    | A map from DamageCause to Float, where the Float is multiplied against any damage received from the mapped DamageCause while this interaction is executing.                                                                                                                                                                                                                                                |
+| KnockbackModifiers  | `Map`<br />(Key Type: `DamageCause`, Value Type: `Float`)               | **No**    | A map from DamageCause to Float, where the Float is multiplied against any knockback force received from the mapped DamageCause while this interaction is executing.                                                                                                                                                                                                                                       |
+| AngledWielding      | `AngledWielding`                                                        | **No**    | Configuration to only trigger block effects from certain angles.                                                                                                                                                                                                                                                                                                                                           |
+| StaminaCost         | `StaminaCost`                                                           | **No**    | If the Owner entity receives damage that matches `DamageModifiers` or `AngledWielding` while this interaction is executing, then the entity's stamina will be deducted according to this configuration.                                                                                                                                                                                                    |
+| BlockedEffects      | `DamageEffects`                                                         | **No**    | If the Owner entity receives damage that matches `DamageModifiers` or `AngledWielding` while this interaction is executing, then these effects will be applied to the instance of damage.                                                                                                                                                                                                                  |
+| BlockedInteractions | `Asset`<br />(Asset Type: `RootInteraction`)                            | **No**    | If the Owner entity receives damage that matches `DamageModifiers` or `AngledWielding` while this interaction is executing, then this RootInteraction will be launched as a brand new interaction chain with the Owner entity as both Owner and User, and the attacker as the Target entity.  This new interaction chain is, notably, brand new, **not** forked from the current one.                      |
+
+**AngledWielding Fields**
+
+| Field Name         | Type                                                      | Required? | Notes                                                                                                                                                                                                            |
+| ------------------ | --------------------------------------------------------- | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Angle              | `Float`<br />(Default: 0.0)                               | **No**    | Angle in degrees relative to the Owner entity where the angled protection is centered. 0.0 means pointed towards the front of the Owner entity.                                                                  |
+| AngleDistance      | `Float`<br />(Default: 0.0)                               | **No**    | Angle in degrees indicating how wide the cone of protection is.                                                                                                                                                  |
+| DamageModifiers    | `Map`<br />(Key Type: `DamageCause`, Value Type: `Float`) | **No**    | A map from DamageCause to Float, where the Float is multiplied against any damage received from the mapped DamageCause received from within the cone of protection while this interaction is executing.          |
+| KnockbackModifiers | `Map`<br />(Key Type: `DamageCause`, Value Type: `Float`) | **No**    | A map from DamageCause to Float, where the Float is multiplied against any knockback force received from the mapped DamageCause received from within the cone of protection while this interaction is executing. |
+
+**StaminaCost Fields**
+
+| Field Name | Type                                             | Required? | Notes                                                                                                                                                                                                                                                |
+| ---------- | ------------------------------------------------ | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| CostType   | `CostType`<br />(Default: `MaxHealthPercentage`) | **No**    | How to calculate stamina consumed by blocking from the raw pre-block damage. If `Damage`, then the stamina consumed will be `rawDamage / Value`. If `MaxHealthPercentage`, then the stamina consumed will be `rawDamage / (EntityMaxHealth * Value)` |
+| Value      | `Float`<br />(Default: 0.04)                     | **No**    | The value to use in the `CostType` formula.                                                                                                                                                                                                          |
+
+**DamageEffects Fields**
+
+| Field Name             | Type                                         | Required? | Notes                                                                           |
+| ---------------------- | -------------------------------------------- | --------- | ------------------------------------------------------------------------------- |
+| ModelParticles         | `Array`<br />(Element Type: `ModelParticle`) | **No**    | Particle systems to trigger in the first-person view.                           |
+| WorldParticles         | `Array`<br />(Element Type: `WorldParticle`) | **No**    | Particle systems to trigger in the third-person view.                           |
+| LocalSoundEventId      | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | 2D sound to play locally to the attacking entity if they are a player.          |
+| WorldSoundEventId      | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | Sound to play in the world at the Owner entity's location.                      |
+| PlayerSoundEventId     | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | 2D sound to play locally to the Owner entity if they are a player.              |
+| ViewDistance           | `Double`<br />(Default: 75.0)                | **No**    | Distance at which these effects should play for other players.                  |
+| Knockback              | `Knockback`                                  | **No**    | The properties of the knockback that will be applied.                           |
+| CameraEffect           | `Asset`<br />(Asset Type: `CameraEffect`)    | **No**    | CameraEffect to briefly apply locally to the Owner entity if they are a player. |
+| StaminaDrainMultiplier | `Float`<br />(Default: 1.0)                  | **No**    | This multiplier is applied to the `StaminaCost`, if any.                        |
+
+**Knockback Fields**
+
+| Field Name     | Type                                       | Required? | Notes                                                                                                                      |
+| -------------- | ------------------------------------------ | --------- | -------------------------------------------------------------------------------------------------------------------------- |
+| Type           | `String`                                   | **No**    | If provided, specifies a type of knockback to use. Each knockback type may come with additional fields.                    |
+| Force          | `Double`<br />(Default: 0.0)               | **No**    | The amount of force to apply to the Owner entity.                                                                          |
+| Duration       | `Double`<br />(Default: 0.0)               | **No**    | If 0.0, apply the force as a single impulse.  If more, continuously apply the force over a period of time.                 |
+| VelocityType   | `ChangeVelocityType`<br />(Default: `Add`) | **No**    | How to apply the force, either adding it to the entity's current velocity, or setting the velocity to the knockback force. |
+| VelocityConfig | `VelocityConfig`                           | **No**    | Characteristics of friction as the Owner entity is thrown by this knockback.                                               |
+
+**Knockback Type: Force**
+
+Apply the calculated knockback force along the provided direction.
+
+| Field Name | Type                         | Required? | Notes                                                                                |
+| ---------- | ---------------------------- | --------- | ------------------------------------------------------------------------------------ |
+| Direction  | `Vector3`<br />(Default: Up) | **No**    | Which direction the player should be flung, relative to the direction of the attack. |
+
+**Knockback Type: Point**
+
+Apply the calculated knockback force laterally along the XZ plane, plus provided Y velocity.
+
+| Field Name | Type                        | Required? | Notes                                                                                                   |
+| ---------- | --------------------------- | --------- | ------------------------------------------------------------------------------------------------------- |
+| OffsetX    | `Integer`<br />(Default: 0) | **No**    | Offset the source position of the knockback left or right perpendicular to the direction of the attack. |
+| OffsetZ    | `Integer`<br />(Default: 0) | **No**    | Offset the source position of the knockback, forward or backward along the directon of the attack.      |
+| RotateY    | `Integer`<br />(Default: 0) | **No**    | Rotate the knockback direction around the Y axis, where 0 is the default attack direction.              |
+| VelocityY  | `Float`<br />(Default: 0.0) | **No**    | Add vertical velocity to the knockback force after the direction and force has been calculated.         |
+
+**Knockback Type: Directional**
+
+Apply the calculated knockback force along the attack direction, removing any vertical component and replacing it with a provided Y velocity.
+
+| Field Name | Type                      | Required? | Notes                                                                                                                                            |
+| ---------- | ------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------ |
+| RelativeX  | `Float`<br />(Default: 0) | **No**    | Apply additional force left or right perpendicular to the direction of the attack. The additional force is multiplied by the knockback strength. |
+| RelativeZ  | `Float`<br />(Default: 0) | **No**    | Apply additional force forward or backward along the attack direction. The additional force is multiplied by the knockback strength.             |
+| VelocityY  | `Float`<br />(Default: 0) | **No**    | Replace the vertical velocity of the knockback with this value.  This value is not multiplied by knockback strength.                             |
+
+**VelocityConfig Fields**
+
+| Field Name          | Type                                              | Required? | Notes                                                                                                                                                                                           |
+| ------------------- | ------------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| GroundResistance    | `Float`<br />(Default: 0.82)                      | **No**    | The minimum amount of friction applied when the entity is in contact with the ground.  1.0 = no friction, 0.0 = total friction                                                                  |
+| GroundResistanceMax | `Float`<br />(Default: 0.0)                       | **No**    | The maximum amount of friction applied when the entity is in contact with the ground.  1.0 = no friction, 0.0 = total friction                                                                  |
+| AirResistance       | `Float`<br />(Default: 0.96)                      | **No**    | The minimum amount of friction applied when the entity is in the air. 1.0 = no friction, 0.0 = total friction                                                                                   |
+| AirResistanceMax    | `Float`<br />(Default: 0.0)                       | **No**    | The maximum amount of friction applied when the entity is in the air. 1.0 = no friction, 0.0 = total friction                                                                                   |
+| Threshold           | `Float`<br />(Default: 1.0)                       | **No**    | The speed at which the maximum amount of friction will be applied to the entity. The amount of friction applied will increase from minimum to maximum as the entity moves from 0 to this speed. |
+| Style               | `VelocityThresholdStyle`<br />(Default: `Linear`) | **No**    | The curve that friction follows as the entity's speed increases toward the `Threshold`.                                                                                                         |
+
+**CostType Values**
+
+- `MaxHealthPercentage`
+- `Damage`
+
+**ChangeVelocityType Values**
+
+- `Add`
+- `Set`
+
+**VelocityThresholdStyle Values**
+
+- `Linear`
+- `Exp`
+
+## Blocks
+
+These are interaction types meant to reason about and modify blocks in the world.  The most important concept unique
+to these interactions is the Block Target.  Like the Entity Target, it is mutable and can come from many places.
+However, for interaction chains initiated by the client, the block target will initially be the block that the player's cursor was
+over, if any.
+
+Additionally, for interaction chains initiated by the client, the client will send along which face of the block is targeted,
+which is used by a few block-related interactions.
+It is left up to each interaction type that cares about block faces as to how to handle this behavior for simulated input
+(i.e. NPCs initiating chains that are normally initated by the client).  At the time of this writing, all block-related
+interactions choose the top face where relevant in simulated input.
+
+### BlockCondition
+
+This interaction has a field `Matchers` which specifies certain conditions, such as block type, state, etc.  This
+interaction fails if the current target block does not match all of them.
+
+**BlockCondition Fields**
+
+| Field Name       | Type                                        | Required? | Notes                                                                                                                                                                                                                                                                                                                                   |
+| ---------------- | ------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false)             | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction.                                                                                                                                                                                                       |
+| Matchers         | `Array`<br />(Element Type: `BlockMatcher`) | **Yes**   | A list of conditions that the target block must match or this condition will fail.<br />**Note: This field is technically not required but there is a bug that makes it dangerous to not provide at the time of this writing.**<br />**Note: If no conditions are added to this array, the interaction will fail, counterintuitively.** |
+
+**BlockMatcher Fields**
+
+| Field Name | Type                       | Required? | Notes                                                                          |
+| ---------- | -------------------------- | --------- | ------------------------------------------------------------------------------ |
+| Block      | `BlockIdMatcher`           | **No**    | If provided, requires the block itself match some set of conditions.           |
+| Face       | `BlockFace`                | **No**    | If provided and not 'None', requires a specific block face be targeted.        |
+| StaticFace | `Boolean` (Default: false) | **No**    | If false, the face condition will be adjusted by the block's current rotation. |
+
+**BlockFace Values**
+
+- `Up`
+- `Down`
+- `North`
+- `South`
+- `East`
+- `West`
+- `None`
+
+**BlockIdMatcher Fields**
+
+| Field Name | Type                                   | Required? | Notes                                                                      |
+| ---------- | -------------------------------------- | --------- | -------------------------------------------------------------------------- |
+| Id         | `Asset`<br />(Asset Type: `BlockType`) | **No**    | If provided, the block must match the specified `BlockType`.               |
+| State      | `String`                               | **No**    | If provided, the block's current state must match the provided state name. |
+| Tag        | `String`                               | **No**    | If provided, the block type's asset tags must contain the provided tag.    |
+
+### DestroyCondition
+
+This interaction fails if the current User entity cannot destroy the current target blcok.
+
+**DestroyCondition Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+
+### PlacementCountCondition
+
+This interaction accepts the name of a BlockType that has the TrackedPlacement BlockEntity. The interaction will fail if the number of
+blocks of the provided BlockType in the world do not match the provided condition.
+
+**PlacementCountCondition Fields**
+
+| Field Name | Type                           | Required? | Notes                                                                                                                                                                                                                                                           |
+| ---------- | ------------------------------ | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Block      | `String`                       | **Yes**   | The BlockType to examine. The number of instances of the BlockType in the world will be compared to Value.<br />**Note: The specified BlockType must have the TrackedPlacement BlockEntity. Otherwise, the number of blocks in the world will always be zero.** |
+| Value      | `Integer`<br />(Default: 0)    | **No**    | The value to compare the number of blocks in the world with.                                                                                                                                                                                                    |
+| LessThan   | \`Boolean<br />(Default: true) | **No**    | If true, the interaction will fail if the number of blocks in the world is greater than or equal to Value. If false, the interaction will fail if the number of blocks in the world is less than or equal to Value.                                             |
+
+### BreakBlock
+
+This interaction attempts to break the target block while acting as the User entity. The User entity must be a player. It
+is not guaranteed to work, depending on world settings and the User entity's current state, it may not work.  If it
+fails, it will fail the interaction under some circumstances, but not others.
+
+**Note: In particular, if `Harvest`=false and the player is in Survival mode, the player will simply execute a damage operation
+against the block. Even when the Tool field is specified, the player's currently-held item can impact the results in unintuitive
+ways.**
+
+This interaction will fail if there is no block target, if `Harvest`=true and the
+block is not harvestable, or if the world settings prevent the Harvest/Break operation.
+It will generally not fail otherwise, even if the block was not broken or damaged.
+The block will generally break every time if `Harvest`=true or the player is in
+Creative mode.
+
+**BreakBlock Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                                                                                                                                                                                                  |
+| ---------------- | ------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction.                                                                                                                                                                      |
+| Harvest          | `Boolean` (Default: false)      | **No**    | If true, harvest the block and deposit the drops in the player's inventory. This operation will generally always succeed.  If false, this interaction will effectively perform whatever action would have occurred if the player had left-clicked the block.                                           |
+| Tool             | `String`                        | **No**    | If `Harvest`=true, the player is in Survival mode, and this field is provided, then the break operation will be performed as though with this tool type.<br />**This field mostly doesn't work.  Your held item will be used for most block damage calculations regardless of this field's contents.** |
+| MatchTool        | `Boolean` (Default: false)      | **No**    | If true, `Harvest`=true, the player is in Survival mode, and `Tool` is provided, block breaking will be prevented unless `Tool` is a valid gathering tool for the target block. The interaction will not be failed, even if block breaking is prevented in this manner.                                |
+
+### ChangeBlock
+
+This interaction requires a mapping from one or more current BlockTypes to one or more target BlockTypes.  If the
+target block is one of the key BlockTypes, then it will be changed to the mapped target BlockType.  If the current
+BlockType of the target block does not appear as a key in the Changes field, then this interaction fails.
+
+**ChangeBlock Fields**
+
+| Field Name        | Type                                                        | Required? | Notes                                                                                                                             |
+| ----------------- | ----------------------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget  | `Boolean`<br />(Default: false)                             | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+| Changes           | `Map`<br />(Key Type: `BlockType`, Value Type: `BlockType`) | **No**    | A list of potential block type changes, with each entry having a current and new BlockType id.                                    |
+| WorldSoundEventId | `Asset`<br />(Asset Type: `SoundEvent`)                     | **No**    | If provided, this SoundEvent is played in the world at the position of the block if the block successfully changes.               |
+| RequireNotBroken  | `Boolean`<br />(Default: false)                             | **No**    | If true, this interaction will fail if the player's held item is broken (durability 0), and the block change will not take place. |
+
+### ChangeState
+
+This interaction requires a mapping from one or more current block state names to one or more state names. If the
+target block is in one of the key block states, then it will be changed to the mapped target blocks tate. If the
+current block state of the target block does nto appear as a key in the Changes field, then this interaction fails.
+
+All blocks start out with a null state by default.  This null state can be referenced by the key "default" and the block
+can be returned to that state with the value "default".
+
+**ChangeState Fields**
+
+| Field Name       | Type                                                  | Required? | Notes                                                                                                                                          |
+| ---------------- | ----------------------------------------------------- | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false)                       | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction.              |
+| Changes          | `Map`<br />(Key Type: `String`, Value Type: `String`) | **No**    | A list of potential block state changes, with each entry having a current and new state name.                                                  |
+| UpdateBlockState | `Boolean`<br />(Default: false)                       | **No**    | If true, performs a full refresh of the block's BlockEntity component and notifies nearby players as though a full block type change occurred. |
+
+### CycleBlockGroup
+
+This interaction will attempt to change the target block to the next block type in one of the BlockGroups it belongs to.
+If the block type belongs to multiple BlockGroups, which one is used is effectively arbitrary. The User entity must be
+a player. If the block cannot be changed for any reason (entity not a player, no block target, block does not belong
+to a BlockGroup, etc.). If the block is the only entry in the BlockGroup, this interaction will succeed and the block
+will be considered changed despite nothing happening.  Unlike most other block-changing interactions, this one will
+fail if the world settings prevent players from breaking blocks.
+
+**This interaction always reduces the player's held item's durability by a single 'hit' worth of damage if the block
+changes. There is no way to prevent it. The block type will change and the interaction will succeed even if the player's
+held item is broken, however.**
+
+**CycleBlockGroup Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+
+### DestroyBlock
+
+This interaction destroys the target block without dropping anything.  It will successfully destroy the block if the
+target block exists and this interaction has no failure conditions.
+
+**This interaction has no additional fields.**
+
+### PickBlock
+
+This interaction is effectively equivalent to using the middle mouse button in creative mode. In survival mode, the
+block's item will be moved to the user's current active hotbar slot if it is in the player's inventory.  This
+interaction is performed entirely on the client and cannot be performed by non-players.  It is unclear if this
+interaction has failure conditions.
+
+**PickBlock Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+
+### PlaceBlock
+
+This interaction is effectively identical to a right clicking while holding a block in their hand, with some
+additional options. For one, it can be executed with any LivingEntity as the User entity. For another, it has some
+useful fields.  For the most part, though, it follows the same behaviors and rules as any ordinary block placement
+by a player.
+
+It's not clear under what circumstances this interaction can fail. The server will not fail the interaction under any
+special circumstances (including when there is no target block, or when `BlockTypeToPlace` is not provided and the
+LivingEntity is not holding a block). However, the client is very involved with the function of this interaction and
+its behavior is unknown.
+
+**PlaceBlock Fields**
+
+| Field Name         | Type                                   | Required? | Notes                                                                                                                                                                                                                                                                                                                                                           |
+| ------------------ | -------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| BlockTypeToPlace   | `Asset`<br />(Asset Type: `BlockType`) | **No**    | If provided, the block placed by this interaction will be the specified BlockType. If not provided, the User entity's held item will be used, instead, if it is a block.                                                                                                                                                                                        |
+| RemoveItemInHand   | `Boolean`<br />(Default: True)         | **No**    | If true and the User entity is not a player in Creative mode, the item in the player's hand must match the block being placed and one quantity will be removed for each block placed. If the item does not match, the block cannot be placed.  If false, the player's hand item is ignored entirely.\*\*                                                        |
+| AllowDragPlacement | `Boolean`<br />(Default: True)         | **No**    | If true and the interaction was triggered on the client by a player, then the player can hold the input that was used to activate this interaction chain and move the mouse around in order to execute this interaction repeatedly and place several blocks. The interaction chain will not move onto the next interaction until the player releases the input. |
+
+### RunOnBlockTypes
+
+This interaction retrieves all blocks within a provided radius of the User entity. For each block that matches any of
+the provided BlockSets, a new interaction chain will be forked that uses the matching block as the target block.
+This interaction will continue executing until all forked interaction chains have completed.  The interaction will fail if no
+blocks within the radius match the provided BlockSets or if all of the forked interaction chains fail.
+
+**RunOnBlockTypes Fields**
+
+| Field Name   | Type                                         | Required?        | Notes                                                                                                                                                                                                                                                                                      |
+| ------------ | -------------------------------------------- | ---------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| Range        | `Integer`                                    | **Yes**          | The spherical radius around the User entity to search for blocks. Must be at least 1.                                                                                                                                                                                                      |
+| BlockSets    | `AssetArray`<br />(Element Type: `BlockSet`) | **No**           | A list of BlockSets to match nearby blocks again. Only blocks that match any of the BlockSets will have interaction chains forked for them.                                                                                                                                                |
+| MaxCount     | `Integer`                                    | **Yes**          | The maximum number of blocks that will be located with the search. Further blocks will be ignored. If there are more matching blocks within the radius than this number, the specific set of blocks that will be found is completely arbitrary and may change from execution to execution. |
+| Interactions | `Asset`<br />(Asset Type: `RootInteraction`) | **No, but yes.** | The RootInteraction that will be forked for each matching block.  This interaction will not fail to validate if it is missing, but every execution of this interaction will fail.                                                                                                          |
+
+### UseBlock
+
+If the target block has an interaction for this interaction chain's interaction type, execute it immediately as part of
+this interaction chain. The execution will be wrapped in UseBlockEvent.Pre and UseBlockEvent.Post events, and cancellations
+of the UserBlockEvent.Pre event are respected. The User entity is considered the triggering entity for both events.
+
+If the target block does not have an interaction for this interaction chain's interaction type, this interaction fails.
+
+**This interaction has no additional fields.**
+
+## Items
+
+These are interactions intended to interface with an entity's inventory. There is no concept of an "item target",
+unfortunately, so these generally either interact with the entity's held item or the entity's inventory at a high level.
+
+### AddItem
+
+Adds a specified quantity of a specified item to the User entity's inventory, preferring to add it to the
+entity's hotbar where possible. This interaction will have no effect on User entities that are not LivingEntities.
+This interaction has no failure states.
+
+**Note: This interaction has a bug in its field validators that will cause interactions that reference items declared
+in the same mod to fail validation on startup.  Additionally, this interaction has a bug that will cause it to
+fail and have no effect if the User entity has no block target. Use ModifyInventory instead.**
+
+**AddItem Fields**
+
+| Field Name       | Type                              | Required? | Notes                                                                                                                             |
+| ---------------- | --------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false)   | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+| ItemId           | `Asset`<br />(Asset Type: `Item`) | **Yes**   | The item id of the item to add to the player's inventory.                                                                         |
+| Quantity         | `Integer`<br />(Default: 0)       | **No**    | The quantity of the item to add to the player's inventory.                                                                        |
+
+### CheckUniqueItemUsage
+
+This interaction will check whether it has run once for the User entity with their currently-held item before. If it hasn't,
+it will succeed. If it has, it will fail. It will also fail if the User entity is not a player. The interaction will record
+the item id of the User entity's currently-held item on success, ensuring it cannot be successfully run with that player
+and item id combination again.
+
+**This interaction has no additional fields.**
+
+### ChangeActiveSlot
+
+This interaction does not inherit from SimpleInteraction and therefore has no Next or Failed fields.  The `CancelOnItemChange`
+field is ignored for this interaction and is always treated as false. This interaction will set the User entity's currently-
+active hotbar slot to the specified slot index. If none is specified, the interaction chain's target slot will be used,
+if any. Otherwise, slot 0 will be used.  If a slot is specified and it is already active, then this interaction will
+have no effect, but if no slot is specified and the interaction chain's target slot is already active, the logic in
+the next paragraph will still be executed. This interaction will also have no effect if the User entity is not a
+LivingEntity.
+
+Once the slot has changed, a new SwapTo interaction chain will be forked off for the selected slot.
+If a target slot was specified, then the interaction chain's current target slot will be set to the specified slot, as will
+the forked SwapTo interaction chain. If this interaction chain was initiated by a player swapping an item into or out of
+an occupied active hotbar slot, then the swap will be executed after the slot is changed and before the SwapTo
+interaction is forked. Not running this interaction in the resulting SwapFrom interaction chain is a way for the server
+to cancel players performing these sorts of swap interactions. The default behavior for these swap interactions is that
+the SwapFrom interaction chain will be initiated with the currently-active-slot as the target slot. As a result, the
+target slot will usually not change when this interaction runs, it merely exists as a signal for the server to continue the
+item swap.
+
+**ChangeActiveSlot Fields**
+
+| Field Name | Type      | Required? | Notes                                                                                                                                                                                                     |
+| ---------- | --------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| TargetSlot | `Integer` | **No**    | If not provided, indicates the slot the player's active hotbar slot should be changed to.  Otherwise, the interaction chain's target slot will be used (which is usually the already-active hotbar slot). |
+
+### EquipItem
+
+This interaction will equip the User entity's currently-held item into the appropriate armor slot, if it is armor. The
+interaction will fail if the item is armor but it cannot be equipped for some reason. The interaction will succeed but
+take no action if the User entity cannot equip armor or if the item is not armor.
+
+**This interaction has no additional fields.**
+
+### IncreaseBackpackCapacity
+
+This interaction will increase the User entity's backpack size by the provided amount.  **It will additionally remove one
+quantity from the player's currently-held item. There is no way to prevent this.**  This interaction will have no effect
+if the User entity is not a player.  This interaction has no special failure conditions, even if the User entity
+is not a player, or the player is not currently holding an item.
+
+| Field Name | Type                        | Required? | Notes                                                                                   |
+| ---------- | --------------------------- | --------- | --------------------------------------------------------------------------------------- |
+| Capacity   | `Integer`<br />(Default: 1) | **No**    | The additional backpack capacity to add to the player. **Must be between 1 and 32767.** |
+
+### ModifyInventory
+
+This interaction attempts to perform one or more inventory-modifying actions against the User entity. The User entity must
+be a player. If they are not, no actions will be performed, but the interaction will not fail. Any item removals performed
+by this interaction, either as a result of `ItemToRemove` or `AdjustHeldItemQuantity`, are both atomic (meaning the entire
+quantity must be removed, or none) and required (meaning that the interaction will fail and no further actions taken if
+the removal fails for any reason).  Item additions performed by this interaction, either as a result of `ItemToAdd` or
+`AdjustHeldItemQuantity` will drop excess items on the ground near the player if necesary and continue on.
+
+This interaction first executes the item removal in `ItemToRemove`, if any, then adjusts the held item as specified by
+`AdjustHeldItemQuantity`, if provided, then executes the item addition in `ItemToAdd`, if any, and then finally executes
+the damage/healing of the held item in `AdjustHeldItemDurability`, if provided.
+
+**ModifyDurability Fields**
+
+| Field Name               | Type                            | Required? | Notes                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
+| ------------------------ | ------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| RequiredGameMode         | `GameMode`                      | **No**    | If provided, only execute the inventory-modifying actions if the player is in the provided GameMode. The interaction will not fail if the GameMode doesn't match.                                                                                                                                                                                                                                                                                                                                                                               |
+| ItemToRemove             | `ItemStack`                     | **No**    | If provided, a matching item will be removed in the provided quantity. If there is no matching item in the player inventory in the required quantity, then the interaction will fail and further actions will not be executed.                                                                                                                                                                                                                                                                                                                  |
+| AdjustHeldItemQuantity   | `Integer`<br />(Default: 0)     | **No**    | The player's held item, if any, will have its quantity will be modified by the provided amount- subtracted from if this number is negative or added to if this item is positive.  If the player has no held item, then this field will have no effect regardless of its value and the interaction will NOT fail.  If the player's inventory does not have sufficient quantity of items to support the removal, this interaction will fail and further actions will not be executed. Excess items will be dropped on the ground near the player. |
+| ItemToAdd                | `ItemStack`                     | **No**    | If provided, the ItemStack will be added to the player's inventory. Excess items will be dropped on the ground near the player.                                                                                                                                                                                                                                                                                                                                                                                                                 |
+| AdjustHeldItemDurability | `Double`<br />(Default: 0.0)    | **No**    | The player's held item, if any, will have its durability adjusted by the specified amount.  The durability cannot go below 0 or raise above the item's maximum durability. Invalid durability values in this field will not cause the interaction to fail. Neither will it fail if the player has no held item.                                                                                                                                                                                                                                 |
+| BrokenItem               | `String`                        | **No**    | This field should contain an ItemId, but it is not validated by the server on startup, so be careful.  This field can have the value of "Empty" to specify no item, or an empty hand. If specified and the `AdjustHeldItemDurability` operation reduces the player's held item to 0 durability, the player's held item is changed to this ItemId. If the inventory replacement fails, this interaction will fail.                                                                                                                               |
+| NotifyOnBreak            | `Boolean`<br />(Default: false) | **No**    | If true and the `AdjustHeldItemDurability` operation reduces the player's held item to 0 durability, this interaction will perform the usual audiovisual feedback of a broken tool. It will play the usual tool breaking sound and send the player a text message in chat that their item has broken.                                                                                                                                                                                                                                           |
+| NotifyOnBreakMessage     | `String`                        | **No**    | If provided, and `NotifyOnBreak` is true, when the player is notified of a broken tool by this interaction, the message sent to their chat will instead be the translation key specified by this field. The translation key supports the templating parameter `{itemName}`. See the translation key `server.general.repair.itemBroken_Hoe` for an example.                                                                                                                                                                                      |
+
+**GameMode Values**
+
+- `Creative`: The game is currently in Creative Mode
+- `Adventure`: The game is currently in Adventure Mode
+
+**ItemStack Fields**
+
+| Field Name                   | Type                              | Required? | Notes                                                                                |
+| ---------------------------- | --------------------------------- | --------- | ------------------------------------------------------------------------------------ |
+| Id                           | `Asset`<br />(Asset Type: `Item`) | **Yes**   | The id of the Item asset this stack contains.                                        |
+| Quantity                     | `Integer`<br />(Default: 1)       | **No**    | The number of items in this stack.<br />**Must be greater than 0.**                  |
+| Durability                   | `Double`<br />(Default: 0.0)      | **No**    | The durability of the item stack.<br />**Cannot be negative.**                       |
+| MaxDurability                | `Double`<br />(Default: 0.0)      | **No**    | The maximum durability of the item this stack contains.<br />**Cannot be negative.** |
+| Metadata                     | `Bson Document`                   | **No**    | If provided, applies the bson to the item stack metadata.                            |
+| OverrideDroppedItemAnimation | `Boolean`\*(Default: false)       | **No**    | ???                                                                                  |
+
+### PickupItem
+
+This interaction will attempt to pick up the User entity's current target entity and add it to their inventory. It will
+fail if the User entity is not a player, if they do not have a target entity, or if the target entity is not an item
+located in the world.  It will not fail if the player simply cannot pick up the item.
+
+**This interaction has no additional fields.**
+
+### RefillContainer
+
+This interaction will fail if the User entity is not a player. The interaction will draw a ray from the player's head
+down their look direction until the edge of the player's held item's interaction range or until the first solid block.
+The nearest fluid block of a type listed in this interaction's `States` map will result in the one of the player's
+currently-held items being converted to the fluid's related item state.  If the `States` map indicates a durability
+for the new item state, then the converted item will use that durability. If the item is already in the fluid's related
+item state, then this interaction will fail if the player's held item is already at maximum durability (unless the
+`States` map indicates a durability value greater than the item's maximum, in which case the interaction will succeed
+but the item will not change).  Otherwise, the durability listed for the fluid in the `States` map will be added to the
+item's current durability.
+
+If the interaction has not failed by this point, the fluid block in the world may be transformed to a different type if one is listed
+in the `States` map.
+
+If any part of this process does not proceed for any reason (for instance, if the player is not holding an item),
+then this interaction will fail.
+
+**RefillContainer Fields**
+
+| Field Name | Type                                                       | Required? | Notes                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| ---------- | ---------------------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| States     | `Map`<br />(Key Type: `String`, Value Type: `RefillState`) | **Yes**   | A map from item state names to `RefillState` objects, which contain information such as acceptable fluid block types, durability increases, and what fluid type to convert the targeted fluid block to after refill, if any. If the player targets a fluid block that matches one of the fluid types in the `RefillState`, the item will be converted to the keyed item state and the `RefillState` will be used to decide what happens next. |
+
+**RefillState Fields**
+
+| Field Name     | Type                                  | Required? | Notes                                                                                                                                                                                                                                                                                                                           |
+| -------------- | ------------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| AllowedFluids  | `Array`<br />(Element Type: `String`) | **Yes**   | If any of these fluids are targeted by the player, the player's held item will be converted to the keyed item state and `Durability` and `TransformFluid` will be used.                                                                                                                                                         |
+| Durability     | `Double`<br />(Default: -1.0)         | **No**    | If the player's held item changes item states, this value is the new item's durability, unless it is negative, in which case the item will begin at full durability. If the player's held item is already in the item state, and the item is not already at full durability, this value will be added to the item's durability. |
+| TransformFluid | `String`                              | **No**    | If provided, this field is a fluid id that the targeted fluid block should be transformed to if the player's held item is successfully updated.                                                                                                                                                                                 |
+
+## Entities
+
+### DamageEntity
+
+This interaction does not inherit from SimpleInteraction, but adds its own Next and Failed fields that
+work similarly.
+
+This interaction will cause the User entity to damage the Target entity.  It has the capability to apply different
+damage based on the direction of the attack or what body part was targeted by the User entity, with each possibility
+providing different damage calculations, effects, and Next interaction. If multiple entires match the attack, `TargetedDamage`
+(body part damage) takes highest priority, then the first matching `AngledDamage` in the list, then the default
+damage in the base interaction fields.  It is possible for elements of these different damage priorities to be taken peacemeal if higher-priority
+damage fields do not overwrite lower-priority damage fields. For instance,
+damage calculation could be taken from `TargetedDamage`, the damage effects could be taken from the first matching
+`AngledDamage`, and the Next interaction coming from the default damage field.
+
+If all damage dealt by this interaction is cancelled, then this interaction will fail, and the `Failed` interaction
+will be executed next in the chain. If any damage dealt by this interaction is blocked, then this interaction will
+succeed, but the `Blocked` interaction wil lbe executed next in the chain. Otherwise, the highest-precedent matching
+`Next` interaction that you provide will be executed.  For instance, if you provide `Next` interactions for all
+`TargetedDamage` and `AngledDamage` entries, and one in the interaction's `Next` field, then a headshot could result
+in a unique `Next` interaction being executed, even if there is a matching `AngledDamage` entry. However, if you leave
+the `Next` interaction out of your `TargetedDamage` entries, a special `Next` interaction for backstabs could be
+executed.  Otherwise, the `Next` field in the root of the interaction will be executed instead.
+
+DamageEntity has an unusual relationship with `RunTime`. This interaction always ends immediately after its first tick,
+regardless of the status of `RunTime` or `WaitForAnimationToFinish`.  However, if damage dealt by this interaction is
+calculated as `DamageCalculatorType` `Dps`, then the `RunTime` will be used to determine the precise amount of damage to
+deal. If `RunTime` is 0, then no damage will be dealt.
+
+**DamageEntity Fields**
+
+| Field Name       | Type                                                          | Required?                                                                                                                    | Notes                                                                                                                                                                                                                                                                                                                                                                         |
+| ---------------- | ------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| DamageCalculator | `DamageCalculator`                                            | **No**                                                                                                                       | If provided, describes the damage amounts and types to apply to the Target entity.                                                                                                                                                                                                                                                                                            |
+| DamageEffects    | `DamageEffects`                                               | **No**                                                                                                                       | If provided, describes particles, sounds, knockback, etc. to apply to the target entity on damage.                                                                                                                                                                                                                                                                            |
+| Next             | `Asset`<br />(Asset Type: `Interaction`)                      | **No**  After this interaction has finished, "Next" will be executed if damage was dealt to the target and none was blocked. |                                                                                                                                                                                                                                                                                                                                                                               |
+| AngledDamage     | `Array`<br />(Element Type: `AngledDamage`)                   | **No**                                                                                                                       | If provided, allows alternative `DamageCalculator`, `DamageEffects`, and `Next` entries for attacks that approach the target from certain angles.                                                                                                                                                                                                                             |
+| TargetedDamage   | `Map`<br />(Key Type: `String`, Value Type: `TargetedDamage`) | **Yes**                                                                                                                      | This field must be provided, but is not required to have any entries.  This is a map from body part names to `TargetedDamage` values. Hypixel only uses one body part name: `Head`, and it is not clear whether there are others.  If provided, allows alternative `DamageCalculator`, `DamageEffects`, and `Next` entries for attacks that damage specific enemy body parts. |
+| EntityStatsOnHit | `Array`<br />(Element Type: `EntityStatOnHit`)                | **No**                                                                                                                       | If provided, allows this attack to reduce enemy stats other than health.  Each individual damage application dealt by the same ability will apply stat reductions, at diminishing returns. All damage dealt in interaction chains forked by a Selector interaction will share the number of hits across all targets.                                                          |
+| Failed           | `Asset`<br />(Asset Type: `Interaction`)                      | **No**                                                                                                                       | After this interaction has finished, "Failed" will be executed if no damage hits were applied to the player, or if all damage hits were cancelled.                                                                                                                                                                                                                            |
+| Blocked          | `Asset`<br />(Asset Type: `Interaction`)                      | **No**                                                                                                                       | After this interaction has finished, "Blocked" will be executed if any damage hits were blocked by the target.                                                                                                                                                                                                                                                                |
+
+**DamageCalculator Fields**
+
+| Field Name                | Type                                                      | Required? | Notes                                                                                                                                                                                                                                                 |
+| ------------------------- | --------------------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Type                      | `DamageCalculatorType`<br />(Default: Absolute)           | **No**    | Whether the damage being applied is `Absolute` or \`Dps'.                                                                                                                                                                                             |
+| Class                     | `DamageClass`<br />(Default: Unknown)                     | **No**    | The type of attack producing the damage. Some weapon systems apply equipment modifiers based on this value.                                                                                                                                           |
+| BaseDamage                | `Map`<br />(Key Type: `DamageCause`, Value Type: `Float`) | **No**    | A set of DamageCauses and how much base damage is dealt for each.                                                                                                                                                                                     |
+| SequentialModifierStep    | `Float`<br />(Default: 0.0)                               | **No**    | Value between 0.0-1.0. Each additional hit from a single ability will have its damage reduced by this much as a percentage. All damage dealt in interaction chains forked by a Selector interaction will share the number of hits across all targets. |
+| SequentialModifierMinimum | `Float`<br />(Default: 0.0)                               | **No**    | Value between 0.0-1.0. `SequentialModifierStep` cannot reduce damage below this percentage regardless of the number of hits.                                                                                                                          |
+| RandomPercentageModifier  | `Float`<br />(Default: 0.0)                               | **No**    | A random value between +/- this amount multiplied by the base damage will be added to the base damage.                                                                                                                                                |
+
+**DamageEffects Fields**
+
+| Field Name             | Type                                         | Required? | Notes                                                                                   |
+| ---------------------- | -------------------------------------------- | --------- | --------------------------------------------------------------------------------------- |
+| ModelParticles         | `Array`<br />(Element Type: `ModelParticle`) | **No**    | Particle systems to trigger in the first-person view.                                   |
+| WorldParticles         | `Array`<br />(Element Type: `WorldParticle`) | **No**    | Particle systems to trigger in the third-person view.                                   |
+| LocalSoundEventId      | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | 2D sound to play locally to the attacking entity if they are a player.                  |
+| WorldSoundEventId      | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | Sound to play in the world at the Target entity's location.                             |
+| PlayerSoundEventId     | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | 2D sound to play locally to the Target entity if they are a player.                     |
+| ViewDistance           | `Double`<br />(Default: 75.0)                | **No**    | Distance at which these effects should play for other players.                          |
+| Knockback              | `Knockback`                                  | **No**    | The properties of the knockback that will be applied.                                   |
+| CameraEffect           | `Asset`<br />(Asset Type: `CameraEffect`)    | **No**    | CameraEffect to briefly apply locally to the Target entity if they are a player.        |
+| StaminaDrainMultiplier | `Float`<br />(Default: 1.0)                  | **No**    | This multiplier is applied to the stamina cost incurred by the target blocking, if any. |
+
+**AngledDamage Fields**
+
+| Field Name       | Type                                     | Required? | Notes                                                                                                                                                                                                     |
+| ---------------- | ---------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| AngleDistance    | `Float`<br />(Default: 0)                | **No**    | The width in degrees of the matching arc around the Target entity. If the attack against the Target originates from within the arc, then the properties below will be applied to the attack, if provided. |
+| Angle            | `Float`<br />(Default: 0.0)              | **No**    | The angle in degrees around the Target entity at which the matching arc is centered.                                                                                                                      |
+| DamageCalculator | `DamageCalculator`                       | **No**    | If provided and the attack against the Target entity originates from within the provided arc, this DamageCalculator will override the interaction's `DamageCalculator` field.                             |
+| DamageEffects    | `DamageEffects`                          | **No**    | If provided and the attack against the Target entity originates from within the provided arc, this DamageEffects will override the interaction's `DamageEffects` field.                                   |
+| Next             | `Asset`<br />(Asset Type: `Interaction`) | **No**    | If provided and the attack against the Target entity originates from within the provided arc, this Interaction will override the interaction's `Next` field.                                              |
+
+**TargetedDamage Fields**
+
+| Field Name       | Type                                     | Required? | Notes                                                                                                                                                                                            |
+| ---------------- | ---------------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| DamageCalculator | `DamageCalculator`                       | **No**    | If provided and this TargetedDamage was matched, this DamageCalculator will override the interaction's `DamageCalculator` field and the `DamageCalculator` field of any matching `AngledDamage`. |
+| DamageEffects    | `DamageEffects`                          | **No**    | If provided and this TargetedDamage was matched, this DamageEffects will override the interaction's `DamageEffects` field and the `DamageEffects` field of any matching `AngledDamage`.          |
+| Next             | `Asset`<br />(Asset Type: `Interaction`) | **No**    | If provided and this TargetedDamage was matched, this Interaction will override the interaction's `Next` field and the `Next` field of any matching `AngledDamage`.                              |
+
+**EntityStatOnHit Fields**
+
+| Field Name                  | Type                                                                       | Required? | Notes                                                                                                                                                                                                                                                                                        |
+| --------------------------- | -------------------------------------------------------------------------- | --------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| EntityStatId                | `Asset`<br />(AssetType: `EntityStatType`)                                 | **Yes**   | Which entity stat to affect.                                                                                                                                                                                                                                                                 |
+| Amount                      | `Float`<br />(Default: 0.0)                                                | **No**    | How much of the stat to apply for each damage application. Use negative numbers to reduce stats.                                                                                                                                                                                             |
+| MultipliersPerEntitiesHit   | `Array`<br />(Element Type: `Float`, Default: `[1.0, 0.6, 0.4, 0.2, 0.1]`) | **No**    | The diminishing returns curve to be applied for multiple damage applications by the same ability. Each hit's stat impact will be multiplied by the next value in the list.  If there are more hits than array elements, subsequent hits will be multiplied by `MultiplierPerExtraEntityHit`. |
+| MultiplierPerExtraEntityHit | `Float`<br />(Default: 0.05)                                               | **No**    | If an ability carries out more damage applications than there are elements in the `MultipliersPerEntitiesHit` array, then subsequent stat values will be multiplied by this number.                                                                                                          |
+
+**Knockback Fields**
+
+| Field Name     | Type                                       | Required? | Notes                                                                                                                      |
+| -------------- | ------------------------------------------ | --------- | -------------------------------------------------------------------------------------------------------------------------- |
+| Type           | `String`                                   | **No**    | If provided, specifies a type of knockback to use. Each Target type may come with additional fields.                       |
+| Force          | `Double`<br />(Default: 0.0)               | **No**    | The amount of force to apply to the Owner entity.                                                                          |
+| Duration       | `Double`<br />(Default: 0.0)               | **No**    | If 0.0, apply the force as a single impulse.  If more, continuously apply the force over a period of time.                 |
+| VelocityType   | `ChangeVelocityType`<br />(Default: `Add`) | **No**    | How to apply the force, either adding it to the entity's current velocity, or setting the velocity to the knockback force. |
+| VelocityConfig | `VelocityConfig`                           | **No**    | Characteristics of friction as the Owner entity is thrown by this knockback.                                               |
+
+**Knockback Type: Force**
+
+Apply the calculated knockback force along the provided direction.
+
+| Field Name | Type                         | Required? | Notes                                                                                |
+| ---------- | ---------------------------- | --------- | ------------------------------------------------------------------------------------ |
+| Direction  | `Vector3`<br />(Default: Up) | **No**    | Which direction the entity should be flung, relative to the direction of the attack. |
+
+**Knockback Type: Point**
+
+Apply the calculated knockback force laterally along the XZ plane, plus provided Y velocity.
+
+| Field Name | Type                        | Required? | Notes                                                                                                   |
+| ---------- | --------------------------- | --------- | ------------------------------------------------------------------------------------------------------- |
+| OffsetX    | `Integer`<br />(Default: 0) | **No**    | Offset the source position of the knockback left or right perpendicular to the direction of the attack. |
+| OffsetZ    | `Integer`<br />(Default: 0) | **No**    | Offset the source position of the knockback, forward or backward along the directon of the attack.      |
+| RotateY    | `Integer`<br />(Default: 0) | **No**    | Rotate the knockback direction around the Y axis, where 0 is the default attack direction.              |
+| VelocityY  | `Float`<br />(Default: 0.0) | **No**    | Add vertical velocity to the knockback force after the direction and force has been calculated.         |
+
+**Knockback Type: Directional**
+
+Apply the calculated knockback force along the attack direction, removing any vertical component and replacing it with a provided Y velocity.
+
+| Field Name | Type                      | Required? | Notes                                                                                                                                            |
+| ---------- | ------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------ |
+| RelativeX  | `Float`<br />(Default: 0) | **No**    | Apply additional force left or right perpendicular to the direction of the attack. The additional force is multiplied by the knockback strength. |
+| RelativeZ  | `Float`<br />(Default: 0) | **No**    | Apply additional force forward or backward along the attack direction. The additional force is multiplied by the knockback strength.             |
+| VelocityY  | `Float`<br />(Default: 0) | **No**    | Replace the vertical velocity of the knockback with this value.  This value is not multiplied by knockback strength.                             |
+
+**VelocityConfig Fields**
+
+| Field Name          | Type                                              | Required? | Notes                                                                                                                                                                                           |
+| ------------------- | ------------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| GroundResistance    | `Float`<br />(Default: 0.82)                      | **No**    | The minimum amount of friction applied when the entity is in contact with the ground.  1.0 = no friction, 0.0 = total friction                                                                  |
+| GroundResistanceMax | `Float`<br />(Default: 0.0)                       | **No**    | The maximum amount of friction applied when the entity is in contact with the ground.  1.0 = no friction, 0.0 = total friction                                                                  |
+| AirResistance       | `Float`<br />(Default: 0.96)                      | **No**    | The minimum amount of friction applied when the entity is in the air. 1.0 = no friction, 0.0 = total friction                                                                                   |
+| AirResistanceMax    | `Float`<br />(Default: 0.0)                       | **No**    | The maximum amount of friction applied when the entity is in the air. 1.0 = no friction, 0.0 = total friction                                                                                   |
+| Threshold           | `Float`<br />(Default: 1.0)                       | **No**    | The speed at which the maximum amount of friction will be applied to the entity. The amount of friction applied will increase from minimum to maximum as the entity moves from 0 to this speed. |
+| Style               | `VelocityThresholdStyle`<br />(Default: `Linear`) | **No**    | The curve that friction follows as the entity's speed increases toward the `Threshold`.                                                                                                         |
+
+**DamageCalculatorType Values**
+
+- `Absolute`
+- `Dps`
+
+**DamageClass Values**
+
+- `Unknown`
+- `Light`
+- `Charged`
+- `Signature`
+
+**ChangeVelocityType Values**
+
+- `Add`
+- `Set`
+
+**VelocityThresholdStyle Values**
+
+- `Linear`
+- `Exp`
+
+### LaunchProjectile
+
+This is just a worse version of Projectile and is slated to be removed.  Use Projectile.
+
+### Projectile
+
+This interaction will spawn a new projectile at the User entity's eye position that will travel in its look direction.
+
+| Field Name | Type                                          | Required? | Notes                                                  |
+| ---------- | --------------------------------------------- | --------- | ------------------------------------------------------ |
+| Config     | `Asset`<br />(Asset Type: `ProjectileConfig`) | **No**    | Configuration describing the projectile to be spawned. |
+
+### RemoveEntity
+
+Despawns the specified entity from the world. This interaction will have no effect if the specified entity is a player. This
+interaction has no special failure conditions.
+
+| Field Name | Type                                     | Required? | Notes                  |
+| ---------- | ---------------------------------------- | --------- | ---------------------- |
+| Entity     | `InteractionTarget`<br />(Default: User) | **No**    | The entity to despawn. |
+
+**InteractionTarget Values**
+
+- `User` - The user of this interaction chain. The entity whose actions caused this interaction chain to be executed. This is usually the same as the Owner.
+- `Owner` - The owner of this interaction chain. The entity upon whom this interaction chain is executing.
+- `Target` - The entity target of this interaction chain, if any.  This value is mutable (and can therefore come from many places) but most commonly, it is an entity the User was targeting when this interaction chain began executing.
+
+### SendMessage
+
+This interaction sends a message to the Owner entity if that entity can receive messages.  Otherwise, the message
+is written to the server logs.  If the entity is a player, the message will appear in the player's chat window.
+
+\*\*SendMessage
+
+| Field Name | Type     | Required? | Notes                                                                                                                 |
+| ---------- | -------- | --------- | --------------------------------------------------------------------------------------------------------------------- |
+| Message    | `String` | **No**    | A text message to be sent to the Owner entity.  If this field is not provided, `Key` is used instead.                 |
+| Key        | `String` | **No**    | A translation key for a message to be sent to the Owner entity. If `Message` is provided, then this field is ignored. |
+
+### UseEntity
+
+This interaction is not in use by Hypixel and has some unusual qualities that mean it probably won't do what you want it
+to.  Do not use it.
+
+This interaction will retrieve the entity currently targeted by the client (NOT the interaction chain's current Target
+entity) and execute that entity's RootInteraction for this interaction chain's current interaction type. The
+RootInteraction will be executed as part of this current interaction chain. None of the properties of this interaction
+chain will be modified.
+
+This interaction will fail if the client is not currently targeting an entity, or if no interaction for the current
+interaction type exists on the entity.
+
+## Stats
+
+Hytale's resource system has been written about fairly extensively.  You can use these interactions to modify stats in
+response to actions or use stats as a cost for abilities.
+
+### ChangeStat
+
+This interaction applies a set of raw stat changes to the User entity. It has no special failure conditions.
+
+| Field Name    | Type                                                         | Required? | Notes                                                                                                                                                                                                                      |
+| ------------- | ------------------------------------------------------------ | --------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| StatModifiers | `Map`<br />(Key Type: `EntityStatType`, Value Type: `Float`) | **Yes**   | A set of stats to modify and what value to apply to them.                                                                                                                                                                  |
+| ValueType     | `ValueType`<br />(Default: Absolute)                         | **No**    | Whether the values in the `StatModifiers` map represent flat values to apply to the stat total, or percentages (0.0-100.0). Percentage values are percentage of the difference between the maximum and minimum stat value. |
+| Behaviour     | `ChangeStatBehavior`<br />(Default: Add)                     | **No**    | Whether the values in the `StatModifiers` map represent deltas to add into the User entity's current stat values, or fixed values to set the entity's stats to.                                                            |
+
+**ValueType Values**
+
+- `Absolute`
+- `Percent`
+
+**ChangeStatBehaviour Values**
+
+- `Add`
+- `Set`
+
+### ChangeStatWithModifier
+
+This interaction is like ChangeStat, except an armor stat modifier can be chosen which will apply bonuses and penalties
+to a stat from the User entity's equipped armor before it is applied.
+
+| Field Name            | Type                                                         | Required? | Notes                                                                                                                                                                                                                      |
+| --------------------- | ------------------------------------------------------------ | --------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| StatModifiers         | `Map`<br />(Key Type: `EntityStatType`, Value Type: `Float`) | **Yes**   | A set of stats to modify and what value to apply to them.                                                                                                                                                                  |
+| ValueType             | `ValueType`<br />(Default: Absolute)                         | **No**    | Whether the values in the `StatModifiers` map represent flat values to apply to the stat total, or percentages (0.0-100.0). Percentage values are percentage of the difference between the maximum and minimum stat value. |
+| Behaviour             | `ChangeStatBehavior`<br />(Default: Add)                     | **No**    | Whether the values in the `StatModifiers` map represent deltas to add into the User entity's current stat values, or fixed values to set the entity's stats to.                                                            |
+| InteractionModifierId | `InteractionModifierId`                                      | **Yes**   | The armor interaction modifier to apply bonuses and penalties for.                                                                                                                                                         |
+
+**ValueType Values**
+
+- `Absolute`
+- `Percent`
+
+**ChangeStatBehaviour Values**
+
+- `Add`
+- `Set`
+
+**InteractionModifierId Values**
+
+- `Dodge`
+
+### StatsCondition
+
+This interaction will fail if the User entity cannot afford the specified stats costs, or if it does not have the
+requested stats.
+
+| Field Name | Type                                                         | Required? | Notes                                                                                                                                                                                    |
+| ---------- | ------------------------------------------------------------ | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Costs      | `Map`<br />(Key Type:` EntityStatType`, Value Type: `Float`) | **Yes**   | A set of costs that the User entity needs to be able to afford for this interaction to succeed.                                                                                          |
+| ValueType  | `ValueType`<br />(Default: Absolute)                         | **No**    | Whether the values in the `Costs` map represetn flat values or percentages (0.0-100.0).  Percentage values are percentage of the difference between the maximum and minimum value.       |
+| LessThan   | `Boolean`<br />(Default: false)                              | **No**    | If true, this interaction will fail unless the User entity's current stat values are at or **below** the specified levels.  If false, they must be at or **above** the specified levels. |
+| Lenient    | `Boolean`<br />(Default: false)                              | **No**    | If true and `LessThan` is true, and a player's minimum stat value is below zero, then the player can afford a stat cost if the current value of a stat if above 0.                       |
+
+**ValueType Values**
+
+- `Absolute`
+- `Percent`
+
+### StatsConditionWithModifier
+
+This interaction is like StatsCondition, except an armor stat modifier can be chosen which will apply bonuses and penalties
+to a stat's cost from the User entity's equipped armor before it is compared.
+
+| Field Name            | Type                                                         | Required? | Notes                                                                                                                                                                                    |
+| --------------------- | ------------------------------------------------------------ | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Costs                 | `Map`<br />(Key Type:` EntityStatType`, Value Type: `Float`) | **Yes**   | A set of costs that the User entity needs to be able to afford for this interaction to succeed.                                                                                          |
+| ValueType             | `ValueType`<br />(Default: Absolute)                         | **No**    | Whether the values in the `Costs` map represetn flat values or percentages (0.0-100.0).  Percentage values are percentage of the difference between the maximum and minimum value.       |
+| LessThan              | `Boolean`<br />(Default: false)                              | **No**    | If true, this interaction will fail unless the User entity's current stat values are at or **below** the specified levels.  If false, they must be at or **above** the specified levels. |
+| Lenient               | `Boolean`<br />(Default: false)                              | **No**    | If true and `LessThan` is true, and a player's minimum stat value is below zero, then the player can afford a stat cost if the current value of a stat if above 0.                       |
+| InteractionModifierId | `InteractionModifierId`                                      | **Yes**   | The armor interaction modifier to apply bonuses and penalties for.                                                                                                                       |
+
+**ValueType Values**
+
+- `Absolute`
+- `Percent`
+
+**InteractionModifierId Values**
+
+- `Dodge`
+
+## EntityEffects
+
+EntityEffects are buff or debuff effects that can be applied to a LivingEntity.  These can have a variety of effects from
+movement speed changes to periodic damage.
+
+### EffectCondition
+
+This interaction will fail if the specified entity's EntityEffects do not match the provided conditions.
+
+**EffectCondition Fields**
+
+| Field Name      | Type                                             | Required? | Notes                                                                                                                                                                                                             |
+| --------------- | ------------------------------------------------ | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Entity          | `InteractionTarget`<br />(Default: User)         | **Yes**   | The entity to examine for EntityEffects. This field can indicate the Owner, User, or Target of this interaction chain.                                                                                            |
+| Match           | `Match`<br />(Default: All)                      | **No**    | If `All`, then this interaction will fail if any EntityEffect in the `EntityEffectIds` is not on the specified entity. If `None`, then this interaction will fail if any EntityEffect IS on the specified entity. |
+| EntityEffectIds | `AssetArray`<br />(Element Type: `EntityEffect`) | **Yes**   | The set of EntityEffects to check against the specified entity and `Match`.                                                                                                                                       |
+
+**InteractionTarget Values**
+
+- `User` - The user of this interaction chain. The entity whose actions caused this interaction chain to be executed. This is usually the same as the Owner.
+- `Owner` - The owner of this interaction chain. The entity upon whom this interaction chain is executing.
+- `Target` - The entity target of this interaction chain, if any.  This value is mutable (and can therefore come from many places) but most commonly, it is an entity the User was targeting when this interaction chain began executing.
+
+**Match Values**
+
+- `All` - All EntityEffects must be on the specified entity for this interaction to succeed.
+- `None` - None of the EntityEffects must be on the specified entity for this interaction to succeed.
+
+### ApplyEffect
+
+This interaction will apply the specified EntityEffect to the specified Entity.  It has no special failure conditions.
+
+**ApplyEffect Fields**
+
+| Field Name | Type                                      | Required? | Notes                                                                                                                  |
+| ---------- | ----------------------------------------- | --------- | ---------------------------------------------------------------------------------------------------------------------- |
+| Entity     | `InteractionTarget`<br />(Default: User)  | **Yes**   | The entity to apply the EntityEffect to. This field can indicate the Owner, User, or Target of this interaction chain. |
+| EffectId   | `Asset`<br />(Asset Type: `EntityEffect`) | **Yes**   | The effect to apply.                                                                                                   |
+
+**InteractionTarget Values**
+
+- `User` - The user of this interaction chain. The entity whose actions caused this interaction chain to be executed. This is usually the same as the Owner.
+- `Owner` - The owner of this interaction chain. The entity upon whom this interaction chain is executing.
+- `Target` - The entity target of this interaction chain, if any.  This value is mutable (and can therefore come from many places) but most commonly, it is an entity the User was targeting when this interaction chain began executing.
+
+### ClearEntityEffect
+
+This interaction will remove the specified EntityEffect from the specified Entity. It has no special failure conditions.
+It will not fail if the Entity does not have the EntityEffect.
+
+**ClearEntityEffect Fields**
+
+| Field Name | Type                                      | Required? | Notes                                                                                                                     |
+| ---------- | ----------------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------- |
+| Entity     | `InteractionTarget`<br />(Default: User)  | **Yes**   | The entity to remove the EntityEffect from. This field can indicate the Owner, User, or Target of this interaction chain. |
+| EffectId   | `Asset`<br />(Asset Type: `EntityEffect`) | **Yes**   | The effect to remove.                                                                                                     |
+
+**InteractionTarget Values**
+
+- `User` - The user of this interaction chain. The entity whose actions caused this interaction chain to be executed. This is usually the same as the Owner.
+- `Owner` - The owner of this interaction chain. The entity upon whom this interaction chain is executing.
+- `Target` - The entity target of this interaction chain, if any.  This value is mutable (and can therefore come from many places) but most commonly, it is an entity the User was targeting when this interaction chain began executing.
+
+## Farming
+
+These are interaction types built to support the in-game farming system in Hytale. They are mostly block-related interactions
+with a few exceptions.
+
+### ChangeFarmingStage
+
+If the target block is a farming block, this interaction will attempt to modify the current farming stage in one of
+three ways.  The interaction can optionally specify which StageSet to use for the new stage. If it is not specified,
+the current StageSet will be used. If any part of the the process of changing the growth stage fails, this interaction
+will fail, with the one exception that attempting to set the stage to the crop's existing stage will have no effect but
+still succeed.
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                                                                                                                                                                          |
+| ---------------- | ------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction.                                                                                                                                              |
+| StageSet         | `String`                        | **No**    | If provided, set the block's current stage to one in the provided StageSet. Otherwise, use the crop's current StageSet.                                                                                                                                                        |
+| Increase         | `Integer`                       | **No**    | If provided, increase the current stage by the specified amount. If the specified stage does not exist, the block will be set to the closest extant stage.                                                                                                                     |
+| Decrease         | `Integer`                       | **No**    | If provided and `Increase` is not provided, decrease the current stage by the specified amount. If the specified stage does not exist, the block will be set to the closest extant stage.                                                                                      |
+| Stage            | `Integer`<br />(Default: -1)    | **No**    | If provided and `Increase`/`Decrease` are not provided, set the current stage to the specified stage. If this value is less than 0, set the current stage to the final growth stage. If the specified stage does not exist, the block will be set to the closest extant stage. |
+
+### FertilizeSoil
+
+If the target block is unfertilized tilled soil or a farming block on top of unfertilized tilled soil, fertilizes the soil.
+The interaction will fail otherwise.
+
+**FertilizeSoil Fields**
+
+| Field Name       | Type                                  | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false)       | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+| RefreshModifiers | `Array`<br />(Element Type: `String`) | **No**    | Does nothing.                                                                                                                     |
+
+### HarvestCrop
+
+This interaction will attempt to execute the harvest action on the current block target and add the crop's drops to the User entity's
+inventory.  The block will either be destroyed or set to its post-harvest growth stage, depending on the farming
+configuration of the block.  This will happen (and the player will receive the full harvest drops) regardless of the
+block's current growth stage. This interaction has no special failure conditions, even if the block target isn't a
+farming block or gathering isn't permitted in the current world, but nothing will occur in those cases.
+
+**HarvestCrop Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+
+### UseWateringCan
+
+If the target block is tilled soil or a farming block on top of tilled soil, waters the soil for the specified duration.
+The interaction will fail otherwise.
+
+**UseWateringCan Fields**
+
+| Field Name       | Type                                  | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false)       | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+| Duration         | `Integer`<br />(Default: 0)           | **No**    | The duration in seconds to water the soil for.                                                                                    |
+| RefreshModifiers | `Array`<br />(Element Type: `String`) | **No**    | Does nothing.                                                                                                                     |
diff --git a/content/docs/bg-BG/contributing/index.mdx b/content/docs/bg-BG/contributing/index.mdx
new file mode 100644
index 00000000..58a59fef
--- /dev/null
+++ b/content/docs/bg-BG/contributing/index.mdx
@@ -0,0 +1,39 @@
+---
+title: Contributing
+---
+
+# Contributing to HytaleModding
+
+We welcome contributions from the community to help improve and expand the HytaleModding documentation. Whether you're fixing typos, adding new tutorials, or providing code examples, your contributions are valuable!
+
+## How to Contribute
+
+### Reporting Issues
+
+If you've found a issue with the documentation, please report it by opening a new issue on our [GitHub repository](https://github.com/HytaleModding/site/issues).
+
+If you can work on this issue yourself, you can ask to be assigned to it and submit a PR.
+
+### Submitting Pull Requests
+
+1. Fork the repository on GitHub.
+2. Clone your fork to your local machine.
+3. Create a new branch for your changes.
+
+```bash
+git checkout -b my-feature-branch
+```
+
+4. Make your changes and commit them with clear messages. We follow [conventional commits](https://www.conventionalcommits.org/en/v1.0.0/), your PR will not be accepted if your commit messages do not follow this convention.
+
+```bash
+git commit -m "feat: add feature X to documentation"
+```
+
+5. Push your changes to your fork.
+
+```bash
+git push origin my-feature-branch
+```
+
+6. Open a Pull Request on the original repository, describing your changes and why they should be merged.
diff --git a/content/docs/bg-BG/contributing/pr-guidelines.mdx b/content/docs/bg-BG/contributing/pr-guidelines.mdx
new file mode 100644
index 00000000..c226da04
--- /dev/null
+++ b/content/docs/bg-BG/contributing/pr-guidelines.mdx
@@ -0,0 +1,41 @@
+---
+title: PR Guidelines
+description: Guidelines that reviewers and contributors should follow when submitting and reviewing pull requests.
+---
+
+# Pull Request Guidelines
+
+To ensure a smooth and efficient review process, both contributors and reviewers should adhere to the following guidelines when submitting and reviewing pull requests (PRs).
+
+## For Contributors
+
+1. **Descriptive Titles and Descriptions**
+   - Use clear and concise titles that summarize the changes.
+   - Provide detailed descriptions of what the PR does, why the changes are necessary, and any relevant context.
+2. **Link to Issues**
+   - In your PR title, add `GH-ISSUE-NUMBER` to link the PR to the relevant issue. This is required for all PRs.
+3. **Small, Focused Changes**
+   - Aim to keep PRs small and focused on a single issue or feature. This makes it easier for reviewers to understand and provide feedback.
+4. **Code Quality**
+   - Ensure your code follows the project's coding standards and best practices.
+   - Include comments where necessary to explain complex logic.
+   - Always test your changes locally before submitting the PR to catch any issues early.
+   - Format your code using `bun format` to maintain consistency across the codebase.
+5. **Testing**
+   - Test your changes thoroughly before submitting the PR.
+   - If applicable, include unit tests or integration tests to verify your changes.
+6. **Documentation**
+   - Update or add documentation as needed to reflect your changes.
+7. **Commit Messages**
+   - Use clear and descriptive commit messages that follow the [conventional commits](https://www.conventionalcommits.org/en/v1.0.0/) format.
+8. **Check for Conflicts**
+   - Before submitting your PR, ensure that your branch is up to date with the base branch to minimize merge conflicts.
+
+## For Reviewers
+
+- You are supposed to review PRs thoroughly, and request changes if needed.
+- Provide constructive feedback and suggestions for improvement.
+- Verify that the changes meet the project's coding standards and best practices.
+- Deploy the PR using the dokploy integration to ensure the changes work as expected.
+- Ensure that documentation is updated as necessary.
+- Approve the PR only when you are satisfied with the changes and all checks have passed.
diff --git a/content/docs/bg-BG/contributing/translate.mdx b/content/docs/bg-BG/contributing/translate.mdx
new file mode 100644
index 00000000..c62ffdde
--- /dev/null
+++ b/content/docs/bg-BG/contributing/translate.mdx
@@ -0,0 +1,74 @@
+---
+title: Translate
+description: How to translate HytaleModding to your language
+---
+
+# Translating HytaleModding
+
+HytaleModding is translated with the help of the community using **Crowdin**. If you want to help translate or improve existing translations, this is the right place.
+
+## Steps to Translate
+
+All translations are managed **via Crowdin**.
+
+1. Visit [our Crowdin project](https://crowdin.com/project/hytalemodding) and log in if required.
+2. Click on your language.
+3. Click on the file/article you wish to translate. We recommend starting with Official Documentation, and then Server Plugin Documentation.
+4. Start translating!
+5. Approved translations will appear on the website.
+
+### Video Guide
+
+<iframe src="https://www.youtube.com/embed/NHiG1rDRgks" allowFullScreen />
+
+## How to discuss
+
+You can always report issues or discuss specific topics directly on Crowdin, but we recommend using Discord instead of the Crowdin comment system to keep everything organized in one place.
+
+1. Join [our Discord](https://discord.gg/hytalemodding)
+2. Open `#translations` channel. Here you can discuss or ask questions that are not related to a specific language.
+3. If you want to join a thread, you are required to run `/translator <your-language>` command here. The bot will add you to the thread for your language.
+
+## Translation Guidelines
+
+- You need to be confident in what you are translating. You should be able to read the text you just translated and understand the meaning of it very easily.
+- It should use the simplest form of language possible. Use English words if the translation is unknown to the majority in your country.
+- Use your imagination, trust yourself. Feel free to change any context as you wish as long as it can still get the same point across and is understandable.
+- These guidelines are more important than language-specific guidelines, but less important than Hytale terminology and rules.
+
+## What not to translate
+
+We request you all to not translate these specific sections of the website:
+
+### Callout types
+
+Callouts are the boxes that contain important information. We request you to not translate the types as they only work in English.
+
+**Example:**
+
+```mdx
+<Callout type="warning" title="Translate this title!">
+Translate the text inside the callout!
+</Callout>
+```
+
+In this example, please don't translate the word warning, the rest you can translate.
+
+### Icons
+
+Icon names must not be translated.
+They are technical identifiers mapped directly to existing icons. Translating them will break the icon rendering.
+
+```mdx
+icon: Globe
+```
+
+---
+
+{/* 
+For translators who will edit this page:
+
+- You are required to translate the Guidelines as they change.
+- General guidelines should be translated but not edited.
+- Learn how to use Markdown from writing_guides.mdx
+*/}
diff --git a/content/docs/bg-BG/contributing/writing-guides.mdx b/content/docs/bg-BG/contributing/writing-guides.mdx
new file mode 100644
index 00000000..55c52ade
--- /dev/null
+++ b/content/docs/bg-BG/contributing/writing-guides.mdx
@@ -0,0 +1,86 @@
+---
+title: Writing Guides
+---
+
+## Creating a guide file
+
+To start writing a guide, you need to create a file with extension `.mdx`. You need to create this file inside the `/content/docs/en` directory, now it depends in which section you want to make the guide, so you can decide which folder you should put it in after that.
+
+Suppose I want to make a java basics guide, I'd put it in `/content/docs/en/guides/java-basics`. You'll have to do some digging to find out where you want to place it.
+
+<Callout>
+  If there's already a guide in the section you want to write about, you can just press on the "Edit On GitHub" button on our website and it'll take you to the folder, now you can write in the same folder to have your guide appear in the same section.
+</Callout>
+
+## Frontmatter
+
+Frontmatter is the metadata of your guide, it tells our website how to display your guide. This needs to be at the very top of the file, which starts with `---` and ends with `---`.
+
+Here's an example:
+
+```mdx
+---
+title: "Java Basics"
+description: "Learn the basics of Java programming."
+authors:
+    - name: "Your Name"
+      url: "https://yourwebsite.com"
+---
+```
+
+Now as you can see, it's pretty self explanatory, you just need to fill in the details for your specific guide. If you don't have a URL you want to link yourself to, just don't write that whole line. Additionally, the authors section is optional, so if you don't want to add it, you can just leave it out although we encourage you to do so and credit yourself.
+
+The indentation in the frontmatter is important, so make sure to keep it consistent with the example.
+
+## Content Structure
+
+You should structure the content of your guide in a clear and organized manner. Here are some tips on how to do that:
+
+- **Introduction:** Start with an overview of the topic and what the reader can expect to learn.
+- **Prerequisites:** List any prerequisites or prior knowledge the reader should have before diving into the guide.
+- **Step-by-Step Instructions:** Break down the content into clear, actionable steps. Use headings and subheadings to organize the information.
+- **Code Examples:** Include code snippets to illustrate key points. Make sure to explain each example thoroughly.
+- **Conclusion:** Summarize the main points and encourage the reader to explore further or try out what they've learned.
+
+Now if you're writing a really big section, you should split this into multiple pages so that it's easier for the reader to digest the information. No one wants to read a big wall of text all at once!
+
+When we write guides, we should also think of how people will consume them, and many people prefer to skim content rather than read it in detail. This is why it's better to split information into multiple pages, so it looks like a smaller amount of information to the reader. Also, consider using bullet points, numbered lists, and other formatting techniques to make the content more scannable.
+
+## Formatting
+
+We use [Markdown](https://www.markdownguide.org/) for formatting our guides. Here are some key points to keep in mind:
+
+- Use headings (`#`, `##`, `###`) to organize your content.
+- Use bullet points and numbered lists for clarity.
+- Use code blocks (\`\`\`) for code snippets.
+- Use links to reference other guides or external resources.
+
+This is the same type of formatting you'll see on most documentation websites, and also social media platforms like Discord.
+
+You can also make a Callout to highlight important information or tips. Use the following syntax:
+
+```mdx
+<Callout>
+    This is a callout message.
+</Callout>
+```
+
+<Callout>
+  This is a callout message.
+</Callout>
+
+You can change the color of the callout by adding a `type` attribute. For example:
+
+```mdx
+<Callout type="info">
+    This is an info callout.
+</Callout>
+```
+
+Available types are: `info`, `warning`, `error`, and `success`.
+
+## Conclusion
+
+That's all! You are now a master at writing guides. Just remember, do not think you need to be perfect with your English, write the guide the way you will explain the topic to someone, and don't hesitate to ask for feedback or help if you need it.
+
+Happy writing!
diff --git a/content/docs/bg-BG/established-information/client/index.mdx b/content/docs/bg-BG/established-information/client/index.mdx
new file mode 100644
index 00000000..39e863f6
--- /dev/null
+++ b/content/docs/bg-BG/established-information/client/index.mdx
@@ -0,0 +1,69 @@
+---
+title: The Hytale Client
+description: Information regarding the Hytale client.
+---
+
+<Callout>
+  The client is written in C#, compiled to machine code before distribution, and not moddable. Single-player runs on a local server. All mods must go through the server API.
+</Callout>
+
+# No Client-Side Mods
+
+There is no client-side modding.
+
+> We don't intend to support any client mods - Slikey
+
+## Why?
+
+1. No need to download externally.
+   * Hytale wants to "avoid a fragmented ecosystem where every server requires a different modded client".
+
+2. Client security.
+   * Running `.jar` files from third-party sites on the client can easily introduce malware.
+   > [We don't want to expose players] to the security and safety risks that exist on some other modding platform.
+
+3. Client stability.
+   * Hytale may move to other platforms on which client modding is impossible, so they're locking it down early to set the right direction early.
+   > We believe that the results that people get in other block games using client mods can be easily achieved using our server-sided modding. In other block games you have to install a client mod in order to get new blocks, NPCs, UI, etc.Hytale does all of that just by listening to the server. The server will basically "mod" the client temporarily in a really safe way to add and modify your gameplay experience. You could make your very own version of Orbis, using none of our models, music, world generation, combat or anything. You have control and you can rip it all out without ever touching the client. Think about how Roblox works.. You never change your App. You just click on an experience you want and you get all you need without modding your installation itself. - Slikey
+
+## Client Mods are Not Needed
+
+The typical use cases for client mods are:
+
+* Cosmetic changes (resource packs, shaders, capes, etc.): servers own visuals, not the client.
+* Performance: the base game will offer necessary performance controls.
+* Accessibility: the base game will be accessible on its own.
+* User Interface: servers own UI, not the client.
+
+### Client-Side Prediction
+
+Hytale uses data-driven client-side prediction to mitigate lag, as all interactions take place on the server and are relayed back to the client. This is already present for some systems but currently limited, though further integration is planned for the future. It's also planned to work with the visual scripting system in the future for further optimization.
+
+## Client-Side Execution
+
+The team is exploring allowing execution of code by the client (which is distinct from modding the client; this is code sent from the server), though this is not guaranteed.
+
+# Models
+
+The client and assets pipeline accepts `.blockymodel`, a custom format for Hytale. The official Blockbench plugin will allow you to export to this format.
+
+# Client Technical Details
+
+There will only ever be one current, supported version of the client.
+
+> Java version will be kept updated by us and right now we are on the latest version (Java 25)
+> The game version will not be selectable to avoid the version jungle we experienced on our hypixel server network. We simply want to make sure that multiplayer networks can rely on players having the latest version of the game to not have to support 15+ versions of the client. - Slikey
+
+The client is multithreaded.
+
+## GUI
+
+The GUI is built from C# bindings using Noesis.
+
+## Build System
+
+Hytale uses NativeAOT ("Ahead of Time") to build the client, which compiles C# to machine code for distribution. This means that, without reverse-engineering the machine code, mods will have to go through the server API.
+
+# Other Information
+
+The client has its own versioning and protocol to interact with servers.
diff --git a/content/docs/bg-BG/established-information/developer-qa-insights.mdx b/content/docs/bg-BG/established-information/developer-qa-insights.mdx
new file mode 100644
index 00000000..47915c97
--- /dev/null
+++ b/content/docs/bg-BG/established-information/developer-qa-insights.mdx
@@ -0,0 +1,125 @@
+---
+title: Developer Q&A Technical Insights
+description: Comprehensive summary of technical insights from Hytale developers covering architecture, modding, gameplay systems, and development philosophy.
+---
+
+# Developer Q&A Technical Insights
+
+This extensive Q&A session with Hytale developers reveals critical technical details about the game's architecture, modding philosophy, gameplay systems, and development approach.
+
+## Technical Architecture
+
+### Network & Infrastructure
+
+* **Protocol**: Uses QUIC (reliable UDP with unreliable channels) instead of TCP
+* **Server Compatibility**: Runs on any platform supporting Java 25
+* **Connection Method**: Direct IP initially, server discovery planned post-launch
+* **Data Layer**: Current custom serialization format will be replaced post-launch
+* **Performance**: Multi-core support - each world has main thread + parallel execution
+* **Rendering**: OpenGL 3.3 for Mac compatibility, potential future Vulkan/Metal migration
+* **Tick Model**: Base server tick rate is 30 TPS by default; can be changed using server plugins.
+
+### Security & Distribution
+
+* **No Client-Side Code Execution**: Prevents remote code execution exploits
+* **Downloads Limited To**: Configuration files and assets only
+* **Mod Distribution**: Community platforms (CurseForge, Modrinth), no immediate in-game marketplace
+* **Server Hosting**: Available day 1, no business agreements required (just EULA/TOS)
+
+## Modding Capabilities
+
+### Server-Side Power
+
+* **Full Java Access**: Database connections, web requests, any Java functionality
+* **Custom Libraries**: Can create Lua scripting, ML frameworks, or any Java library
+* **Server Modification**: Shared source code allows heavy server modifications
+* **Hot Reload**: Supported for most asset types
+* **Documentation**: Public GitBook planned, though initially sparse
+
+### Content Creation (No Code Required)
+
+* **World Generation**: Custom biomes and maps without Java
+* **NPCs & Items**: JSON-based configuration
+* **Crafting Recipes**: Data-driven system
+* **Visual Scripting**: Replaces command blocks, fully sandboxed
+* **Prefab System**: Sophisticated building blocks with in-game editor
+
+### Advanced Modding
+
+* **Combat System**: Data-driven interaction system for attack chains and abilities
+* **Sub-Hitboxes**: Support for complex boss mechanics (needs improvement)
+* **Status Effects**: Buff/debuff system with custom effects and stats
+* **Custom UI**: NoesisGUI transition enables powerful interface customization
+* **Block Physics**: Selective system (trees fall, but placed blocks don't)
+
+## Gameplay Systems
+
+### Core Mechanics
+
+* **Stamina System**: No hunger by default (can be modded in)
+* **Gravity**: Selective block physics - trees collapse, buildings can float
+* **Lighting**: Major overhaul to fix model/voxel inconsistencies
+* **World Height**: Currently limited, may change with voxel storage updates
+* **Automation**: No redstone equivalent at launch (moddable)
+
+### Player Systems
+
+* **Character Models**: Humans by default, changeable in creative mode
+* **Multiplayer Avatars**: Server-controlled (no custom models in multiplayer)
+* **Skins**: Full customization possible ("mod yourself into a potato")
+* **Shapeshifting**: Transformation potions exist for fun/modding
+
+### World & NPCs
+
+* **Faction System**: Living world with dynamic NPC interactions
+* **Village Systems**: Planned dynamic villages with relationships and behaviors
+* **Chunk Loading**: Entities unload when out of all players' render distance
+* **Seeds**: Shareable world generation seeds supported
+
+## Development Philosophy
+
+### Release Strategy
+
+* **Base Game Priority**: Adventure mode is primary focus, modding architecture supports it
+* **Tech Debt**: Acknowledged as necessary for release, commitment to improvement
+* **Update Frequency**: Very frequent updates planned, especially post-launch
+* **Version Policy**: Always latest version, but servers can run modified versions
+
+### Community Focus
+
+* **Creator Support**: Development bounties planned for community contributors
+* **Tutorials**: Official modding tutorials planned with partners
+* **Feedback Integration**: Strong commitment to community-driven improvements
+* **Accessibility**: Designed for lower-end hardware, reasonable system requirements
+
+### Tools & Documentation
+
+* **Blockbench Integration**: Replaces custom "Hytale Model Maker"
+* **Machinima Tools**: Full cinematic creation capabilities
+* **Creative Tools**: Major reveal planned for building/creation features
+* **Source Access**: Server code will be unobfuscated with developer comments
+
+## Platform Support
+
+* **Current**: Windows (primary)
+* **Planned**: Mac/Linux support actively in development
+* **VR**: Not feasible in near future
+* **Performance**: Uncapped framerate, designed for accessibility
+* **Offline Play**: Single-player works without internet connection
+
+## Monetization & Legal
+
+* **No Pay-to-Win**: Firm commitment against P2W mechanics
+* **Cosmetics Only**: Low-price cosmetic packs to support infrastructure
+* **Server EULA**: Terms being finalized for server monetization policies
+* **QUIC Blocking**: Acknowledged issue in some regions, no alternative protocol
+
+## Current Limitations
+
+* **Custom Shaders**: Not supported until sandboxing solution found
+* **UI/Input Limitations**: Being expanded but currently restricted
+* **Documentation**: Sparse initially, will improve over time
+* **Client Mods**: No client-side code execution for security
+* **Nameplates**: Currently limited customization
+
+This comprehensive technical foundation positions Hytale as a secure, extensible platform that empowers creators while maintaining performance, accessibility, and a commitment to continuous improvement.
diff --git a/content/docs/bg-BG/established-information/faq.mdx b/content/docs/bg-BG/established-information/faq.mdx
new file mode 100644
index 00000000..f9b651ef
--- /dev/null
+++ b/content/docs/bg-BG/established-information/faq.mdx
@@ -0,0 +1,45 @@
+---
+title: Frequently Asked Questions
+description: Frequently Asked Questions about Hytale modding.
+---
+
+On this page, we'll answer some of your Frequently Asked Questions.
+
+## 1. Can the client be modded?
+
+No, the client is not able to be modded, although the Client will not have control over how the game and the UI looks.
+
+The server decides the visuals, more like the "Resource Packs" available in Minecraft. The server decides what mods are used
+
+## 2. What Network Protocol will be used?
+
+Hytale will use the QUIC transport protocol.
+
+For context, the two main Internet protocols are UDP and TCP.
+
+* UDP is connectionless, fast, fire-and-forget packets but has less reliability as packets can be lost.
+* TCP is connection-based, slower than UDP, can guarantee packet delivery with much more reliability.
+  Both are pretty fast in modern times, games can run fine on both (but generally prefer UDP).
+
+QUIC is a **hybrid protocol** that builds off UDP to get the same speed benefits, but adds some layers of reliability like TCP.
+Essentially, a solid choice for game development that blends speed and reliability.
+
+## 3. What are Transfer Packets?
+
+Transfer packets in Hytale are small data payloads *(4kb)* that allow players to move from one server to another while carrying information.
+They are not equivalent to something like BungeeCord or Velocity and are primarily intended for smaller servers.
+
+Unlike BungeeCord, they do not manage network-wide features such as global plugins.
+Implementing DDOS protection would also be incredibly hard for smaller networks by using transfer packets.
+
+Transfer packets work quite well in scenarios such as small server networks or hubs where players will hop between servers without the loss of progress. For example, a player might finish a dungeon on one server and then move to a lobby or different game mode with their inventory and stats intact. This lessens server costs and enables the developers to put more effort into gameplay improvement rather than complicated network setups.
+
+## 4. Will Hytale support dedicated servers?
+
+Yes, Hytale will support dedicated servers. This allows server owners to host their own Hytale servers on their own hardware or through third-party hosting services.
+
+Dedicated servers provide more control over server settings, mods, and performance compared to using official hosting solutions.
+
+## 5. Will Hytale support modding on consoles?
+
+As of now, Hytale modding is primarily focused on PC platforms.
diff --git a/content/docs/bg-BG/established-information/gameplay/creative.mdx b/content/docs/bg-BG/established-information/gameplay/creative.mdx
new file mode 100644
index 00000000..c2c4e4b4
--- /dev/null
+++ b/content/docs/bg-BG/established-information/gameplay/creative.mdx
@@ -0,0 +1,243 @@
+---
+title: Creative
+description: Information regarding the creative mode in Hytale.
+---
+
+# Creative Mode
+
+Creative mode in Hytale is a sandbox mode that allows players to edit the world freely.
+
+## World Editing Tools
+
+Creative mode includes a variety of tools to help players edit the world. It includes undo functionality for edits.
+
+Note that the below sections were unnamed in the video demo of the tools.
+
+---
+
+### Laser Pointer
+
+Displays a ray from the player's camera in the direction the player is looking.
+
+#### Settings
+
+- Duration (Integer Slider): Description unknown as of December 2025.
+- Laser Color (Hex Color Code): Description unknown as of December 2025.
+
+### Sculpt Brush Tool
+
+Allows the user to raise and lower the terrain to more accurately sculpt and blend shapes. Supports most features of the Paint Brush.
+
+### Line Brush Tool
+
+Unknown as of December 2025.
+
+### Selection Tool
+
+Allows the user to select and edit regions of the world by transforming selections of blocks or a prefab via position, rotation, and extrusion.
+
+#### Settings
+
+- Mode (Combo Box: Set, Wall, Fill, Replace): Description unknown as of December 2025.
+- Material (Integer Slider): Description unknown as of December 2025.
+- Weight (Integer Slider): Description unknown as of December 2025.
+- Pitch (Integer): Description unknown as of December 2025.
+
+### Ruler
+
+Allows the user to measure distances between multiple points in 3D space, with support for multiple measurement lines and editing of measured points.
+
+### Layer Brush Tool
+
+Unknown as of December 2025.
+
+### Paste Tool
+
+Allows the user to paste a copied selection of blocks or a prefab at the point at which the player is looking. The paste is relative to the selection's anchor point. If the selection is a prefab, the anchor point may be set in the Prefab Editor. It is unknown if the selection's anchor may be set otherwise.
+
+### Flood Brush Tool
+
+Unknown as of December 2025.
+
+### Paint Brush Tool
+
+Brushes are used to make large changes to the world from far away.
+
+#### General Abilities
+
+- Place Shapes and Prefabs
+- Replace Blocks
+- Create Axis Locks and Masks
+
+#### Settings
+
+- Material
+- Width (Integer Slider): Description unknown as of December 2025.
+- Height (Integer Slider): Description unknown as of December 2025.
+- Shape (Combo Box: Cube, Sphere, Cylinder, Cone, Inverted Cone, Pyramid, Inverted Pyramid, Cuboid Grid): Description unknown as of December 2025.
+- Origin (Combo Box: Center, Bottom, Top): Description unknown as of December 2025.
+- Mirror Axis (Combo Box: None, Unknown other options): Description unknown as of December 2025.
+- Wall Thickness (Integer Slider): Description unknown as of December 2025.
+- Density (Integer Slider): Description unknown as of December 2025.
+
+#### Presets:
+
+- Boulder: Creates a boulder at the point at which the player is looking.
+- Grassy Path: Transforms the terrain into a grass path at the point at which the player is looking.
+- Rubble: Generate rubble at the point at which the player is looking.
+- Tentacle: TBD
+- Lava Cracks: Transforms the terrain into a lava crack at the point at which the player is looking.
+- Hot Springs: TBD
+- Ruins: Generates a ruin at the point at which the player is looking.
+- Ruin Roofs: Generates a ruin with a roof at the point at which the player is looking.
+- Grass: TBD
+- Mountain: Places consecutive chunks of terrain to form a mountain at the point at which the player is looking.
+- Ruins: TBD
+
+---
+
+### Entity Grabber Tool
+
+Unknown as of December 2025.
+
+### Noise Brush Tool
+
+Unknown as of December 2025.
+
+### Scatter Brush Tool
+
+Unknown as of December 2025.
+
+### Extrude Brush Tool
+
+Unknown as of December 2025.
+
+### Prefab Selector Tool
+
+Allows the user to select a prefab when inside the Prefab Editor. May be used with the copy command.
+
+### Smooth Brush Tool
+
+Unknown as of December 2025.
+
+### Hitbox Tool
+
+Unknown as of December 2025.
+
+### Set Anchor Tool
+
+Allows the user to set an anchor point for a prefab when inside the Prefab Editor.
+
+### Tint Brush Tool
+
+Unknown as of December 2025.
+
+---
+
+## Creative Mode Quick Settings
+
+Note that these are WIP and subject to change. **Not all settings and functionality are currently known**.
+
+- Tool Reach Distance (Integer Slider): Description unknown as of December 2025.
+- Tool Delay Minimum (Integer Slider): Description unknown as of December 2025.
+- Brush Opacity (Integer Slider): Description unknown as of December 2025.
+- Selection Opacity (Integer Slider): Description unknown as of December 2025.
+- Selection Panel Opacity (Integer Slider): Description unknown as of December 2025.
+- Enable Brush Shape Rendering (Toggle): Description unknown as of December 2025.
+- Display Legend (Toggle): Description unknown as of December 2025.
+- Show Tool Notifications (Toggle): Description unknown as of December 2025.
+- Default Laser Pointer (Hex Color Code): Description unknown as of December 2025.
+- Enable Brush Spacing (Toggle): Description unknown as of December 2025.
+- Spacing Between Br? (Integer Slider): Description unknown as of December 2025.
+- Flight Intertia (Integer Slider): Description unknown as of December 2025.
+- Flight Mode (Combo Box: Hover, Directional): Description unknown as of December 2025.
+- No Clip (Toggle): Description unknown as of December 2025.
+- Air Placement (Toggle): Description unknown as of December 2025.
+
+## Content Creation Tools
+
+Hytale includes a variety of built-in content creation tools to help players create and edit content.
+
+### Asset Editor
+
+Unknown as of December 2025.
+
+### Model Editor
+
+Unknown as of December 2025.
+
+### Asset Node Editor
+
+Unknown as of December 2025.
+
+### World Tools
+
+These are tools that allow the user to directly edit the current world.
+
+#### Prefab Editor
+
+Allows the user to create or edit prefabs in a separate space.
+
+##### Settings
+
+- Saved configs (Unknown type; presumably a file)
+- Root Dir (Unknown type; presumably a folder)
+- Prefab Paths or Folders (Unknown type; presumably a list of paths or folders)
+- Recursively Search for Prefabs (Toggle)
+- Spawn Entities and NPCs (Toggle)
+- Desired Y Level to Paste (Integer)
+- Blocks Between Prefabs (Integer)
+- WorldGen Type (Combo Box: Flat, Unknown other options): Description unknown as of December 2025.
+- (Flat WorldGen Only) Num Air Blocks Below Prefabs (Integer): Description unknown as of December 2025.
+- Axis to Paste On (Combo Box: X, Unknown other options): Description unknown as of December 2025.
+- Alignment Method (Combo Box: By Anchor, Unknown other options): Description unknown as of December 2025.
+
+#### Prefab List
+
+- Lists all user created prefabs and allows the user to load a prefab into the Paste tool.
+- User can pick from server, assets, or worldgen prefabs.
+
+#### Spawn NPC
+
+Unknown as of December 2025.
+
+#### Spawn Particle
+
+Unknown as of December 2025.
+
+#### Change Player Model
+
+- Allows the player to change their model with an adjustable scale.
+
+#### Tint Chunk
+
+Unknown as of December 2025.
+
+#### Instances
+
+Unknown as of December 2025.
+
+### Builder Tools
+
+Unknown as of December 2025.
+
+### Machinima
+
+Machinima is a built-in sequence editor, allowing the user to create and edit sequences of actions to be played back in game. It includes a built-in interactive keyframe editor.
+
+The speed of playback can be adjusted via commands.
+
+The user may add actors for the sequence to control.
+
+- Reference
+- Camera
+- Entity
+- Item
+- Player
+
+## Commands
+
+Commands are entered into the world's chat console and begin with a forward slash `/`.
+
+- `set <block>`: allows the user to set the blocks in a selection to the specified block.
+- `inventory clear`: allows the user to clear their inventory.
diff --git a/content/docs/bg-BG/established-information/server-plugin-insights.mdx b/content/docs/bg-BG/established-information/server-plugin-insights.mdx
new file mode 100644
index 00000000..a99f3f12
--- /dev/null
+++ b/content/docs/bg-BG/established-information/server-plugin-insights.mdx
@@ -0,0 +1,93 @@
+---
+title: Server Code Insights
+description: Slikey shared some insights about server code on 12/15/2025. This document covers key points and takeaways from that discussion.
+---
+
+<Callout type="info" title="Note">
+  The following information is based on insights shared by Technical Director Slikey on December 15, 2025 on the Hytale Discord Server. It provides an overview of the server code architecture and plugin capabilities.
+
+  Majority of this document is just straight quotes from Slikey with minimal commentary. It is more over to preserve the information shared rather than reword it.
+</Callout>
+
+# Server Source Code
+
+The server will be released as shared source - we will have the source code with no obfuscation and all their comments.
+
+### License
+
+The license permits usage for any **hytale related** things, so as long as you don't use the server / source to make your own game or sell their algorithms.
+
+# Permission system
+
+After being asked in the Hytale Modding server, Lead Architect Zero has replied:
+
+It's quite basic, so don't expect much but yes we do have a permissions system built in. It also support implementing your own backend. Ex. if you wanted to store it in a database.
+
+![Premission Source Snippet](/assets/premission-system.png)
+
+# World Gen Implementation
+
+The following block of text is directly from Lead Architect Zero:
+
+You can totally implement a custom world gen in a plugin super easy. So if you want a totally different config or logic for generating terrain you can add that into a plugin and then configure a world to use that,
+We have some stuff load prefabs and there is existing code in the current world generators that could possibly be reused but no APIs specifically for the details of the generation itself.
+
+```java
+public interface IWorldGenProvider {
+    BuilderCodecMapCodec<IWorldGenProvider> CODEC = new BuilderCodecMapCodec<>("Type", true);
+
+    IWorldGen getGenerator() throws WorldGenLoadException;
+}
+```
+
+```java
+public interface IWorldGen {
+    @Nullable
+    WorldGenTimingsCollector getTimings();
+
+    CompletableFuture<GeneratedChunk> generate(int seed, long index, int x, int z, LongPredicate stillNeeded);
+
+    @Deprecated
+    Transform[] getSpawnPoints(int seed);
+
+    @Nonnull
+    default ISpawnProvider getDefaultSpawnProvider(int seed) {
+        return new FitToHeightMapSpawnProvider(new IndividualSpawnProvider(getSpawnPoints(seed)));
+    }
+
+    default void shutdown() {}
+}
+```
+
+# Server Code Snippets
+
+Some code snippets from a plugin they made were also shared. The following snippets are directly quoted from Technical Director Slikey:
+
+## BlockSpawner Plugin
+
+Alright, I'll drop some code snippets here for a simple plugin called "BlockSpawner" which will turn into a "random" block when put into the world based on the configured rules
+
+There is more code here in general but it shows the Asset System and the plugin layout. You can see that the asset system defines "Codecs" which are used to serialize and deserialize data. Using these codecs we can generate schemas.
+Let's say you connect to a server and open the asset editor: the server will send those schemas - so every single asset type defined server side, even you own, now become part of the asset editor on the client - no need to do anything, you just get to enjoy the editor UI for making your assets that you defined
+
+![Block Spawner Code 1](/assets/blockspawner-code-1.png)
+![Block Spawner Code 2](/assets/blockspawner-code-2.png)
+![Block Spawner Code 3](/assets/blockspawner-code-3.png)
+![Block Spawner Manifest](/assets/blockspawner-manifest.png)
+
+> i guess this part also shows a bit how we use constants to store some language keys - Slikey
+> (in reference to the image below)
+
+![Constants to store Language Keys](/assets/constants.png)
+
+> you can completely customize the chunk storage provider, we for example made one that is just empty where it doesn't load any chunks from disk
+> you could add an MySQLChunkStorageProvider and it could read the data from a database
+> and the same goes for worldgen, you can simply implement this interface to generate a world generator - slikey
+
+![Chunks 1](/assets/chunks-1.png)
+![Chunks 2](/assets/chunks-2.png)
+![Chunks 3](/assets/chunks-3.png)
+
+> i mean here are all the weapons defined, you tell me, obviously you will discover limitations but i think there is plenty of room to make changes - this stuff is actually hard though, there is a lot of QoL to have happen here
+
+![Weapons 1](/assets/weapons-1.png)
diff --git a/content/docs/bg-BG/established-information/server/content-categories/art-assets.mdx b/content/docs/bg-BG/established-information/server/content-categories/art-assets.mdx
new file mode 100644
index 00000000..1e926874
--- /dev/null
+++ b/content/docs/bg-BG/established-information/server/content-categories/art-assets.mdx
@@ -0,0 +1,123 @@
+---
+title: Modelling & Texturing / Art Assets
+description: Information about 3D Modelling, Texturing and Art Assets in Hytale.
+---
+
+# Modelling / Texture Art
+
+Hytale provides comprehensive support for 3D modeling and texture art creation, with specialized tools and workflows designed to maintain the game's distinctive visual style while empowering creators.
+
+## Current Mod Tooling
+
+### Blockbench
+
+Hytale uses **Blockbench** as the primary tool for 3D modeling and animation:
+
+* **Official support**: Used for "creating Hytale models, textures, and animations"
+* **Special plugin**: Hytale has a dedicated [Blockbench Plugin](https://www.blockbench.net/plugins/hytale_plugin).
+* **Direct compatibility**: The plugin allows creators to "create Hytale-compatible models, textures, and animations directly in Blockbench"
+* **Replaces legacy tools**: Fully replaces the old Hytale Model Maker to better support established creative workflows in the community
+* **Safety features**: Only allows you to add things compatible with the engine, so no need to worry about breaking anything
+
+## Model Constraints
+
+### Geometry Types
+
+The vast majority of models in Hytale are constrained to specific geometric primitives:
+
+**3D Elements**:
+
+* Blocks
+* Cuboids
+* Boxes
+
+**2D Elements**:
+
+* Quads
+* Rectangles
+* Planes (composed of 2 triangles)
+
+### Design Philosophy
+
+These constraints serve multiple purposes:
+
+* **Performance optimization**: Ensures efficient rendering and game performance
+* **Consistent art style**: Maintains Hytale's distinctive visual aesthetic
+* **Seamless integration**: Makes mods feel more cohesive with the base game
+
+## Pixel Density Standards
+
+Hytale uses different pixel densities for different types of content:
+
+### Standard Densities
+
+* **Blocks**: 32px density
+* **Player models**: 64px density
+* **Mobs**: Likely also 64px density
+* **Player equipment**: 64px density (weapons, cosmetics, armor, etc.)
+
+### Flexibility
+
+* **Wrong density handling**: Using incorrect density may cause assets to appear at the wrong size, but will not cause import failures
+* **No strict restrictions**: Pixel ratio, rotation, and scaling are not restricted
+* **Forgiving system**: The tools are designed to be flexible while maintaining compatibility
+
+## Hytale Asset Editor
+
+### In-Game Editor
+
+The Asset Editor is a comprehensive tool that will ship with the game:
+
+* **Ships with game**: Available to all players from launch
+* **External tool requirement**: Does not support image editing, you must use external tools for texture creation
+* **Data asset editing**: Primary editor for working with Data Assets
+* **Expanding capabilities**: Currently supports most features, though has limitations around NPCs, worldgen, and interactions that will expand over time
+
+### Particle Creation
+
+The Asset Editor includes robust particle creation tools:
+
+* **In-game creation**: Particles are created directly in-game using the Asset Editor
+* **Industry standard**: Particle logic is robust and similar to Unity/Unreal particle systems
+* **Event-driven**: Particles can be spawned on events or interactions (like opening doors)
+* **Entity attachment**: Can attach particles to entities with specific attachment points
+* **Dynamic movement**: Supports particles moving with their anchor points
+* **Time delays**: Supports time-based particle effects and delays
+
+## Materials
+
+### Optimization Focus
+
+Hytale takes a different approach to materials compared to other engines:
+
+* **Pre-optimized**: Materials are very optimized and artists cannot create custom materials
+* **Performance priority**: This constraint ensures consistent performance across all content
+* **Curated system**: Maintains visual consistency while maximizing efficiency
+
+## Best Practices
+
+### Asset Optimization
+
+Key considerations from Hytale's development team:
+
+* **Mindful resource usage**: Be conscious of how many blocks/quads you use and texture file sizes
+* **Avoid bloat**: Goal is to prevent unnecessary asset bloat that could impact performance
+* **Efficiency focus**: Balance visual quality with technical constraints
+
+### Future Documentation
+
+* **Best practice guide**: A comprehensive "best practice" guide for art and modeling will be released at some point
+* **Flexible boundaries**: Most creative goals can be achieved without breaking anything in the system
+* **Community-driven workflows**: Tools are designed to support established creative workflows in the modding community
+
+## Integration with Development Pipeline
+
+The modeling and texture art workflow integrates seamlessly with Hytale's broader development ecosystem:
+
+* **Asset Editor compatibility**: Models created in Blockbench work directly with the Hytale Asset Editor
+* **Data Asset integration**: 3D models can be configured and customized through Data Assets
+* **Visual Scripting support**: Models can be controlled and animated through Visual Scripting
+* **Java plugin extensibility**: Advanced model behaviors can be implemented through Java plugins
+* **Particle integration**: Models can have particles attached at specific points for enhanced visual effects
+
+This integrated approach ensures that 3D modeling and texture art aren't isolated creative processes, but core components of Hytale's comprehensive development environment.
diff --git a/content/docs/bg-BG/established-information/server/content-categories/data-assets.mdx b/content/docs/bg-BG/established-information/server/content-categories/data-assets.mdx
new file mode 100644
index 00000000..1c11ef23
--- /dev/null
+++ b/content/docs/bg-BG/established-information/server/content-categories/data-assets.mdx
@@ -0,0 +1,61 @@
+---
+title: Data Assets
+description: Information about data assets in Hytale and how they drive gameplay behavior and content creation.
+---
+
+# Data Assets
+
+Data Assets are JSON files which drive gameplay behavior and core content in Hytale. They provide a powerful, data-driven approach to creating and modifying game elements without needing to write code.
+
+## What Are Data Assets?
+
+Data Assets allow you to create or modify fundamental game elements through JSON configuration files:
+
+* **Blocks**: Define new block types and their properties
+* **Items**: Create custom items with unique behaviors
+* **NPCs**: Configure non-player characters and their AI
+* **World generation**: Control how the world is generated
+* **Loot tables**: Define what items drop from various sources
+
+## Comparison to Minecraft
+
+Data Assets are analogous to Minecraft's data pack JSON files, but with significantly broader scope. While Minecraft's data packs are somewhat limited, Hytale's data-driven architecture means that core game elements like blocks, items, and NPCs can all be modified through JSON files.
+
+This expanded data-driven approach gives modders much more power to customize the game without needing to dive into complex programming.
+
+## Development Tools
+
+Recognizing that JSON editing can be tedious and error-prone when done by hand, Hytale plans to provide multiple tools to make working with Data Assets more accessible:
+
+### Node Editor
+
+Hytale is developing a "Node Editor" to make Data Asset management more user-friendly:
+
+* **Visual interface**: Provides a graphical way to work with data relationships
+* **Customization focus**: Particularly helpful for customizing NPCs, interactions, and world generation
+* **Integrated workflow**: Works directly within the Hytale Asset Editor for a unified creator suite
+* **Accessibility**: Makes complex data relationships easier to understand and modify
+
+### Additional Tools
+
+Beyond the Node Editor, Hytale plans to support:
+
+* **Visual JSON generators**: Graphical interfaces for creating JSON without writing syntax
+* **Form-based editors**: Structured forms that generate the appropriate JSON automatically
+* **Multiple workflow options**: Different tools for different comfort levels and use cases
+
+## Power and Simplicity
+
+The effectiveness of Data Assets is demonstrated by their simplicity. For example, making raptors rideable in Hytale reportedly requires only 4 lines of JSON configuration - showcasing how powerful yet accessible the system is designed to be.
+
+This balance between power and accessibility is central to Hytale's modding philosophy: providing professional-grade tools that don't require programming expertise to use effectively.
+
+## Integration with Other Systems
+
+Data Assets work seamlessly with Hytale's other development approaches:
+
+* **Visual Scripting**: Can reference and manipulate data defined in Data Assets
+* **Java plugins**: Can read from and modify Data Assets for more complex behaviors
+* **Asset Editor**: Provides a unified interface for managing both visual assets and their data configurations
+
+This integration ensures that Data Assets aren't isolated configuration files, but rather a core part of Hytale's comprehensive development environment.
diff --git a/content/docs/bg-BG/established-information/server/content-categories/plugin.mdx b/content/docs/bg-BG/established-information/server/content-categories/plugin.mdx
new file mode 100644
index 00000000..5b585924
--- /dev/null
+++ b/content/docs/bg-BG/established-information/server/content-categories/plugin.mdx
@@ -0,0 +1,48 @@
+---
+title: Java Modding (Server Plugins)
+description: An introduction to what we know of Hytale's Java-based modding system as of writing this article.
+---
+
+Hytale's modding capabilities include a Java-based modding system that allows modders
+to create custom behaviors, interactions, and game mechanics. While the full details of
+this system are not publicly documented as the game is still in development and not
+released, we can summarize what is currently known about it.
+
+### Important Details of Modding in Hytale
+
+Hytale's modding goes on server side and not client side, meaning that mods/plugins are
+hosted on the server and players connect to these modded servers to experience the custom content
+without needing to install anything on their end. This approach ensures a consistent experience
+for all players on a modded server.
+
+### Overview of Java-Based Modding
+
+The server-side modding system in Hytale is based on Java, making the server plugins JAR files.
+
+We're guessing this is done so that Minecraft modders can easily transition to Hytale modding,
+as Minecraft modding is also primarily Java-based. This allows modders familiar with Java
+to leverage their existing knowledge when creating mods for Hytale.
+
+#### Singleplayer Concerns
+
+Despite the name, server plugins can also be used in singleplayer mode.
+Hytale's singleplayer mode runs a local server instance, allowing players to use server plugins
+even when playing alone. This means that mods created as server plugins can enhance the singleplayer experience as well.
+
+### Mixin System
+
+Mixins were used in Minecraft modding to directly modify the game’s code, even able to overwrite
+or redirect logic and values. An extremely powerful but somewhat brittle system which depends
+on the source code/game version staying pretty much the same.
+
+We have no official information on Mixins in Hytale. Despite that, we have reason to believe they will not
+need to be supported for the following reasons:
+
+1. For a properly designed game, 95% of Mixin use cases can be solved with a good API instead.
+   In fact, many Minecraft modding APIs simply mixin to provide the API so the developers using
+   those APIs don’t have to write the mixin themselves.
+   * This is typically replacing hardcoded values and overwriting hardcoded behaviors.
+   * Hytale should ideally make these both API or data-driven.
+2. APIs can also be much more resilient than the game version. We can have a separate API
+   version system which means the same code will not need to be modified across multiple updates
+   until the API changes in a breaking way.
diff --git a/content/docs/bg-BG/established-information/server/content-categories/visual-scripting.mdx b/content/docs/bg-BG/established-information/server/content-categories/visual-scripting.mdx
new file mode 100644
index 00000000..16cb0508
--- /dev/null
+++ b/content/docs/bg-BG/established-information/server/content-categories/visual-scripting.mdx
@@ -0,0 +1,59 @@
+---
+title: Visual Scripting
+description: An introduction to what we know of Hytale's visual scripting system as of writing this.
+---
+
+# Visual Scripting
+
+Hytale plans to support Visual Scripting as a method to make advanced logic and control flow accessible to a wider audience. This system will not be available at launch, but should be available shortly after launch.
+
+## Overview
+
+Visual Scripting in Hytale is designed to function similarly to Blueprints in Unreal Engine. It allows designers to create complex behaviors through a visual interface that matches how they think about game logic, without needing to write code directly.
+
+### Key Features
+
+* **Subset of Java functionality**: Visual Scripting can do a subset of what is possible with Java plugins
+* **Designer-friendly**: "Designers are empowered through a visual language that matches how they think about behaviors"
+* **Programmer extensible**: Programmers can extend and optimize the system by adding new visual nodes and performance-sensitive implementations
+* **Safe sharing environment**: Provides a sandboxed, safe environment for sharing logic between modders
+
+## Advantages Over Traditional Coding
+
+Visual Scripting makes writing custom logic more accessible by removing common hurdles found when developing in Java:
+
+* **No complex environment setup**: No need to worry about installing the right tools or configuring development environments
+* **Syntax-free development**: Removes the need to learn and remember programming syntax
+* **Safer sharing**: Malware in visual scripting should be virtually impossible
+* **More inclusive**: Lowers the barrier to entry for non-programmers
+
+## Relationship with Java
+
+Visual Scripting and Java plugins are designed to work in tandem:
+
+* **Java extends Visual Scripting**: Programmers can create new visual nodes using Java
+* **Performance optimization**: While Visual Scripting may not be as optimized as Java directly, programmers can implement performance-critical logic in Java and expose it as visual nodes
+* **Best of both worlds**: Allows the majority of logic to remain in the accessible Visual Scripting environment while keeping expensive operations optimized
+
+Hytale strongly recommends Visual Scripting since it is both more accessible and safer to share and download. However, staying purely in Java will still work for those who prefer it.
+
+## 3D Visual Scripting
+
+One of Hytale's unique features is bringing visual scripting directly into the 3D world:
+
+* **In-world editing**: Link levers, doors, spawners, triggers, and other elements directly inside the game
+* **Adventure map creation**: Excellent for building adventure maps and encounters without leaving Hytale
+* **Similar to DOOM SnapMap**: Provides a familiar workflow for those who have used similar systems
+* **Fully integrated**: Works seamlessly with the asset and scripting stack
+
+## No Text-Based Scripting
+
+Hytale has made a deliberate decision not to include text-based scripting languages. Their reasoning:
+
+* **False compromise**: Text-based scripting is often introduced to "help non-programmers" but still requires learning programming concepts
+* **Complexity increase**: Programmers end up juggling two languages where one is less powerful
+* **Still requires syntax**: Designers still need to learn syntax and programming concepts
+* **Less inclusive**: Doesn't truly solve the accessibility problem
+* **Fragmentation**: Avoids "fragmenting logic across multiple 'half-languages'"
+
+Instead, Hytale believes visual scripting is a better approach that truly makes game logic accessible to a wider audience while maintaining the power and flexibility needed
diff --git a/content/docs/bg-BG/established-information/server/interface/inputs.mdx b/content/docs/bg-BG/established-information/server/interface/inputs.mdx
new file mode 100644
index 00000000..b6b3ff3b
--- /dev/null
+++ b/content/docs/bg-BG/established-information/server/interface/inputs.mdx
@@ -0,0 +1,16 @@
+---
+title: Inputs
+description: Information about input methods supported in Hytale.
+---
+
+Hytale is designed to support a variety of input methods to accommodate different player preferences and platforms.
+
+## Interaction System
+
+Hytale features a robust interaction system that allows plugins to customize how keybinds are interpreted and what actions they trigger. This system is data-driven, enabling modders to create complex interactions through assets.
+
+Modders can define custom keybinds for various actions, such as using abilities or interacting with objects in the game world. The interaction system is designed to be powerful, though it may require some effort to manage the complexity of the assets involved.
+
+> You can use your own interactions to use keybinds for whatever you want. Interaction system is very powerful but we still need to work on its usability as the assets can become quite complex and hard to handle
+
+\- [slikey](https://discord.com/channels/523059903812599811/1428794280868184064/1441291391065129103)
diff --git a/content/docs/bg-BG/established-information/server/interface/ui-customization.mdx b/content/docs/bg-BG/established-information/server/interface/ui-customization.mdx
new file mode 100644
index 00000000..d2acbd6b
--- /dev/null
+++ b/content/docs/bg-BG/established-information/server/interface/ui-customization.mdx
@@ -0,0 +1,80 @@
+---
+title: UI Customization
+description: Information about UI customization in Hytale.
+---
+
+UI can be customized via **server-side** modding. Many of the UI pages shown to players are available to be modified by server owners through mods.
+
+## UI Customization in Hytale
+
+Hytale provides extensive UI customization capabilities through server-side modding, allowing server owners to modify many of the UI pages that players interact with.
+
+### Control Flow
+
+The UI system in Hytale follows a specific control flow pattern:
+
+1. Server sends UI data to the client
+2. Client renders the UI
+3. User interacts with the UI (e.g., pressing a button)
+4. Client sends the interaction event to the server
+5. Server executes the callback logic for the event
+
+This architecture means:
+
+* The client is responsible for rendering UI and sending user interactions to the server
+* The server handles all the actual logic behind user interactions
+
+<Callout type="warning" title="Possible Performance Implications">
+  <span>
+    Because the server processes all UI logic, there is an inherent latency
+    impact on UI responsiveness. Button clicks and other interactions must
+    travel to the server before taking effect, meaning network ping directly
+    affects UI responsiveness.
+  </span>
+
+  <span>
+    Additionally, since client-side modding is not supported, no modded values
+    persist on the client.
+  </span>
+</Callout>
+
+### UI Layout Assets
+
+Hytale's UI customization system works through the following structure:
+
+* **UI Layout**: Sent to the client as an asset
+* **UI Behavior**: Defined in Java code
+* **Custom Layouts**: Enables creation of bespoke UI layouts rather than repurposing existing ones (unlike inventory menu modifications in Minecraft)
+
+### UI Framework Implementations
+
+Hytale currently supports multiple UI implementations, with plans to consolidate on NoesisGUI:
+
+#### Legacy Implementation
+
+* Serves as an example of server modding capabilities
+* Uses a combination of in-game elements, UI Markup Assets, and Java mod code
+* Utilizes a legacy custom markup language
+* Will be deprecated in favor of NoesisGUI
+
+#### NoesisGUI (Primary Framework)
+
+* Uses XAML Markup Language for UI definition
+* Supports multiple languages for internationalization
+* Runs on C# bindings on the client side (not C++)
+* Represents the future direction of Hytale's UI system
+
+#### Third Framework
+
+* Currently being phased out
+* Will be replaced by NoesisGUI as part of the consolidation effort
+
+### Performance Considerations
+
+Due to the server-side nature of UI processing, there are inherent performance characteristics to consider:
+
+* **Latency Impact**: Button clicks and UI interactions must travel to the server before taking effect, meaning network ping directly affects UI responsiveness
+* **No Client Persistence**: Since client-side modding is not supported, no modded values persist on the client
+* **Optimized Architecture**: Hytale's system is designed to minimize latency through efficient communication protocols and optimized server performance, ensuring smooth interactions despite server-side processing requirements
+
+The architecture prioritizes security and consistency by centralizing UI logic on the server while maintaining responsive user experiences
diff --git a/content/docs/bg-BG/established-information/server/server-first-dev.mdx b/content/docs/bg-BG/established-information/server/server-first-dev.mdx
new file mode 100644
index 00000000..1ed97a61
--- /dev/null
+++ b/content/docs/bg-BG/established-information/server/server-first-dev.mdx
@@ -0,0 +1,29 @@
+---
+title: Server-First Development
+description: Information regarding what Server-First Development means, and more.
+---
+
+Hytale is being developed with a "server-first" approach. This means that the server is considered the authoritative source of game state and logic, while the client primarily handles rendering and user input.
+
+## What does "Server-First" mean?
+
+In a server-first architecture, the server is responsible for managing the game world, enforcing rules, and processing player actions. The client connects to the server to receive updates about the game state and to send player inputs. This approach helps ensure consistency and fairness in multiplayer environments, as the server has control over the game logic.
+
+## Benefits of Server-First Development
+
+* **Consistency**: Since the server is the authoritative source, all players experience the same game state, reducing discrepancies and cheating.
+* **Scalability**: Server-first architectures can be more easily scaled to accommodate large numbers
+  of players, as the server can manage resources and distribute load effectively.
+* **Security**: By centralizing game logic on the server, it becomes more difficult for players to manipulate the game state unfairly.
+* **Easier Updates**: Updates and changes can be made on the server side without requiring players to download new client versions.
+* **Only One Version**: There won't be a version selector for the Hytale Client, meaning that server owners do not need to support multiple versions and can rely on everyone being on the latest client. This will help both server owners and modders.
+
+## Implications for Modding
+
+Modders will primarily interact with the server-side components of Hytale. This means that mods will often focus on altering game logic, rules, and behaviors that are managed by the server. Client-side modifications are not allowed (as of the information given right now).
+
+Overall, the server-first approach in Hytale aims to create a robust and fair multiplayer experience while providing modders with powerful tools to customize and enhance the game.
+
+## Conclusion
+
+The server-first development model is a key aspect of Hytale's architecture, ensuring a consistent and secure multiplayer experience. Modders should focus on server-side modifications to fully leverage the capabilities of this approach and create engaging content for players.
diff --git a/content/docs/bg-BG/guides/ecs/block-components.mdx b/content/docs/bg-BG/guides/ecs/block-components.mdx
new file mode 100644
index 00000000..ca68b38a
--- /dev/null
+++ b/content/docs/bg-BG/guides/ecs/block-components.mdx
@@ -0,0 +1,247 @@
+---
+title: Block Components
+description: Learn how to use the block components.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+  - name: oskarscot
+    link: https://oskar.scot
+---
+
+# Overview
+
+In this guide, you'll learn how to use block components to create a ticking block.
+
+<Callout>
+  For a more complete reference, you may also want to review FarmingSystems.Ticking, as much of the underlying logic is based on its implementation.
+</Callout>
+
+## Steps
+
+### 1. ExampleBlock - holds block behavior
+
+```java
+public class ExampleBlock implements Component<ChunkStore> {
+
+    public static final BuilderCodec CODEC = BuilderCodec.builder(ExampleBlock.class, ExampleBlock::new).build();
+
+    // Components usually require a copy constructor as well but since we don't actually hold any data in this component this is not neccessary
+    public ExampleBlock() { }
+
+    public static ComponentType getComponentType() {
+        return ExamplePlugin.get().getExampleBlockComponentType();
+    }
+
+    @Nullable
+    public Component<ChunkStore> clone() {
+        return new ExampleBlock();
+    }
+}
+```
+
+ExampleBlock is a custom component that stores the behavior and data for your ticking block. Here, it simply places an Ice Block at x + 1 relative to its current position when it ticks.
+
+---
+
+### 2. ExampleInitializer - marks blocks as ticking when placed
+
+```java
+public class ExampleInitializer extends RefSystem {
+
+    @Override
+    public void onEntityAdded(@Nonnull Ref ref, @Nonnull AddReason reason, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+        BlockModule.BlockStateInfo info = (BlockModule.BlockStateInfo) commandBuffer.getComponent(ref, BlockModule.BlockStateInfo.getComponentType());
+        if (info == null) return;
+
+        ExampleBlock generator = (ExampleBlock) commandBuffer.getComponent(ref, ExamplePlugin.get().getExampleBlockComponentType());
+        if (generator != null) {
+            int x = ChunkUtil.xFromBlockInColumn(info.getIndex());
+            int y = ChunkUtil.yFromBlockInColumn(info.getIndex());
+            int z = ChunkUtil.zFromBlockInColumn(info.getIndex());
+
+            WorldChunk worldChunk = (WorldChunk) commandBuffer.getComponent(info.getChunkRef(), WorldChunk.getComponentType());
+            if (worldChunk != null) {
+				worldChunk.setTicking(x, y, z, true);
+            }
+        }
+    }
+
+    @Override
+    public void onEntityRemove(@Nonnull Ref ref, @Nonnull RemoveReason reason, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+    }
+
+    @Override
+    public Query getQuery() {
+        return Query.and(BlockModule.BlockStateInfo.getComponentType(), ExamplePlugin.get().getExampleBlockComponentType());
+    }
+}
+```
+
+ExampleInitializer is a RefSystem that reacts when block entities with the ExampleBlock component are added or removed. This is crucial for marking blocks as ticking when they're first placed.
+
+**Key Points:**
+
+- Tells the game that this block should tick, allowing `ExampleSystem` to process it.
+
+```java
+worldChunk.setTicking(x, y, z, true);
+```
+
+---
+
+### 3. ExampleSystem - handles ticking
+
+```java
+public class ExampleSystem extends EntityTickingSystem {
+
+    public void tick(float dt, int index, @Nonnull ArchetypeChunk archetypeChunk, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+        BlockSection blocks = (BlockSection) archetypeChunk.getComponent(index, BlockSection.getComponentType());
+
+        assert blocks != null;
+
+        if (blocks.getTickingBlocksCountCopy() != 0) {
+            ChunkSection section = (ChunkSection) archetypeChunk.getComponent(index, ChunkSection.getComponentType());
+
+            assert section != null;
+
+            BlockComponentChunk blockComponentChunk = (BlockComponentChunk) commandBuffer.getComponent(section.getChunkColumnReference(), BlockComponentChunk.getComponentType());
+
+            assert blockComponentChunk != null;
+
+            blocks.forEachTicking(blockComponentChunk, commandBuffer, section.getY(), (blockComponentChunk1, commandBuffer1, localX, localY, localZ, blockId) -> {
+                Ref<ChunkStore> blockRef = blockComponentChunk.getEntityReference(ChunkUtil.indexBlockInColumn(localX, localY, localZ));
+                if (blockRef == null) {
+                    return BlockTickStrategy.IGNORED;
+                } else {
+                    ExampleBlock exampleBlock = (ExampleBlock) commandBuffer1.getComponent(blockRef, ExampleBlock.getComponentType());
+                    if (exampleBlock != null) {
+                        WorldChunk worldChunk = (WorldChunk) commandBuffer.getComponent(section.getChunkColumnReference(), WorldChunk.getComponentType());
+                        World world = worldChunk.getWorld();
+
+                        int globalX = localX + (worldChunk.getX() * 32);
+                        int globalZ = localZ + (worldChunk.getZ() * 32);
+
+                        // We need to execute setBlock on the world thread as you cannot call store functions from a system
+                        // This is because of the architecture of the server, depending on your needs you can also use the CommandBuffer
+                        world.execute(() -> {
+                            world.setBlock(globalX + 1, localY, globalZ, "Rock_Ice");
+                        });
+
+                        return BlockTickStrategy.CONTINUE;
+
+                    } else {
+                        return BlockTickStrategy.IGNORED;
+                    }
+                }
+            });
+        }
+    }
+
+    @Nullable
+    public Query getQuery() {
+        return Query.and(BlockSection.getComponentType(), ChunkSection.getComponentType());;
+    }
+}
+```
+
+ExampleSystem is an EntityTickingSystem that runs every tick to execute the logic for all ticking blocks with the ExampleBlock component.
+
+**Key Points:**
+
+- **Get the block component**
+
+```java
+ExampleBlock exampleBlock = (ExampleBlock) commandBuffer.getComponent(blockRef, ExampleBlock.getComponentType());
+```
+
+- **Convert local chunk coordinates to world coordinates**
+
+```java
+int globalX = localX + (worldChunk.getX() * 32);
+int globalZ = localZ + (worldChunk.getZ() * 32);
+```
+
+- **Run the block logic**
+
+```java
+exampleBlock.runBlockAction(globalX, localY, globalZ, worldChunk.getWorld());
+```
+
+- **Keep the block ticking in the next tick**
+
+```java
+return BlockTickStrategy.CONTINUE;
+```
+
+---
+
+### 4. ExamplePlugin - registers components and systems
+
+```java
+public class ExamplePlugin extends JavaPlugin {
+    protected static ExamplePlugin instance;
+    private static final HytaleLogger LOGGER = HytaleLogger.forEnclosingClass();
+    private ComponentType exampleBlockComponentType;
+
+    public static ExamplePlugin get() {
+        return instance;
+    }
+
+    public ExamplePlugin(@Nonnull JavaPluginInit init) {
+        super(init);
+        LOGGER.atInfo().log("Hello from " + this.getName() + " version " + this.getManifest().getVersion().toString());
+    }
+
+    @Override
+    protected void setup() {
+        instance = this;
+        LOGGER.atInfo().log("Setting up plugin " + this.getName());
+        this.exampleBlockComponentType = this.getChunkStoreRegistry().registerComponent(ExampleBlock.class, "ExampleBlock", ExampleBlock.CODEC);
+    }
+	
+	@Override
+	protected void start() {
+		this.getChunkStoreRegistry().registerSystem(new ExampleSystem());
+		this.getChunkStoreRegistry().registerSystem(new ExampleInitializer());
+	}
+
+    public ComponentType getExampleBlockComponentType() {
+        return this.exampleBlockComponentType;
+    }
+}
+```
+
+---
+
+### 5. Configure In-Game
+
+![block-component-1](/assets/guides/block-component-1.png)
+
+![block-component-2](/assets/guides/block-component-2.png)
+
+With this logic, the block will now continuously place an Ice Block at the coordinates x + 1 relative to its current position every time it ticks.
+
+---
+
+## Common Issues
+
+### NullPointerException on Startup
+
+**Error message:**
+
+```java
+java.lang.NullPointerException: Cannot invoke "com.hypixel.hytale.component.query.Query.validateRegistry(com.hypixel.hytale.component.ComponentRegistry)" because "query" is null
+```
+
+**Cause:**
+This error occurs when your module is loaded **before** the required Hytale modules.
+
+**Fix:**
+Add `EntityModule` and `BlockModule` as dependencies in your `manifest.json` to ensure proper load order.
+
+```json
+"Dependencies": {
+  "Hytale:EntityModule": "*",
+  "Hytale:BlockModule": "*"
+}
+```
diff --git a/content/docs/bg-BG/guides/ecs/entity-component-system.mdx b/content/docs/bg-BG/guides/ecs/entity-component-system.mdx
new file mode 100644
index 00000000..391a276d
--- /dev/null
+++ b/content/docs/bg-BG/guides/ecs/entity-component-system.mdx
@@ -0,0 +1,72 @@
+---
+title: Entity Component System
+description: A basic introduction into ECS (Entity Component System)
+---
+
+<Callout type="warning">
+  This guide requires basic understanding of OOP concepts such as inheritance.
+
+  Please make sure you have a good understanding of these concepts before reading this guide.
+</Callout>
+
+<Callout type="info">
+  This guide is currently only on the theory of ECS and will not have code examples.
+
+  Code examples are intentionally omitted to avoid confusion about how Hytale’s ECS may be implemented.
+</Callout>
+
+# Introduction
+
+An Entity Component System otherwise known as ECS is a design pattern in game development.
+
+ECS is made up of Entities, which reference Components and Systems that operates on Entities.
+
+It also focuses on composition over inheritance, eliminating rigid hierarchy, helps separate behavior and data and makes reusability easier.
+
+# Composition Over Inheritance
+
+Before getting into understanding what ECS is made of, lets understand what is the ECS philosophy.
+
+We can describe composition as "has X" and inheritance as "is X".
+When we inherit a class in Java, we inherit all of its attributes and methods.
+While in composition we can choose for each object what it references and what systems will work on it.
+
+# Entities, Components and Systems
+
+## Entities
+
+An Entity is just a unique identifier.
+
+- It contains no data.
+- It contains no logic
+
+Think of entities as nouns that can be described using components
+
+## Components
+
+Components are just plain data containers.
+
+- They store only data
+- They contain no behavior or logic
+- They describe traits or aspects of an entity
+
+Examples of components:
+
+- A 'Position' component that stores X, Y and Z coordinates
+- A 'Velocity' component that stores the speed along each axis
+- A 'Health' component that stores the current health of the entity
+
+Think of components as adjectives that describe an entity
+
+## Systems
+
+Systems contains the logic for your game (or in this case, a mod).
+
+- It Operates on all entities that have a specific set of components
+- It Does not store entity data itself
+- It Applies behavior by reading and modifying component data
+
+For example:
+
+- A "WinConditionSystem" may process every Entity that contains the components "Position" and "Velocity"
+- If an entity reaches the position `(0, 0, 0)`, the system will trigger a "You Won!" message.
diff --git a/content/docs/bg-BG/guides/ecs/example-ecs-plugin.mdx b/content/docs/bg-BG/guides/ecs/example-ecs-plugin.mdx
new file mode 100644
index 00000000..2f01d79e
--- /dev/null
+++ b/content/docs/bg-BG/guides/ecs/example-ecs-plugin.mdx
@@ -0,0 +1,244 @@
+---
+title: Example ECS Plugin
+description: In this guide you will learn how to create a simple poison system utilizing all of the features you previously learned about Hytale's ECS system
+authors:
+  - name: oskarscot
+    url: https://oskar.scot
+  - name: jacobwojoski
+    url: https://github.com/jacobwojoski
+---
+
+## Practical Example: Poison System
+
+Putting together everything you learned so far, here's a complete poison effect. When applied to any entity, it deals damage at a set interval until it expires and removes itself.
+
+```java
+package scot.oskar.hytaletemplate.components;
+
+import com.hypixel.hytale.component.Component;
+import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
+import javax.annotation.Nullable;
+
+public class PoisonComponent implements Component<EntityStore> {
+
+  private float damagePerTick;
+  private float tickInterval;
+  private int remainingTicks;
+  private float elapsedTime;
+
+  // Add static getter and setter to store componentType in the component instead of getting it from the plugin singleton.
+  // - This allows anyone to call PoisonComponent.getComponentType() instead of ExamplePlugin.get().getPoisonComponentType();
+  // - You could also update the setter to be a singleton if desired.
+  // - Adding a throw condition if getComponentType() returns null could also be good.
+  private static ComponentType<EntityStore, PoisonComponent> type;
+  public static ComponentType<EntityStore, PoisonComponent> getComponentType(){
+    return this.type;
+  }
+  public static void setComponentType(ComponentType<EntityStore, PoisonComponent> type){
+    this.type = type;
+  }
+
+  // A builder codec is needed to allow components to be saved and loaded from disk
+  public static final BuilderCodec<PoisonComponent> CODEC = BuilderCodec
+        .builder(PoisonComponent.class, PoisonComponent::new)
+        .append(
+            new KeyedCodec<>("DamagePerTick", Codec.FLOAT),
+            (component, value) -> component.damagePerTick = value,
+            component -> component.damagePerTick
+        ).add()
+        .append(
+            new KeyedCodec<>("TickInterval", Codec.FLOAT),
+            (component, value) -> component.tickInterval = value,
+            component -> component.tickInterval
+        ).add()
+        .append(
+            new KeyedCodec<>("RemainingTicks", Codec.INTEGER),
+            (component, value) -> component.remainingTicks = value,
+            component -> component.remainingTicks
+        )
+        .add()
+        .append(
+            new KeyedCodec<>("ElapsedTime", Codec.FLOAT),
+            (component, value) -> component.elapsedTime = value,
+            component -> component.elapsedTime
+        )
+        .add()
+        .build();
+
+  public PoisonComponent() {
+    this(5f, 1.0f, 10);
+  }
+
+  public PoisonComponent(float damagePerTick, float tickInterval, int totalTicks) {
+    this.damagePerTick = damagePerTick;
+    this.tickInterval = tickInterval;
+    this.remainingTicks = totalTicks;
+    this.elapsedTime = 0f;
+  }
+
+  public PoisonComponent(PoisonComponent other) {
+    this.damagePerTick = other.damagePerTick;
+    this.tickInterval = other.tickInterval;
+    this.remainingTicks = other.remainingTicks;
+    this.elapsedTime = other.elapsedTime;
+  }
+
+  @Nullable
+  @Override
+  public Component<EntityStore> clone() {
+    return new PoisonComponent(this);
+  }
+
+  public float getDamagePerTick() {
+    return damagePerTick;
+  }
+
+  public float getTickInterval() {
+    return tickInterval;
+  }
+
+  public int getRemainingTicks() {
+    return remainingTicks;
+  }
+
+  public float getElapsedTime() {
+    return elapsedTime;
+  }
+
+  public void addElapsedTime(float dt) {
+    this.elapsedTime += dt;
+  }
+
+  public void resetElapsedTime() {
+    this.elapsedTime = 0f;
+  }
+
+  public void decrementRemainingTicks() {
+    this.remainingTicks--;
+  }
+
+  public boolean isExpired() {
+    return this.remainingTicks <= 0;
+  }
+}
+```
+
+```java
+package scot.oskar.hytaletemplate.systems;
+
+import com.hypixel.hytale.component.ArchetypeChunk;
+import com.hypixel.hytale.component.CommandBuffer;
+import com.hypixel.hytale.component.ComponentType;
+import com.hypixel.hytale.component.Ref;
+import com.hypixel.hytale.component.Store;
+import com.hypixel.hytale.component.SystemGroup;
+import com.hypixel.hytale.component.query.Query;
+import com.hypixel.hytale.component.system.tick.EntityTickingSystem;
+import com.hypixel.hytale.server.core.modules.entity.damage.Damage;
+import com.hypixel.hytale.server.core.modules.entity.damage.DamageCause;
+import com.hypixel.hytale.server.core.modules.entity.damage.DamageModule;
+import com.hypixel.hytale.server.core.modules.entity.damage.DamageSystems;
+import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+import scot.oskar.hytaletemplate.components.PoisonComponent;
+
+public class PoisonSystem extends EntityTickingSystem<EntityStore> {
+
+  private final ComponentType<EntityStore, PoisonComponent> poisonComponentType;
+
+  public PoisonSystem(ComponentType<EntityStore, PoisonComponent> poisonComponentType) {
+    this.poisonComponentType = poisonComponentType;
+  }
+
+  @Override
+  public void tick(float dt, int index, @Nonnull ArchetypeChunk<EntityStore> archetypeChunk,
+      @Nonnull Store<EntityStore> store, @Nonnull CommandBuffer<EntityStore> commandBuffer) {
+
+    // You could also just call PoisonComponent.getComponentType() instead of taking in the passed in variable here.
+    PoisonComponent poison = archetypeChunk.getComponent(index, poisonComponentType);
+    Ref<EntityStore> ref = archetypeChunk.getReferenceTo(index);
+
+    poison.addElapsedTime(dt);
+
+    if (poison.getElapsedTime() >= poison.getTickInterval()) {
+      poison.resetElapsedTime();
+
+      Damage damage = new Damage(Damage.NULL_SOURCE, DamageCause.OUT_OF_WORLD, poison.getDamagePerTick());
+      DamageSystems.executeDamage(ref, commandBuffer, damage);
+
+      poison.decrementRemainingTicks();
+    }
+
+    if (poison.isExpired()) {
+      commandBuffer.removeComponent(ref, poisonComponentType);
+    }
+  }
+
+  @Nullable
+  @Override
+  public SystemGroup<EntityStore> getGroup() {
+    return DamageModule.get().getGatherDamageGroup();
+  }
+
+  @Nonnull
+  @Override
+  public Query<EntityStore> getQuery() {
+    return Query.and(this.poisonComponentType);
+  }
+}
+```
+
+```java
+package scot.oskar.hytaletemplate.commands;
+
+public class ExampleCommand extends AbstractPlayerCommand {
+
+  public ExampleCommand() {
+    super("test", "Super test command!");
+  }
+
+  @Override
+  protected void execute(@Nonnull CommandContext commandContext, @Nonnull Store<EntityStore> store, 
+      @Nonnull Ref<EntityStore> ref, @Nonnull PlayerRef playerRef, @Nonnull World world) {
+    Player player = store.getComponent(ref, Player.getComponentType());
+    PoisonComponent poison = new PoisonComponent(3f, 0.5f, 8);
+    store.addComponent(ref, PoisonComponent.getComponentType(), poison);
+    player.sendMessage(Message.raw("You have been poisoned!").color(Color.GREEN).bold(true));
+  }
+}
+```
+
+```java
+package scot.oskar.hytaletemplate;
+
+public final class ExamplePlugin extends JavaPlugin {
+
+  private static ExamplePlugin instance;
+
+  public ExamplePlugin(@Nonnull JavaPluginInit init) {
+    super(init);
+    instance = this;
+  }
+
+  @Override
+  protected void setup() {
+    this.getCommandRegistry().registerCommand(new ExampleCommand());
+    this.getEventRegistry().registerGlobal(PlayerReadyEvent.class, ExampleEvent::onPlayerReady);
+    this.getEventRegistry().registerGlobal(PlayerChatEvent.class, ChatFormatter::onPlayerChat);
+
+    // Register the component & set the type in the component class so its easier to retrieve.
+    ComponentType<EntityStore, PoisonComponent> poisonComponentType = this.getEntityStoreRegistry()
+        .registerComponent(PoisonComponent.class, PoisonComponent::new);
+    PoisonComponent.setComponentType(poisonComponentType);
+
+    this.getEntityStoreRegistry().registerSystem(new PoisonSystem(PoisonComponent.getComponentType()));
+  }
+
+  public static ExamplePlugin get() {
+    return instance;
+  }
+}
+```
+
+The query uses only `poisonComponentType` which means the system will process any entity with a `PoisonComponent`, not just players. This makes it flexible for poisoning NPCs, mobs, or any living entity. The system places itself in the `GatherDamageGroup` so the damage it creates flows through the full damage pipeline including armor reduction and invulnerability checks.
diff --git a/content/docs/bg-BG/guides/ecs/hytale-ecs-theory.mdx b/content/docs/bg-BG/guides/ecs/hytale-ecs-theory.mdx
new file mode 100644
index 00000000..52d8b1f5
--- /dev/null
+++ b/content/docs/bg-BG/guides/ecs/hytale-ecs-theory.mdx
@@ -0,0 +1,307 @@
+---
+title: Hytale ECS Theory
+description: In this guide you will learn about the basics of Hytale's powerful ECS system as well as create your own component, a system, and work together with other systems to create gameplay logic.
+authors:
+  - name: oskarscot
+    url: https://oskar.scot
+  - name: musava_ribica
+    url: https://forum.hytalemodding.dev/u/musava_ribica
+  - name: Marcel-TO
+    url: https://marcel-to.net
+---
+
+## Store
+
+The `Store` class is the core of Hytale's ECS system, it's responsible for storing entities, if you ever need to access an entity, you need access to the store. It utilises a concept called Archetypes where data is grouped together in chunks. For example if we have 100 Trorks, they will be chunked together along with their components so that they're closely packed together and faster to retrieve.
+
+## EntityStore
+
+When looking through Hytale's server code you will find that most of the time `Store` will be of type `EntityStore`. This name can be misleading as it might suggest that it's a `Store` for entities.
+But didn't we just say that the base `Store` already stores entities? The `EntityStore` class implements `WorldProvider` meaning that `EntityStore` is responsible for accessing a specific Hytale `World`. It maintains internal maps `entitiesByUuid` and `networkIdToRef`, allowing you to find a specific entity by its persistent ID or its networking ID.
+
+Every Entity has a `UUIDComponent` as well as a `NetworkId` which are used by the `EntityStore` to lookup entities inside of the `Store`.
+
+## ChunkStore
+
+Another type of `Store` that you might come across is the `ChunkStore`, it is responsible for storing all the components, related to blocks inside of the `World`. You can retrieve `WorldChunk`s which are your general chunk Components.
+A `WorldChunk` component contains an `EntityChunk` which holds all the Entities that are inside of the chunk as well as their reference to the EntityStore. It also holds the `BlockChunk` which consists of `BlockSection`s. There are more components making up the overall world and chunk systems but
+for now this is the basic understanding for the `ChunkStore`. You can use it to retrieve data about chunks and their blocks as well as entities on a given chunk and create block and chunk systems.
+
+## Holder
+
+A Holder is essentially a blueprint for an entity. Before an entity exists in the Store (and thus in the world), it exists as a `Holder`. It collects and holds all the necessary components (data). You can compare it analogous to shopping cart. You grab all components you need and once you have everything, check out at the store which will take your cart and create a valid entity ID and hand you back a receipt (a Ref).
+
+Let's take a look at an example: initializing players. In `Universe`, the `addPlayer` method demonstrates it perfectly.
+When a player connects, we don't immediately throw them into the ECS. We first construct their data in a Holder.
+Notice that `PlayerStorage#load` method, which loads player data from disk, returns a `CompletableFuture<Holder<EntityStore>>`.
+What it means is that the method is async and the future will contain a Holder for something in the `EntityStore`.
+Just open the `Universe `class, find the `addPlayer` method and read it start to end. Trust me, it will help you a lot when you see the actual process how an entity is constructed, what it has to pass through. In the end, `Universe` calls `world#addPlayer`, which (after dispatching an event) calls the delightful
+
+```java
+Ref<EntityStore> ref = playerRefComponent.addToStore(store);
+```
+
+and `PlayerRef#addToStore` has this:
+
+```java
+store.addEntity(this.holder, AddReason.LOAD);
+```
+
+## Ref (Reference)
+
+For those familiar with languages like C++, you probably already can guess what this class is purely by the name of it. However, a Ref is a safe "handle" or pointer to an entity. You should **NEVER** store a direct reference to an entity object, you use a Ref instead. It tracks whether an entity is still alive. If you call `validate()` on a Ref for an entity that has been deleted, it throws an exception.
+
+## Player Components
+
+In Hytale, a "Player" is not just one object. It is a single entity composed of multiple specialized components. Understanding the difference between `Player` and `PlayerRef` is crucial for modding.
+
+### PlayerRef
+
+Despite its name, PlayerRef is a Component, not a handle. It represents the player's connection and identity. It's a special component which stays active as long as the player is connected to the server, even if the player switches worlds. The key data that it stores are the player's username, UUID, language as well as the packet handler.
+
+### Player
+
+The `Player` component represents the player's physical presence. It only exists when the player is actually spawned in a world. Providing access to gameplay specific data, this component differs per world.
+
+To interact with an entity, you use the `Store` to retrieve its components via their `ComponentType`. Because Hytale uses a decoupled system, you don't call `entity.getHealth()`. Instead, you ask the `Store` for the health data associated with that entity's `Ref`.
+
+```java
+@Override
+protected void execute(@Nonnull CommandContext commandContext, @Nonnull Store<EntityStore> store,
+    @Nonnull Ref<EntityStore> ref, @Nonnull PlayerRef playerRef, @Nonnull World world) {
+  Player player = store.getComponent(ref, Player.getComponentType());
+  UUIDComponent component = store.getComponent(ref, UUIDComponent.getComponentType());
+  TransformComponent transform = store.getComponent(ref, TransformComponent.getComponentType());
+  player.sendMessage(Message.raw("UUIDComponent : " + component.getUuid()));
+  player.sendMessage(Message.raw("Transform : " + transform.getPosition()));
+}
+```
+
+In here we use the `Store<EntityStore>` to access the `Player` component using the `Ref<EntityStore>`. We can do the same for other components like the `UUIDComponent` or the `TransformComponent` to retrieve the entity Transform containing the position and rotation.
+
+## Components
+
+Components are pure data containers. They hold state but contain no logic. In Hytale, components must implement `Component<EntityStore>` and provide a clone method for the ECS to copy them when needed.
+
+```java
+public class PoisonComponent implements Component<EntityStore> {
+
+  private float damagePerTick;
+  private float tickInterval;
+  private int remainingTicks;
+  private float elapsedTime;
+
+  public PoisonComponent() {
+    this(5f, 1.0f, 10);
+  }
+
+  public PoisonComponent(float damagePerTick, float tickInterval, int totalTicks) {
+    this.damagePerTick = damagePerTick;
+    this.tickInterval = tickInterval;
+    this.remainingTicks = totalTicks;
+    this.elapsedTime = 0f;
+  }
+
+  public PoisonComponent(PoisonComponent other) {
+    this.damagePerTick = other.damagePerTick;
+    this.tickInterval = other.tickInterval;
+    this.remainingTicks = other.remainingTicks;
+    this.elapsedTime = other.elapsedTime;
+  }
+
+  @Nullable
+  @Override
+  public Component<EntityStore> clone() {
+    return new PoisonComponent(this);
+  }
+
+  public float getDamagePerTick() {
+    return damagePerTick;
+  }
+
+  public float getTickInterval() {
+    return tickInterval;
+  }
+
+  public int getRemainingTicks() {
+    return remainingTicks;
+  }
+
+  public float getElapsedTime() {
+    return elapsedTime;
+  }
+
+  public void addElapsedTime(float dt) {
+    this.elapsedTime += dt;
+  }
+
+  public void resetElapsedTime() {
+    this.elapsedTime = 0f;
+  }
+
+  public void decrementRemainingTicks() {
+    this.remainingTicks--;
+  }
+
+  public boolean isExpired() {
+    return this.remainingTicks <= 0;
+  }
+}
+```
+
+The default constructor is required for the registration factory. The copy constructor is used by `clone()` which the ECS calls internally when it needs to duplicate component data.
+
+## CommandBuffer
+
+The `CommandBuffer` queues changes to entities. Use it instead of modifying the store directly to ensure thread safety and proper ordering. You'll use it to add components, remove components, and execute damage.
+
+```java
+commandBuffer.addComponent(ref, componentType, new MyComponent());
+
+commandBuffer.removeComponent(ref, componentType);
+
+MyComponent comp = commandBuffer.getComponent(ref, componentType);
+```
+
+## Codec
+
+Codecs handle serialization and deserialization of components. Hytale uses them to save and load entity data to and from disk as well as sending component data over the network. When creating a custom component, you must also create a corresponding Codec.
+
+There are multiple Codec types already implemented in the default Codec Interface:
+
+- Codec.STRING
+- Codec.BOOLEAN
+- Codec.DOUBLE
+- Codec.FLOAT
+- Codec.BYTE
+- Codec.SHORT
+- Codec.INTEGER
+- Codec.LONG
+- Codec.DOUBLE_ARRAY
+- Codec.FLOAT_ARRAY
+- Codec.INT_ARRAY
+- Codec.LONG_ARRAY
+- Codec.STRING_ARRAY
+- Codec.PATH
+- Codec.INSTANT
+- Codec.DURATION
+- Codec.DURATION_SECONDS
+- Codec.LOG_LEVEL
+- Codec.UUID_BINARY
+- Codec.UUID_STRING
+
+Aside from the basic types, there are also more complex Codec implementations like `CodecMap`, `ObjectMapCodec` or `EnumCodec`.
+
+### Builder Codec
+
+The `BuilderCodec` is a powerful utility for creating your custom codecs. It allows you to define how each field in your component is serialized and deserialized. Each Field needs to have the following information:
+
+- The KeyedCodec to use for serialization/deserialization of the field. This can be one of the built-in codecs or a custom codec if your field is a complex type. To initialize a KeyedCodec you need to provide a unique string identifier for the codec and the actual Codec instance to use for the field.
+
+<Callout type="warning">
+  Keep in mind that every KeyedCodec identifier string must start Uppercase and be unique across your entire mod. This means that if you have multiple components, each field's KeyedCodec identifier must not clash with any other field's identifier in any other component within your mod. Otherwise you may run into serialization issues.
+</Callout>
+
+- A setter function to set the field value on the component
+- A getter function to retrieve the field value from the component
+
+This might seem tedious at first but it ensures that your component can be correctly serialized and deserialized by the ECS system. Let's take a look at each of the required parameters in detail:
+
+- **KeyedCodec**: This defines how the data is converted to and from a storable format. For example, if you have an integer field, you would use `Codec.INTEGER`.
+  ```java
+  // Example of creating a KeyedCodec for a String field
+  KeyedCodec<String> example = new KeyedCodec<String>("ExampleIdForCodec", Codec.STRING);
+  // Example of creating a KeyedCodec for an Integer field
+  KeyedCodec<Integer> exampleInt = new KeyedCodec<Integer>("ExampleIntIdForCodec", Codec.INTEGER);
+  ```
+
+- **Setter Function**: This is a lambda function that takes an instance of your component + the value to set and sets the field value on the component. For example, if you have a field called `myCustomField` in your custom component, your setter function would look like this:
+  ```java
+  (data, value) -> data.myCustomField = value
+  ```
+
+- **Getter Function**: This is a lambda function that takes an instance of your component and returns the value of the field you want to serialize. For example, if you have a field called `myCustomField` in your custom component, your getter function would look like this:
+  ```java
+  (data) -> data.myCustomField
+  ```
+
+<Callout type="info">
+  Lambda functions are a concise way to represent functional interfaces in Java. They allow you to pass behavior as parameters, making your code more flexible and reusable. In the context of Codec creation, they enable you to define how to get and set field values without needing to create separate classes or methods for each field.
+
+  If you are unfamiliar with lambda functions, you can view them as short and compressed methods that can be defined inline. They are particularly useful for scenarios where you need to pass simple behavior, such as getting or setting a value, without the overhead of creating a full class or method.
+
+  As an example, consider the following lambda function used as a getter:
+
+  ```java
+  (data) -> data.myCustomField
+  ```
+
+  This lambda takes a single parameter `data` (which would be an instance of your component) and returns the value of `myCustomField`. It's equivalent to writing a method like this:
+
+  ```java
+  public Object getMyCustomField(MyComponent data) {
+      return data.myCustomField;
+  }
+  ```
+</Callout>
+
+After defining the necessary parameters, you can create a `BuilderCodec` for your component. As example let's look at how to create a Codec for the previously defined `PoisonComponent`. For the purpose of this example, let's assume that the `PoisonComponent` has only the following fields:
+
+- `damagePerTick` (float)
+- `poisonName` (String)
+
+```java
+public class PoisonComponent implements Component<EntityStore> {
+    private float damagePerTick;
+    private String poisonName;
+
+    // Constructors, getters, setters, clone method omitted for brevity
+
+        public static final BuilderCodec<PoisonComponent> CODEC = BuilderCodec.builder(PoisonComponent.class, PoisonComponent::new)
+            .append(
+                new KeyedCodec<Float>("DamagePerTick", Codec.FLOAT),
+                (data, value) -> data.damagePerTick = value,
+                (data) -> data.damagePerTick
+            )
+            .add()
+            .append(
+                new KeyedCodec<String>("PoisonName", Codec.STRING),
+                (data, value) -> data.poisonName = value,
+                (data) -> data.poisonName
+            )
+            .add()
+            .build();
+}
+```
+
+You can also add validators to your Codec fields to ensure that the data being serialized/deserialized meets certain criteria. For example, if you want to ensure that the `damagePerTick` field is always non-negative or the poison name is never null, you can add a validator like this:
+
+```java
+.append(
+    new KeyedCodec<Float>("DamagePerTick", Codec.FLOAT),
+    (data, value) -> data.damagePerTick = value,
+    (data) -> data.damagePerTick
+)
+.addValidator(Validators.greaterThan(0))
+.add()
+
+.append(
+    new KeyedCodec<String>("PoisonName", Codec.STRING),
+    (data, value) -> data.poisonName = value,
+    (data) -> data.poisonName
+)
+.addValidator(Validators.nonNull())
+.add()
+```
+
+### Complex Codec Examples
+
+If you want to have a map inside your component, you can use the MapCodec class to build a KeyedCodec for it. Here's an example of how to create a Codec for a Map field:
+
+```java
+var damagePerTick = new KeyedCodec<>("DamagePerTick", new MapCodec<>(Codec.FLOAT, HashMap<String, Float>::new));
+```
+
+<Callout type="info">
+  This also works with custom Objects as long as you have a Codec defined for the Object type.
+</Callout>
diff --git a/content/docs/bg-BG/guides/ecs/systems.mdx b/content/docs/bg-BG/guides/ecs/systems.mdx
new file mode 100644
index 00000000..eec8e494
--- /dev/null
+++ b/content/docs/bg-BG/guides/ecs/systems.mdx
@@ -0,0 +1,230 @@
+---
+title: Systems
+description: In this guide you will learn about how systems work inside of Hytale.
+authors:
+  - name: oskarscot
+    url: https://oskar.scot
+---
+
+Systems are where the logic lives. While components are pure data containers, systems operate on entities that match specific component queries. The ECS scheduler runs systems each tick, passing in only the entities that have the components the system cares about.
+
+### EntityTickingSystem
+
+The most common system type. It runs every tick and processes each entity matching its query individually.
+
+```java
+public class PoisonSystem extends EntityTickingSystem<EntityStore> {
+
+  private final ComponentType<EntityStore, PoisonComponent> poisonComponentType;
+
+  public PoisonSystem(ComponentType<EntityStore, PoisonComponent> poisonComponentType) {
+    this.poisonComponentType = poisonComponentType;
+  }
+
+  @Override
+  public void tick(float dt, int index, @Nonnull ArchetypeChunk<EntityStore> archetypeChunk,
+      @Nonnull Store<EntityStore> store, @Nonnull CommandBuffer<EntityStore> commandBuffer) {
+
+    PoisonComponent poison = archetypeChunk.getComponent(index, poisonComponentType);
+    Ref<EntityStore> ref = archetypeChunk.getReferenceTo(index);
+
+    poison.addElapsedTime(dt);
+
+    if (poison.getElapsedTime() >= poison.getTickInterval()) {
+      poison.resetElapsedTime();
+
+      Damage damage = new Damage(Damage.NULL_SOURCE, DamageCause.OUT_OF_WORLD, poison.getDamagePerTick());
+      DamageSystems.executeDamage(ref, commandBuffer, damage);
+
+      poison.decrementRemainingTicks();
+    }
+
+    if (poison.isExpired()) {
+      commandBuffer.removeComponent(ref, poisonComponentType);
+    }
+  }
+
+  @Nullable
+  @Override
+  public SystemGroup<EntityStore> getGroup() {
+    return DamageModule.get().getGatherDamageGroup();
+  }
+
+  @Nonnull
+  @Override
+  public Query<EntityStore> getQuery() {
+    return Query.and(this.poisonComponentType);
+  }
+}
+```
+
+The `tick` method receives `dt` which is delta time since the last tick. This lets you accumulate time for interval-based logic rather than counting ticks. The `ArchetypeChunk` gives you access to the entity's components via the index, and `getReferenceTo` returns the `Ref` you need for issuing commands.
+
+### TickingSystem
+
+Runs once per tick globally, not per-entity. Use this for world-wide updates or logic that doesn't target specific entities.
+
+```java
+public class GlobalUpdateSystem extends TickingSystem<EntityStore> {
+
+  @Override
+  public void tick(float dt, int index, Store<EntityStore> store) {
+    World world = store.getExternalData().getWorld();
+  }
+}
+```
+
+### DelayedEntitySystem
+
+Like `EntityTickingSystem` but with a built-in delay. The constructor takes a float representing seconds between executions.
+
+```java
+public class HealthRegenSystem extends DelayedEntitySystem<EntityStore> {
+
+  public HealthRegenSystem() {
+    super(1.0f);
+  }
+
+  @Override
+  public void tick(float dt, int index, @Nonnull ArchetypeChunk<EntityStore> archetypeChunk,
+      @Nonnull Store<EntityStore> store, @Nonnull CommandBuffer<EntityStore> commandBuffer) {
+    // Runs every 1 second per matching entity
+  }
+
+  @Nonnull
+  @Override
+  public Query<EntityStore> getQuery() {
+    return Query.and(Player.getComponentType());
+  }
+}
+```
+
+### RefSystem
+
+We can also create systems to listen for changes on entities themselves. This is done through a `RefSystem`, for example let's say we want to perform an action whenever we add a component to an entity, update it or remove it.
+This can be done via the `RefChangeSystem<ECS_STORE, COMPONENT>`. Let's break down the example below:
+
+```java
+public class PermissionAttachmentSystem extends RefChangeSystem<EntityStore, PermissionAttachment> {
+
+  private static final HytaleLogger LOGGER = HytaleLogger.forEnclosingClass();
+
+  @Nonnull
+  @Override
+  public ComponentType<EntityStore, PermissionAttachment> componentType() {
+    return EntityStoreRegistry.get().getPermissionAttachmentComponentType();
+  }
+
+  @Override
+  public void onComponentAdded(@Nonnull Ref<EntityStore> ref, @Nonnull PermissionAttachment permissionAttachment, @Nonnull Store<EntityStore> store, @Nonnull CommandBuffer<EntityStore> commandBuffer) {
+    UUIDComponent component = store.getComponent(ref, UUIDComponent.getComponentType());
+    UUID playerUuid = component.getUuid();
+
+    // PermissionAttachment component was added to a new entity
+  }
+
+  @Override
+  public void onComponentSet(@Nonnull Ref<EntityStore> ref, @Nullable PermissionAttachment oldAttachment, @Nonnull PermissionAttachment newAttachment, @Nonnull Store<EntityStore> store, @Nonnull CommandBuffer<EntityStore> commandBuffer) {
+    UUIDComponent component = store.getComponent(ref, UUIDComponent.getComponentType());
+    UUID playerUuid = component.getUuid();
+
+    // PermissionAttachment component was updated using replaceComponent or putComponent
+  }
+
+  @Override
+  public void onComponentRemoved(@Nonnull Ref<EntityStore> ref, @Nonnull PermissionAttachment permissionAttachment, @Nonnull Store<EntityStore> store, @Nonnull CommandBuffer<EntityStore> commandBuffer) {
+    UUIDComponent component = store.getComponent(ref, UUIDComponent.getComponentType());
+    UUID playerUuid = component.getUuid();
+
+    // PermissionAttachment component was removed from an entity
+  }
+
+  @Nullable
+  @Override
+  public Query<EntityStore> getQuery() {
+    return EntityStoreRegistry.get().getPermissionAttachmentComponentType();
+  }
+}
+```
+
+In this system we listen for changes on the `PermissionAttachment` component inside of the `EntityStore`. This gives us access to `onComponentAdded`, `onComponentSet` and `onComponentRemoved` which in this example caches and persists permission data
+which is stored on a player inside of a custom `PermissionAttachment` component.
+
+## Queries
+
+Queries filter which entities a system processes. The ECS only passes entities to your system's `tick` method if they have all the components specified in the query.
+
+```java
+// Single component - any entity with PoisonComponent
+Query.and(poisonComponentType)
+
+// Multiple components - entities with both
+Query.and(poisonComponentType, Player.getComponentType())
+
+// Exclusion - players that aren't dead
+Query.and(Player.getComponentType(), Query.not(DeathComponent.getComponentType()))
+```
+
+## SystemGroups and Dependencies
+
+Systems can declare which group they belong to and what dependencies they have. This controls execution order which is critical for systems that interact.
+
+```java
+@Nullable
+@Override
+public SystemGroup<EntityStore> getGroup() {
+  return DamageModule.get().getGatherDamageGroup();
+}
+```
+
+For more complex ordering you can override `getDependencies`:
+
+```java
+@Nonnull
+public Set<Dependency<EntityStore>> getDependencies() {
+  return Set.of(
+    new SystemGroupDependency(Order.AFTER, DamageModule.get().getFilterDamageGroup()),
+    new SystemDependency(Order.BEFORE, PlayerSystems.ProcessPlayerInput.class)
+  );
+}
+```
+
+The damage system is a good example of why ordering matters. Hytale's damage pipeline has four stages: GatherDamageGroup collects damage sources, FilterDamageGroup applies reductions and cancellations, then damage is applied to health, and finally InspectDamageGroup handles side effects like particles and sounds. If these ran in the wrong order you'd play death animations before the entity dies or apply armor reduction after health is already subtracted.
+
+## Registering Components and Systems
+
+Components and systems must be registered during plugin setup. The `EntityStoreRegistry` handles this.
+
+```java
+public final class ExamplePlugin extends JavaPlugin {
+
+  private static ExamplePlugin instance;
+  private ComponentType<EntityStore, PoisonComponent> poisonComponent;
+
+  public ExamplePlugin(@Nonnull JavaPluginInit init) {
+    super(init);
+    instance = this;
+  }
+
+  @Override
+  protected void setup() {
+    this.getCommandRegistry().registerCommand(new ExampleCommand());
+    this.getEventRegistry().registerGlobal(PlayerReadyEvent.class, ExampleEvent::onPlayerReady);
+    this.getEventRegistry().registerGlobal(PlayerChatEvent.class, ChatFormatter::onPlayerChat);
+
+    this.poisonComponent = this.getEntityStoreRegistry()
+        .registerComponent(PoisonComponent.class, PoisonComponent::new);
+    this.getEntityStoreRegistry().registerSystem(new PoisonSystem(this.poisonComponent));
+  }
+
+  public ComponentType<EntityStore, PoisonComponent> getPoisonComponentType() {
+    return poisonComponent;
+  }
+
+  public static ExamplePlugin get() {
+    return instance;
+  }
+}
+```
+
+The `registerComponent` method returns a `ComponentType` which acts as a key for accessing that component type throughout your plugin. Store it as a field and pass it to any systems that need it. The second argument is a factory for creating default instances.
diff --git a/content/docs/bg-BG/guides/java-basics/00-introduction.mdx b/content/docs/bg-BG/guides/java-basics/00-introduction.mdx
new file mode 100644
index 00000000..b0130d74
--- /dev/null
+++ b/content/docs/bg-BG/guides/java-basics/00-introduction.mdx
@@ -0,0 +1,52 @@
+---
+title: 00 - Introduction to Java
+description: A beginner's guide to understanding the fundamentals of Java programming for Hytale modding.
+---
+
+Welcome to your journey into Java Programming! This guide is designed to introduce you into the basics of java.
+
+## What is Java?
+
+Java is a powerful, object-oriented programming language created in 1995. It's one of the most popular programming languages in the world and is used for everything from mobile apps to enterprise software. Most importantly for us, it's the language Hytale uses for its servers & modding API.
+
+## What You'll Learn
+
+This guide is structured to take you step-by-step through:
+
+1. Java Syntax and Basics
+2. Control Flow
+3. Object-Oriented Programming
+
+We will then focus on only Hytale-specific concepts. (tbd)
+
+## Setting up your Environment
+
+Before we dive into programming, you'll need some essentials, you need to install:
+
+### Java Development Kit (JDK)
+
+Download and install JDK 25 or above from the [official Oracle website](https://www.oracle.com/java/technologies/javase-jdk25-downloads.html) or use an open-source alternative like [AdoptOpenJDK](https://adoptopenjdk.net/).
+
+### Integrated Development Environment (IDE)
+
+An IDE is a software application that provides comprehensive facilities to programmers for software development. Popular choices for Java include:
+
+* [IntelliJ IDEA](https://www.jetbrains.com/idea/)
+* [Eclipse](https://www.eclipse.org/)
+
+## How to Use This Guide
+
+1. Read each article in order - Concepts build on each other
+2. Type out the examples - Don't copy-paste; typing helps you learn
+3. Experiment - Modify examples to see what happens
+4. Practice - Each article includes exercises
+5. Be patient - Programming is a skill that takes time to develop
+
+## The Modding Mindset
+
+Modding is creative problem-solving. You'll be:
+
+* Adding new blocks, items, and creatures to Hytale
+* Changing game mechanics to create unique experiences
+* Building systems that interact with the game world
+* Sharing your creations with the community
diff --git a/content/docs/bg-BG/guides/java-basics/01-variables.mdx b/content/docs/bg-BG/guides/java-basics/01-variables.mdx
new file mode 100644
index 00000000..ab375091
--- /dev/null
+++ b/content/docs/bg-BG/guides/java-basics/01-variables.mdx
@@ -0,0 +1,78 @@
+---
+title: 01 - Variables & Data Types
+description: An introduction to variables and data types in Java programming.
+---
+
+Variables are containers that store data in your program. Think of them as labeled boxes where you can put different types of information.
+
+## What is a Variable?
+
+A variable has three key components:
+
+1. **Type**: What kind of data it holds (e.g., integer, string, boolean)
+2. **Name**: The label you use to refer to the variable
+3. **Value**: The data it contains
+
+## Declaring/Creating Variables
+
+In Java, you must declare a variable before using it, like you'd need a box before putting something in it. The syntax is:
+
+```java
+int age; // A declaration
+age = 18; // An assignment
+
+int age = 18; // Declaration and assignment in one line, also considered an initialization
+```
+
+## Data Types
+
+You might wonder what "int" means. It's a primitive data type in Java. Java has 8 primitive and non-primitive (reference) data types.
+You will learn the difference between them later. Here are the most important ones for modding:
+
+| Data Type | Description                   | Example                    |
+| --------- | ----------------------------- | -------------------------- |
+| int       | Integer (whole numbers)       | `int score = 100;`         |
+| double    | Decimal numbers               | `double pi = 3.14;`        |
+| boolean   | True or false values          | `boolean isActive = true;` |
+| char      | Single character              | `char grade = 'A';`        |
+| String    | Sequence of characters (text) | `String name = "Hytale";`  |
+
+## Type Conversion
+
+Sometimes you might not want a variable to stay the same type. You can convert between types:
+
+### Automatic
+
+```java
+int num = 10;
+double decimalNum = num; // 10.0 - works automatically
+```
+
+### Manual (Casting)
+
+```java
+double decimalNum = 9.78;
+int num = (int) decimalNum; // 9 - decimals are dropped
+```
+
+## Constants
+
+If you want a variable that shouldn't change, use the `final` keyword:
+
+```java
+final double PI = 3.14159;
+```
+
+**Convention**: Constants use ALL_CAPS_WITH_UNDERSCORES.
+
+## Practice
+
+It's best to practice what you just learnt - don't look above now and try to do this yourself. If you get stuck, look back up!
+
+1. Declare an integer variable named `lives` and set it to 3.
+2. Declare a double variable named `gravity` and set it to 9.81.
+3. Declare a boolean variable named `isGameOver` and set it to false.
+4. Convert the `lives` variable to a double and store it in a new variable named `livesAsDouble`.
+5. Declare a constant named `MAX_LEVEL` and set it to 100.
+
+Great! You've learned about variables and data types in Java. Now we're going to learn about operators and expressions in the next lesson.
diff --git a/content/docs/bg-BG/guides/java-basics/02-operators.mdx b/content/docs/bg-BG/guides/java-basics/02-operators.mdx
new file mode 100644
index 00000000..18634665
--- /dev/null
+++ b/content/docs/bg-BG/guides/java-basics/02-operators.mdx
@@ -0,0 +1,128 @@
+---
+title: 02 - Operators and Expressions
+description: An introduction to operators and expressions in Java programming.
+---
+
+Operators are symbols that perform operations on variables and values. They're the verbs of programming - they make things happen!
+
+## Arithmetic Operators
+
+Used for mathematical calculations:
+
+```java
+int a = 10;
+int b = 5;
+
+int sum = a + b;        // Addition: 15
+int difference = a - b; // Subtraction: 5
+int product = a * b;    // Multiplication: 50
+int quotient = a / b;   // Division: 2
+int remainder = a % b;  // Modulus (remainder): 0
+```
+
+<Callout type="info" title="Division Note">
+  When dividing integers, Java performs integer division, which means it discards any decimal part. For example, `7 / 2` would result in `3`, not `3.5`.
+
+  ```java
+  int x = 7 / 2;       // 3 (not 3.5!) - Integer division
+  double y = 7.0 / 2;  // 3.5 - At least one double gives double result
+  double z = (double) 7 / 2;  // 3.5 - Casting works too
+  ```
+</Callout>
+
+### Modulus (%) - The remainder Operator
+
+The modulus operator returns the remainder of a division operation:
+
+```java
+int remainder = 10 % 3; // 1 (because 10 divided by 3 is 3 with a remainder of 1)
+```
+
+## Compound Assignment Operators
+
+These operators combine an arithmetic operation with assignment:
+
+```java
+int a = 10;
+
+a = a + 5;  // The old way
+
+a += 5;     // a = a + 5
+a -= 3;     // a = a - 3
+a *= 2;     // a = a * 2
+a /= 4;     // a = a / 4
+a %= 3;     // a = a % 3
+```
+
+## Increment and Decrement Operators
+
+Used to increase or decrease a variable's value by 1:
+
+```java
+int a = 5;
+a++; // Increment: a becomes 6
+a--; // Decrement: a becomes 5 again
+```
+
+<Callout type="info" title="Prefix vs Postfix">
+  ```java
+  int a = 5;
+  int b = a++; // b is 5, a is now 6
+  int c = ++a; // a is 7, c is now 7
+  ```
+</Callout>
+
+## Comparison Operators
+
+Used to compare two values, returning a boolean result (`true` or `false`):
+
+```java
+int a = 10;
+int b = 5;
+
+a == b // false - Equal to
+a != b // true  - Not equal to
+a > b  // true  - Greater than
+a < b  // false - Less than
+a >= b // true  - Greater than or equal to
+a <= b // false - Less than or equal to
+```
+
+## Logical Operators
+
+Used to combine multiple boolean expressions:
+
+```java
+boolean x = true;
+boolean y = false;
+
+x && y // false - Logical AND
+x || y // true  - Logical OR
+!x     // false - Logical NOT
+```
+
+### Combining Logical Operators
+
+```java
+boolean result = (a > b) && (b < 10); // true if both conditions are true
+```
+
+## String Concatenation
+
+The `+` operator can also be used to concatenate (join) strings:
+
+```java
+String greeting = "Hello, " + "world!"; // "Hello, world!"
+String name = "Alice";
+String greetingWithName = "Hello, " + name + "!"; // "Hello, Alice!"
+```
+
+## Operator Precedence
+
+Operator Precedence means which operator gets evaluated first in an line of code. Think of it like BODMAS/PEMDAS in math!
+
+```java
+int result = 10 + 5 * 2; // result is 20, not 30
+```
+
+{/* practice to be added */}
diff --git a/content/docs/bg-BG/guides/java-basics/03-control-flow-if.mdx b/content/docs/bg-BG/guides/java-basics/03-control-flow-if.mdx
new file mode 100644
index 00000000..af2d1c22
--- /dev/null
+++ b/content/docs/bg-BG/guides/java-basics/03-control-flow-if.mdx
@@ -0,0 +1,128 @@
+---
+title: 03 - Control Flow If Statements
+description: Learn how to control the flow of your Java programs using if statements.
+---
+
+Programs need to make decisions. If statements let your code choose different paths based on conditions.
+
+## Basic If Statement
+
+The simplest form checks one condition:
+
+```java
+int health = 20;
+
+if (health > 10) {
+    System.out.println("You are healthy!");
+}
+```
+
+### Structure
+
+```java
+if (condition) {
+    // code to execute if condition is true
+}
+```
+
+## If-Else Statements
+
+Choose between two paths:
+
+```java
+int health = 5;
+
+if (health > 10) {
+    System.out.println("You are healthy!");
+} else {
+    System.out.println("You need healing!");
+}
+```
+
+## If-Else Else-If Chain
+
+Check multiple conditions in sequence:
+
+```java
+
+int health = 7;
+
+if (health > 15) {
+    System.out.println("You are in great shape!");
+} else if (health > 5) {
+    System.out.println("You are okay.");
+} else {
+    System.out.println("You need healing!");
+}
+```
+
+## Nested If Statements
+
+You can place if statements inside other if statements:
+
+```java
+int health = 12;
+
+if (health > 10) {
+    if (health > 15) {
+        System.out.println("You are in great shape!");
+    } else {
+        System.out.println("You are healthy!");
+    }
+} else {
+    System.out.println("You need healing!");
+}
+```
+
+## Compound Conditions
+
+You can combine multiple conditions using logical operators:
+
+```java
+
+// AND - both must be true
+int health = 12;
+boolean hasPotion = true;
+
+if (health > 10 && hasPotion) {
+    System.out.println("You are healthy and have a potion!");
+} else if (health > 10) {
+    System.out.println("You are healthy but need a potion!");
+} else {
+    System.out.println("You need healing!");
+}
+
+// OR - at least one must be true
+
+int health = 8;
+boolean hasPotion = false;
+if (health > 10 || hasPotion) {
+    System.out.println("You are either healthy or have a potion!");
+} else {
+    System.out.println("You need healing and a potion!");
+}
+
+// NOT - reverses the condition
+
+int health = 8;
+if (!(health > 10)) {
+    System.out.println("You need healing!");
+} else {
+    System.out.println("You are healthy!");
+}
+```
+
+## Ternary Operator
+
+A compact way to assign values:
+
+```java
+int health = 12;
+String status = (health > 10) ? "Healthy" : "Needs Healing";
+```
+
+### Syntax
+
+```java
+variable = (condition) ? valueIfTrue : valueIfFalse;
+```
diff --git a/content/docs/bg-BG/guides/java-basics/04-control-flow-loops.mdx b/content/docs/bg-BG/guides/java-basics/04-control-flow-loops.mdx
new file mode 100644
index 00000000..8ff5b509
--- /dev/null
+++ b/content/docs/bg-BG/guides/java-basics/04-control-flow-loops.mdx
@@ -0,0 +1,165 @@
+---
+title: 04 - Control Flow Loops
+description: Learn how to repeat code efficiently using loops in Java
+---
+
+Loops let you repeat code without writing it over and over. They're essential for processing collections, generating worlds, and updating game objects.
+
+## While Loop
+
+Repeats code while a condition is true:
+
+```java tab="Code"
+
+int countdown = 5;
+
+while (countdown > 0) {
+    System.out.println(countdown);
+    countdown--;
+}
+System.out.println("Blast off!");
+```
+
+```java tab="Output"
+5
+4
+3
+2
+1
+Blast off!
+```
+
+### Structure
+
+```java
+while (condition) {
+    // code to repeat
+}
+```
+
+<Callout type="warning" title="Infinite Loops">
+  Always make sure your loop condition will eventually become false, or your program will run forever!
+
+  ```java tab="Bad Example"
+  int x = 0;
+  while (x < 10) {
+      System.out.println("Stuck!");
+      // Forgot to increase x!
+  }
+  ```
+
+  ```java tab="Good Example"
+  int x = 0;
+  while (x < 10) {
+      System.out.println("Counting: " + x);
+      x++; // This increases x! // [!code ++]
+  }
+  ```
+</Callout>
+
+## Do-While Loop
+
+Like a while loop, but always runs at least once:
+
+```java
+int health = 0;
+
+do {
+    System.out.println("Attempting respawn...");
+    health = 100;
+} while (health <= 0);
+```
+
+## For Loop
+
+Best when you know how many times to repeat:
+
+```java tab="Code"
+for (int i = 1; i <= 5; i++) {
+    System.out.println("Level " + i);
+}
+```
+
+```java tab="Output"
+Level 1
+Level 2
+Level 3
+Level 4
+Level 5
+```
+
+### Structure
+
+```java
+for (initialization; condition; update) {
+    // code to repeat
+}
+```
+
+<Callout type="info" title="For Loop Parts">
+  ```java
+  for (int i = 0; i < 10; i++) {
+  //   ^         ^        ^
+  //   Start     Stop     Step
+  }
+  ```
+
+  * **Initialization**: int i = 0 - Runs once at the start
+  * **Condition**: i < 10 - Checked before each loop
+  * **Update**: i++ - Runs after each loop
+</Callout>
+
+## Break Statement
+
+You can exit a loop early with `break`:
+
+```java
+
+for (int i = 1; i <= 10; i++) {
+    if (i == 6) {
+        break; // Exit loop when i is 6
+    }
+    System.out.println(i);
+}
+
+```
+
+## Continue Statement
+
+Skip to the next iteration with `continue`:
+
+```java
+for (int i = 1; i <= 10; i++) {
+    if (i % 2 == 0) {
+        continue; // Skip even numbers
+    }
+    System.out.println(i); // Prints only odd numbers
+}
+```
+
+## Nested Loops
+
+You can put loops inside other loops:
+
+```java
+for (int i = 1; i <= 3; i++) {
+    for (int j = 1; j <= 2; j++) {
+        System.out.println("i: " + i + ", j: " + j);
+    }
+}
+```
+
+<Callout type="warning" title="Nested Loop Performance">
+  Be careful with nested loops! They can slow down your mod significantly.
+
+  ```java
+  // This runs 1,000,000 times!
+  for (int i = 0; i < 1000; i++) {
+      for (int j = 0; j < 1000; j++) {
+          // Code here
+      }
+  }
+  ```
+
+  Try to avoid deeply nested loops when processing large amounts of data.
+</Callout>
diff --git a/content/docs/bg-BG/guides/java-basics/05-arrays.mdx b/content/docs/bg-BG/guides/java-basics/05-arrays.mdx
new file mode 100644
index 00000000..b00d18fb
--- /dev/null
+++ b/content/docs/bg-BG/guides/java-basics/05-arrays.mdx
@@ -0,0 +1,306 @@
+---
+title: 05 - Arrays
+description: Learn how to store and manage collections of data using arrays.
+---
+
+Arrays let you store multiple values of the same type in a single variable. Think of an array as a row of boxes, each holding one item.
+
+## Creating Arrays
+
+### Method 1: Declare and Initialize Separately
+
+```java
+int[] numbers;           // Declare
+numbers = new int[5];    // Create array with 5 spaces
+```
+
+### Method 2: All at Once
+
+```java
+int[] numbers = new int[5];
+```
+
+### Method 3: With Initial Values
+
+```java
+int[] numbers = {10, 20, 30, 40, 50};
+```
+
+<Callout type="info" title="Array Size">
+  Once you create an array, its size is **fixed**. You can't add or remove elements later!
+
+  ```java
+  int[] inventory = new int[9];  // Always has exactly 9 slots
+  ```
+</Callout>
+
+## Accessing Array Elements
+
+Arrays use **index** numbers starting from **0**:
+
+```java
+String[] players = {"Alice", "Bob", "Charlie"};
+
+System.out.println(players[0]); // "Alice"
+System.out.println(players[1]); // "Bob"
+System.out.println(players[2]); // "Charlie"
+```
+
+### Visual Representation
+
+| Index | 0       | 1     | 2         |
+| ----- | ------- | ----- | --------- |
+| Value | "Alice" | "Bob" | "Charlie" |
+
+## Modifying Array Values
+
+```java
+int[] health = {100, 80, 90};
+
+health[1] = 60;  // Change Bob's health to 60
+
+System.out.println(health[0]); // 100
+System.out.println(health[1]); // 60
+System.out.println(health[2]); // 90
+```
+
+## Array Length
+
+Use `.length` to get the size of an array:
+
+```java
+int[] scores = {45, 67, 89, 92, 55};
+System.out.println(scores.length); // 5
+```
+
+<Callout type="warning" title="Length is Not a Method">
+  Notice there are no parentheses! It's `array.length`, not `array.length()`.
+</Callout>
+
+## Looping Through Arrays
+
+### Using For Loop
+
+```java
+String[] items = {"Sword", "Shield", "Potion"};
+
+for (int i = 0; i < items.length; i++) {
+    System.out.println(items[i]);
+}
+```
+
+### Using Enhanced For Loop (For-Each)
+
+```java
+String[] items = {"Sword", "Shield", "Potion"};
+
+for (String item : items) {
+    System.out.println(item);
+}
+```
+
+<Callout type="info" title="Enhanced For Loop">
+  The enhanced for loop is simpler and safer, but you can't modify the array or know the current index.
+
+  ```java
+  // When you need the index
+  for (int i = 0; i < items.length; i++) {
+      System.out.println(i + ": " + items[i]);
+  }
+
+  // When you just need the values
+  for (String item : items) {
+      System.out.println(item);
+  }
+  ```
+</Callout>
+
+## Multidimensional Arrays
+
+Arrays can hold other arrays, creating a grid:
+
+```java
+int[][] grid = {
+    {1, 2, 3},
+    {4, 5, 6},
+    {7, 8, 9}
+};
+
+System.out.println(grid[0][0]); // 1
+System.out.println(grid[1][2]); // 6
+System.out.println(grid[2][1]); // 8
+```
+
+### Visual Representation
+
+|       | 0 | 1 | 2 |
+| ----- | - | - | - |
+| **0** | 1 | 2 | 3 |
+| **1** | 4 | 5 | 6 |
+| **2** | 7 | 8 | 9 |
+
+### Looping Through 2D Arrays
+
+```java tab="Code"
+int[][] grid = {
+    {1, 2, 3},
+    {4, 5, 6}
+};
+
+for (int row = 0; row < grid.length; row++) {
+    for (int col = 0; col < grid[row].length; col++) {
+        System.out.print(grid[row][col] + " ");
+    }
+    System.out.println();
+}
+```
+
+```java tab="Output"
+1 2 3
+4 5 6
+```
+
+## Practical Examples
+
+### Player Inventory System
+
+```java
+String[] inventory = new String[9]; // 9 hotbar slots
+
+// Add items
+inventory[0] = "Diamond Sword";
+inventory[1] = "Shield";
+inventory[8] = "Food";
+
+// Display inventory
+for (int i = 0; i < inventory.length; i++) {
+    if (inventory[i] != null) {
+        System.out.println("Slot " + i + ": " + inventory[i]);
+    } else {
+        System.out.println("Slot " + i + ": Empty");
+    }
+}
+```
+
+### Find Highest Score
+
+```java
+int[] scores = {45, 92, 67, 88, 55, 71};
+int highest = scores[0];
+
+for (int i = 1; i < scores.length; i++) {
+    if (scores[i] > highest) {
+        highest = scores[i];
+    }
+}
+
+System.out.println("Highest score: " + highest);
+```
+
+### Calculate Average
+
+```java
+double[] temperatures = {23.5, 25.0, 22.8, 24.3, 26.1};
+double sum = 0;
+
+for (double temp : temperatures) {
+    sum += temp;
+}
+
+double average = sum / temperatures.length;
+System.out.println("Average temperature: " + average);
+```
+
+### Block Grid (2D Array)
+
+```java
+String[][] terrain = new String[5][5];
+
+// Fill with grass
+for (int x = 0; x < 5; x++) {
+    for (int z = 0; z < 5; z++) {
+        terrain[x][z] = "grass";
+    }
+}
+
+// Place some stone
+terrain[2][2] = "stone";
+terrain[1][3] = "stone";
+
+// Display grid
+for (int x = 0; x < terrain.length; x++) {
+    for (int z = 0; z < terrain[x].length; z++) {
+        System.out.print(terrain[x][z] + " ");
+    }
+    System.out.println();
+}
+```
+
+## Common Array Operations
+
+### Copy an Array
+
+```java
+int[] original = {1, 2, 3, 4, 5};
+int[] copy = original.clone();
+
+// Or manually
+int[] copy2 = new int[original.length];
+for (int i = 0; i < original.length; i++) {
+    copy2[i] = original[i];
+}
+```
+
+### Search for a Value
+
+```java
+String[] items = {"Sword", "Shield", "Potion", "Bow"};
+String target = "Potion";
+int foundIndex = -1;
+
+for (int i = 0; i < items.length; i++) {
+    if (items[i].equals(target)) {
+        foundIndex = i;
+        break;
+    }
+}
+
+if (foundIndex != -1) {
+    System.out.println("Found at index: " + foundIndex);
+} else {
+    System.out.println("Not found");
+}
+```
+
+### Count Occurrences
+
+```java
+String[] blocks = {"stone", "dirt", "stone", "grass", "stone"};
+String searchFor = "stone";
+int count = 0;
+
+for (String block : blocks) {
+    if (block.equals(searchFor)) {
+        count++;
+    }
+}
+
+System.out.println(searchFor + " appears " + count + " times");
+```
+
+## Array Limitations
+
+<Callout type="warning" title="Fixed Size">
+  Arrays can't grow or shrink. If you need flexibility, you'll learn about `ArrayList` later!
+
+  ```java
+  int[] numbers = new int[5];
+  // Can't add a 6th element!
+
+  // If you need more space, create a new array
+  int[] bigger = new int[10];
+  for (int i = 0; i < numbers.length; i++) {
+      bigger[i] = numbers[i];
+  }
+  ```
+</Callout>
diff --git a/content/docs/bg-BG/guides/java-basics/06-methods-functions.mdx b/content/docs/bg-BG/guides/java-basics/06-methods-functions.mdx
new file mode 100644
index 00000000..5b24e32b
--- /dev/null
+++ b/content/docs/bg-BG/guides/java-basics/06-methods-functions.mdx
@@ -0,0 +1,436 @@
+---
+title: 06 - Methods (Functions)
+description: Learn how to organize and reuse code with methods.
+---
+
+Methods are reusable blocks of code that perform specific tasks. They help you avoid repeating code and make your programs easier to understand.
+
+## What is a Method?
+
+Think of a method as a recipe. You define it once, then use it whenever you need it.
+
+```java tab="Code"
+public class Game {
+    public static void main(String[] args) {
+        greet();        // Call the method
+        greet();        // Call it again!
+    }
+    
+    // Method definition
+    public static void greet() {
+        System.out.println("Welcome to Hytale!");
+    }
+}
+```
+
+```text tab="Output"
+Welcome to Hytale!
+Welcome to Hytale!
+```
+
+## Method Structure
+
+```java
+public static void methodName() {
+//  ^      ^     ^      ^       ^
+//  |      |     |      |       |
+// access static return name  parameters
+// modifier       type
+    // Code goes here
+}
+```
+
+We'll learn what `public` and `static` mean later. For now, just use them.
+
+## Methods with Parameters
+
+Parameters let you pass data into methods:
+
+```java
+public static void greetPlayer(String name) {
+    System.out.println("Hello, " + name + "!");
+}
+
+public static void main(String[] args) {
+    greetPlayer("Alice");  // Hello, Alice!
+    greetPlayer("Bob");    // Hello, Bob!
+}
+```
+
+### Multiple Parameters
+
+```java
+public static void dealDamage(String target, int damage) {
+    System.out.println(target + " takes " + damage + " damage!");
+}
+
+public static void main(String[] args) {
+    dealDamage("Zombie", 20);    // Zombie takes 20 damage!
+    dealDamage("Skeleton", 15);  // Skeleton takes 15 damage!
+}
+```
+
+<Callout type="info" title="Parameter Order Matters">
+  When calling a method, arguments must match the parameter order:
+
+  ```java
+  public static void createItem(String name, int quantity, double price) {
+      // ...
+  }
+
+  // Correct
+  createItem("Sword", 1, 50.0);
+
+  // Wrong - Order matters!
+  createItem(1, "Sword", 50.0);  // Error!
+  ```
+</Callout>
+
+## Methods with Return Values
+
+Methods can send data back using `return`:
+
+```java
+public static int add(int a, int b) {
+    int sum = a + b;
+    return sum;
+}
+
+public static void main(String[] args) {
+    int result = add(5, 3);
+    System.out.println(result);  // 8
+}
+```
+
+The return type must match what you return:
+
+* `void` - Returns nothing
+* `int` - Returns an integer
+* `double` - Returns a decimal
+* `boolean` - Returns true/false
+* `String` - Returns text
+
+```java
+public static String getItemName() {
+    return "Diamond Sword";
+}
+
+public static boolean isPlayerAlive(int health) {
+    return health > 0;
+}
+
+public static double calculateDamage(int attack, double multiplier) {
+    return attack * multiplier;
+}
+```
+
+<Callout type="warning" title="Return Stops Execution">
+  Once a method hits `return`, it immediately exits. Code after `return` won't run!
+
+  ```java
+  public static int getValue() {
+      return 10;
+      System.out.println("This never runs!");  // Unreachable code!
+  }
+  ```
+</Callout>
+
+## Practical Examples
+
+### Health System
+
+```java tab="Code"
+public static void displayHealth(String name, int health, int maxHealth) {
+    double percentage = (health * 100.0) / maxHealth;
+    System.out.println(name + ": " + health + "/" + maxHealth + 
+                      " (" + percentage + "%)");
+}
+
+public static void main(String[] args) {
+    displayHealth("Player", 75, 100);
+    displayHealth("Boss", 450, 500);
+}
+```
+
+```text tab="Output"
+Player: 75/100 (75.0%)
+Boss: 450/500 (90.0%)
+```
+
+### Damage Calculator
+
+```java tab="Code"
+public static int calculateDamage(int baseAttack, int weaponDamage, boolean isCritical) {
+    int totalDamage = baseAttack + weaponDamage;
+    
+    if (isCritical) {
+        totalDamage *= 2;
+    }
+    
+    return totalDamage;
+}
+
+public static void main(String[] args) {
+    int damage1 = calculateDamage(10, 15, false);  // 25
+    int damage2 = calculateDamage(10, 15, true);   // 50
+    
+    System.out.println("Normal hit: " + damage1);
+    System.out.println("Critical hit: " + damage2);
+}
+```
+
+### Level Requirements
+
+```java tab="Code"
+public static int getXPForLevel(int level) {
+    return level * 100;
+}
+
+public static boolean canLevelUp(int currentXP, int currentLevel) {
+    int required = getXPForLevel(currentLevel + 1);
+    return currentXP >= required;
+}
+
+public static void main(String[] args) {
+    int playerXP = 450;
+    int playerLevel = 4;
+    
+    if (canLevelUp(playerXP, playerLevel)) {
+        System.out.println("You can level up!");
+    } else {
+        int needed = getXPForLevel(playerLevel + 1) - playerXP;
+        System.out.println("Need " + needed + " more XP");
+    }
+}
+```
+
+### Distance Calculator
+
+```java tab="Code"
+public static double calculateDistance(int x1, int y1, int x2, int y2) {
+    int dx = x2 - x1;
+    int dy = y2 - y1;
+    return Math.sqrt(dx * dx + dy * dy);
+}
+
+public static boolean isInRange(int x1, int y1, int x2, int y2, double range) {
+    double distance = calculateDistance(x1, y1, x2, y2);
+    return distance <= range;
+}
+
+public static void main(String[] args) {
+    // Check if enemy is in attack range
+    if (isInRange(0, 0, 5, 5, 10.0)) {
+        System.out.println("Target in range!");
+    }
+}
+```
+
+## Method Overloading
+
+You can have multiple methods with the same name but different parameters:
+
+```java
+public static void displayMessage(String message) {
+    System.out.println(message);
+}
+
+public static void displayMessage(String message, int times) {
+    for (int i = 0; i < times; i++) {
+        System.out.println(message);
+    }
+}
+
+public static void main(String[] args) {
+    displayMessage("Hello");           // Calls first version
+    displayMessage("Hello", 3);        // Calls second version
+}
+```
+
+<Callout type="info" title="Method Overloading Rules">
+  Methods are considered different if they have:
+
+  * Different number of parameters
+  * Different types of parameters
+  * Different order of parameters
+
+  ```java
+  public static void test(int a) { }
+  public static void test(int a, int b) { }        // Different count
+  public static void test(double a) { }            // Different type
+  public static void test(String a, int b) { }     // Different types
+  public static void test(int a, String b) { }     // Different order
+
+  // Wrong - Only return type is different
+  public static int test(int a) { }
+  ```
+</Callout>
+
+## Common Patterns in Hytale Modding
+
+### Item Creation
+
+```java
+public static Item createItem(String name, int durability) {
+    Item item = new Item();
+    item.setName(name);
+    item.setDurability(durability);
+    return item;
+}
+
+public static Item createSword() {
+    return createItem("Sword", 100);
+}
+
+public static Item createPickaxe() {
+    return createItem("Pickaxe", 150);
+}
+```
+
+### Block Placement Validation
+
+```java
+public static boolean canPlaceBlock(int x, int y, int z) {
+    // Check if position is valid
+    if (y < 0 || y > 255) {
+        return false;
+    }
+    
+    // Check if block already exists
+    if (isBlockAt(x, y, z)) {
+        return false;
+    }
+    
+    return true;
+}
+
+public static void placeBlock(int x, int y, int z, String type) {
+    if (canPlaceBlock(x, y, z)) {
+        // Place the block
+        System.out.println("Placed " + type + " at (" + x + ", " + y + ", " + z + ")");
+    } else {
+        System.out.println("Cannot place block there!");
+    }
+}
+```
+
+### Player State Checks
+
+```java
+public static boolean isLowHealth(int health, int maxHealth) {
+    return (health * 100.0 / maxHealth) < 25;
+}
+
+public static String getHealthStatus(int health, int maxHealth) {
+    double percentage = (health * 100.0) / maxHealth;
+    
+    if (percentage >= 75) {
+        return "Healthy";
+    } else if (percentage >= 50) {
+        return "Injured";
+    } else if (percentage >= 25) {
+        return "Critical";
+    } else {
+        return "Near Death";
+    }
+}
+```
+
+## Best Practices
+
+<Callout type="info" title="Method Naming">
+  Use descriptive verb-based names that explain what the method does:
+
+  ```java
+  // Good
+  public static void calculateDamage() { }
+  public static boolean isPlayerAlive() { }
+  public static String getItemName() { }
+  public static void displayInventory() { }
+
+  // Bad
+  public static void dmg() { }        // Too short
+  public static void method1() { }    // Not descriptive
+  public static void stuff() { }      // Too vague
+  ```
+</Callout>
+
+## Practice Exercises
+
+1. **Temperature Converter**: Write methods to convert:
+   * Celsius to Fahrenheit: `(C × 9/5) + 32`
+   * Fahrenheit to Celsius: `(F - 32) × 5/9`
+
+2. **Circle Calculator**: Create methods that calculate:
+   * Area: `π × radius²`
+   * Circumference: `2 × π × radius`
+   * Use `Math.PI` for π
+
+3. **Item Durability**: Write these methods:
+   * `damageItem(int current, int damage)` - returns new durability
+   * `isBroken(int durability)` - returns true if durability is less than or equal to 0
+   * `repairItem(int current, int max)` - returns max durability
+
+4. **Password Validator**: Create a method that checks if a password is valid:
+   * At least 8 characters long
+   * Contains at least one number
+   * Returns true if valid, false otherwise
+
+<Callout type="info" title="Division Note">
+  When writing a password validator, you may need a way to compare array values. For example:
+
+  ```java
+  String[] array1 = {"Apple", "Banana"};
+  String[] array2 = {"Apple", "Banana"};
+
+  //Wrong:
+  array1[0] == array2[0];       // false
+  /*
+  Array is a non-primitive data type. Java compares reference (non-primitive) data types by 
+  their location in Java's memory, not by their values.
+  */
+
+  // To compare the actual values of reference data types, use the .equals() method:
+  array1[0].equals(array2[0]);       // true 
+
+  // This does not apply to primitive data types.
+  ```
+</Callout>
+
+## Common Mistakes
+
+```java
+// Wrong - Forgetting return statement
+public static int getValue() {
+    int x = 10;
+    // Forgot to return!
+} !
+
+// Correct
+public static int getValue() {
+    int x = 10;
+    return x;
+}
+
+// Wrong - Wrong return type
+public static int getText() {
+    return "Hello";  // Error! Should return int, not String
+}
+
+// Correct
+public static String getText() {
+    return "Hello";
+}
+
+// Wrong - Not calling the method
+public static void main(String[] args) {
+    greet;  // Error! Missing ()
+}
+
+// Correct
+public static void main(String[] args) {
+    greet();
+}
+```
+
+---
diff --git a/content/docs/bg-BG/guides/java-basics/07-introduction-oop.mdx b/content/docs/bg-BG/guides/java-basics/07-introduction-oop.mdx
new file mode 100644
index 00000000..058b7e5e
--- /dev/null
+++ b/content/docs/bg-BG/guides/java-basics/07-introduction-oop.mdx
@@ -0,0 +1,378 @@
+---
+title: 07 - Introduction to Object-Oriented Programming
+description: Learn the fundamentals of classes and objects in Java.
+---
+
+Object-Oriented Programming (OOP) is the foundation of Java and Hytale modding. Instead of just having variables and methods floating around, we organize them into **classes** and **objects**.
+
+## What is a Class?
+
+A class is a blueprint for creating objects. Think of it like a recipe or a template.
+
+```java
+public class Player {
+    // Properties (data)
+    String name;
+    int health;
+    int level;
+    
+    // Behavior (methods)
+    public void takeDamage(int damage) {
+        health -= damage;
+        System.out.println(name + " took " + damage + " damage!");
+    }
+}
+```
+
+## What is an Object?
+
+An object is an instance created from a class. If a class is a blueprint, an object is the actual thing built from that blueprint.
+
+```java
+public class Main {
+    public static void main(String[] args) {
+        // Create objects from the Player class
+        Player player1 = new Player();
+        player1.name = "Alice";
+        player1.health = 100;
+        player1.level = 5;
+        
+        Player player2 = new Player();
+        player2.name = "Bob";
+        player2.health = 80;
+        player2.level = 3;
+        
+        // Use the objects
+        player1.takeDamage(20);  // Alice took 20 damage!
+        player2.takeDamage(15);  // Bob took 15 damage!
+    }
+}
+```
+
+<Callout type="info" title="Class vs Object">
+  **Class** = Blueprint (the idea of a player)
+  **Object** = Actual thing (Alice, Bob, specific players)
+
+  One class can create many objects, just like one recipe can make many cakes!
+</Callout>
+
+## Creating a Simple Class
+
+Let's create a `Sword` class for Hytale:
+
+```java
+public class Sword {
+    // Properties
+    String name;
+    int damage;
+    int durability;
+    
+    // Method to use the sword
+    public void attack(String target) {
+        System.out.println("Attacking " + target + " for " + damage + " damage!");
+        durability -= 1;
+        
+        if (durability <= 0) {
+            System.out.println(name + " broke!");
+        }
+    }
+    
+    // Method to display info
+    public void displayInfo() {
+        System.out.println("Weapon: " + name);
+        System.out.println("Damage: " + damage);
+        System.out.println("Durability: " + durability);
+    }
+}
+```
+
+Using the class:
+
+```java
+public class Main {
+    public static void main(String[] args) {
+        Sword sword = new Sword();
+        sword.name = "Iron Sword";
+        sword.damage = 15;
+        sword.durability = 3;
+        
+        sword.displayInfo();
+        sword.attack("Zombie");
+        sword.attack("Skeleton");
+        sword.attack("Spider");  // This will break the sword
+    }
+}
+```
+
+## Constructors
+
+Instead of setting properties one by one, use a **constructor** to initialize objects:
+
+```java
+public class Sword {
+    String name;
+    int damage;
+    int durability;
+    
+    // Constructor
+    public Sword(String weaponName, int weaponDamage, int weaponDurability) {
+        name = weaponName;
+        damage = weaponDamage;
+        durability = weaponDurability;
+    }
+    
+    public void attack(String target) {
+        System.out.println("Attacking " + target + " for " + damage + " damage!");
+        durability--;
+    }
+}
+```
+
+Now creating swords is easier:
+
+```java
+public class Main {
+    public static void main(String[] args) {
+        // Much cleaner!
+        Sword ironSword = new Sword("Iron Sword", 15, 100);
+        Sword diamondSword = new Sword("Diamond Sword", 25, 200);
+        
+        ironSword.attack("Zombie");
+        diamondSword.attack("Boss");
+    }
+}
+```
+
+<Callout type="info" title="Constructor Rules">
+  * Same name as the class
+  * No return type (not even `void`)
+  * Called automatically when you use `new`
+  * Can have multiple constructors (overloading)
+
+  ```java
+  public class Item {
+      String name;
+      int value;
+      
+      // Constructor with all parameters
+      public Item(String name, int value) {
+          this.name = name;
+          this.value = value;
+      }
+      
+      // Constructor with just name
+      public Item(String name) {
+          this.name = name;
+          this.value = 0;  // Default value
+      }
+  }
+  ```
+</Callout>
+
+## The `this` Keyword
+
+`this` refers to the current object. Use it to clarify when parameter names match property names:
+
+```java
+public class Player {
+    String name;
+    int health;
+    
+    public Player(String name, int health) {
+        this.name = name;      // this.name = the property
+        this.health = health;  // name = the parameter
+    }
+}
+```
+
+Without `this`, Java gets confused:
+
+```java
+public Player(String name, int health) {
+    name = name;      // ❌ Which name? Ambiguous!
+    health = health;  // ❌ Which health? Ambiguous!
+}
+```
+
+## Practical Examples
+
+### Item Class
+
+```java
+public class Item {
+    String name;
+    String type;
+    int quantity;
+    double weight;
+    
+    public Item(String name, String type, int quantity, double weight) {
+        this.name = name;
+        this.type = type;
+        this.quantity = quantity;
+        this.weight = weight;
+    }
+    
+    public void use() {
+        if (quantity > 0) {
+            quantity--;
+            System.out.println("Used " + name + ". Remaining: " + quantity);
+        } else {
+            System.out.println("No more " + name + " left!");
+        }
+    }
+    
+    public double getTotalWeight() {
+        return weight * quantity;
+    }
+}
+```
+
+```java
+public class Main {
+    public static void main(String[] args) {
+        Item potion = new Item("Health Potion", "Consumable", 5, 0.5);
+        
+        potion.use();  // Used Health Potion. Remaining: 4
+        System.out.println("Total weight: " + potion.getTotalWeight()); // 2.0
+    }
+}
+```
+
+### Monster Class
+
+```java
+public class Monster {
+    String name;
+    int health;
+    int attack;
+    boolean isHostile;
+    
+    public Monster(String name, int health, int attack, boolean isHostile) {
+        this.name = name;
+        this.health = health;
+        this.attack = attack;
+        this.isHostile = isHostile;
+    }
+    
+    public void takeDamage(int damage) {
+        health -= damage;
+        System.out.println(name + " took " + damage + " damage!");
+        
+        if (health <= 0) {
+            System.out.println(name + " was defeated!");
+        } else {
+            System.out.println(name + " has " + health + " health left.");
+        }
+    }
+    
+    public int attackPlayer() {
+        if (isHostile && health > 0) {
+            System.out.println(name + " attacks for " + attack + " damage!");
+            return attack;
+        }
+        return 0;
+    }
+    
+    public boolean isAlive() {
+        return health > 0;
+    }
+}
+```
+
+```java
+public class Main {
+    public static void main(String[] args) {
+        Monster zombie = new Monster("Zombie", 50, 10, true);
+        Monster chicken = new Monster("Chicken", 10, 0, false);
+        
+        zombie.takeDamage(20);        // Zombie took 20 damage!
+        int damage = zombie.attackPlayer();  // Zombie attacks for 10 damage!
+        
+        if (zombie.isAlive()) {
+            System.out.println("Monster is still alive!");
+        }
+    }
+}
+```
+
+### Block Class
+
+```java
+public class Block {
+    String type;
+    int x, y, z;
+    boolean isSolid;
+    int hardness;
+    
+    public Block(String type, int x, int y, int z, boolean isSolid, int hardness) {
+        this.type = type;
+        this.x = x;
+        this.y = y;
+        this.z = z;
+        this.isSolid = isSolid;
+        this.hardness = hardness;
+    }
+    
+    public void breakBlock() {
+        System.out.println("Breaking " + type + " block at (" + x + ", " + y + ", " + z + ")");
+        System.out.println("Hardness: " + hardness);
+    }
+    
+    public String getPosition() {
+        return "(" + x + ", " + y + ", " + z + ")";
+    }
+    
+    public boolean canWalkThrough() {
+        return !isSolid;
+    }
+}
+```
+
+## Access Modifiers (Preview)
+
+You've seen `public` - it means "anyone can access this". We'll learn more about access control later, but here's a preview:
+
+```java
+public class Example {
+    public String publicVar;      // Anyone can access
+    private String privateVar;    // Only this class can access
+    /* (no modifier) */ String defaultVar; // Package access
+}
+```
+
+For now, use `public` for everything. We'll learn when to use `private` in the next article.
+
+<Callout type="info" title="Why Use Classes?">
+  Classes help you:
+
+  * **Organize** related data and methods together
+  * **Reuse** code easily (create many objects from one class)
+  * **Model** real-world things (players, items, monsters)
+  * **Maintain** code (changes in one place affect all objects)
+
+  Without classes, managing 100 players would require 100 separate variables for each property. With classes, it's just 100 Player objects!
+</Callout>
+
+## Practice Exercises
+
+1. **Create a `Potion` Class**:
+   * Properties: name, healAmount, uses
+   * Constructor to set all properties
+   * Method `drink()` that heals and decreases uses
+   * Method `isEmpty()` that returns true if uses less than or equal to 0
+
+2. **Create a `Chest` Class**:
+   * Properties: isLocked, itemCount, capacity
+   * Constructor
+   * Method `addItem()` that checks capacity
+   * Method `unlock()` that sets isLocked to false
+   * Method `isFull()` that checks if itemCount >= capacity
+
+3. **Create a `Villager` Class**:
+   * Properties: name, profession, tradeCount
+   * Constructor
+   * Method `greet()` that prints a greeting
+   * Method `trade()` that increases tradeCount
+   * Method `getInfo()` that displays all properties
+
+4. **Create Multiple Objects**: Using any class you made, create 3 different objects and test all their methods.
diff --git a/content/docs/bg-BG/guides/java-basics/08-access-modifiers.mdx b/content/docs/bg-BG/guides/java-basics/08-access-modifiers.mdx
new file mode 100644
index 00000000..da2bf33b
--- /dev/null
+++ b/content/docs/bg-BG/guides/java-basics/08-access-modifiers.mdx
@@ -0,0 +1,595 @@
+---
+title: 08 - Encapsulation and Access Modifiers
+description: Learn how to protect and control access to your class data.
+---
+
+Encapsulation is about hiding the internal details of a class and controlling how its data is accessed and modified. This prevents bugs and makes your code more maintainable.
+
+## The Problem Without Encapsulation
+
+```java
+public class Player {
+    public String name;
+    public int health;
+    public int maxHealth;
+}
+
+public class Main {
+    public static void main(String[] args) {
+        Player player = new Player();
+        player.health = 100;
+        player.maxHealth = 100;
+        
+        // Oops! Someone can break the rules
+        player.health = 500;      // Health over maximum!
+        player.health = -50;      // Negative health!
+        player.name = "";         // Empty name!
+    }
+}
+```
+
+Without protection, anyone can set invalid values!
+
+## Access Modifiers
+
+Java has keywords that control who can access your class members:
+
+| Modifier    | Class | Package | Subclass | World |
+| ----------- | ----- | ------- | -------- | ----- |
+| `public`    | ✓     | ✓       | ✓        | ✓     |
+| `protected` | ✓     | ✓       | ✓        | ✗     |
+| (none)      | ✓     | ✓       | ✗        | ✗     |
+| `private`   | ✓     | ✗       | ✗        | ✗     |
+
+**For now, focus on:**
+
+* `public` - Anyone can access
+* `private` - Only this class can access
+
+## Making Properties Private
+
+```java
+public class Player {
+    private String name;
+    private int health;
+    private int maxHealth;
+    
+    public Player(String name, int maxHealth) {
+        this.name = name;
+        this.health = maxHealth;
+        this.maxHealth = maxHealth;
+    }
+}
+```
+
+Now you can't access properties directly:
+
+```java
+Player player = new Player("Alice", 100);
+player.health = 500;  // ❌ Error! health is private
+```
+
+## Getters and Setters
+
+To access private properties, create **getter** and **setter** methods:
+
+```java
+public class Player {
+    private String name;
+    private int health;
+    private int maxHealth;
+    
+    public Player(String name, int maxHealth) {
+        this.name = name;
+        this.health = maxHealth;
+        this.maxHealth = maxHealth;
+    }
+    
+    // Getter - returns the value
+    public int getHealth() {
+        return health;
+    }
+    
+    // Setter - sets the value with validation
+    public void setHealth(int health) {
+        if (health < 0) {
+            this.health = 0;
+        } else if (health > maxHealth) {
+            this.health = maxHealth;
+        } else {
+            this.health = health;
+        }
+    }
+    
+    public String getName() {
+        return name;
+    }
+    
+    public int getMaxHealth() {
+        return maxHealth;
+    }
+}
+```
+
+Now you can safely interact with the object:
+
+```java
+Player player = new Player("Alice", 100);
+
+player.setHealth(150);  // Automatically capped at 100
+System.out.println(player.getHealth());  // 100
+
+player.setHealth(-20);  // Automatically set to 0
+System.out.println(player.getHealth());  // 0
+```
+
+<Callout type="info" title="Getter and Setter Naming">
+  Follow Java naming conventions:
+
+  * **Getter**: `get` + property name (capitalized)
+  * **Setter**: `set` + property name (capitalized)
+  * **Boolean**: `is` + property name (capitalized)
+
+  ```java
+  private int health;
+  public int getHealth() { }
+  public void setHealth(int health) { }
+
+  private boolean alive;
+  public boolean isAlive() { }
+  public void setAlive(boolean alive) { }
+
+  private String name;
+  public String getName() { }
+  public void setName(String name) { }
+  ```
+</Callout>
+
+## Benefits of Encapsulation
+
+### 1. Validation
+
+```java
+public class Item {
+    private int durability;
+    private int maxDurability;
+    
+    public void setDurability(int durability) {
+        if (durability < 0) {
+            this.durability = 0;
+        } else if (durability > maxDurability) {
+            this.durability = maxDurability;
+        } else {
+            this.durability = durability;
+        }
+    }
+    
+    public boolean isBroken() {
+        return durability <= 0;
+    }
+}
+```
+
+### 2. Read-Only Properties
+
+Sometimes you don't want a setter:
+
+```java
+public class Monster {
+    private String id;  // Should never change
+    private int health;
+    
+    public Monster(String id, int health) {
+        this.id = id;
+        this.health = health;
+    }
+    
+    // Getter only - no setter!
+    public String getId() {
+        return id;
+    }
+    
+    public int getHealth() {
+        return health;
+    }
+    
+    public void setHealth(int health) {
+        this.health = health;
+    }
+}
+```
+
+### 3. Computed Properties
+
+Getters don't have to return a field directly:
+
+```java
+public class Player {
+    private int health;
+    private int maxHealth;
+    
+    public int getHealth() {
+        return health;
+    }
+    
+    // Computed property
+    public double getHealthPercentage() {
+        return (health * 100.0) / maxHealth;
+    }
+    
+    // Computed property
+    public boolean isLowHealth() {
+        return getHealthPercentage() < 25;
+    }
+}
+```
+
+## Practical Examples
+
+### Item with Durability
+
+```java
+public class Tool {
+    private String name;
+    private int durability;
+    private int maxDurability;
+    private boolean broken;
+    
+    public Tool(String name, int maxDurability) {
+        this.name = name;
+        this.durability = maxDurability;
+        this.maxDurability = maxDurability;
+        this.broken = false;
+    }
+    
+    public void use() {
+        if (broken) {
+            System.out.println(name + " is broken!");
+            return;
+        }
+        
+        durability--;
+        System.out.println(name + " used. Durability: " + durability);
+        
+        if (durability <= 0) {
+            broken = true;
+            System.out.println(name + " broke!");
+        }
+    }
+    
+    public void repair() {
+        durability = maxDurability;
+        broken = false;
+        System.out.println(name + " repaired!");
+    }
+    
+    // Getters
+    public String getName() {
+        return name;
+    }
+    
+    public int getDurability() {
+        return durability;
+    }
+    
+    public boolean isBroken() {
+        return broken;
+    }
+    
+    public double getDurabilityPercentage() {
+        return (durability * 100.0) / maxDurability;
+    }
+}
+```
+
+### Bank Account Example
+
+```java
+public class PlayerWallet {
+    private int gold;
+    private int silver;
+    
+    public PlayerWallet() {
+        this.gold = 0;
+        this.silver = 0;
+    }
+    
+    public void addGold(int amount) {
+        if (amount > 0) {
+            gold += amount;
+            System.out.println("Added " + amount + " gold");
+        }
+    }
+    
+    public boolean spendGold(int amount) {
+        if (amount > gold) {
+            System.out.println("Not enough gold!");
+            return false;
+        }
+        
+        gold -= amount;
+        System.out.println("Spent " + amount + " gold");
+        return true;
+    }
+    
+    public int getGold() {
+        return gold;
+    }
+    
+    public int getTotalValue() {
+        // 1 gold = 100 silver
+        return gold * 100 + silver;
+    }
+}
+```
+
+### Protected Block System
+
+```java
+public class ProtectedBlock {
+    private int x, y, z;
+    private String type;
+    private String owner;
+    private boolean locked;
+    
+    public ProtectedBlock(int x, int y, int z, String type, String owner) {
+        this.x = x;
+        this.y = y;
+        this.z = z;
+        this.type = type;
+        this.owner = owner;
+        this.locked = true;
+    }
+    
+    public boolean canBreak(String playerName) {
+        if (!locked) {
+            return true;
+        }
+        
+        return playerName.equals(owner);
+    }
+    
+    public void unlock(String playerName) {
+        if (playerName.equals(owner)) {
+            locked = false;
+            System.out.println("Block unlocked");
+        } else {
+            System.out.println("You don't own this block!");
+        }
+    }
+    
+    // Getters only - position and owner shouldn't change
+    public int getX() {
+        return x;
+    }
+    
+    public int getY() {
+        return y;
+    }
+    
+    public int getZ() {
+        return z;
+    }
+    
+    public String getOwner() {
+        return owner;
+    }
+    
+    public boolean isLocked() {
+        return locked;
+    }
+}
+```
+
+## When to Use Private vs Public
+
+<Callout type="info" title="General Rules">
+  **Make it private by default!** Only make things public if they need to be accessed from outside.
+
+  **Private:**
+
+  * Internal data (health, position, inventory)
+  * Helper methods used only within the class
+  * Anything that needs validation
+
+  **Public:**
+
+  * Methods that define the class's behavior
+  * Constructor
+  * Methods other classes need to call
+
+  ```java
+  public class Example {
+      // Private - internal data
+      private int internalCounter;
+      private String secretKey;
+      
+      // Public - part of the interface
+      public void doSomething() {
+          // Uses private helper method
+          validateData();
+      }
+      
+      // Private - internal helper
+      private void validateData() {
+          // ...
+      }
+  }
+  ```
+</Callout>
+
+## The `final` Keyword
+
+`final` means a variable can't be changed after it's set:
+
+```java
+public class Player {
+    private final String id;  // Can't change after creation
+    private String name;      // Can change
+    private int health;       // Can change
+    
+    public Player(String id, String name) {
+        this.id = id;
+        this.name = name;
+    }
+    
+    public String getId() {
+        return id;
+    }
+    
+    // No setId() - it's final!
+    
+    public String getName() {
+        return name;
+    }
+    
+    public void setName(String name) {
+        this.name = name;
+    }
+}
+```
+
+## The `static` Keyword
+
+### Static Members
+
+A class can define two kinds of members:
+
+* **Instance members** — owned by each object (each instance has its own copy).
+
+* **Static members** — owned by the class (one shared copy for the entire type).
+
+Put simply: instance members belong to objects; static members belong to the class itself and are shared by all objects of that type.
+
+#### Declaration
+
+```java
+    /* (access modifier) */ static ... memberName; 
+```
+
+#### Example
+
+```java
+class Data {
+    public int x; // Instanced member
+    public static int y = 1000; // Static member
+
+    // Instanced member:
+    // can access to both static and non-static members
+    public void foo() {
+        x = 100; // OK - same as this.x = 100;
+        y = 100; // OK - same as Data.y = 200;
+    }
+
+    // Static member:
+    // cannot access to non-static variables
+    public static void bar() {
+        x = 100; // Error: non-static variable x cannot be referenced from a static context
+        y = 100; // OK
+    }
+}
+```
+
+#### Accessing static members
+
+```java
+Data data = new Data();
+data.x = 1000; // OK
+
+data.y = 1000; // OK-ish - not really suggested; it's better to use Data.y
+Data.y = 1000; // OK - best practice
+
+Data.x = 1000; // Error: cannot access instanced variables in a static context
+```
+
+### Static Fields
+
+A static field represents a data member owned by the class type rather than the object. Static fields are also stored in a specific memory location that's been shared between all the object instances that are created.
+
+It is declared as following:
+
+```java
+/* (access modifier) (optional) */ static /* final/volatile (optional) */ fieldName;
+```
+
+Let's take the same Data class example and add this constructor:
+
+```java
+public Data() {
+    y++; // remember that's the same as Data.y++;
+}
+```
+
+```java
+// Every instance of Data will have a private copy of the instanced member x
+// However it will point to the same location in memory for the member y
+Data d1 = new Data(); // y = 1001
+d1.x = 5;
+Data d2 = new Data(); // y = 1002
+d2.x = 25;
+Data d3 = new Data(); // y = 1003
+// ... and so on
+```
+
+### Static Methods
+
+Static methods essentially represent a function member of a certain class type
+
+From the Data class remember the function (instanced method) `foo` and (static method) `bar`
+
+One can access those methods via:
+
+```java
+Data d1 = new Data();
+
+d1.foo(); // Instanced method: Accessible ONLY by an object
+
+Data.bar(); // Static method: accessible without an object
+```
+
+### Static Initializer
+
+Use a *static initializer* block to run initialization logic when the class is first loaded:
+
+```java
+class OtherData {
+    private static int a = 12;
+    private static int b;
+    private static String msg;
+
+    static {
+        msg = "Initialization..."
+        System.out.println(msg);
+        b = 4;
+        // ... complex initialization that can't be done in a single expression
+    }
+}
+```
+
+## Practice Exercises
+
+1. **Create a `BankAccount` Class**:
+   * Private properties: accountNumber, balance
+   * Constructor to set account number
+   * Methods: deposit(), withdraw(), getBalance()
+   * Validation: can't withdraw more than balance
+   * Account number should be read-only
+
+2. **Create a `Door` Class**:
+   * Private properties: isLocked, keyCode
+   * Constructor to set the key code
+   * Methods: lock(), unlock(String code), isLocked()
+   * unlock() only works with correct code
+   * Code should be private (don't expose it!)
+
+3. **Create a `PlayerStats` Class**:
+   * Private properties: strength, defense, speed
+   * Constructor to set all stats
+   * Getters for all stats
+   * Method: getPowerLevel() that returns strength + defense + speed
+   * Stats can't be negative or over 100
+
+4. **Refactor a Class**: Take one of your classes from the previous lesson and add proper encapsulation:
+   * Make all properties private
+   * Add appropriate getters and setters
+   * Add validation where needed
diff --git a/content/docs/bg-BG/guides/java-basics/09-string.mdx b/content/docs/bg-BG/guides/java-basics/09-string.mdx
new file mode 100644
index 00000000..a374811b
--- /dev/null
+++ b/content/docs/bg-BG/guides/java-basics/09-string.mdx
@@ -0,0 +1,493 @@
+---
+title: 09 - Working with Strings
+description: Master text manipulation and string operations in Java.
+---
+
+Strings are one of the most commonly used types in Java. They're essential for handling player names, chat messages, item descriptions, and like everything you see.
+
+## String Basics
+
+Strings are objects that store text:
+
+```java
+String name = "Simon";
+String message = "Welcome to Hytale!";
+String empty = "";
+```
+
+<Callout type="warning" title="Strings are Immutable">
+  Once created, a String **cannot be changed**. Methods that seem to modify a string actually create a new one!
+
+  ```java
+  String text = "Hello";
+  text.toUpperCase();           // Creates "HELLO" but doesn't save it
+  System.out.println(text);     // Still "Hello"
+
+  String upper = text.toUpperCase();  // ✓ Save the result
+  System.out.println(upper);          // "HELLO"
+  ```
+</Callout>
+
+## String Methods
+
+### Length
+
+```java
+String name = "Alice";
+int length = name.length();
+System.out.println(length);  // 5
+```
+
+### Changing Case
+
+```java
+String text = "Hello World";
+String upper = text.toUpperCase();  // "HELLO WORLD"
+String lower = text.toLowerCase();  // "hello world"
+```
+
+### Checking Contents
+
+```java
+String message = "Welcome to Hytale";
+
+boolean hasHytale = message.contains("Hytale");  // true
+boolean hasMinecraft = message.contains("Minecraft");  // false
+
+boolean starts = message.startsWith("Welcome");  // true
+boolean ends = message.endsWith("Hytale");  // true
+```
+
+### Extracting Parts
+
+```java
+String text = "Hello World";
+
+char first = text.charAt(0);      // 'H'
+char last = text.charAt(10);      // 'd'
+
+String sub1 = text.substring(0, 5);   // "Hello"
+String sub2 = text.substring(6);      // "World"
+```
+
+<Callout type="info" title="Substring Indices">
+  `substring(start, end)` includes `start` but excludes `end`:
+
+  ```java
+  String text = "Hytale";
+  //             012345 (indices)
+
+  text.substring(0, 2);  // "Hy" (indices 0 and 1)
+  text.substring(2, 6);  // "tale" (indices 2, 3, 4, 5)
+  text.substring(2);     // "tale" (from 2 to end)
+  ```
+</Callout>
+
+### Replacing Text
+
+```java
+String text = "I love Minecraft";
+String replaced = text.replace("Minecraft", "Hytale");
+System.out.println(replaced);  // "I love Hytale"
+
+String noSpaces = "Hello World".replace(" ", "");
+System.out.println(noSpaces);  // "HelloWorld"
+```
+
+### Trimming Whitespace
+
+```java
+String messy = "  Hello World  ";
+String clean = messy.trim();
+System.out.println(clean);  // "Hello World" (no spaces at ends)
+```
+
+### Splitting Strings
+
+```java
+String command = "give player sword 5";
+String[] parts = command.split(" ");
+
+System.out.println(parts[0]);  // "give"
+System.out.println(parts[1]);  // "player"
+System.out.println(parts[2]);  // "sword"
+System.out.println(parts[3]);  // "5"
+```
+
+## String Comparison
+
+<Callout type="warning" title="Never Use == for Strings">
+  Always use `.equals()` to compare string contents!
+
+  ```java
+  String name1 = "Steve";
+  String name2 = "Steve";
+
+  // Wrong - Compares object references
+  if (name1 == name2) {
+      System.out.println("Same");
+  }
+
+  // Correct - Compares actual text
+  if (name1.equals(name2)) {
+      System.out.println("Same");
+  }
+
+  // Ignore case when comparing
+  if (name1.equalsIgnoreCase("steve")) {
+      System.out.println("Same (ignoring case)");
+  }
+  ```
+</Callout>
+
+### Comparing Order
+
+```java
+String a = "Apple";
+String b = "Banana";
+
+int result = a.compareTo(b);
+// result < 0 if a comes before b
+// result == 0 if a equals b
+// result > 0 if a comes after b
+
+if (a.compareTo(b) < 0) {
+    System.out.println(a + " comes before " + b);
+}
+```
+
+## String Concatenation
+
+### Using + Operator
+
+```java
+String first = "Hello";
+String second = "World";
+String combined = first + " " + second;  // "Hello World"
+
+int score = 100;
+String message = "Score: " + score;  // "Score: 100"
+```
+
+### Using concat()
+
+```java
+String result = "Hello".concat(" World");  // "Hello World"
+```
+
+### Building Long Strings
+
+For many concatenations, use `StringBuilder`:
+
+```java
+StringBuilder builder = new StringBuilder();
+builder.append("Player: ");
+builder.append("Alice");
+builder.append(", Level: ");
+builder.append(10);
+builder.append(", Health: ");
+builder.append(100);
+
+String result = builder.toString();
+System.out.println(result);
+// "Player: Alice, Level: 10, Health: 100"
+```
+
+<Callout type="info" title="Why StringBuilder?">
+  Regular concatenation creates many temporary strings:
+
+  ```java
+  // Inefficient - Creates many temporary strings
+  String result = "";
+  for (int i = 0; i < 1000; i++) {
+      result = result + i;  // Creates 1000 temporary strings!
+  }
+
+  // Efficient - StringBuilder is mutable
+  StringBuilder sb = new StringBuilder();
+  for (int i = 0; i < 1000; i++) {
+      sb.append(i);  // Modifies one object
+  }
+  String result = sb.toString();
+  ```
+
+  Use `StringBuilder` when building strings in loops!
+</Callout>
+
+## Practical Examples
+
+### Parse Player Command
+
+```java
+public class CommandParser {
+    public static void parseCommand(String command) {
+        // "/give Steve diamond_sword 1"
+        String[] parts = command.split(" ");
+        
+        String action = parts[0].replace("/", "");  // "give"
+        String player = parts[1];                   // "Steve"
+        String item = parts[2];                     // "diamond_sword"
+        int amount = Integer.parseInt(parts[3]);    // 1
+        
+        System.out.println("Action: " + action);
+        System.out.println("Player: " + player);
+        System.out.println("Item: " + item);
+        System.out.println("Amount: " + amount);
+    }
+    
+    public static void main(String[] args) {
+        parseCommand("/give Steve diamond_sword 1");
+    }
+}
+```
+
+### Format Player Display Name
+
+```java
+public class PlayerFormatter {
+    public static String formatName(String name, int level, String rank) {
+        StringBuilder formatted = new StringBuilder();
+        
+        if (rank != null && !rank.isEmpty()) {
+            formatted.append("[").append(rank).append("] ");
+        }
+        
+        formatted.append(name);
+        formatted.append(" (Lv. ").append(level).append(")");
+        
+        return formatted.toString();
+    }
+    
+    public static void main(String[] args) {
+        String display1 = formatName("Alice", 10, "VIP");
+        System.out.println(display1);  // "[VIP] Alice (Lv. 10)"
+        
+        String display2 = formatName("Bob", 5, null);
+        System.out.println(display2);  // "Bob (Lv. 5)"
+    }
+}
+```
+
+### Validate Username
+
+```java
+public class UsernameValidator {
+    public static boolean isValid(String username) {
+        // Rules: 3-16 characters, letters and numbers only
+        
+        if (username == null || username.isEmpty()) {
+            return false;
+        }
+        
+        username = username.trim();
+        
+        if (username.length() < 3 || username.length() > 16) {
+            return false;
+        }
+        
+        for (int i = 0; i < username.length(); i++) {
+            char c = username.charAt(i);
+            if (!Character.isLetterOrDigit(c)) {
+                return false;
+            }
+        }
+        
+        return true;
+    }
+    
+    public static void main(String[] args) {
+        System.out.println(isValid("Steve"));      // true
+        System.out.println(isValid("Player_123")); // false (has underscore)
+        System.out.println(isValid("ab"));         // false (too short)
+        System.out.println(isValid(""));           // false (empty)
+    }
+}
+```
+
+### Item Description Builder
+
+```java
+public class ItemDescription {
+    public static String buildDescription(String name, String rarity, 
+                                         int damage, int durability) {
+        StringBuilder desc = new StringBuilder();
+        
+        // Title with rarity color code
+        desc.append(getRarityColor(rarity));
+        desc.append(name);
+        desc.append("\n");
+        
+        // Stats
+        desc.append("Damage: ").append(damage).append("\n");
+        desc.append("Durability: ").append(durability).append("/");
+        desc.append(durability).append("\n");
+        desc.append("Rarity: ").append(rarity);
+        
+        return desc.toString();
+    }
+    
+    private static String getRarityColor(String rarity) {
+        switch (rarity.toLowerCase()) {
+            case "legendary": return "§6";  // Gold
+            case "epic": return "§5";       // Purple
+            case "rare": return "§9";       // Blue
+            case "common": return "§f";     // White
+            default: return "§7";           // Gray
+        }
+    }
+    
+    public static void main(String[] args) {
+        String desc = buildDescription("Excalibur", "Legendary", 50, 1000);
+        System.out.println(desc);
+    }
+}
+```
+
+### Chat Message Filter
+
+```java
+public class ChatFilter {
+    private static String[] bannedWords = {"badword1", "badword2"};
+    
+    public static String filterMessage(String message) {
+        String filtered = message.toLowerCase();
+        
+        for (String word : bannedWords) {
+            if (filtered.contains(word)) {
+                String replacement = "*".repeat(word.length());
+                filtered = filtered.replace(word, replacement);
+            }
+        }
+        
+        return filtered;
+    }
+    
+    public static void main(String[] args) {
+        String message = "This is a badword1 test";
+        String clean = filterMessage(message);
+        System.out.println(clean);  // "this is a ******** test"
+    }
+}
+```
+
+## String Formatting
+
+### Using String.format()
+
+```java
+String name = "Alice";
+int level = 10;
+double health = 85.5;
+
+String formatted = String.format("%s is level %d with %.1f%% health", 
+                                 name, level, health);
+System.out.println(formatted);
+// "Alice is level 10 with 85.5% health"
+```
+
+<Callout type="info" title="Format Specifiers">
+  Common format codes:
+
+  - `%s` - String
+  - `%d` - Integer
+  - `%f` - Floating point
+  - `%.2f` - Float with 2 decimal places
+  - `%n` - New line (platform independent)
+
+  ```java
+  String.format("Name: %s", "Steve");          // "Name: Steve"
+  String.format("Level: %d", 10);              // "Level: 10"
+  String.format("Health: %.1f", 85.5);         // "Health: 85.5"
+  String.format("Position: (%d, %d, %d)", 
+                10, 64, -5);                    // "Position: (10, 64, -5)"
+  ```
+</Callout>
+
+## Common String Operations
+
+### Check if String is Empty
+
+```java
+String text = "";
+
+// Check for empty or null
+if (text == null || text.isEmpty()) {
+    System.out.println("Empty!");
+}
+
+// Check for empty, null, or whitespace only
+if (text == null || text.trim().isEmpty()) {
+    System.out.println("Empty or whitespace!");
+}
+```
+
+### Count Occurrences
+
+```java
+public static int countOccurrences(String text, String target) {
+    int count = 0;
+    int index = 0;
+    
+    while ((index = text.indexOf(target, index)) != -1) {
+        count++;
+        index += target.length();
+    }
+    
+    return count;
+}
+
+// Usage
+int count = countOccurrences("hello hello world", "hello");
+System.out.println(count);  // 2
+```
+
+### Reverse a String
+
+```java
+public static String reverse(String text) {
+    StringBuilder sb = new StringBuilder(text);
+    return sb.reverse().toString();
+}
+
+// Usage
+String reversed = reverse("Hello");
+System.out.println(reversed);  // "olleH"
+```
+
+### Check if Palindrome
+
+```java
+public static boolean isPalindrome(String text) {
+    String cleaned = text.toLowerCase().replaceAll("[^a-z0-9]", "");
+    String reversed = new StringBuilder(cleaned).reverse().toString();
+    return cleaned.equals(reversed);
+}
+
+// Usage
+System.out.println(isPalindrome("racecar"));     // true
+System.out.println(isPalindrome("hello"));       // false
+```
+
+## Practice Exercises
+
+1. **Username Checker**: Write a method that checks if a username:
+   - Is between 3 and 16 characters
+   - Contains only letters, numbers, and underscores
+   - Doesn't start with a number
+   - Returns true if valid, false otherwise
+
+2. **Command Parser**: Parse this command format: `/teleport x y z`
+   - Extract the coordinates
+   - Convert them to integers
+   - Return an array of the three values
+
+3. **Chat Formatter**: Create a method that formats chat messages:
+   - Input: player name, rank, message
+   - Output: `"[RANK] PlayerName: message"`
+   - If no rank, just show `"PlayerName: message"`
+
+4. **Word Counter**: Count how many words are in a sentence (words are separated by spaces)
+
+5. **Title Case**: Convert a string to title case:
+   - Input: `"hello world"`
+   - Output: `"Hello World"`
diff --git a/content/docs/bg-BG/guides/java-basics/10-arraylist.mdx b/content/docs/bg-BG/guides/java-basics/10-arraylist.mdx
new file mode 100644
index 00000000..343ae5d5
--- /dev/null
+++ b/content/docs/bg-BG/guides/java-basics/10-arraylist.mdx
@@ -0,0 +1,530 @@
+---
+title: 10 - ArrayList and Collections
+description: Learn to use flexible, resizable collections in Java.
+---
+
+Arrays have a fixed size, but what if you need to add or remove elements? That's where `ArrayList` comes in - a resizable collection that grows and shrinks automatically.
+
+## ArrayList Basics
+
+```java
+import java.util.ArrayList;
+
+public class Main {
+    public static void main(String[] args) {
+        // Create an ArrayList of Strings
+        ArrayList<String> players = new ArrayList<>();
+        
+        // Add elements
+        players.add("Alice");
+        players.add("Bob");
+        players.add("Charlie");
+        
+        System.out.println(players);  // [Alice, Bob, Charlie]
+    }
+}
+```
+
+<Callout type="info" title="ArrayList vs Array">
+  | **Array**                               | **ArrayList**                                         |
+  | --------------------------------------- | ----------------------------------------------------- |
+  | Fixed size                              | Resizable (grows/shrinks)                             |
+  | Can hold primitives (int, double, etc.) | Can only hold objects (Integer, Double, String, etc.) |
+  | Faster access                           | More features (add, remove, etc.)                     |
+  | `int[] numbers = new int[10];`          | `ArrayList<Integer> numbers = new ArrayList<>();`     |
+</Callout>
+
+## Creating ArrayLists
+
+```java
+import java.util.ArrayList;
+
+// Empty ArrayList
+ArrayList<String> items = new ArrayList<>();
+
+// With initial values (Java 9+)
+ArrayList<String> colors = new ArrayList<>(List.of("Red", "Green", "Blue"));
+
+// Different types
+ArrayList<Integer> numbers = new ArrayList<>();
+ArrayList<Double> prices = new ArrayList<>();
+ArrayList<Boolean> flags = new ArrayList<>();
+```
+
+<Callout type="warning" title="Primitives in ArrayList">
+  You can't use primitives directly. Use their wrapper classes:
+
+  ```java
+  // Wrong
+  ArrayList<int> numbers = new ArrayList<>();
+
+  // Correct - Use wrapper class
+  ArrayList<Integer> numbers = new ArrayList<>();
+  ```
+
+  Wrapper classes:
+
+  - `int` → `Integer`
+  - `double` → `Double`
+  - `boolean` → `Boolean`
+  - `char` → `Character`
+</Callout>
+
+## Common ArrayList Methods
+
+### Adding Elements
+
+```java
+ArrayList<String> items = new ArrayList<>();
+
+items.add("Sword");           // Add to end
+items.add("Shield");
+items.add(0, "Helmet");       // Add at specific index
+
+System.out.println(items);    // [Helmet, Sword, Shield]
+```
+
+### Accessing Elements
+
+```java
+ArrayList<String> items = new ArrayList<>();
+items.add("Sword");
+items.add("Shield");
+
+String first = items.get(0);    // "Sword"
+String second = items.get(1);   // "Shield"
+
+int size = items.size();        // 2
+```
+
+### Removing Elements
+
+```java
+ArrayList<String> items = new ArrayList<>();
+items.add("Sword");
+items.add("Shield");
+items.add("Potion");
+
+items.remove(1);               // Remove by index (Shield)
+items.remove("Potion");        // Remove by value
+
+System.out.println(items);     // [Sword]
+```
+
+### Checking Contents
+
+```java
+ArrayList<String> items = new ArrayList<>();
+items.add("Sword");
+items.add("Shield");
+
+boolean hasSword = items.contains("Sword");     // true
+boolean hasAxe = items.contains("Axe");         // false
+
+boolean isEmpty = items.isEmpty();              // false
+int size = items.size();                        // 2
+```
+
+### Modifying Elements
+
+```java
+ArrayList<String> items = new ArrayList<>();
+items.add("Wooden Sword");
+
+items.set(0, "Iron Sword");    // Replace at index 0
+
+System.out.println(items);     // [Iron Sword]
+```
+
+### Clearing All Elements
+
+```java
+ArrayList<String> items = new ArrayList<>();
+items.add("Sword");
+items.add("Shield");
+
+items.clear();                 // Remove everything
+System.out.println(items);     // []
+```
+
+## Looping Through ArrayList
+
+### Using For Loop
+
+```java
+ArrayList<String> players = new ArrayList<>();
+players.add("Alice");
+players.add("Bob");
+players.add("Charlie");
+
+for (int i = 0; i < players.size(); i++) {
+    System.out.println(players.get(i));
+}
+```
+
+### Using Enhanced For Loop
+
+```java
+for (String player : players) {
+    System.out.println(player);
+}
+```
+
+### Using forEach (Java 8+)
+
+```java
+players.forEach(player -> System.out.println(player));
+```
+
+## Practical Examples
+
+### Player Inventory System
+
+```java
+import java.util.ArrayList;
+
+public class Inventory {
+    private ArrayList<String> items;
+    private int maxSize;
+    
+    public Inventory(int maxSize) {
+        this.items = new ArrayList<>();
+        this.maxSize = maxSize;
+    }
+    
+    public boolean addItem(String item) {
+        if (items.size() >= maxSize) {
+            System.out.println("Inventory full!");
+            return false;
+        }
+        
+        items.add(item);
+        System.out.println("Added: " + item);
+        return true;
+    }
+    
+    public boolean removeItem(String item) {
+        if (items.remove(item)) {
+            System.out.println("Removed: " + item);
+            return true;
+        }
+        
+        System.out.println("Item not found!");
+        return false;
+    }
+    
+    public void displayInventory() {
+        System.out.println("=== Inventory (" + items.size() + "/" + maxSize + ") ===");
+        for (int i = 0; i < items.size(); i++) {
+            System.out.println((i + 1) + ". " + items.get(i));
+        }
+    }
+    
+    public int getItemCount() {
+        return items.size();
+    }
+    
+    public boolean isFull() {
+        return items.size() >= maxSize;
+    }
+}
+
+// Usage
+public class Main {
+    public static void main(String[] args) {
+        Inventory inv = new Inventory(5);
+        
+        inv.addItem("Sword");
+        inv.addItem("Shield");
+        inv.addItem("Potion");
+        inv.displayInventory();
+        
+        inv.removeItem("Shield");
+        inv.displayInventory();
+    }
+}
+```
+
+### Quest System
+
+```java
+import java.util.ArrayList;
+
+public class QuestManager {
+    private ArrayList<String> activeQuests;
+    private ArrayList<String> completedQuests;
+    
+    public QuestManager() {
+        this.activeQuests = new ArrayList<>();
+        this.completedQuests = new ArrayList<>();
+    }
+    
+    public void startQuest(String questName) {
+        if (!activeQuests.contains(questName)) {
+            activeQuests.add(questName);
+            System.out.println("Quest started: " + questName);
+        } else {
+            System.out.println("Quest already active!");
+        }
+    }
+    
+    public void completeQuest(String questName) {
+        if (activeQuests.remove(questName)) {
+            completedQuests.add(questName);
+            System.out.println("Quest completed: " + questName);
+        } else {
+            System.out.println("Quest not found in active quests!");
+        }
+    }
+    
+    public void displayQuests() {
+        System.out.println("\n=== Active Quests ===");
+        if (activeQuests.isEmpty()) {
+            System.out.println("No active quests");
+        } else {
+            for (String quest : activeQuests) {
+                System.out.println("- " + quest);
+            }
+        }
+        
+        System.out.println("\n=== Completed Quests ===");
+        if (completedQuests.isEmpty()) {
+            System.out.println("No completed quests");
+        } else {
+            for (String quest : completedQuests) {
+                System.out.println("" + quest);
+            }
+        }
+    }
+    
+    public int getTotalCompleted() {
+        return completedQuests.size();
+    }
+}
+```
+
+### Leaderboard System
+
+```java
+import java.util.ArrayList;
+import java.util.Collections;
+
+public class Leaderboard {
+    private ArrayList<Integer> scores;
+    private ArrayList<String> players;
+    
+    public Leaderboard() {
+        this.scores = new ArrayList<>();
+        this.players = new ArrayList<>();
+    }
+    
+    public void addScore(String player, int score) {
+        players.add(player);
+        scores.add(score);
+        System.out.println(player + " scored " + score + " points!");
+    }
+    
+    public void displayTop(int count) {
+        System.out.println("\n=== Top " + count + " Players ===");
+        
+        // Create copies to sort
+        ArrayList<Integer> sortedScores = new ArrayList<>(scores);
+        ArrayList<String> sortedPlayers = new ArrayList<>(players);
+        
+        // Bubble sort (simple for learning)
+        for (int i = 0; i < sortedScores.size() - 1; i++) {
+            for (int j = 0; j < sortedScores.size() - i - 1; j++) {
+                if (sortedScores.get(j) < sortedScores.get(j + 1)) {
+                    // Swap scores
+                    int tempScore = sortedScores.get(j);
+                    sortedScores.set(j, sortedScores.get(j + 1));
+                    sortedScores.set(j + 1, tempScore);
+                    
+                    // Swap players
+                    String tempPlayer = sortedPlayers.get(j);
+                    sortedPlayers.set(j, sortedPlayers.get(j + 1));
+                    sortedPlayers.set(j + 1, tempPlayer);
+                }
+            }
+        }
+        
+        // Display top scores
+        int limit = Math.min(count, sortedScores.size());
+        for (int i = 0; i < limit; i++) {
+            System.out.println((i + 1) + ". " + sortedPlayers.get(i) + 
+                             " - " + sortedScores.get(i) + " points");
+        }
+    }
+}
+```
+
+### Online Players Tracker
+
+```java
+import java.util.ArrayList;
+
+public class OnlinePlayersTracker {
+    private ArrayList<String> onlinePlayers;
+    
+    public OnlinePlayersTracker() {
+        this.onlinePlayers = new ArrayList<>();
+    }
+    
+    public void playerJoin(String playerName) {
+        if (!onlinePlayers.contains(playerName)) {
+            onlinePlayers.add(playerName);
+            broadcast(playerName + " joined the game");
+            updatePlayerCount();
+        }
+    }
+    
+    public void playerLeave(String playerName) {
+        if (onlinePlayers.remove(playerName)) {
+            broadcast(playerName + " left the game");
+            updatePlayerCount();
+        }
+    }
+    
+    public boolean isOnline(String playerName) {
+        return onlinePlayers.contains(playerName);
+    }
+    
+    public int getPlayerCount() {
+        return onlinePlayers.size();
+    }
+    
+    public void listPlayers() {
+        System.out.println("\n=== Online Players (" + getPlayerCount() + ") ===");
+        for (String player : onlinePlayers) {
+            System.out.println("• " + player);
+        }
+    }
+    
+    private void broadcast(String message) {
+        System.out.println("[Server] " + message);
+    }
+    
+    private void updatePlayerCount() {
+        System.out.println("Players online: " + getPlayerCount());
+    }
+}
+```
+
+## ArrayList of Custom Objects
+
+You can store your own classes in ArrayLists:
+
+```java
+public class Player {
+    private String name;
+    private int level;
+    
+    public Player(String name, int level) {
+        this.name = name;
+        this.level = level;
+    }
+    
+    public String getName() {
+        return name;
+    }
+    
+    public int getLevel() {
+        return level;
+    }
+    
+    @Override
+    public String toString() {
+        return name + " (Lv. " + level + ")";
+    }
+}
+
+public class Main {
+    public static void main(String[] args) {
+        ArrayList<Player> players = new ArrayList<>();
+        
+        players.add(new Player("Alice", 10));
+        players.add(new Player("Bob", 15));
+        players.add(new Player("Charlie", 8));
+        
+        // Display all players
+        for (Player player : players) {
+            System.out.println(player);
+        }
+        
+        // Find player by name
+        for (Player player : players) {
+            if (player.getName().equals("Bob")) {
+                System.out.println("Found: " + player);
+            }
+        }
+    }
+}
+```
+
+## Useful ArrayList Operations
+
+### Convert to Array
+
+```java
+ArrayList<String> list = new ArrayList<>();
+list.add("A");
+list.add("B");
+
+String[] array = list.toArray(new String[0]);
+```
+
+### Convert Array to ArrayList
+
+```java
+String[] array = {"A", "B", "C"};
+ArrayList<String> list = new ArrayList<>(Arrays.asList(array));
+```
+
+### Copy an ArrayList
+
+```java
+ArrayList<String> original = new ArrayList<>();
+original.add("A");
+original.add("B");
+
+// Shallow copy
+ArrayList<String> copy = new ArrayList<>(original);
+```
+
+### Find Index of Element
+
+```java
+ArrayList<String> items = new ArrayList<>();
+items.add("Sword");
+items.add("Shield");
+
+int index = items.indexOf("Shield");  // 1
+int notFound = items.indexOf("Axe");  // -1
+```
+
+## Practice Exercises
+
+1. **Shopping Cart**: Create a shopping cart system:
+   - Add items
+   - Remove items
+   - Calculate total items
+   - Clear cart
+
+2. **Friend List**: Create a friend management system:
+   - Add friend
+   - Remove friend
+   - Check if someone is a friend
+   - Display all friends
+
+3. **Todo List**: Build a todo list:
+   - Add task
+   - Mark task as complete (move to completed list)
+   - Display active tasks
+   - Display completed tasks
+
+4. **High Scores**: Create a high score system:
+   - Add scores
+   - Display top 5 scores in order
+   - Remove lowest score if more than 10 scores exist
+
+---
diff --git a/content/docs/bg-BG/guides/java-basics/11-hashmaps.mdx b/content/docs/bg-BG/guides/java-basics/11-hashmaps.mdx
new file mode 100644
index 00000000..a06511cf
--- /dev/null
+++ b/content/docs/bg-BG/guides/java-basics/11-hashmaps.mdx
@@ -0,0 +1,568 @@
+---
+title: 11 - HashMap and Key-Value Storage
+description: Learn to store and retrieve data using key-value pairs.
+---
+
+A `HashMap` stores data in key-value pairs, like a real-world dictionary. You look up a word (key) to find its definition (value). This is perfect for player data, item properties, and configuration settings.
+
+## HashMap Basics
+
+```java
+import java.util.HashMap;
+
+public class Main {
+    public static void main(String[] args) {
+        // Create a HashMap (String keys, Integer values)
+        HashMap<String, Integer> playerLevels = new HashMap<>();
+        
+        // Add key-value pairs
+        playerLevels.put("Alice", 10);
+        playerLevels.put("Bob", 15);
+        playerLevels.put("Charlie", 8);
+        
+        // Get a value by key
+        int aliceLevel = playerLevels.get("Alice");  // 10
+        
+        System.out.println("Alice is level " + aliceLevel);
+    }
+}
+```
+
+<Callout type="info" title="HashMap vs ArrayList">
+  | **HashMap**                     | **ArrayList**                 |
+  | ------------------------------- | ----------------------------- |
+  | Unordered                       | Ordered by index (0, 1, 2...) |
+  | Access by key (can be any type) | Access by position            |
+  | Good for looking up values      | Good for lists of items       |
+  | Each key is unique              | Can have duplicates           |
+
+  ```java
+  // ArrayList - access by number
+  ArrayList<String> players = new ArrayList<>();
+  players.add("Alice");
+  String player = players.get(0);  // Get first player
+
+  // HashMap - access by name
+  HashMap<String, Integer> levels = new HashMap<>();
+  levels.put("Alice", 10);
+  int level = levels.get("Alice");  // Get Alice's level
+  ```
+</Callout>
+
+## Common HashMap Methods
+
+### Adding and Updating
+
+```java
+HashMap<String, Integer> scores = new HashMap<>();
+
+scores.put("Alice", 100);     // Add new entry
+scores.put("Bob", 150);
+scores.put("Alice", 200);     // Update existing (Alice now 200)
+```
+
+### Getting Values
+
+```java
+HashMap<String, Integer> scores = new HashMap<>();
+scores.put("Alice", 100);
+
+int score = scores.get("Alice");        // 100
+Integer missing = scores.get("Dave");   // null (doesn't exist)
+
+// Get with default value
+int score2 = scores.getOrDefault("Dave", 0);  // 0 (returns default)
+```
+
+### Checking for Keys/Values
+
+```java
+HashMap<String, Integer> scores = new HashMap<>();
+scores.put("Alice", 100);
+
+boolean hasAlice = scores.containsKey("Alice");    // true
+boolean hasDave = scores.containsKey("Dave");      // false
+
+boolean has100 = scores.containsValue(100);        // true
+boolean has200 = scores.containsValue(200);        // false
+```
+
+### Removing Entries
+
+```java
+HashMap<String, Integer> scores = new HashMap<>();
+scores.put("Alice", 100);
+scores.put("Bob", 150);
+
+scores.remove("Alice");           // Remove by key
+System.out.println(scores);       // {Bob=150}
+
+scores.clear();                   // Remove everything
+System.out.println(scores);       // {}
+```
+
+### Size and Empty Check
+
+```java
+HashMap<String, Integer> scores = new HashMap<>();
+scores.put("Alice", 100);
+
+int size = scores.size();         // 1
+boolean empty = scores.isEmpty(); // false
+```
+
+## Looping Through HashMap
+
+### Loop Through Keys
+
+```java
+HashMap<String, Integer> scores = new HashMap<>();
+scores.put("Alice", 100);
+scores.put("Bob", 150);
+scores.put("Charlie", 75);
+
+for (String name : scores.keySet()) {
+    System.out.println(name);
+}
+// Output: Alice, Bob, Charlie (order may vary)
+```
+
+### Loop Through Values
+
+```java
+for (Integer score : scores.values()) {
+    System.out.println(score);
+}
+// Output: 100, 150, 75 (order may vary)
+```
+
+### Loop Through Both Keys and Values
+
+```java
+for (String name : scores.keySet()) {
+    int score = scores.get(name);
+    System.out.println(name + ": " + score);
+}
+
+// Or using entrySet (more efficient)
+for (var entry : scores.entrySet()) {
+    String name = entry.getKey();
+    int score = entry.getValue();
+    System.out.println(name + ": " + score);
+}
+```
+
+<Callout type="info" title="HashMap Order">
+  HashMap does **not** maintain insertion order! If you need order, use `LinkedHashMap`:
+
+  ```java
+  import java.util.LinkedHashMap;
+
+  LinkedHashMap<String, Integer> orderedScores = new LinkedHashMap<>();
+  orderedScores.put("Alice", 100);
+  orderedScores.put("Bob", 150);
+  orderedScores.put("Charlie", 75);
+
+  // Will print in insertion order
+  for (String name : orderedScores.keySet()) {
+      System.out.println(name);
+  }
+  // Output: Alice, Bob, Charlie (guaranteed order)
+  ```
+</Callout>
+
+## Practical Examples
+
+### Player Statistics System
+
+```java
+import java.util.HashMap;
+
+public class PlayerStats {
+    private HashMap<String, Integer> stats;
+    
+    public PlayerStats() {
+        this.stats = new HashMap<>();
+        // Initialize default stats
+        stats.put("health", 100);
+        stats.put("mana", 50);
+        stats.put("strength", 10);
+        stats.put("defense", 5);
+        stats.put("speed", 8);
+    }
+    
+    public int getStat(String statName) {
+        return stats.getOrDefault(statName, 0);
+    }
+    
+    public void setStat(String statName, int value) {
+        stats.put(statName, value);
+    }
+    
+    public void modifyStat(String statName, int amount) {
+        int current = getStat(statName);
+        stats.put(statName, current + amount);
+    }
+    
+    public void displayStats() {
+        System.out.println("=== Player Stats ===");
+        for (var entry : stats.entrySet()) {
+            System.out.println(entry.getKey() + ": " + entry.getValue());
+        }
+    }
+}
+
+// Usage
+public class Main {
+    public static void main(String[] args) {
+        PlayerStats stats = new PlayerStats();
+        stats.displayStats();
+        
+        stats.modifyStat("strength", 5);
+        stats.modifyStat("health", -20);
+        
+        System.out.println("\nAfter modifications:");
+        stats.displayStats();
+    }
+}
+```
+
+### Item Properties Database
+
+```java
+import java.util.HashMap;
+
+public class ItemDatabase {
+    private HashMap<String, HashMap<String, Object>> items;
+    
+    public ItemDatabase() {
+        this.items = new HashMap<>();
+    }
+    
+    public void addItem(String itemName) {
+        HashMap<String, Object> properties = new HashMap<>();
+        properties.put("damage", 0);
+        properties.put("durability", 100);
+        properties.put("rarity", "Common");
+        properties.put("stackable", true);
+        
+        items.put(itemName, properties);
+    }
+    
+    public void setProperty(String itemName, String property, Object value) {
+        if (items.containsKey(itemName)) {
+            items.get(itemName).put(property, value);
+        }
+    }
+    
+    public Object getProperty(String itemName, String property) {
+        if (items.containsKey(itemName)) {
+            return items.get(itemName).get(property);
+        }
+        return null;
+    }
+    
+    public void displayItem(String itemName) {
+        if (!items.containsKey(itemName)) {
+            System.out.println("Item not found!");
+            return;
+        }
+        
+        System.out.println("=== " + itemName + " ===");
+        HashMap<String, Object> props = items.get(itemName);
+        for (var entry : props.entrySet()) {
+            System.out.println(entry.getKey() + ": " + entry.getValue());
+        }
+    }
+}
+
+// Usage
+public class Main {
+    public static void main(String[] args) {
+        ItemDatabase db = new ItemDatabase();
+        
+        db.addItem("Iron Sword");
+        db.setProperty("Iron Sword", "damage", 15);
+        db.setProperty("Iron Sword", "rarity", "Uncommon");
+        
+        db.displayItem("Iron Sword");
+    }
+}
+```
+
+### Configuration Manager
+
+```java
+import java.util.HashMap;
+
+public class GameConfig {
+    private HashMap<String, String> settings;
+    
+    public GameConfig() {
+        this.settings = new HashMap<>();
+        loadDefaults();
+    }
+    
+    private void loadDefaults() {
+        settings.put("difficulty", "normal");
+        settings.put("musicVolume", "50");
+        settings.put("sfxVolume", "50");
+        settings.put("renderDistance", "10");
+        settings.put("showFPS", "false");
+    }
+    
+    public String getSetting(String key) {
+        return settings.getOrDefault(key, "");
+    }
+    
+    public void setSetting(String key, String value) {
+        settings.put(key, value);
+        System.out.println("Set " + key + " to " + value);
+    }
+    
+    public int getIntSetting(String key) {
+        String value = getSetting(key);
+        try {
+            return Integer.parseInt(value);
+        } catch (NumberFormatException e) {
+            return 0;
+        }
+    }
+    
+    public boolean getBooleanSetting(String key) {
+        return "true".equalsIgnoreCase(getSetting(key));
+    }
+    
+    public void displaySettings() {
+        System.out.println("=== Game Settings ===");
+        for (var entry : settings.entrySet()) {
+            System.out.println(entry.getKey() + " = " + entry.getValue());
+        }
+    }
+}
+```
+
+### Player Inventory with Quantities
+
+```java
+import java.util.HashMap;
+
+public class Inventory {
+    private HashMap<String, Integer> items;
+    private int maxSlots;
+    
+    public Inventory(int maxSlots) {
+        this.items = new HashMap<>();
+        this.maxSlots = maxSlots;
+    }
+    
+    public boolean addItem(String itemName, int quantity) {
+        if (items.size() >= maxSlots && !items.containsKey(itemName)) {
+            System.out.println("Inventory full!");
+            return false;
+        }
+        
+        int current = items.getOrDefault(itemName, 0);
+        items.put(itemName, current + quantity);
+        System.out.println("Added " + quantity + "x " + itemName);
+        return true;
+    }
+    
+    public boolean removeItem(String itemName, int quantity) {
+        if (!items.containsKey(itemName)) {
+            System.out.println("Don't have that item!");
+            return false;
+        }
+        
+        int current = items.get(itemName);
+        if (current < quantity) {
+            System.out.println("Not enough " + itemName);
+            return false;
+        }
+        
+        if (current == quantity) {
+            items.remove(itemName);
+        } else {
+            items.put(itemName, current - quantity);
+        }
+        
+        System.out.println("Removed " + quantity + "x " + itemName);
+        return true;
+    }
+    
+    public int getQuantity(String itemName) {
+        return items.getOrDefault(itemName, 0);
+    }
+    
+    public boolean hasItem(String itemName) {
+        return items.containsKey(itemName);
+    }
+    
+    public void displayInventory() {
+        System.out.println("\n=== Inventory (" + items.size() + "/" + maxSlots + " slots) ===");
+        if (items.isEmpty()) {
+            System.out.println("Empty");
+        } else {
+            for (var entry : items.entrySet()) {
+                System.out.println(entry.getKey() + " x" + entry.getValue());
+            }
+        }
+    }
+}
+
+// Usage
+public class Main {
+    public static void main(String[] args) {
+        Inventory inv = new Inventory(10);
+        
+        inv.addItem("Wood", 64);
+        inv.addItem("Stone", 32);
+        inv.addItem("Wood", 20);  // Adds to existing
+        
+        inv.displayInventory();
+        
+        inv.removeItem("Wood", 50);
+        inv.displayInventory();
+    }
+}
+```
+
+### Cooldown Manager
+
+```java
+import java.util.HashMap;
+
+public class CooldownManager {
+    private HashMap<String, Long> cooldowns;
+    
+    public CooldownManager() {
+        this.cooldowns = new HashMap<>();
+    }
+    
+    public void startCooldown(String ability, long durationMs) {
+        long endTime = System.currentTimeMillis() + durationMs;
+        cooldowns.put(ability, endTime);
+        System.out.println(ability + " on cooldown for " + (durationMs / 1000) + " seconds");
+    }
+    
+    public boolean isOnCooldown(String ability) {
+        if (!cooldowns.containsKey(ability)) {
+            return false;
+        }
+        
+        long endTime = cooldowns.get(ability);
+        long now = System.currentTimeMillis();
+        
+        if (now >= endTime) {
+            cooldowns.remove(ability);
+            return false;
+        }
+        
+        return true;
+    }
+    
+    public long getRemainingTime(String ability) {
+        if (!isOnCooldown(ability)) {
+            return 0;
+        }
+        
+        long endTime = cooldowns.get(ability);
+        long now = System.currentTimeMillis();
+        return (endTime - now) / 1000;  // Return seconds
+    }
+    
+    public boolean useAbility(String ability, long cooldownSeconds) {
+        if (isOnCooldown(ability)) {
+            long remaining = getRemainingTime(ability);
+            System.out.println(ability + " is on cooldown (" + remaining + "s remaining)");
+            return false;
+        }
+        
+        System.out.println("Used " + ability + "!");
+        startCooldown(ability, cooldownSeconds * 1000);
+        return true;
+    }
+}
+```
+
+## HashMap with Custom Objects
+
+Store your own classes as values:
+
+```java
+public class Player {
+    private String name;
+    private int level;
+    private int health;
+    
+    public Player(String name, int level) {
+        this.name = name;
+        this.level = level;
+        this.health = 100;
+    }
+    
+    // Getters and setters...
+    
+    @Override
+    public String toString() {
+        return name + " (Lv. " + level + ", HP: " + health + ")";
+    }
+}
+
+public class Main {
+    public static void main(String[] args) {
+        HashMap<String, Player> players = new HashMap<>();
+        
+        players.put("player1", new Player("Alice", 10));
+        players.put("player2", new Player("Bob", 15));
+        
+        // Get and use player
+        Player alice = players.get("player1");
+        System.out.println(alice);
+    }
+}
+```
+
+## Nested HashMaps
+
+HashMaps can contain other HashMaps:
+
+```java
+// Store multiple properties per player
+HashMap<String, HashMap<String, Integer>> playerData = new HashMap<>();
+
+// Add player with stats
+HashMap<String, Integer> aliceStats = new HashMap<>();
+aliceStats.put("level", 10);
+aliceStats.put("health", 100);
+aliceStats.put("mana", 50);
+playerData.put("Alice", aliceStats);
+
+// Access nested data
+int aliceLevel = playerData.get("Alice").get("level");
+System.out.println("Alice's level: " + aliceLevel);
+```
+
+## Practice Exercises
+
+1. **Phone Book**: Create a phone book that stores names and phone numbers. Add methods to:
+   - Add contact
+   - Find number by name
+   - Delete contact
+   - Display all contacts
+
+2. **Grade Manager**: Store student names and grades. Create methods to:
+   - Add student with grade
+   - Update grade
+   - Calculate class average
+   - Find highest grade
+
+3. **Word Counter**: Write a program that counts how many times each word appears in a sentence using a HashMap.
+
+4. **Item Shop**: Create a shop where items have names and prices. Add methods to:
+   - Add item with price
+   - Get item price
+   - Apply discount to all items
+   - Display all items and prices
+
+---
diff --git a/content/docs/bg-BG/guides/java-basics/12-exception-handling.mdx b/content/docs/bg-BG/guides/java-basics/12-exception-handling.mdx
new file mode 100644
index 00000000..a43155d0
--- /dev/null
+++ b/content/docs/bg-BG/guides/java-basics/12-exception-handling.mdx
@@ -0,0 +1,504 @@
+---
+title: 12 - Exception Handling
+description: Learn how to handle errors gracefully in your Java programs.
+---
+
+Exceptions are errors that occur while your program is running. Instead of crashing, you can "catch" these errors and handle them gracefully.
+
+## What is an Exception?
+
+An exception is an event that disrupts the normal flow of your program:
+
+```java
+String text = null;
+System.out.println(text.length());  // NullPointerException - crashes!
+```
+
+Without handling, this crashes your mod and breaks the game!
+
+## Try-Catch Blocks
+
+Use `try-catch` to handle exceptions:
+
+```java
+try {
+    // Code that might throw an exception
+    String text = null;
+    System.out.println(text.length());
+} catch (NullPointerException e) {
+    // Code to handle the error
+    System.out.println("Error: text was null!");
+}
+
+System.out.println("Program continues...");
+```
+
+<Callout type="info" title="How Try-Catch Works">
+  1. Code in `try` block runs normally
+  2. If an exception occurs, execution jumps to `catch` block
+  3. After `catch` block, program continues normally
+  4. If no exception occurs, `catch` block is skipped
+
+  ```java
+  try {
+      // Try to do something risky
+      int result = 10 / 0;  // Division by zero!
+  } catch (ArithmeticException e) {
+      // Handle the error
+      System.out.println("Can't divide by zero!");
+  }
+  // Program keeps running
+  ```
+</Callout>
+
+## Common Exception Types
+
+### NullPointerException
+
+Accessing methods/properties on null objects:
+
+```java
+String name = null;
+
+try {
+    int length = name.length();
+} catch (NullPointerException e) {
+    System.out.println("Name is null!");
+}
+```
+
+### ArrayIndexOutOfBoundsException
+
+Accessing invalid array index:
+
+```java
+int[] numbers = {1, 2, 3};
+
+try {
+    int value = numbers[10];  // Index 10 doesn't exist!
+} catch (ArrayIndexOutOfBoundsException e) {
+    System.out.println("Invalid array index!");
+}
+```
+
+### NumberFormatException
+
+Converting invalid strings to numbers:
+
+```java
+try {
+    int number = Integer.parseInt("abc");  // Not a number!
+} catch (NumberFormatException e) {
+    System.out.println("Invalid number format!");
+}
+```
+
+### ArithmeticException
+
+Math errors like division by zero:
+
+```java
+try {
+    int result = 10 / 0;
+} catch (ArithmeticException e) {
+    System.out.println("Math error!");
+}
+```
+
+## Multiple Catch Blocks
+
+Handle different exceptions differently:
+
+```java
+String input = "abc";
+
+try {
+    int number = Integer.parseInt(input);
+    int result = 100 / number;
+    System.out.println(result);
+} catch (NumberFormatException e) {
+    System.out.println("Invalid number!");
+} catch (ArithmeticException e) {
+    System.out.println("Cannot divide by zero!");
+}
+```
+
+## Catching Multiple Exception Types
+
+Catch multiple exceptions in one block:
+
+```java
+try {
+    // Some risky code
+} catch (NumberFormatException | ArithmeticException e) {
+    System.out.println("Math-related error occurred!");
+}
+```
+
+## The Finally Block
+
+Code that **always** runs, whether exception occurs or not:
+
+```java
+try {
+    System.out.println("Opening file...");
+    // Code that might fail
+} catch (Exception e) {
+    System.out.println("Error: " + e.getMessage());
+} finally {
+    System.out.println("Closing file...");
+    // This ALWAYS runs - good for cleanup
+}
+```
+
+<Callout type="info" title="When to Use Finally">
+  Use `finally` for cleanup tasks that must always happen:
+
+  - Closing files
+  - Releasing resources
+  - Saving data
+  - Logging
+
+  ```java
+  FileReader file = null;
+  try {
+      file = new FileReader("data.txt");
+      // Read file
+  } catch (Exception e) {
+      System.out.println("Error reading file");
+  } finally {
+      if (file != null) {
+          file.close();  // Always close the file!
+      }
+  }
+  ```
+</Callout>
+
+## Getting Exception Information
+
+The exception object contains useful information:
+
+```java
+try {
+    int result = Integer.parseInt("xyz");
+} catch (NumberFormatException e) {
+    System.out.println("Message: " + e.getMessage());
+    System.out.println("Type: " + e.getClass().getName());
+    e.printStackTrace();  // Print full error details
+}
+```
+
+## Practical Examples
+
+### Safe Player Input
+
+```java
+import java.util.Scanner;
+
+public class PlayerInput {
+    public static int getPlayerChoice(Scanner scanner) {
+        while (true) {
+            try {
+                System.out.print("Enter choice (1-5): ");
+                String input = scanner.nextLine();
+                int choice = Integer.parseInt(input);
+                
+                if (choice < 1 || choice > 5) {
+                    System.out.println("Please enter a number between 1 and 5");
+                    continue;
+                }
+                
+                return choice;
+            } catch (NumberFormatException e) {
+                System.out.println("Invalid input! Please enter a number.");
+            }
+        }
+    }
+    
+    public static void main(String[] args) {
+        Scanner scanner = new Scanner(System.in);
+        int choice = getPlayerChoice(scanner);
+        System.out.println("You chose: " + choice);
+    }
+}
+```
+
+### Safe Item Durability Update
+
+```java
+public class Item {
+    private String name;
+    private int durability;
+    private int maxDurability;
+    
+    public Item(String name, int maxDurability) {
+        this.name = name;
+        this.durability = maxDurability;
+        this.maxDurability = maxDurability;
+    }
+    
+    public void damage(int amount) {
+        try {
+            if (amount < 0) {
+                throw new IllegalArgumentException("Damage cannot be negative!");
+            }
+            
+            durability -= amount;
+            
+            if (durability < 0) {
+                durability = 0;
+            }
+            
+            System.out.println(name + " durability: " + durability + "/" + maxDurability);
+            
+            if (durability == 0) {
+                System.out.println(name + " broke!");
+            }
+        } catch (IllegalArgumentException e) {
+            System.out.println("Error: " + e.getMessage());
+        }
+    }
+}
+```
+
+### Safe Config Loading
+
+```java
+import java.util.HashMap;
+
+public class ConfigLoader {
+    private HashMap<String, String> settings;
+    
+    public ConfigLoader() {
+        this.settings = new HashMap<>();
+        loadDefaults();
+    }
+    
+    private void loadDefaults() {
+        settings.put("maxPlayers", "10");
+        settings.put("difficulty", "normal");
+        settings.put("pvpEnabled", "true");
+    }
+    
+    public int getIntSetting(String key, int defaultValue) {
+        try {
+            String value = settings.get(key);
+            if (value == null) {
+                return defaultValue;
+            }
+            return Integer.parseInt(value);
+        } catch (NumberFormatException e) {
+            System.out.println("Invalid number for " + key + ", using default");
+            return defaultValue;
+        }
+    }
+    
+    public boolean getBooleanSetting(String key, boolean defaultValue) {
+        try {
+            String value = settings.get(key);
+            if (value == null) {
+                return defaultValue;
+            }
+            return Boolean.parseBoolean(value);
+        } catch (Exception e) {
+            System.out.println("Invalid boolean for " + key + ", using default");
+            return defaultValue;
+        }
+    }
+    
+    public void setSetting(String key, String value) {
+        if (key == null || value == null) {
+            System.out.println("Key and value cannot be null!");
+            return;
+        }
+        settings.put(key, value);
+    }
+}
+```
+
+### Safe Array Access
+
+```java
+public class Inventory {
+    private String[] items;
+    
+    public Inventory(int size) {
+        this.items = new String[size];
+    }
+    
+    public boolean setItem(int slot, String item) {
+        try {
+            if (slot < 0 || slot >= items.length) {
+                throw new ArrayIndexOutOfBoundsException("Invalid slot: " + slot);
+            }
+            
+            items[slot] = item;
+            System.out.println("Placed " + item + " in slot " + slot);
+            return true;
+        } catch (ArrayIndexOutOfBoundsException e) {
+            System.out.println("Error: " + e.getMessage());
+            return false;
+        }
+    }
+    
+    public String getItem(int slot) {
+        try {
+            return items[slot];
+        } catch (ArrayIndexOutOfBoundsException e) {
+            System.out.println("Invalid slot: " + slot);
+            return null;
+        }
+    }
+}
+```
+
+### Command Parser with Error Handling
+
+```java
+public class CommandParser {
+    public static void parseCommand(String command) {
+        try {
+            if (command == null || command.trim().isEmpty()) {
+                throw new IllegalArgumentException("Command cannot be empty!");
+            }
+            
+            String[] parts = command.split(" ");
+            
+            if (parts.length < 2) {
+                throw new IllegalArgumentException("Invalid command format!");
+            }
+            
+            String action = parts[0];
+            String target = parts[1];
+            
+            switch (action) {
+                case "give":
+                    if (parts.length < 4) {
+                        throw new IllegalArgumentException("Usage: give <player> <item> <amount>");
+                    }
+                    String item = parts[2];
+                    int amount = Integer.parseInt(parts[3]);
+                    
+                    if (amount <= 0) {
+                        throw new IllegalArgumentException("Amount must be positive!");
+                    }
+                    
+                    System.out.println("Giving " + amount + " " + item + " to " + target);
+                    break;
+                    
+                case "tp":
+                    if (parts.length < 5) {
+                        throw new IllegalArgumentException("Usage: tp <player> <x> <y> <z>");
+                    }
+                    int x = Integer.parseInt(parts[2]);
+                    int y = Integer.parseInt(parts[3]);
+                    int z = Integer.parseInt(parts[4]);
+                    
+                    System.out.println("Teleporting " + target + " to " + x + ", " + y + ", " + z);
+                    break;
+                    
+                default:
+                    throw new IllegalArgumentException("Unknown command: " + action);
+            }
+        } catch (NumberFormatException e) {
+            System.out.println("Error: Invalid number in command!");
+        } catch (IllegalArgumentException e) {
+            System.out.println("Error: " + e.getMessage());
+        } catch (Exception e) {
+            System.out.println("Unexpected error: " + e.getMessage());
+        }
+    }
+    
+    public static void main(String[] args) {
+        parseCommand("give Steve diamond 5");
+        parseCommand("give Steve sword abc");  // Invalid number
+        parseCommand("tp Alice 10 64 20");
+        parseCommand("unknown command");       // Unknown command
+    }
+}
+```
+
+## Throwing Exceptions
+
+You can throw your own exceptions:
+
+```java
+public class Player {
+    private int health;
+    
+    public void setHealth(int health) {
+        if (health < 0) {
+            throw new IllegalArgumentException("Health cannot be negative!");
+        }
+        if (health > 100) {
+            throw new IllegalArgumentException("Health cannot exceed 100!");
+        }
+        this.health = health;
+    }
+}
+```
+
+<Callout type="info" title="When to Throw Exceptions">
+  Throw exceptions when:
+
+  - Method receives invalid input
+  - Operation cannot be completed
+  - Preconditions are not met
+  - Something unexpected happens
+
+  ```java
+  public void damagePlayer(int damage) {
+      if (damage < 0) {
+          throw new IllegalArgumentException("Damage must be positive!");
+      }
+      // Apply damage
+  }
+
+  public Item getItem(int slot) {
+      if (slot < 0 || slot >= inventory.length) {
+          throw new IndexOutOfBoundsException("Invalid inventory slot!");
+      }
+      return inventory[slot];
+  }
+  ```
+</Callout>
+
+## Checked vs Unchecked Exceptions
+
+<Callout type="warning" title="Exception Types">
+  **Unchecked Exceptions** (RuntimeException):
+
+  - Don't need to be caught
+  - Usually programming errors
+  - Examples: NullPointerException, ArrayIndexOutOfBoundsException
+
+  **Checked Exceptions**:
+
+  - Must be caught or declared
+  - Usually external errors (files, network)
+  - Examples: IOException, FileNotFoundException
+
+  ```java
+  // Unchecked - no need to catch
+  int result = 10 / 0;  // ArithmeticException
+
+  // Checked - must catch or declare
+  try {
+      FileReader file = new FileReader("data.txt");  // IOException
+  } catch (IOException e) {
+      // Handle error
+  }
+  ```
+</Callout>
+
+## Practice Exercises
+
+1. **Safe Division Calculator**: Create a method that divides two numbers. Handle division by zero and invalid input gracefully.
+
+2. **Player Level Setter**: Create a method that sets player level (1-100). Throw an exception if invalid, and handle it in main.
+
+3. **Safe Array Access**: Create a method that safely accesses array elements. Return null if index is invalid instead of crashing.
+
+4. **Config Parser**: Read a config string like "maxPlayers=10" and parse it. Handle invalid formats gracefully.
+
+5. **File Name Validator**: Create a method that checks if a filename is valid (no special characters, not empty). Throw exceptions for invalid names.
diff --git a/content/docs/bg-BG/guides/java-basics/13-inheritance.mdx b/content/docs/bg-BG/guides/java-basics/13-inheritance.mdx
new file mode 100644
index 00000000..1650c27a
--- /dev/null
+++ b/content/docs/bg-BG/guides/java-basics/13-inheritance.mdx
@@ -0,0 +1,629 @@
+---
+title: 13 - Inheritance
+description: Learn how to create class hierarchies and reuse code effectively.
+---
+
+Inheritance lets you create new classes based on existing ones. The new class inherits all the properties and methods of the parent class, and can add its own or modify inherited ones.
+
+## What is Inheritance?
+
+Think of inheritance like a family tree. A child inherits traits from their parent, but can also have their own unique traits.
+
+```java
+// Parent class (superclass)
+public class Entity {
+    protected String name;
+    protected int health;
+    
+    public Entity(String name, int health) {
+        this.name = name;
+        this.health = health;
+    }
+    
+    public void takeDamage(int damage) {
+        health -= damage;
+        System.out.println(name + " took " + damage + " damage!");
+    }
+}
+
+// Child class (subclass)
+public class Player extends Entity {
+    private int level;
+    
+    public Player(String name, int health, int level) {
+        super(name, health);  // Call parent constructor
+        this.level = level;
+    }
+    
+    public void levelUp() {
+        level++;
+        System.out.println(name + " leveled up to " + level + "!");
+    }
+}
+```
+
+<Callout type="info" title="Inheritance Terminology">
+  - **Superclass/Parent**: The class being inherited from (Entity)
+  - **Subclass/Child**: The class inheriting (Player)
+  - **extends**: Keyword to inherit from a class
+  - **super**: Keyword to access parent class members
+
+  ```java
+  public class Monster extends Entity {
+      // Monster IS-A Entity
+      // Monster inherits from Entity
+      // Entity is the parent, Monster is the child
+  }
+  ```
+</Callout>
+
+## The extends Keyword
+
+Use `extends` to inherit from a class:
+
+```java
+public class Animal {
+    protected String name;
+    
+    public void makeSound() {
+        System.out.println(name + " makes a sound");
+    }
+}
+
+public class Dog extends Animal {
+    public void wagTail() {
+        System.out.println(name + " wags tail");
+    }
+}
+
+public class Main {
+    public static void main(String[] args) {
+        Dog dog = new Dog();
+        dog.name = "Buddy";
+        dog.makeSound();  // Inherited from Animal
+        dog.wagTail();    // Dog's own method
+    }
+}
+```
+
+## The super Keyword
+
+`super` refers to the parent class:
+
+### Calling Parent Constructor
+
+```java
+public class Entity {
+    protected String name;
+    
+    public Entity(String name) {
+        this.name = name;
+    }
+}
+
+public class Player extends Entity {
+    private int level;
+    
+    public Player(String name, int level) {
+        super(name);  // Call parent constructor FIRST
+        this.level = level;
+    }
+}
+```
+
+<Callout type="warning" title="Constructor Rules">
+  - `super()` must be the **first** statement in child constructor
+  - If you don't call `super()`, Java automatically calls the no-argument parent constructor
+  - If parent has no no-argument constructor, you MUST call `super()` with arguments
+
+  ```java
+  // Wrong - super() not first
+  public Player(String name, int level) {
+      this.level = level;
+      super(name);  // Error!
+  }
+
+  // Correct
+  public Player(String name, int level) {
+      super(name);  // First statement
+      this.level = level;
+  }
+  ```
+</Callout>
+
+### Calling Parent Methods
+
+```java
+public class Entity {
+    protected int health;
+    
+    public void takeDamage(int damage) {
+        health -= damage;
+        System.out.println("Entity took damage!");
+    }
+}
+
+public class Player extends Entity {
+    @Override
+    public void takeDamage(int damage) {
+        super.takeDamage(damage);  // Call parent version
+        if (health < 20) {
+            System.out.println("Warning: Low health!");
+        }
+    }
+}
+```
+
+## Method Overriding
+
+Child classes can replace parent methods:
+
+```java
+public class Entity {
+    public void attack() {
+        System.out.println("Entity attacks!");
+    }
+}
+
+public class Player extends Entity {
+    @Override  // Good practice to use this annotation
+    public void attack() {
+        System.out.println("Player swings sword!");
+    }
+}
+
+public class Monster extends Entity {
+    @Override
+    public void attack() {
+        System.out.println("Monster bites!");
+    }
+}
+
+public class Main {
+    public static void main(String[] args) {
+        Player player = new Player();
+        Monster monster = new Monster();
+        
+        player.attack();   // "Player swings sword!"
+        monster.attack();  // "Monster bites!"
+    }
+}
+```
+
+<Callout type="info" title="@Override Annotation">
+  Always use `@Override` when overriding methods:
+
+  - Helps catch typos (if method doesn't exist in parent, you get an error)
+  - Makes code clearer
+  - Good documentation
+
+  ```java
+  // Without @Override - typo not caught
+  public void attac() {  // Typo! Creates new method instead
+      // ...
+  }
+
+  // With @Override - error caught immediately
+  @Override
+  public void attac() {  // Error: method doesn't exist in parent
+      // ...
+  }
+  ```
+</Callout>
+
+## Access Modifiers in Inheritance
+
+- `public` - Accessible everywhere
+- `protected` - Accessible in class and subclasses
+- `private` - Only in the class (not inherited)
+
+```java
+public class Parent {
+    public int publicVar;      // Child can access
+    protected int protectedVar; // Child can access
+    private int privateVar;     // Child CANNOT access
+    
+    private void privateMethod() {
+        // Child cannot call this
+    }
+    
+    protected void protectedMethod() {
+        // Child can call this
+    }
+}
+
+public class Child extends Parent {
+    public void test() {
+        publicVar = 10;      // OK
+        protectedVar = 20;   // OK
+        privateVar = 30;     // Error!
+        
+        protectedMethod();   // OK
+        privateMethod();     // Error!
+    }
+}
+```
+
+## Practical Examples
+
+### Game Entity Hierarchy
+
+```java
+// Base class for all entities
+public class Entity {
+    protected String name;
+    protected int health;
+    protected int maxHealth;
+    protected double x, y, z;
+    
+    public Entity(String name, int maxHealth) {
+        this.name = name;
+        this.health = maxHealth;
+        this.maxHealth = maxHealth;
+    }
+    
+    public void takeDamage(int damage) {
+        health -= damage;
+        if (health < 0) health = 0;
+        System.out.println(name + " took " + damage + " damage. Health: " + health);
+    }
+    
+    public boolean isAlive() {
+        return health > 0;
+    }
+    
+    public void moveTo(double x, double y, double z) {
+        this.x = x;
+        this.y = y;
+        this.z = z;
+        System.out.println(name + " moved to (" + x + ", " + y + ", " + z + ")");
+    }
+}
+
+// Player extends Entity
+public class Player extends Entity {
+    private int level;
+    private int experience;
+    private int mana;
+    
+    public Player(String name) {
+        super(name, 100);
+        this.level = 1;
+        this.experience = 0;
+        this.mana = 50;
+    }
+    
+    public void gainExperience(int amount) {
+        experience += amount;
+        System.out.println("Gained " + amount + " XP");
+        
+        if (experience >= level * 100) {
+            levelUp();
+        }
+    }
+    
+    private void levelUp() {
+        level++;
+        maxHealth += 10;
+        health = maxHealth;
+        mana += 5;
+        System.out.println("Level up! Now level " + level);
+    }
+    
+    @Override
+    public void takeDamage(int damage) {
+        super.takeDamage(damage);
+        if (health < maxHealth * 0.25) {
+            System.out.println("⚠ WARNING: Low health!");
+        }
+    }
+}
+
+// Monster extends Entity
+public class Monster extends Entity {
+    private int attackPower;
+    private String type;
+    
+    public Monster(String name, int health, int attackPower, String type) {
+        super(name, health);
+        this.attackPower = attackPower;
+        this.type = type;
+    }
+    
+    public int attack() {
+        System.out.println(name + " attacks!");
+        return attackPower;
+    }
+    
+    @Override
+    public void takeDamage(int damage) {
+        super.takeDamage(damage);
+        if (!isAlive()) {
+            System.out.println(name + " was defeated!");
+        }
+    }
+}
+
+// Boss extends Monster (multi-level inheritance)
+public class Boss extends Monster {
+    private int phase;
+    
+    public Boss(String name, int health, int attackPower) {
+        super(name, health, attackPower, "Boss");
+        this.phase = 1;
+    }
+    
+    @Override
+    public void takeDamage(int damage) {
+        super.takeDamage(damage);
+        
+        // Change phase at 50% health
+        if (phase == 1 && health < maxHealth / 2) {
+            phase = 2;
+            System.out.println(name + " enters PHASE 2!");
+        }
+    }
+    
+    @Override
+    public int attack() {
+        int damage = super.attack();
+        if (phase == 2) {
+            damage *= 2;
+            System.out.println("ENRAGED ATTACK!");
+        }
+        return damage;
+    }
+}
+```
+
+### Item Hierarchy
+
+```java
+// Base Item class
+public class Item {
+    protected String name;
+    protected int value;
+    protected double weight;
+    
+    public Item(String name, int value, double weight) {
+        this.name = name;
+        this.value = value;
+        this.weight = weight;
+    }
+    
+    public void use() {
+        System.out.println("Using " + name);
+    }
+    
+    public String getInfo() {
+        return name + " ($" + value + ", " + weight + " kg)";
+    }
+}
+
+// Weapon extends Item
+public class Weapon extends Item {
+    private int damage;
+    private int durability;
+    
+    public Weapon(String name, int value, double weight, int damage, int durability) {
+        super(name, value, weight);
+        this.damage = damage;
+        this.durability = durability;
+    }
+    
+    @Override
+    public void use() {
+        if (durability > 0) {
+            System.out.println("Attacking with " + name + " for " + damage + " damage!");
+            durability--;
+        } else {
+            System.out.println(name + " is broken!");
+        }
+    }
+    
+    @Override
+    public String getInfo() {
+        return super.getInfo() + ", Damage: " + damage + ", Durability: " + durability;
+    }
+}
+
+// Consumable extends Item
+public class Consumable extends Item {
+    private int healAmount;
+    private int uses;
+    
+    public Consumable(String name, int value, double weight, int healAmount, int uses) {
+        super(name, value, weight);
+        this.healAmount = healAmount;
+        this.uses = uses;
+    }
+    
+    @Override
+    public void use() {
+        if (uses > 0) {
+            System.out.println("Used " + name + ", restored " + healAmount + " health!");
+            uses--;
+        } else {
+            System.out.println("No " + name + " left!");
+        }
+    }
+    
+    @Override
+    public String getInfo() {
+        return super.getInfo() + ", Heals: " + healAmount + ", Uses: " + uses;
+    }
+}
+
+// Armor extends Item
+public class Armor extends Item {
+    private int defense;
+    private String slot;
+    
+    public Armor(String name, int value, double weight, int defense, String slot) {
+        super(name, value, weight);
+        this.defense = defense;
+        this.slot = slot;
+    }
+    
+    @Override
+    public void use() {
+        System.out.println("Equipped " + name + " (+" + defense + " defense)");
+    }
+    
+    @Override
+    public String getInfo() {
+        return super.getInfo() + ", Defense: " + defense + ", Slot: " + slot;
+    }
+}
+```
+
+## Polymorphism
+
+Child objects can be treated as parent objects:
+
+```java
+Entity entity1 = new Player("Alice");
+Entity entity2 = new Monster("Goblin", 50, 10, "Hostile");
+Entity entity3 = new Boss("Dragon", 500, 50);
+
+// All can use Entity methods
+entity1.takeDamage(10);
+entity2.takeDamage(10);
+entity3.takeDamage(10);
+
+// Array of different types
+Entity[] entities = {
+    new Player("Bob"),
+    new Monster("Zombie", 30, 8, "Hostile"),
+    new Monster("Spider", 20, 5, "Hostile")
+};
+
+// Process all entities the same way
+for (Entity entity : entities) {
+    entity.takeDamage(5);
+}
+```
+
+<Callout type="info" title="Polymorphism Benefits">
+  Polymorphism lets you write code that works with parent types but handles child types correctly:
+
+  ```java
+  public void damageEntity(Entity entity, int damage) {
+      entity.takeDamage(damage);
+      // Works for Player, Monster, Boss, etc.
+      // Each uses their own version of takeDamage()
+  }
+
+  // Can call with any Entity type
+  damageEntity(new Player("Alice"), 10);
+  damageEntity(new Monster("Goblin", 50, 10, "Hostile"), 10);
+  damageEntity(new Boss("Dragon", 500, 50), 10);
+  ```
+</Callout>
+
+## The Object Class
+
+All classes in Java automatically inherit from `Object`:
+
+```java
+public class MyClass {
+    // Automatically extends Object
+    // Has methods like toString(), equals(), etc.
+}
+```
+
+Common Object methods to override:
+
+```java
+public class Player {
+    private String name;
+    private int level;
+    
+    @Override
+    public String toString() {
+        return "Player: " + name + " (Lv. " + level + ")";
+    }
+    
+    @Override
+    public boolean equals(Object obj) {
+        if (obj instanceof Player) {
+            Player other = (Player) obj;
+            return this.name.equals(other.name);
+        }
+        return false;
+    }
+}
+```
+
+## Final Classes and Methods
+
+`final` prevents inheritance or overriding:
+
+```java
+// Final class - cannot be extended
+public final class SpecialItem {
+    // No class can extend this
+}
+
+// Final method - cannot be overridden
+public class Entity {
+    public final void printName() {
+        System.out.println(name);
+    }
+}
+
+public class Player extends Entity {
+    @Override
+    public void printName() {  // Error! Method is final
+        // Cannot override
+    }
+}
+```
+
+## Common Mistakes
+
+```java
+// Wrong - Forgetting super()
+public class Player extends Entity {
+    public Player(String name) {
+        // Error! Entity has no no-arg constructor
+    }
+}
+
+// Correct
+public class Player extends Entity {
+    public Player(String name) {
+        super(name, 100);  // Call parent constructor
+    }
+}
+
+// Wrong - Accessing private members
+public class Child extends Parent {
+    public void test() {
+        privateVar = 10;  // Error! private is not inherited
+    }
+}
+
+// Correct - Use protected
+public class Parent {
+    protected int protectedVar;  // Child can access
+}
+
+// Wrong - Multiple inheritance (not allowed in Java)
+public class Child extends Parent1, Parent2 {  // Error!
+}
+
+// Correct - Single inheritance only
+public class Child extends Parent {
+}
+```
+
+## Practice Exercises
+
+1. **Vehicle Hierarchy**: Create a `Vehicle` class with properties like speed and fuel. Create `Car` and `Motorcycle` subclasses with their own unique features.
+
+2. **Shape Calculator**: Create a `Shape` class with a `calculateArea()` method. Create `Circle`, `Rectangle`, and `Triangle` subclasses that override this method.
+
+3. **RPG Characters**: Create a `Character` class. Extend it to make `Warrior`, `Mage`, and `Archer` classes with unique abilities.
+
+4. **Animal Sounds**: Create an `Animal` class with a `makeSound()` method. Create various animal subclasses that override this method.
diff --git a/content/docs/bg-BG/guides/learning-to-learn.mdx b/content/docs/bg-BG/guides/learning-to-learn.mdx
new file mode 100644
index 00000000..567e514e
--- /dev/null
+++ b/content/docs/bg-BG/guides/learning-to-learn.mdx
@@ -0,0 +1,37 @@
+---
+title: Learning to Learn
+description: A guide to help you become a better learner and adapt to new information effectively.
+icon: CircleQuestionMark
+---
+
+## Why learn to code? We have visual scripting!
+
+Yes we do, and honestly you should try that out. Visual scripting is a great addition to Hytale and we know it'll be powerful, but nothing beats the ability of being able to read and write Java code, with the ability to build even more powerful mods and plugins.
+
+<Callout type="info" title="Visual Scripting vs Coding">
+  Visual scripting is great for beginners and for simple tasks, but coding allows for more complex and efficient solutions. Learning to code opens up a wider range of possibilities for modding Hytale.
+
+  We will have guides on visual scripting when Hytale releases from Day 1.
+</Callout>
+
+## Should everyone trying to mod Hytale learn how to code?
+
+No one should feel like they HAVE to learn to code to make stuff in Hytale. Simon and his team have validated this time and time again with their strives in graph editors and visual scripting. You can change mob behavior, world generation, etc. all with just these tools.
+
+But if you're looking to build more complex things (from utilities to entirely custom server software) that could be used by large scale server networks and big names, you'll want to learn how to code. And that's where this guide comes in...
+
+## Okay, I'm interested. What's to come?
+
+Over the course of these next several lessons you'll learn the basics of coding, how to read documentation, and how to find resources to help you learn more on your own.
+
+The guides themselves will take a very big "bird's-eye view" approach to things and provide links to resources to do the actual coding. This is done because, quite frankly, enough resources exist on how to learn this stuff, it's just the act of finding the right stuff on Google that can be hard. Learning to be able to code without guidance is the goal. The Hytale Modding community is always there to help you, but to become a truly well rounded developer, you'll have to pick up a lot of this stuff just by reading from resources.
+
+<Callout type="info" title="Finding Resources">
+  We have created a small Java Basics series to help you get started with the language itself, but beyond that, you'll be expected to find your own resources to learn more. We recommend sites like [w3schools](https://www.w3schools.com/java/) and [GeeksforGeeks](https://www.geeksforgeeks.org/java/) as great starting points.
+</Callout>
+
+Our goal is to teach you how to Mod Hytale, and that will always be our goal. This is the reason we can't teach you everything about Java or programming in general. Instead, we want to give you the tools to be able to learn on your own, so you can continue to grow as a developer even after you've completed our guides.
+
+## Any closing thoughts?
+
+Remember, learning to code is hard. You will trip and fall, but you will be able to get back up. Stay resilient, believe you can make cool stuff, and I promise you success will come. Happy coding!
diff --git a/content/docs/bg-BG/guides/plugin/animated-block-textures.mdx b/content/docs/bg-BG/guides/plugin/animated-block-textures.mdx
new file mode 100644
index 00000000..42bfa51f
--- /dev/null
+++ b/content/docs/bg-BG/guides/plugin/animated-block-textures.mdx
@@ -0,0 +1,101 @@
+---
+title: Animated Block Textures
+description: Learn how to attach a .blockyanim to a block
+authors:
+  - name: Burkino
+---
+
+import { File, Folder, Files } from 'fumadocs-ui/components/files';
+
+So, you want to make your blocks feel more alive through animations, do you?\
+Now for the most part this is the exact same as [Creating custom blocks](./creating-block).
+![blue fire gif](/assets/guides/blue_fire.gif)
+
+## Prerequisites
+
+This is NOT a guide on animating or texturing or even using BlockBench, why? Because I don't know how to do that.\
+The only thing we will be doing is taking the fire texture, changing the color, and applying it to our new fire block.
+
+## Setup
+
+To start, you're obviously going to want to grab the `Common/VFX/Fire/Fire.png` file. How you do it is up to you, in the Asset Editor you'll need to switch to the Common tab.\
+I'll assume you know how colorize or change the hue of an image, so go ahead and do that now and save it as `Blue_Fire.png`.
+
+The other assets used in this guide are `Common/VFX/Fire/Fire.blockymodel` and `Common/Blocks/Animations/Fire/Fire_Burn.blockyanim` (both renamed to `Blue_Fire`) but since we won't be changing them it's probably fine to leave them. I will reference the `Blue_Fire` versions as a way to point out what should be custom assets.\
+I will also duplicate `Server/Item/Item/Deco/Deco_Fire.json` and call it `Deco_Blue_Fire.json`.
+
+## Applying the changes
+
+The `Deco_Blue_Fire` block is actually just a particle emitter, however we will not be using particles, so lets start by removing them in `Block > Particles`.\
+Next we want to set the Block Model (called `CustomModel` in JSON) to `VFX/Blue_Fire/Blue_Fire.blockymodel` and Block Model Textures (`CustomModelTexture` in JSON) to
+
+```json
+[
+    {
+        "Texture": "VFX/Blue_Fire/Blue_Fire.png",
+        "Weight": 1
+    }
+]
+```
+
+Finally, we will apply the .blockyanim to our model, this is done through the Block Model Animation property (`CustomModelAnimation` in JSON) and the value should be `Blocks/Animations/Blue_Fire/Blue_Fire_Burn.blockyanim`.
+
+## Final Code
+
+With that your new blue fire should be done. Here is the minimal JSON for our blue fire.\
+There is an additional `Looping` and `RequiresAlphaBlending` property that I have not gone over, however I hope it is self-explanatory.
+
+```json
+{
+  "BlockType": {
+    "DrawType": "Model",
+    "CustomModel": "VFX/Blue_Fire/Blue_Fire.blockymodel",
+    "CustomModelAnimation": "Blocks/Animations/Blue_Fire/Blue_Fire_Burn.blockyanim",
+    "CustomModelTexture": [
+      {
+        "Texture": "VFX/Blue_Fire/Blue_Fire.png",
+        "Weight": 1
+      }
+    ],
+    "Looping": true,
+    "RequiresAlphaBlending": false
+  },
+  "PlayerAnimationsId": "Block"
+}
+```
+
+<Files>
+  <Folder name="resources" defaultOpen>
+    <Folder name="Server" defaultOpen>
+      <Folder name="Item" defaultOpen>
+        <Folder name="Items" defaultOpen>
+          <Folder name="Deco" defaultOpen>
+            <File name="Deco_Blue_Fire.json" />
+          </Folder>
+        </Folder>
+      </Folder>
+    </Folder>
+
+    <Folder name="Common" defaultOpen>
+      <Folder name="Blocks" defaultOpen>
+        <Folder name="Animations" defaultOpen>
+          <Folder name="Blue_Fire" defaultOpen>
+            <File name="Blue_Fire_Burn.blockyanim" />
+          </Folder>
+        </Folder>
+      </Folder>
+
+      <Folder name="VFX" defaultOpen>
+        <Folder name="Blue_Fire" defaultOpen>
+          <File name="Blue_Fire.blockymodel" />
+
+          <File name="Blue_Fire.png" />
+        </Folder>
+      </Folder>
+    </Folder>
+  </Folder>
+</Files>
+
+## Next steps
+
+Now that you know how to attach an animation to a block, try adding it to a block state.
diff --git a/content/docs/bg-BG/guides/plugin/browsing-serverjar.mdx b/content/docs/bg-BG/guides/plugin/browsing-serverjar.mdx
new file mode 100644
index 00000000..240ed19a
--- /dev/null
+++ b/content/docs/bg-BG/guides/plugin/browsing-serverjar.mdx
@@ -0,0 +1,111 @@
+---
+title: Browsing the server.jar code
+description: Learn how to decompile the HytaleServer.jar and browse the source code.
+authors:
+  - name: musava_ribica
+    url: https://github.com/IamMusavaRibica
+---
+
+Our [patcher](https://github.com/HytaleModding/patcher) tool allows you to easily prepare an environment for exploring the Hytale Server.
+
+## Why?
+
+When you add a compiled jar as a library, IntelliJ only decompiles class by class and doesn't let you search it. For example, you cannot right click some class and then Find Usages. This script will give you a ready to use Hytale server code as a project where you can explore anything you want.
+
+If anything goes wrong, please ping the author in [this post](https://discord.com/channels/1440173445039132724/1460707397189238785) in the Hytale Modding discord server
+
+## Instructions
+
+If you prefer watching over reading, check out the awesome video walkthrough made by Hyphen45. Note that the written instructions have since been improved, but the process remains the same.
+
+<iframe src="https://www.youtube.com/embed/j8dgR_0Hde8" allowFullScreen />
+
+After watching, check out the _Adding HytaleServer as a dependency_ section below.
+
+- Clone the repository `git clone https://github.com/HytaleModding/patcher.git`, and enter the directory using `cd patcher`
+
+- Create a Python virtual environment in the `.venv` folder. The command for this varies by platform but it is probably
+  one of these:
+
+  - `python -m venv .venv`
+  - `python3 -m venv .venv` (Linux)
+  - `py -3.13 -m venv .venv` (Windows)
+
+  In the last one, specifying the version is recommended if you have multiple Pythons installed.
+
+- Activate the virtual environment:
+  - Windows: If you're using normal command prompt, do `".venv\Scripts\activate"` and if you're using PowerShell, do `.\.venv\Scripts\activate`
+  - Linux/Mac: `source .venv/bin/activate`
+  - From now on, you are running python commands from inside the venv, hence you must use `python` instead of `py` or `python3` to invoke python.
+
+- You should now have `(.venv)` prefixed to the current working dir in the terminal.
+
+- Inside the venv, install the dependencies
+  - `pip install -r requirements.txt`
+
+- Install these dependencies and ensure they are on PATH:
+  - `git` - download from [here](https://git-scm.com/install/) and make sure the `C:\Program Files\Git\cmd\` folder is on your PATH.
+  - `java` you need JDK 25 or newer
+  - `jar` (comes with JDK inside the bin folder)
+  - `mvn` - download from [here](https://maven.apache.org/download.cgi), extract and add the `bin` folder on your PATH
+
+After modifying your PATH, don't forget to close existing terminals and start a new one. Verify that those tools are installed by running these commands: `git --version`, `mvn --version`, `java --version`, `jar --version`.
+
+- Put your HytaleServer.jar in the same root directory of this repo or specify an environment variable `HYTALESERVER_JAR_PATH` with the path to your HytaleServer.jar
+
+Then run this:
+
+```shell
+python run.py setup
+```
+
+What will it do:
+
+- copy the HytaleServer.jar into `work/download`
+  - (on Windows) fix `META-INF/license` name collision
+- decompile only the `com.hypixel` package using Vineflower and save the output to `work/decompile`
+- set up a Maven project in `hytale-server` with the decompiled code
+  - all other libraries the server uses are added into pom.xml and you don't have to worry about them.
+
+You can then open the `hytale-server` folder in your favorite IDE and begin exploring the code. For _IntelliJ IDEA_,
+you must first set up the SDK. After opening the project (you can open the `pom.xml` file, IDEA will prompt you to open
+the entire project) press Ctrl+Alt+Shift+S and under _Project_ configure _SDK_ and _Language level_ to **25**.
+
+This decompiled code is likely broken. But it is somewhat usable for exploration. Try Ctrl+Shift+F and search PacketAdapters. Want to figure out where is PlayerSetupConnectEvent constructed? Just find it somewhere then right click and Find Usages, and at the bottom see New instance creation.
+
+## Adding HytaleServer as a dependency
+
+Go into `hytale-server/src/main/java` folder in your terminal (cmd or powershell). Run this command
+
+```shell
+jar -f hytale-server-stripped.jar -c com
+```
+
+Then run this **from the same folder**:
+
+```shell
+mvn install:install-file -Dfile=hytale-server-stripped.jar -DgroupId="com.hypixel.hytale" -DartifactId=HytaleServer-stripped -Dversion="1.0-SNAPSHOT" -Dpackaging=jar
+```
+
+Then, in your plugin project add this dependency and also copy other dependencies from the `hytale-server/pom.xml`.
+
+```xml
+<dependency>
+    <groupId>com.hypixel.hytale</groupId>
+    <artifactId>HytaleServer-stripped</artifactId>
+    <version>1.0-SNAPSHOT</version>
+    <scope>provided</scope>
+    <!-- other dependencies too... -->
+</dependency>
+```
+
+Congratulations!
+
+## Reloading Maven projects
+
+You may have to reload the maven project sometimes. Here's how to do that:\
+![_readme_images/img.png](/assets/reload-maven.png)\
+It is located in the "m" icon on the right side:\
+![_readme_images/m.png](/assets/maven.png)\
+If you don't see it, enable it under View -> Tool Windows -> Maven.\
+![_readme_images/tool_windows.png](/assets/view-windowtools-maven.png)
diff --git a/content/docs/bg-BG/guides/plugin/build-and-test.mdx b/content/docs/bg-BG/guides/plugin/build-and-test.mdx
new file mode 100644
index 00000000..f37534c3
--- /dev/null
+++ b/content/docs/bg-BG/guides/plugin/build-and-test.mdx
@@ -0,0 +1,115 @@
+---
+title: Build and Test Your Mod
+description: Learn how to build your Hytale mod and test it in-game.
+authors:
+  - name: Michael B
+---
+
+If you followed along with the [Setting Up Your Development Environment](./setting-up-env) page, you should now be able to build your project.
+
+## Building Your Mod
+
+In our case, we've **Gradle** as the build system. Gradle is a powerful build automation tool that manages dependencies, compiles your code, and packages everything into a distributable JAR file.
+
+### Understanding Gradle
+
+Gradle can use a `build.gradle.kts` file (Kotlin DSL) to define your project's configuration, dependencies, and build settings. You can learn more about Gradle at the [official Gradle website](https://gradle.org/).
+
+### Building with Gradle
+
+To build your mod, open a terminal in your project directory and run:
+
+```bash
+./gradlew build
+```
+
+This command will:
+
+1. Compile your Java source code
+2. Run any tests (if present)
+3. Package everything into a JAR file
+
+<Callout type="info">
+  If you are using the plugin template from the [Setting Up Your Development Environment](./setting-up-env) guide, then the build script is already set up for you. It includes paths to your Hytale game library and handles the packaging of your mod, managing hytale dependencies and manifest changes.
+
+  If you have a different path to your Hytale installation, you may receive the following error:
+
+  ```bash
+  FAILURE: Build failed with an exception.
+
+  * What went wrong:
+  Failed to find Hytale at the expected location. Please make sure you have installed the game. The expected location can be changed using the hytale.home_path property. Currently looking in 'C:\Path\To\Hytale'
+  ```
+
+  You can change the path by adding a property to your `gradle.properties` file (if it doesn't exist, create it in the root of your project):
+
+  ```properties
+  hytale.home_path=C:\Correct\Path\To\Hytale
+  ```
+</Callout>
+
+### Build Output
+
+Once the build completes successfully, your mod will be located in the `build/libs` directory and named:
+
+```
+ExamplePlugin-1.0.jar
+```
+
+<Callout type="info">
+  The exact name may vary depending on what you configured in your `build.gradle.kts` and `settings.gradle.kts` file. Check the `rootProject.name` and `version` fields to see what your JAR will be named.
+</Callout>
+
+## Testing Your Mod
+
+Now that you've built your mod, it's time to test it in Hytale!
+
+### 1. Locate the Mods Folder
+
+First, you need to find Hytale's mods directory:
+
+1. Go to your Hytale installation directory (The default location is usually in your AppData folder)
+   > On Windows, you can access it by clicking `windows + R` and typing `%appdata%`.
+2. Navigate to: `/UserData/Mods`
+
+The default path would look like:
+
+```
+C:\Users\YourUsername\AppData\Roaming\Hytale\UserData\Mods
+```
+
+<Callout type="warning">
+  If the `Mods` folder doesn't exist, you may need to create it manually or launch Hytale at least once.
+</Callout>
+
+### 2. Copy Your Mod
+
+Copy the `ExamplePlugin-1.0.jar` file from your project's `build/libs` directory into the `Mods` folder you just located.
+
+### 3. Launch Hytale and Verify
+
+1. **Start Hytale**
+2. **Click "Create a New World"**
+3. **Click the settings cog**
+4. **Click "Mods"**
+5. **See your mod** in the list!
+
+If your mod appears in the list, congratulations! Your mod has been successfully loaded by Hytale.
+
+## Troubleshooting
+
+If your mod doesn't appear in the mods list:
+
+- Make sure the JAR file is in the correct `Mods` folder
+- Check that your `manifest.json` file is properly configured
+- Look for any error messages in the Hytale logs
+- Verify that you're using the correct version of Java and Gradle
+
+## Next Steps
+
+Now that you can build and test your mod, you're ready to start adding functionality! Check out these guides:
+
+- [Create Commands](./creating-commands) - Add custom commands to your mod
+- [Create Events](./creating-events) - React to in-game events
+
+Happy modding!
diff --git a/content/docs/bg-BG/guides/plugin/chat-formatting.mdx b/content/docs/bg-BG/guides/plugin/chat-formatting.mdx
new file mode 100644
index 00000000..c76ffd4c
--- /dev/null
+++ b/content/docs/bg-BG/guides/plugin/chat-formatting.mdx
@@ -0,0 +1,205 @@
+---
+title: Formatting the chat
+description: Learn how to format the chat using the PlayerChatEvent and rich text with TinyMessage
+authors:
+  - name: oskarscot
+    url: https://oskar.scot
+---
+
+![chat format example](/assets/guides/chat-example.png)
+
+The chat uses the PlayerChatEvent, it contains the formatter, the PlayerRef for the sender, the content as well as a list of targets (it's safe to assume the targets is the list of players who can see the chat message)
+You can cancel this event as well as modify the content and the formatter.
+
+## Manual Formatting (Standard Approach)
+
+```java
+public class ChatFormatter {
+
+  public static void onPlayerChat(PlayerChatEvent event) {
+    PlayerRef sender = event.getSender();
+    if(event.getContent().equalsIgnoreCase("poo")) {
+      event.setCancelled(true);
+      sender.sendMessage(Message.raw("Hey, you cannot say that!").color(Color.RED));
+    }
+
+    if(event.getContent().equalsIgnoreCase("you stink")) {
+      event.setContent("i stink");
+    }
+
+    event.setFormatter((playerRed, message) ->
+        Message.join(
+            Message.raw("[COOL] ").color(Color.RED),
+            Message.raw(sender.getUsername()).color(Color.YELLOW),
+            Message.raw(" : " + message).color(Color.PINK)
+        ));
+
+  }
+}
+```
+
+The formatter is the following interface:
+
+```java
+  public interface Formatter {
+    @Nonnull
+    Message format(@Nonnull PlayerRef playerRef, @Nonnull String message);
+  }
+}
+```
+
+---
+
+## TinyMessage - Rich Text Formatting (Easy Alternative)
+
+![chat format example](/assets/guides/chat-tinymessage-example.png)
+
+**TinyMessage** is a lightweight, powerful rich text parser for Hytale servers that allows you to use simple tags to create gradients, hex colors, clickable links, and nested styles in chat messages. Similar to minecraft MiniMessage
+
+### Features
+
+- **Gradients:** `<gradient:red:blue>Hello</gradient>` or multi-color `<gradient:gold:red:black>...`
+- **Hex Colors:** `<color:#FF55FF>Custom Colors</color>` or `<color:red>Named Colors</color>`
+- **Standard Styles:** `<b>Bold</b>`, `<i>Italic</i>`, `<u>Underline</u>`, `<mono>Monospace</mono>`
+- **Clickable Links:** `<link:https://google.com>Click me!</link>`
+- **Nested Styling:** Tags can be nested indefinitely
+
+### Usage Examples
+
+```java
+import fi.sulku.hytale.TinyMsg;
+import com.hypixel.hytale.server.core.Message;
+
+// Parse a formatted string into a Message
+Message message = TinyMsg.parse("<gradient:red:blue>Hello World!</gradient>");
+player.sendMessage(message);
+
+// Multiple styles
+TinyMsg.parse("<b><color:gold>Bold Gold Text</color></b>");
+
+// Clickable gradient link
+TinyMsg.parse("<link:https://example.com><gradient:aqua:blue>Click me!</gradient></link>");
+
+// Complex nested styling
+TinyMsg.parse("<b>Bold <i>and italic <color:red>and red</color></i></b>");
+
+// Reset styles mid-text
+TinyMsg.parse("<b>Bold <reset>normal text");
+```
+
+```java
+public class ChatFormatter {
+
+    private void onPlayerChat(PlayerChatEvent event) {
+        PlayerRef sender = event.getSender();
+        if (event.getContent().equalsIgnoreCase("poo")) {
+            event.setCancelled(true);
+            sender.sendMessage(TinyMsg.parse("<red>Hey, you cannot say that!</red>"));
+        }
+
+        if (event.getContent().equalsIgnoreCase("you stink")) {
+            event.setContent("i stink");
+        }
+
+        event.setFormatter((playerRed, message) ->
+                TinyMsg.parse("<red>[COOL] </red><yellow>" + sender.getUsername() + "</yellow><pink> : " + message + "</pink>"));
+  }
+}
+```
+
+### Installation
+
+Links:
+
+<a href="https://github.com/Zoltus/TinyMessage/" target="_blank" rel="noopener noreferrer">
+  Github Repository
+</a>
+
+<a href="https://github.com/Zoltus/TinyMessage/releases" target="_blank" rel="noopener noreferrer">
+  Github Releases
+</a>
+
+Curseforge (coming soon)
+
+## Installation for server owners:
+
+### Download the TinyMessage.jar
+
+Download the latest TinyMessage.jar from the releases page and place it in your server's `mods` folder.
+
+## Installation for developers:
+
+### manifest.json
+
+```json
+"Dependencies": {
+  "Zoltus:TinyMessage": "*"
+},
+```
+
+### For Gradle
+
+```kotlin
+repositories {
+    maven { url = uri("https://jitpack.io") }
+}
+
+dependencies {
+    compileOnly("com.github.Zoltus:TinyMessage:2.0.1") // Use newest version in the repo
+}
+```
+
+### For Maven
+
+```xml
+<repositories>
+    <repository>
+        <id>jitpack.io</id>
+        <url>https://jitpack.io</url>
+    </repository>
+</repositories>
+
+<dependency>
+    <groupId>com.github.Zoltus</groupId>
+    <artifactId>TinyMessage</artifactId>
+    <version>2.0.1</version>
+    <scope>provided</scope>
+</dependency>
+```
+
+---
+
+### API Reference
+
+#### `TinyMsg.parse(String text)`
+
+Parses a string with TinyMsg tags and returns a `Message` object.
+
+**Parameters:**
+
+- `text` - The string to parse
+
+**Returns:**
+
+- `Message` - A Hytale `Message` object ready to be sent to players
+
+### Supported Tags
+
+| Tag                | Aliases               | Example                                 | Description                    |
+| ------------------ | --------------------- | --------------------------------------- | ------------------------------ |
+| `<color:X>`        | `<c:X>`, `<colour:X>` | `<color:red>text</color>`               | Sets text color (named or hex) |
+| `<gradient:X:Y:Z>` | `<grnt:X:Y:Z>`        | `<gradient:red:blue>text</gradient>`    | Creates a color gradient       |
+| `<bold>`           | `<b>`                 | `<b>text</b>`                           | Makes text bold                |
+| `<italic>`         | `<i>`, `<em>`         | `<i>text</i>`                           | Makes text italic              |
+| `<underline>`      | `<u>`                 | `<u>text</u>`                           | Underlines text                |
+| `<monospace>`      | `<mono>`              | `<mono>text</mono>`                     | Uses monospace font            |
+| `<link:URL>`       | `<url:link>`          | `<link:https://google.com>click</link>` | Creates clickable link         |
+| `<reset>`          | `<r>`                 | `<b>bold<reset>normal`                  | Resets all formatting          |
+
+### Named Colors
+
+`black`, `dark_blue`, `dark_green`, `dark_aqua`, `dark_red`, `dark_purple`, `gold`, `gray`, `dark_gray`, `blue`, `green`, `aqua`, `red`, `light_purple`, `yellow`, `white`
+
+### License
+
+TinyMsg is available under the MIT License - feel free to use in your projects!
diff --git a/content/docs/bg-BG/guides/plugin/client-inputs-reference.mdx b/content/docs/bg-BG/guides/plugin/client-inputs-reference.mdx
new file mode 100644
index 00000000..a9f2f085
--- /dev/null
+++ b/content/docs/bg-BG/guides/plugin/client-inputs-reference.mdx
@@ -0,0 +1,94 @@
+---
+title: "Packets: Client-to-Server Reference"
+description: Complete reference for every packet the client can send to the server.
+authors:
+  - name: Vibe Theory & musava
+    url: https://discord.com/users/145420279294722048
+---
+
+Please see [Listening to Packets Guide](https://forum.hytalemodding.dev/d/17-listening-to-packets) for further details
+
+Packet are found in the decompiled server source: `"decompiled/sources/com/hypixel/hytale/protocol/packets"`
+
+---
+
+## Player Packets
+
+Packets sent by the client for player actions, movement, and state updates.
+
+| Packet Name                   | ID  | Fields                                                                                                                                                                                                                                                              |
+| ----------------------------- | --- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `SetClientId`                 | 100 | `clientId`                                                                                                                                                                                                                                                          |
+| `SetGameMode`                 | 101 | `gameMode`                                                                                                                                                                                                                                                          |
+| `SetMovementStates`           | 102 | `movementStates`                                                                                                                                                                                                                                                    |
+| `SetBlockPlacementOverride`   | 103 | `enabled`                                                                                                                                                                                                                                                           |
+| `JoinWorld`                   | 104 | `clearWorld`, `fadeInOut`, `worldUuid`                                                                                                                                                                                                                              |
+| `ClientReady`                 | 105 | `readyForChunks`, `readyForGameplay`                                                                                                                                                                                                                                |
+| `LoadHotbar`                  | 106 | `inventoryRow`                                                                                                                                                                                                                                                      |
+| `SaveHotbar`                  | 107 | `inventoryRow`                                                                                                                                                                                                                                                      |
+| `ClientMovement`              | 108 | `movementStates`, `relativePosition`, `absolutePosition`, `bodyOrientation`, `lookOrientation`, `teleportAck`, `wishMovement`, `velocity`, `mountedTo`, `riderMovementStates`                                                                                       |
+| `ClientTeleport`              | 109 | `teleportId`, `modelTransform`, `resetVelocity`                                                                                                                                                                                                                     |
+| `UpdateMovementSettings`      | 110 | `movementSettings`                                                                                                                                                                                                                                                  |
+| `MouseInteraction`            | 111 | `clientTimestamp`, `activeSlot`, `itemInHandId`, `screenPoint`, `mouseButton`, `mouseMotion`, `worldInteraction`                                                                                                                                                    |
+| `DamageInfo`                  | 112 | `damageSourcePosition`, `damageAmount`, `damageCause`                                                                                                                                                                                                               |
+| `ReticleEvent`                | 113 | `eventIndex`                                                                                                                                                                                                                                                        |
+| `DisplayDebug`                | 114 | `shape`, `matrix`, `color`, `time`, `fade`, `frustumProjection`                                                                                                                                                                                                     |
+| `ClearDebugShapes`            | 115 | _(none)_                                                                                                                                                                                                                                                            |
+| `SyncPlayerPreferences`       | 116 | `showEntityMarkers`, `armorItemsPreferredPickupLocation`, `weaponAndToolItemsPreferredPickupLocation`, `usableItemsItemsPreferredPickupLocation`, `solidBlockItemsPreferredPickupLocation`, `miscItemsPreferredPickupLocation`, `allowNPCDetection`, `respondToHit` |
+| `ClientPlaceBlock`            | 117 | `position`, `rotation`, `placedBlockId`                                                                                                                                                                                                                             |
+| `UpdateMemoriesFeatureStatus` | 118 | `isFeatureUnlocked`                                                                                                                                                                                                                                                 |
+| `RemoveMapMarker`             | 119 | `markerId`                                                                                                                                                                                                                                                          |
+
+## Inventory Packets
+
+Packets sent by the client for inventory management and item manipulation.
+
+| Packet Name             | ID  | Fields                                                                                      |
+| ----------------------- | --- | ------------------------------------------------------------------------------------------- |
+| `UpdatePlayerInventory` | 170 | `storage`, `armor`, `hotbar`, `utility`, `builderMaterial`, `tools`, `backpack`, `sortType` |
+| `SetCreativeItem`       | 171 | `inventorySectionId`, `slotId`, `item`, `override`                                          |
+| `DropCreativeItem`      | 172 | `item`                                                                                      |
+| `SmartGiveCreativeItem` | 173 | `item`, `moveType`                                                                          |
+| `DropItemStack`         | 174 | `inventorySectionId`, `slotId`, `quantity`                                                  |
+| `MoveItemStack`         | 175 | `fromSectionId`, `fromSlotId`, `quantity`, `toSectionId`, `toSlotId`                        |
+| `SmartMoveItemStack`    | 176 | `fromSectionId`, `fromSlotId`, `quantity`, `moveType`                                       |
+| `SetActiveSlot`         | 177 | `inventorySectionId`, `activeSlot`                                                          |
+| `SwitchHotbarBlockSet`  | 178 | `itemId`                                                                                    |
+| `InventoryAction`       | 179 | `inventorySectionId`, `inventoryActionType`, `actionData`                                   |
+
+## Window Packets
+
+Packets sent by the client for UI window interactions.
+
+| Packet Name        | ID  | Fields                                                          |
+| ------------------ | --- | --------------------------------------------------------------- |
+| `OpenWindow`       | 200 | `id`, `windowType`, `windowData`, `inventory`, `extraResources` |
+| `UpdateWindow`     | 201 | `id`, `windowData`, `inventory`, `extraResources`               |
+| `CloseWindow`      | 202 | `id`                                                            |
+| `SendWindowAction` | 203 | `id`, `action`                                                  |
+| `ClientOpenWindow` | 204 | `type`                                                          |
+
+## Other Client Packets
+
+Additional client-to-server packets.
+
+| Packet Name              | ID  | Fields                                             |
+| ------------------------ | --- | -------------------------------------------------- |
+| `ClientReferral`         | 18  | `hostTo`, `data`                                   |
+| `SetUpdateRate`          | 29  | `updatesPerSecond`                                 |
+| `SetTimeDilation`        | 30  | `timeDilation`                                     |
+| `SetChunk`               | 131 | `x`, `y`, `z`, `localLight`, `globalLight`, `data` |
+| `SetChunkHeightmap`      | 132 | `x`, `z`, `heightmap`                              |
+| `SetChunkTintmap`        | 133 | `x`, `z`, `tintmap`                                |
+| `SetChunkEnvironments`   | 134 | `x`, `z`, `environments`                           |
+| `SetFluids`              | 136 | `x`, `y`, `z`, `data`                              |
+| `SetPaused`              | 158 | `paused`                                           |
+| `SetEntitySeed`          | 160 | `entitySeed`                                       |
+| `SetPage`                | 216 | `page`, `canCloseThroughInteraction`               |
+| `SetServerAccess`        | 252 | `access`, `password`                               |
+| `SetMachinimaActorModel` | 261 | `model`, `sceneName`, `actorName`                  |
+| `SetServerCamera`        | 280 | `clientCameraView`, `isLocked`, `cameraSettings`   |
+| `SetFlyCameraMode`       | 283 | `entering`                                         |
+| `SyncInteractionChains`  | 290 | `updates`                                          |
+
+_From Hytale Server build `2026.01.13-dcad8778f`_
diff --git a/content/docs/bg-BG/guides/plugin/creating-block.mdx b/content/docs/bg-BG/guides/plugin/creating-block.mdx
new file mode 100644
index 00000000..07b909ad
--- /dev/null
+++ b/content/docs/bg-BG/guides/plugin/creating-block.mdx
@@ -0,0 +1,101 @@
+---
+title: Creating custom blocks
+description: Learn how to create custom blocks for your Hytale mod.
+authors:
+  - name: Flo_12344
+    url: https://flotterstudio.com
+---
+
+import { File, Folder, Files } from 'fumadocs-ui/components/files';
+
+Creating custom blocks requires enabling asset packs and organizing your files properly.
+
+## Setup
+
+1. Enable asset packs in `manifest.json` by setting `IncludesAssetPack` to `true`
+2. Create the following folder structure:
+
+<Files>
+  <Folder name="resources" defaultOpen>
+    <Folder name="Server" defaultOpen>
+      <Folder name="Item" defaultOpen>
+        <Folder name="Items" />
+      </Folder>
+
+      <Folder name="Languages" defaultOpen>
+        <Folder name="en-US" />
+      </Folder>
+    </Folder>
+
+    <Folder name="Common" defaultOpen>
+      <Folder name="Icons" />
+
+      <Folder name="Blocks" defaultOpen>
+        <Folder name="my_new_block" defaultOpen>
+          <File name="model.blockymodel" />
+        </Folder>
+      </Folder>
+
+      <Folder name="BlockTextures" defaultOpen>
+        <File name="texture.png" />
+      </Folder>
+    </Folder>
+  </Folder>
+</Files>
+
+3. Add translations in `Server/Languages/en-US/items.lang`:
+
+```
+my_new_block.name = My New Block
+my_new_block.description = My Description
+```
+
+## Basic Cube Block
+
+Create `Server/Item/Items/my_new_block.json`:
+
+```json
+{
+  "TranslationProperties": {
+    "Name": "items.my_new_block.name",
+    "Description": "items.my_new_block.description"
+  },
+  "Id": "My_New_Block",
+  "MaxStack": 100,
+  "Icon": "Icons/ItemsGenerated/my_new_block.png",
+  "Categories": [
+    "Blocks.Rocks"
+  ],
+
+  "PlayerAnimationsId": "Block",
+  "Set": "Rock_Stone",
+  "BlockType": {
+    "Material": "Solid",
+    "DrawType": "Cube",
+    "Group": "Stone",
+    "Flags": {},
+    "Gathering": {
+      "Breaking": {
+        "GatherType": "Rocks",
+        "ItemId": "my_new_block"
+      }
+    },
+    "BlockParticleSetId": "Stone",
+    "Textures": [
+      {
+        "All": "BlockTextures/my_new_block.png"
+      }
+    ],
+    "ParticleColor": "#aeae8c",
+    "BlockSoundSetId": "Stone",
+    "BlockBreakingDecalId": "Breaking_Decals_Rock"
+  },
+  "ResourceTypes": [
+    {
+      "Id": "Rock"
+    }
+  ]
+}
+```
+
+Ensure all referenced files exist in their respective folders, and the paths are correct.
diff --git a/content/docs/bg-BG/guides/plugin/creating-commands.mdx b/content/docs/bg-BG/guides/plugin/creating-commands.mdx
new file mode 100644
index 00000000..08572f16
--- /dev/null
+++ b/content/docs/bg-BG/guides/plugin/creating-commands.mdx
@@ -0,0 +1,457 @@
+---
+title: Creating Commands
+description: Learn how to create custom commands for your Hytale mod.
+authors:
+  - name: Neil Revin
+    url: https://itsneil.dev
+  - name: oskarscot
+    url: https://oskar.scot
+  - name: jacobwojoski
+    url: https://github.com/jacobwojoski
+  - name: Marcel-TO
+    url: https://marcel-to.net
+---
+
+In this guide, you will learn how to create custom commands for your Hytale mod.
+You can see information on the following topics:
+
+- Command types
+  - [AbstractAsyncCommand](#the-abstractasynccommand-class)
+  - [AbstractPlayerCommand](#the-abstractplayercommand-class)
+  - [AbstractTargetPlayerCommand](#the-abstracttargetplayercommand-class)
+  - [AbstractTargetEntityCommand](#the-abstracttargetentitycommand-class)
+- [Arguments](#adding-arguments)
+- [Argument Validators](#argument-validators)
+- [Permissions](#permissions)
+- [Command Variants](#command-variants)
+- [Subcommands and Command Collections](#sub-commands-and-command-collections)
+- [Registering the Command](#registering-the-Command)
+- [Video Link](#video-link)
+
+## Command Types
+
+### The `AbstractAsyncCommand` Class
+
+The most basic command is an `AbstractAsyncCommand`. It has very minimal data available to access and interact with. All commands require the user to pass data to the `BaseCommand` constructor using `super`. You will almost always be passing `super(<Command String>, <Command Description>)` unless you are creating [Command Variants](#command-variants)
+
+<Callout type="warning">
+  `AbstractAsyncCommand` runs on its own background thread. This means its execute is not tied to any world instance and because of this it can not edit any **Stores** or **Refs** without getting the desired world first. To access this data any of the other command types would be preferred and are likely what you will want to use instead.
+</Callout>
+
+The main purpose for a command like this would be for something that can happen everywhere and is not tied to a specific world. For example a `serverRules` command to tell the user that's running the command in chat what the server's rules are no matter what world they are in.
+
+```java
+// Command that can be run that lists the server rules in chat to the player
+public class ServerRulesCommand extends AbstractAsyncCommand {
+
+    // Constructor
+    public ServerRulesCommand() {
+        // super(<The command>, <Command description>)
+        super("rules", "Lists the servers rules");
+    }
+
+    // Run the command
+    // context - info about who ran the command. Server console?, Some player?
+    @Override
+    protected CompletableFuture<Void> executeAsync(@Nonnull CommandContext context) {
+        context.sendMessage(Message.raw("The only rule is there are no rules."));
+        return CompletableFuture.completedFuture(null);
+    }
+}
+```
+
+### The `AbstractPlayerCommand` Class
+
+The `AbstractPlayerCommand` is similar to the `AbstractAsyncCommand` but it is tied to a specific Player and World. This allows the command to edit those additional objects that we could not edit before. The limits are that the command is always tied to the player running the command. If you would instead like to target a different player or item use `AbstractTargetPlayerCommand` and `AbstractTargetEntityCommand` respectively.
+
+To create a command, you can extend the `AbstractPlayerCommand` class. You need to provide a constructor that calls the `BaseCommand` constructor with the command name, description, and whether the command requires confirmation (--confirm while running the command).
+
+You can override the `execute` function to implement the command's behavior. It gives you access to the CommandContext which is always a player in this case, the EntityStore, the Reference store, the player reference as well as the World in which the command is being executed.
+Unlike `AbstractAsyncCommand` commands using `AbstractPlayerCommand` run on the world thread, which means they can safely access the `Store` and `Ref`s. This also means that long running actions (like IO) can lead to lag or server lockup.
+
+You can use the `Store` along with the `Ref` to access all entity components like the `Player` component, `UUIDComponent` or `TransformComponent`.
+
+For more information about Hytale's Entity Component System visit the [Hytale ECS Theory](https://hytalemodding.dev/en/docs/plugin/ecs/hytale-ecs-theory) guide.
+
+```java
+public class ExampleCommand extends AbstractPlayerCommand {
+
+  public ExampleCommand() {
+    super("test", "Super test command!");
+  }
+
+  @Override
+  protected void execute(@Nonnull CommandContext commandContext, @Nonnull Store<EntityStore> store, @Nonnull Ref<EntityStore> ref, @Nonnull PlayerRef playerRef, @Nonnull World world) {
+    Player player = store.getComponent(ref, Player.getComponentType()); // also a component
+    UUIDComponent component = store.getComponent(ref, UUIDComponent.getComponentType());
+    TransformComponent transform = store.getComponent(ref, TransformComponent.getComponentType());
+    player.sendMessage(Message.raw("Player#getUuid() : " + player.getUuid())); // returns UUID from UUIDComponent
+    player.sendMessage(Message.raw("UUIDComponent : " + component.getUuid()));
+    player.sendMessage(Message.raw("equal : " + player.getUuid().equals(component.getUuid()))); // they're both the same
+    player.sendMessage(Message.raw("Transform : " + transform.getPosition()));
+  }
+
+}
+```
+
+### The `AbstractTargetPlayerCommand` Class
+
+Like the `AbstractPlayerCommand` but adds a `--player <value: string>` argument to allow the user to specify which player they are targeting.
+Is automatically threaded so you override the `execute` command instead of `executeAsync`.
+[See Example below](#example-command-arg-types)
+
+### The `AbstractTargetEntityCommand` Class
+
+Uses a Ray to see what the player is looking at and tries to run the command on that entity. It is thread safe and will run on whatever world thread that includes the targeted entity. The following shows an example and how the ref provided just becomes a ref to the entity the player was looking at.
+
+```java
+...
+@Override protected void execute (CommandContext context,
+                                    Store<EntityStore> store,
+                                    Ref<EntityStore> ref,
+                                    World world) {
+
+    EntityStatMap stats = store.getComponent(ref, EntityStatMap.getComponentType());
+    // Need to verify were looking at something with stats
+    if (stats != null) {
+        context.sendMessage(Message.raw("This entity has no stats!"));
+        return;
+    }
+
+    int healthIdx = DefaultEntityStatTypes.getHealth();
+    EntityStatValue health = stats.get(healthIdx);
+
+    // Need to verify were looking at something with health
+    if (health != null) {
+        context.sendMessage(Message.raw("This entity has no health!"));
+        return;
+    }
+
+    stats.addValue(healthIdx, 100);
+}
+...
+```
+
+---
+
+## Adding Arguments
+
+Arguments are additional fields that the user can input when running a command. The different types of arguments along with small snippets and a large example can be seen below.
+
+### Command Argument Types
+
+- `withRequiredArg`    // Must be provided and are parsed left -> right in the command
+- `withOptionalArg`    // Returns null if not provided. Needs to have the --`<key> <value>` pair when running the command. `EX: --player Joe`
+- `withDefaultArg`     // Returns a default value if not provided
+- `withFlagArg`        // boolean switch (--debug)
+
+### Required Arguments
+
+Add a required argument to the command that throws an error if its not present. To do this, you can use the `withRequiredArg` method.
+Required args are parsed left to right in the command and don't use a leading flag.
+
+```java
+this.healthArg = this.withRequiredArg("health", "Amount to heal player", ArgTypes.FLOAT);
+```
+
+### Optional Arguments
+
+Adding a optional argument is the same, only change is the method used to create it. You can use the `withOptionalArg` method.
+
+```java
+// Optional args reguare the user the input `--<key> <value>` so the following would require `--message "Good Luck"`
+this.messageArg = this.withOptionalArg("message", "Message to print while healing", ArgTypes.STRING);
+```
+
+### Default Arguments
+
+Adding a default argument has two additional argument for the default value and default value description. You need to use `withDefaultArg` method.
+
+```java
+// args <Command String> <Description> <Default Value> <Desc of default value>
+this.healthArg = this.withDefaultArg("health", "Amount to heal player", ArgTypes.FLOAT, (float)100, "Desc of Default: 100");
+```
+
+### Flag Arguments
+
+Similar as above but the flags return is either true if it exists or false if it does not. You need to use `withFlagArg` method.
+
+```java
+// No type needed due to being a bool
+this.debugArg = this.withFlagArg("debug", "Add debug logs");
+```
+
+### ArgTypes
+
+You can find all the available argument types on the [ArgTypes](../../argtypes) page.
+
+### Example Command Arg Types
+
+Shows all Command argument types with different various input types.
+
+**NOTE:** When getting the value of an argument during execute you need to pass the context with `someArg.get(commandContext)`. Where `commandContext` is the first variable in the execute function.
+
+```java
+// Example usage: /healplayer --health 50 --message "Feels Good" --debug
+public class HealPlayerCommand extends AbstractTargetPlayerCommand {
+    private final DefaultArg<Float> healthArg;
+    private final OptionalArg<String> messageArg;
+    private final FlagArg debugArg;
+
+    public HealPlayerCommand() {
+        super("healplayer", "Healing a player for an <input> amount of HP (default: 100)");
+
+        // Abstract TargetPlayerCommand passes the player that ran the command by default and implements
+        // the use of `--player <value>` to specify someone else
+
+        // args <Command String> <Description> <Default Value> <Desc of default value>
+        this.healthArg = this.withDefaultArg("health", "Amount to heal player", ArgTypes.FLOAT, (float)100, "Desc of Default: 100");
+
+        // Or you could do the following making the health value required instead of with a default.
+        //    You would need to change the declaration to RequiredArg<Float>
+        // this.healthArg = this.withRequiredArg("health", "Amount to heal player", ArgTypes.FLOAT);
+
+// Optional args require the user the input `--<key> <value>` so the following would require `--message "Good Luck"`
+        this.messageArg = this.withOptionalArg("message", "Message to print while healing", ArgTypes.STRING);
+
+        // No type needed due to being a bool
+        this.debugArg = this.withFlagArg("debug", "Add debug logs");
+    }
+
+    @Override
+    protected void execute(@NonNullDecl CommandContext commandContext, @NullableDecl Ref<EntityStore> ref, @NonNullDecl Ref<EntityStore> ref1, @NonNullDecl PlayerRef playerRef, @NonNullDecl World world, @NonNullDecl Store<EntityStore> store) {
+
+        if (this.debugArg.get(commandContext) == true) { // <-- See commandContext passed to argument here
+            commandContext.sendMessage(Message.raw("We are debugging"));
+        }
+
+        // Health is stored in a generic stat map to allowing mods/future content to easily add more stats if desired.
+        EntityStatMap stats = store.getComponent(ref, EntityStatMap.getComponentType());
+        int healthIdx = DefaultEntityStatTypes.getHealth();
+        EntityStatValue health = stats.get(healthIdx);
+
+        float missing = health.getMax() - health.get();
+
+        if (this.debugArg.get(commandContext) == true) { // <-- See commandContext passed to argument here
+            commandContext.sendMessage(Message.raw("Missing:  " + missing + " health"));
+            commandContext.sendMessage(Message.raw("Adding:  " + healthArg.get(commandContext) + " health to "));
+            commandContext.sendMessage(Message.raw(messageArg.get(commandContext)));
+            commandContext.sendMessage(Message.raw("Input Value: " + healthArg.get(commandContext) + " Default"));
+            commandContext.sendMessage(Message.raw("Default Health Value: "+healthArg.getDefaultValue()));
+        }
+
+        stats.addStatValue(healthIdx, healthArg.get(commandContext)); // <-- See commandContext passed to argument here
+    }
+}
+```
+
+## Argument Validators
+
+Argument validators are a way to check the command before the command gets executed. They are added with the `addValidator` method on an argument when calling `withXxxArg`. They provide a nice output to the user when an input value is invalid. There are some common validators provided in the `Validators` class such as `greaterThan`, `lessThan`, and `or`, `max`, `range`, etc.
+
+```java
+...
+    // Common check types example
+    OptionalArg<Integer> healAmount = withOptionalArg("amount", "Heal Amount", ArgTypes.INTEGER)
+        .addValidator(Validators.greaterThan(0))
+        .addValidator(Validators.lessThan(1000));
+...
+```
+
+### Custom Validators
+
+You can also create custom validators by implementing the `com.hypixel.hytale.codec.validation.Validator` interface. The interfaces forces you to implement the `accept` and `updateSchema` method. The `accept` method takes in the argument value and validates it. If the validation fails, you can use the `fail` method of the `com.hypixel.hytale.codec.validation.ValidationResults` class to return an error message.
+The `updateSchema` method is used to update the schema of the command argument. This is used for commands that have dynamic schemas based on the input value. For example, if you have a command that takes in a player name as an argument, you can use the `updateSchema` method to update the schema to include a list of online players for validation.
+
+Here is an example of a custom validator that checks if a string value is equal to a banned word. In this example, the banned word is "badword". If the input value is "badword", the validator will fail and return an error message.
+
+```java
+import com.hypixel.hytale.codec.schema.SchemaContext;
+import com.hypixel.hytale.codec.schema.config.Schema;
+import com.hypixel.hytale.codec.validation.ValidationResults;
+import com.hypixel.hytale.codec.validation.Validator;
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+
+public class MyCustomValidator implements Validator<String> {
+    @Nonnull
+    private final String value;
+
+    public MyCustomValidator(@Nonnull String value) {
+        this.value = value;
+    }
+
+    @Override
+    public void accept(@Nullable String input, @Nonnull ValidationResults results) {
+        if (this.value.equalsIgnoreCase(input)) {
+            results.fail("The given role has been banned.");
+        }
+    }
+
+    @Override
+    public void updateSchema(SchemaContext context, @Nonnull Schema target) {
+        // This method can be used to update the schema of the command argument. This is useful for commands that have dynamic schemas based on the input value. For example, if you have a command that takes in a player name as an argument, you can use the `updateSchema` method to update the schema to include a list of online players for validation.
+        throw new UnsupportedOperationException("Not implemented yet.");
+    }
+}
+```
+
+After the custom validator is created, you can add it to an argument like the following example. In this example, we add the `MyCustomValidator` to a string argument called "role". If the user inputs "badword" as the role, the command will fail and return the error message defined in the `MyCustomValidator`.
+
+```java
+    ...
+    // Custom validator example
+    String bannedRole = "badword";
+
+    OptionalArg<String> roleArg = withOptionalArg("role", "Role to assign", ArgTypes.STRING)
+        .addValidator(new MyCustomValidator(bannedRole));
+    ...
+```
+
+---
+
+## Permissions
+
+This allows the server to control who has access to specific commands. You add the permissions code into the commands constructor. You need to use the `requirePermission` method. You can list multiple permissions if the command requires the player to have multiple to be able to run. You can also use or blocks to allow running the command if the user has one of the defined permissions.
+
+```java
+...
+    // Commands Constructor
+    public HealPlayerCommand() {
+        super("healplayer", "heal a player a given amount of HP");
+
+        // Only players with this permission can use this command
+        requirePermission (HytalePermissions.fromCommand("rules"));
+
+        // Add multiple permission if the player needs multiple to access the command
+        requirePermission (HytalePermissions.fromCommand("usercomands"));
+
+        // Use OR block if it requires one from a list of permissions roles
+        requirePermission (
+            PermissionRules.or (
+                HytalePermissions.fromCommand("moderator"),
+                HytalePermissions.fromCommand("admin")
+            )
+        );
+    }
+...
+```
+
+<Callout type="info">
+  You can add players to permissions groups and custom permissions using the `/perm` command.
+  Use `/perm --help` in game to see usage.
+</Callout>
+
+---
+
+## Command Variants
+
+If you want variants of the same command without doing argument parsing you can instead use `addUsageVariant(new OtherCommandClass())` in the original commands constructor.
+
+The only difference is in the `OtherCommandClass()` constructor you don't pass the command name to the super class.
+
+<Callout type="info">
+  You can also use `addAliases("some_alias", "some_other_alias")` as a way to add shorthand or other ways to write the same command.
+</Callout>
+
+An example of both is below.
+
+```java
+public class GiveCommand extends AbstractPlayerCommand {
+    private final RequiredArg<String> itemArg;
+    public GiveCommand () {
+        super("give", "Give item to yourself");
+        this.itemArg = withRequiredArg("item", "Item", ArgTypes.STRING);
+        addUsageVariant(new GiveOtherCommand());
+
+        addAliases("gv", "gMe");
+    }
+    // Give commands execute should be here
+    ...
+}
+
+// Variant give other command
+public static class GiveOtherCommand extends AbstractAsyncCommand {
+    private final RequiredArg<String> itemArg;
+    private final RequiredArg<String> playerArg;
+
+    public GiveOtherCommand () {
+        super("Give item to another player"); //NOTE: no command name was specified here!
+        this.playerArg = withRequiredArg("player", "Target Player", ArgTypes.PLAYER_REF);
+        this.itemArg = withRequiredArg("item", "Item", ArgTypes.STRING);
+    }
+}
+```
+
+---
+
+## Sub Commands and Command Collections
+
+You can create a collection of commands using an `AbstractCommandCollection`. This does not allow the top level command to actually do anything. All commands must be implemented on the same level. But you can implement a `CommandCollection` of `CommandCollections`.
+
+The following shows an example of a layout and rough code outline on how to set it up.
+
+```
+/admin
+    |--user
+    |    |--rules
+    |    |--teleport
+    |
+    |--server
+          |--restart
+```
+
+```java
+public class RulesCommand extends AbstractPlayerCommand {
+    // See Example above for making commands
+    // ...
+}
+// Teleport command here
+// Restart command here
+...
+// User Collection
+public class UserCommandCollection extends AbstractCommandCollection {
+    public UserCommandCollection () {
+        super("user", "User commands");
+        addSubCommand(new RulesCommand());
+        addSubCommand(new TeleportCommand());
+    }
+}
+// Server Collection here
+...
+public class AdminCommand extends AbstractCommandCollection {
+    public AdminCommand () {
+        super("admin", "Admin commands");
+        addSubCommand(new UserCommandCollection());
+        addSubCommand(new ServerCommandCollection);
+    }
+}
+```
+
+---
+
+## Registering the Command
+
+For any command
+
+```java
+public class MyPlugin extends JavaPlugin {
+
+    @Override
+    public void setup() {
+        // One way to add commands
+        this.getCommandRegistry().registerCommand(new ExampleCommand());
+
+        // Another way to add commands:
+        CommandRegistry registry = getCommandRegistry();
+        registry.registerCommand(new ExampleCommand());
+    }
+}
+```
+
+---
+
+## Video Link
+
+_Special Thanks to [TroubleDev](https://www.youtube.com/@TroubleDEV) for his excellent video guide on all of these features._
+_Video Link: [TroubleDev - Hytale's Command API Explained](https://www.youtube.com/watch?v=KnmhG9MDMgo)_
diff --git a/content/docs/bg-BG/guides/plugin/creating-configuration-file.mdx b/content/docs/bg-BG/guides/plugin/creating-configuration-file.mdx
new file mode 100644
index 00000000..7fcc4413
--- /dev/null
+++ b/content/docs/bg-BG/guides/plugin/creating-configuration-file.mdx
@@ -0,0 +1,115 @@
+---
+title: Creating a Configuration File
+description: Learn how to create and manage configuration files for your Hytale mod.
+authors:
+  - name: Tarook
+    url: https://github.com/Tarroook
+---
+
+In this guide, you will learn how to create and manage configuration files for your Hytale mod.
+
+## Making a Configuration class
+
+To create a configuration file, you first need to create a class that will hold the configuration data.
+This class must have a `BuilderCodec<T>` defined for it, where `T` is the class itself.
+This codec is responsible for serializing and deserializing the configuration data to and from the configuration file.
+Keys added to the codec must be capitalized. If you don't it will throw an error when loading the configuration file.
+
+<Callout type="info">
+  Each variable you want to store in your component must have its own Codec field defined in the BuilderCodec.
+  For more information on how to create custom Codecs, check out the [ECS Codec Guide](../ecs/hytale-ecs-theory#codec).
+</Callout>
+
+```java
+import com.hypixel.hytale.codec.Codec; // Careful to not use other Codec imports
+import com.hypixel.hytale.codec.KeyedCodec;
+import com.hypixel.hytale.codec.builder.BuilderCodec;
+
+public class MyConfig {
+    public static final BuilderCodec<MyConfig> CODEC = BuilderCodec.builder(MyConfig.class, MyConfig::new)
+            .append(new KeyedCodec<Integer>("SomeValue", Codec.INTEGER),
+                    (config, value) -> config.someValue = value, // Setter
+                    (config) -> config.someValue).add() // Getter
+            .append(new KeyedCodec<String>("SomeString", Codec.STRING),
+                    (config, value) -> config.someString = value,
+                    (config) -> config.someString).add()
+            .build();
+
+
+    private int someValue = 12;
+    private String someString = "My default string";
+
+    public MyConfig() {
+    }
+
+    // Getters
+    public int getSomeValue() {
+        return someValue;
+    }
+    public String getSomeString() {
+        return someString;
+    }
+
+    // Setters
+    public void setSomeValue(int someValue) {
+        this.someValue = someValue;
+    }
+    public void setSomeString(String someString) {
+        this.someString = someString;
+    }
+}
+```
+
+In this example, we create a `MyConfig` class with two configuration options: `SomeValue` and `SomeString`.
+The `BuilderCodec<MyConfig>` specifies how to serialize and deserialize these options.
+
+## Loading, Saving and Using the Configuration
+
+### Initial Setup
+
+Using the configuration file is done through the `Config<T>` class. You can create an instance of this class by providing the plugin instance, the codec of your configuration class, and the file name for the configuration file.
+
+In your project's `JavaPlugin` class, you should load the configuration file in the constructor of the plugin, if it is loaded after the setup is done it will throw an error.
+You should also call `save()` on the `Config<T>` in the setup, to ensure that the configuration file is created if it doesn't exist.
+
+```java
+public class ExamplePlugin extends JavaPlugin {
+    private final Config<MyConfig> config = this.withConfig("MyConfig", MyConfig.CODEC);
+
+    @Override
+    public void setup() {
+        config.save(); // Ensures the config file is created if it doesn't exist
+    }
+}
+```
+
+### Using the Configuration
+
+Once this setup is done, you can access the configuration data in your plugin using the `config` instance variable. If you need to access it from other classes, you can either pass it as a parameter or create a getter method in your `JavaPlugin` class.
+You can then access and modify the configuration data using the `get()` method of the `Config<T>` class.
+
+```java
+public class SomeOtherClass {
+    private final ExamplePlugin plugin;
+
+    public SomeOtherClass(ExamplePlugin plugin) {
+        this.plugin = plugin;
+    }
+
+    public void someMethod() {
+        MyConfig myConfig = plugin.getConfig().get();
+        int value = myConfig.getSomeValue();
+        String str = myConfig.getSomeString();
+
+        // Modify the configuration
+        myConfig.setSomeValue(999);
+        myConfig.setSomeString("A new string");
+
+        // Save the updated configuration back to the file
+        plugin.getConfig().save();
+    }
+}
+```
+
+Here, we access the configuration data, modify it, and save the changes back to the configuration file. This change will persist across server restarts.
+You can find the configuration file in the mods folder of the server.
diff --git a/content/docs/bg-BG/guides/plugin/creating-events.mdx b/content/docs/bg-BG/guides/plugin/creating-events.mdx
new file mode 100644
index 00000000..d3f0925d
--- /dev/null
+++ b/content/docs/bg-BG/guides/plugin/creating-events.mdx
@@ -0,0 +1,90 @@
+---
+title: Creating Events Listeners
+description: Learn how to create event listeners for your Hytale mod.
+authors:
+  - name: Neil Revin
+    url: https://itsneil.dev
+  - name: EllieAU
+    url: https://ellie.au
+---
+
+## Event Class
+
+You can import an Event class and create a function with the Event as an argument. [Click here](../../server/events) to look at all available events.
+
+Example plugin when a player is ready (joins a server):
+
+```java
+
+public class ExampleEvent {
+
+    public static void onPlayerReady(PlayerReadyEvent event) {
+        Player player = event.getPlayer();
+        player.sendMessage(Message.raw("Welcome " + player.getDisplayName()));
+    }
+
+}
+```
+
+## Registering the Event
+
+You need to register all events you make in the Main plugin class, usually in the `setup` function.
+
+```java
+public class MyPlugin extends JavaPlugin {
+
+    @Override
+    public void setup() {
+        this.getEventRegistry().registerGlobal(PlayerReadyEvent.class, ExampleEvent::onPlayerReady);
+    }
+}
+```
+
+## ECS Event Classes
+
+For events that fall under the [ECS Events](../../server/events#ecsevent) list you will need to instead create and register an entity event system.
+An example is included below that will cancel the crafting of a recipe if it uses fibre as an input.
+
+```java
+class ExampleCancelCraft extends EntityEventSystem<EntityStore, CraftRecipeEvent.Pre> {
+    public ExampleCancelCraft() {
+        super(CraftRecipeEvent.Pre.class);
+    }
+
+    @Override
+    public void handle(int index,
+                       @Nonnull ArchetypeChunk<EntityStore> archetypeChunk,
+                       @Nonnull Store<EntityStore> store,
+                       @Nonnull CommandBuffer<EntityStore> commandBuffer,
+                       @Nonnull CraftRecipeEvent.Pre craftRecipeEvent) {
+        CraftingRecipe recipe = craftRecipeEvent.getCraftedRecipe();
+        if (recipe.getInput() != null) {
+            for (MaterialQuantity mq : recipe.getInput()) {
+                if (Objects.equals(mq.getItemId(), "Ingredient_Fibre")) {
+                    craftRecipeEvent.setCancelled(true);
+                    break;
+                }
+            }
+        }
+    }
+
+    @Override
+    public Query<EntityStore> getQuery() {
+        return Archetype.empty();
+    }
+}
+```
+
+## Registering ECS Events
+
+You will need to register the system in your plugin:
+
+```java
+public class MyPlugin extends JavaPlugin {
+
+    @Override
+    public void setup() {
+        this.getEntityStoreRegistry().registerSystem(new ExampleCancelCraft());
+    }
+}
+```
diff --git a/content/docs/bg-BG/guides/plugin/customizing-camera-controls.mdx b/content/docs/bg-BG/guides/plugin/customizing-camera-controls.mdx
new file mode 100644
index 00000000..8539683c
--- /dev/null
+++ b/content/docs/bg-BG/guides/plugin/customizing-camera-controls.mdx
@@ -0,0 +1,170 @@
+---
+title: Customizing Camera Controls
+description: Intro to custom camera modding.
+authors:
+  - name: Vibe Theory
+    url: https://discord.com/users/145420279294722048
+---
+
+## The Basics
+
+Hytale provides great camera customizability! Heres the essentials to get started.
+
+Camera is controlled by sending a `SetServerCamera` packet with `ServerCameraSettings`:
+
+```java
+ServerCameraSettings settings = new ServerCameraSettings();
+settings.distance = 10.0f;           // Zoom distance from player
+settings.isFirstPerson = false;      // Third-person mode
+settings.positionLerpSpeed = 0.2f;   // Smooth camera follow
+
+playerRef.getPacketHandler().writeNoCache(
+    new SetServerCamera(ClientCameraView.Custom, true, settings)
+);
+```
+
+This gives you a simple third-person camera. The presets below show more complete configurations.
+
+**Reset to default:**
+
+```java
+playerRef.getPacketHandler().writeNoCache(
+    new SetServerCamera(ClientCameraView.Custom, false, null)
+);
+```
+
+---
+
+## Camera Presets
+
+### Top-Down (RTS/ARPG Style)
+
+_Source: `com.hypixel.hytale.server.core.command.commands.player.camera.PlayerCameraTopdownCommand`_
+
+```java
+ServerCameraSettings settings = new ServerCameraSettings();
+settings.positionLerpSpeed = 0.2f;
+settings.rotationLerpSpeed = 0.2f;
+settings.distance = 20.0f;
+settings.displayCursor = true;
+settings.isFirstPerson = false;
+settings.movementForceRotationType = MovementForceRotationType.Custom;
+// Align movement with camera yaw (horizontal rotation only)
+settings.movementForceRotation = new Direction(-0.7853981634f, 0.0f, 0.0f);  // 45° right
+settings.eyeOffset = true;
+settings.positionDistanceOffsetType = PositionDistanceOffsetType.DistanceOffset;
+settings.rotationType = RotationType.Custom;
+settings.rotation = new Direction(0.0f, -1.5707964f, 0.0f);  // Look straight down
+settings.mouseInputType = MouseInputType.LookAtPlane;
+settings.planeNormal = new Vector3f(0.0f, 1.0f, 0.0f);       // Ground plane
+```
+
+### Side-Scroller (2D Platformer Style)
+
+_Source: `com.hypixel.hytale.server.core.command.commands.player.camera.PlayerCameraSideScrollerCommand`_
+
+```java
+ServerCameraSettings settings = new ServerCameraSettings();
+settings.positionLerpSpeed = 0.2f;
+settings.rotationLerpSpeed = 0.2f;
+settings.distance = 15.0f;
+settings.displayCursor = true;
+settings.isFirstPerson = false;
+settings.movementForceRotationType = MovementForceRotationType.Custom;
+settings.movementMultiplier = new Vector3f(1.0f, 1.0f, 0.0f);  // Lock Z-axis
+settings.eyeOffset = true;
+settings.positionDistanceOffsetType = PositionDistanceOffsetType.DistanceOffset;
+settings.rotationType = RotationType.Custom;
+settings.mouseInputType = MouseInputType.LookAtPlane;
+settings.planeNormal = new Vector3f(0.0f, 0.0f, 1.0f);         // Side plane
+```
+
+### Isometric Character Camera (Diablo style)
+
+```java
+ServerCameraSettings settings = new ServerCameraSettings();
+settings.positionLerpSpeed = 0.2f;
+settings.rotationLerpSpeed = 0.2f;
+settings.isFirstPerson = false;
+settings.distance = 6f;
+settings.allowPitchControls = false;
+settings.displayCursor = true;
+// Force the camera's rotation to be set by the server.
+settings.applyLookType = ApplyLookType.Rotation;
+// Notify that we provide a custom rotation in "settings.rotation"
+settings.rotationType = RotationType.Custom;
+
+// Set the typical isometric rotation to the camera
+Direction direction = new Direction(
+    (float) Math.toRadians(45f),  // yaw
+    (float) Math.toRadians(-35f), // pitch
+    0f                            // roll
+);
+settings.rotation = rotation;
+settings.movementForceRotation = rotation;
+```
+
+## Common Settings Explained
+
+### Position & Rotation
+
+- **`positionLerpSpeed`** (0.0-1.0): How smoothly the camera follows the player. Lower = smoother but slower response.
+- **`rotationLerpSpeed`** (0.0-1.0): How smoothly the camera rotates. Lower = smoother but slower response.
+- **`distance`**: Camera distance from player. Higher = zoomed out more.
+- **`rotation`**: Camera angle as `Direction(yaw, pitch, roll)` in radians.
+- **`rotationType`**: How rotation is calculated. `RotationType.Custom` uses your `rotation` value.
+
+### Movement Alignment
+
+- **`movementForceRotationType`**:
+- `MovementForceRotationType.AttachedToHead` = movement follows where player looks
+- `MovementForceRotationType.Custom` = use `movementForceRotation` value
+- **`movementForceRotation`**: When using `Custom`, this sets the direction for W/S movement. Match yaw with camera but keep pitch at 0.
+
+### Input & Display
+
+- **`displayCursor`**: Show/hide mouse cursor.
+- **`mouseInputType`**:
+- `MouseInputType.LookAtPlane` = mouse moves cursor on a plane (good for top-down)
+- `MouseInputType.LookAtTarget` = mouse rotates camera
+- **`planeNormal`**: For `LookAtPlane`, defines which plane the mouse moves on. `(0,1,0)` = ground plane.
+
+### Advanced
+
+- **`positionDistanceOffsetType`**:
+- `DistanceOffset` = simple distance offset
+- `DistanceOffsetRaycast` = prevents camera clipping through walls
+- **`eyeOffset`**: Offset camera from player's eye position.
+- **`movementMultiplier`**: Scale movement on each axis. `(1,1,0)` = lock Z-axis for 2D movement.
+
+---
+
+## Imports
+
+```java
+import com.hypixel.hytale.protocol.ClientCameraView;
+import com.hypixel.hytale.protocol.Direction;
+import com.hypixel.hytale.protocol.MouseInputType;
+import com.hypixel.hytale.protocol.MovementForceRotationType;
+import com.hypixel.hytale.protocol.PositionDistanceOffsetType;
+import com.hypixel.hytale.protocol.RotationType;
+import com.hypixel.hytale.protocol.ServerCameraSettings;
+import com.hypixel.hytale.protocol.Vector3f;
+import com.hypixel.hytale.protocol.packets.camera.SetServerCamera;
+```
+
+---
+
+## Tips
+
+- **Zoom:** Adjust `distance` (higher = further out)
+- **Smoothness:** `positionLerpSpeed` and `rotationLerpSpeed` control how quickly the camera catches up to its target
+- **Wall clipping:** Use `PositionDistanceOffsetType.DistanceOffsetRaycast`
+- **Lock camera:** Set `isLocked = true` in the packet to prevent player changes
+- **2D movement:** Set `movementMultiplier` to zero out an axis
+- **Isometric cameras:** Always set `movementForceRotation` to match camera yaw for proper movement alignment
+- **Angle calculations:** Use `Math.toRadians(degrees)` or `degrees * Math.PI / 180.0` to convert degrees to radians
+
+---
+
+_From Hytale Server build `2026.01.13-dcad8778f`_
diff --git a/content/docs/bg-BG/guides/plugin/customizing-hotbar-actions.mdx b/content/docs/bg-BG/guides/plugin/customizing-hotbar-actions.mdx
new file mode 100644
index 00000000..e7c2eb76
--- /dev/null
+++ b/content/docs/bg-BG/guides/plugin/customizing-hotbar-actions.mdx
@@ -0,0 +1,298 @@
+---
+title: Customizing Hotbar Actions
+description: Step by step breakdown on customizing hotbar functionality.
+authors:
+  - name: Vibe Theory
+    url: https://discord.com/users/145420279294722048
+---
+
+This guide walks you through creating a custom keybind system for Hytale servers. By the end, you'll understand how to intercept player inputs, block default behaviors, and trigger custom abilities - like launching a projectile when pressing a specific key.
+
+## Learn By Doing
+
+In this guide, We're going to turn hotbar slot 8 (the "9" key) into an ability trigger. When pressed:
+
+1. The normal slot-switching behavior is blocked
+2. The player stays on their current slot
+3. Some ideas to get started on what to have it actually do
+
+This same pattern can be adapted for any custom keybind system - dodge rolls, special attacks, spell casting, etc.
+**Critical Note:** This is for the hotbar only. Further guides on other keys available to override are coming, but each system requires a slightly different approach. This does mean you will lose a hotbar slot for every custom action you add.
+
+---
+
+## Part 1: Understanding the Packet System
+
+You can use the [Listening to Packets Guide](./listening-to-packets) to learn about how the packet system works and how to listen. In short, the Client sends the Server packets for any user interactions the server needs to know about. For the sake of this guide, we care about the `SyncInteractionChains` packet.
+
+### The SyncInteractionChains Packet
+
+This packet (ID 290) is the workhorse for player interactions. It contains an array of `SyncInteractionChain` objects, each describing an interaction the player is attempting.
+
+For slot switching, we care about these fields:
+
+- `interactionType` - What kind of interaction (SwapFrom, SwapTo, Attack, etc.)
+- `activeHotbarSlot` - The slot the player is currently on
+- `data.targetSlot` - The slot they want to switch to
+- `initial` - Whether this is the start of a new interaction chain
+
+When switching from slot 5 to slot 9, you'll see:
+
+```
+SwapFrom: activeSlot=5, targetSlot=8, initial=true
+```
+
+Note: Slot index is 0-based, so slot "9" is index 8.
+
+---
+
+## Part 2: Packet Interception
+
+### Watcher vs Filter
+
+Hytale provides two ways to intercept packets via `PacketAdapters`:
+
+| Type        | Interface             | Can Block? | Use Case                                    |
+| ----------- | --------------------- | ---------- | ------------------------------------------- |
+| **Watcher** | `PlayerPacketWatcher` | No         | Logging, analytics, triggering side effects |
+| **Filter**  | `PlayerPacketFilter`  | Yes        | Blocking/modifying behavior                 |
+
+Since we need to **block** the slot switch, we use `PlayerPacketFilter`. This interface has one method - `test()` - which receives every inbound packet. Return `true` to block the packet, `false` to let it through.
+
+### Setting Up the Handler
+
+Your handler class implements the filter interface. You'll need these imports:
+
+```java
+import com.hypixel.hytale.protocol.Packet;
+import com.hypixel.hytale.protocol.InteractionType;
+import com.hypixel.hytale.protocol.packets.interaction.SyncInteractionChain;
+import com.hypixel.hytale.protocol.packets.interaction.SyncInteractionChains;
+import com.hypixel.hytale.server.core.io.adapter.PlayerPacketFilter;
+import com.hypixel.hytale.server.core.universe.PlayerRef;
+```
+
+The handler skeleton:
+
+```java
+public class AbilitySlotHandler implements PlayerPacketFilter {
+
+    private static final int ABILITY_SLOT = 8;  // Slot index 8 = Key "9"
+
+    @Override
+    public boolean test(@Nonnull PlayerRef playerRef, @Nonnull Packet packet) {
+        // We'll fill this in next
+        return false;
+    }
+}
+```
+
+### Registration
+
+In your plugin, register the handler in `setup()` and store the returned filter so you can deregister later:
+
+```java
+import com.hypixel.hytale.server.core.io.adapter.PacketAdapters;
+import com.hypixel.hytale.server.core.io.adapter.PacketFilter;
+
+// In your plugin class:
+private PacketFilter inboundFilter;
+
+@Override
+protected void setup() {
+    AbilitySlotHandler handler = new AbilitySlotHandler(this);
+    inboundFilter = PacketAdapters.registerInbound(handler);
+}
+
+@Override
+protected void shutdown() {
+    if (inboundFilter != null) {
+        PacketAdapters.deregisterInbound(inboundFilter);
+    }
+}
+```
+
+Great! Now a PlayerPacketFilter is intercepting every inbound packet and letting us choose to block or let them through. Now we need to set up what we're filtering for.
+
+---
+
+## Part 3: Detecting the Ability Trigger
+
+### The test() Method
+
+Inside `test()`, we need to:
+
+1. Check if this is the packet type we care about
+2. Look for our specific trigger condition
+3. Block and handle it, or let it through
+
+```java
+@Override
+public boolean test(@Nonnull PlayerRef playerRef, @Nonnull Packet packet) {
+    // Step 1
+    if (!(packet instanceof SyncInteractionChains syncPacket)) {
+        return false;
+    }
+
+    // Step 2
+    for (SyncInteractionChain chain : syncPacket.updates) {
+        if (chain.interactionType == InteractionType.SwapFrom
+                && chain.data != null
+                && chain.data.targetSlot == ABILITY_SLOT
+                && chain.initial) {
+
+            int originalSlot = chain.activeHotbarSlot;
+            // Trigger ability and fix client state (covered in next sections)
+            handleAbilityTrigger(playerRef, originalSlot);
+            return true;
+        }
+    }
+
+    return false;
+}
+```
+
+**Why these conditions?**
+
+- `SwapFrom` - The client is leaving their current slot
+- `data.targetSlot == 8` - They're trying to go to slot 9
+- `initial == true` - This is a new interaction, not a continuation of an existing one
+
+Okay, now we are filtering for `SyncInteractionChains` packets and detecting when the player tries to switch to our designated ability slot.
+
+---
+
+## Part 4: The Client Desync Problem
+
+### The Challenge
+
+Here's where it gets tricky, because the Client performs this action locally _before_ the server confirms it.
+
+- **Server**: Player stays on slot 5 (we blocked the packet)
+- **Client**: Player is on slot 8 (already switched locally before sending)
+
+The client and server are now **desynced**. The player will appear to be on slot 9 but the server thinks they're on slot 5, so now we need to fix the client state.
+
+### Fixing The Client State: SetActiveSlot Packet
+
+You need to send `SetActiveSlot` (packet 177), which explicitly tells the client which slot to select:
+
+```java
+import com.hypixel.hytale.protocol.packets.inventory.SetActiveSlot;
+import com.hypixel.hytale.server.core.inventory.Inventory;
+
+// Update server-side state
+playerComponent.getInventory().setActiveHotbarSlot((byte) originalSlot);
+
+// Send packet to force client to the correct slot
+SetActiveSlot setActiveSlotPacket = new SetActiveSlot(
+    Inventory.HOTBAR_SECTION_ID,  // -1 indicates the hotbar
+    originalSlot                   // The slot index to select
+);
+playerRef.getPacketHandler().write(setActiveSlotPacket);
+```
+
+This directly tells the client "your selected slot is now X", fixing the desync!
+
+---
+
+## Part 5: Thread Safety: world.execute()
+
+Packet handlers run on network threads, but entity operations must run on the world thread. Use world.execute() to schedule your code in the right place. [See Thread Safety: Using world.execute()](https://forum.hytalemodding.dev/d/21-thread-safety-using-worldexecute) for details.
+
+Schedule your entity operations on the world thread:
+
+```java
+private void handleAbilityTrigger(PlayerRef playerRef, int originalSlot) {
+    Ref<EntityStore> entityRef = playerRef.getReference();
+    if (entityRef == null || !entityRef.isValid()) {
+        return;
+    }
+
+    Store<EntityStore> store = entityRef.getStore();
+    World world = store.getExternalData().getWorld();
+
+    world.execute(() -> {
+        Player playerComponent = store.getComponent(entityRef, Player.getComponentType());
+        if (playerComponent == null) {
+            return;
+        }
+
+        // Your ability logic here
+    });
+}
+```
+
+_Recommendation: read the Thread Safety guide linked above to understand why `world.execute()` is so important (you'll use it often)._
+
+---
+
+## Part 6: Triggering Abilities
+
+Congratulations! You now have a custom keybind you can do basically anything you want with! Here's some starting points:
+
+**Running Commands:** `CommandManager.get().handleCommand(playerRef, "noon")` executes a command as the player. Quick and easy for prototyping.
+
+**More Advanced:** While you could technically just put abilities on commands, some more advanced options like spawning projectiles with `ProjectileModule.get().spawnProjectile()` are a cleaner way to go. This is a bit more involved, such as `TargetUtil.getLook` for player's eye position. As more guides are released this one will be updated to direct you there!
+
+---
+
+## Part 7: Debugging Tips
+
+### Log Everything
+
+When something doesn't work, add logging at each step:
+
+```java
+// Log what packets you're seeing
+plugin.getLogger().at(Level.INFO).log(
+    "[DEBUG] Packet: %s, type=%s, activeSlot=%d, targetSlot=%d",
+    playerRef.getUsername(),
+    chain.interactionType,
+    chain.activeHotbarSlot,
+    chain.data != null ? chain.data.targetSlot : -1
+);
+```
+
+You need this import for logging:
+
+```java
+import java.util.logging.Level;
+```
+
+### Troubleshooting
+
+**Nothing happens when I press the key:**
+
+- Is your packet filter registered? Check for startup logs.
+- Is the packet type correct? Log all packets to see what's actually coming through.
+- Are your conditions matching? Log the chain fields to verify.
+
+**Ability fires but player is stuck on wrong slot:**
+
+- Are you sending `SetActiveSlot` correctly?
+- Verify the code running on the world thread with `world.execute()`.
+
+**Errors about threads or null components:**
+
+- Always check if `entityRef.isValid()` before using it.
+- Always null-check components - players can disconnect mid-operation.
+- Make sure entity operations are inside `world.execute()`.
+
+---
+
+## Going Further
+
+This pattern opens up many possibilities:
+
+- **Multiple ability slots** - Slots 7, 8, 9 as three different abilities
+- **Cooldowns** - Track last use time per player with a Map
+- **Class-based abilities** - Store player class data, trigger different effects
+- **Combo systems** - Track sequences of interactions
+- **Custom projectiles** - Create your own ProjectileConfig assets
+
+## Video Example
+
+<iframe src="https://www.youtube.com/embed/c0rxzyAUGU8" allowFullScreen />
+
+_From Hytale Server build `2026.01.13-dcad8778f`_
diff --git a/content/docs/bg-BG/guides/plugin/instances.mdx b/content/docs/bg-BG/guides/plugin/instances.mdx
new file mode 100644
index 00000000..eede1db2
--- /dev/null
+++ b/content/docs/bg-BG/guides/plugin/instances.mdx
@@ -0,0 +1,194 @@
+---
+title: Instance System
+description: Learn how to create, manage, and teleport players into instances in Hytale.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+---
+
+# Overview
+
+In this guide, you’ll learn how to use the InstancesPlugin to load an instance and teleport a player to it.
+
+## Spawning an Instance
+
+To create a new instance, you use the `spawnInstance` method. This handles copying the world template and initializing it in the universe.
+
+```java
+InstancesPlugin plugin = InstancesPlugin.get();
+World currentWorld = /* current world context */;
+Transform returnPoint = /* where players should go when they leave */;
+
+// Spawn an instance named "Challenge_Combat_1"
+World instanceWorld = InstancesPlugin.get().spawnInstance("Challenge_Combat_1", world, returnPoint).join();
+Universe.get().sendMessage(Message.raw("Instance spawned: " + instanceWorld.getName()));
+```
+
+<Callout>
+  Instance templates should be located in your asset pack under `Server/Instances/[Name]`. Each template must contain an `instance.bson` configuration file.
+</Callout>
+
+## Teleporting Players to Instances
+
+Once an instance is spawned (or while it is loading), you can move players into it. The `InstancesPlugin` provides utility methods for this that handle state consistency.
+
+### Teleporting to an Active Instance
+
+If the `World` object is already available:
+
+```java
+InstancesPlugin.teleportPlayerToInstance(
+    playerRef, 
+    componentAccessor, 
+    instanceWorld, 
+    null // optional override for return point
+);
+```
+
+### Teleporting to a Loading Instance
+
+If you have a `CompletableFuture<World>` from `spawnInstance`, you can queue the teleport to happen as soon as the world is ready.
+
+```java
+CompletableFuture<World> worldFuture = plugin.spawnInstance("Challenge_Combat_1", currentWorld, returnPoint);
+
+InstancesPlugin.teleportPlayerToLoadingInstance(
+    playerRef,
+    componentAccessor,
+    worldFuture,
+    null // optional override for return point
+);
+```
+
+## Exiting Instances
+
+When a player finishes their objective, you can return them to their original world using `exitInstance`. This automatically uses the return point defined during the instance creation.
+
+```java
+InstancesPlugin.exitInstance(playerRef, componentAccessor);
+```
+
+## Managing Instance Removal
+
+Instances can be configured to remove themselves automatically based on certain conditions, such as being empty for a certain duration.
+
+```java
+InstancesPlugin.safeRemoveInstance(instanceWorld);
+```
+
+---
+
+## Command Examples
+
+### Spawn Instance Command
+
+```java
+public class ExampleSpawnInstanceCommand extends CommandBase {
+    private final RequiredArg<String> nameArg;
+
+    public ExampleSpawnInstanceCommand() {
+        super("spawninstance", "Spawns a new instance from a template");
+        this.nameArg = this.withRequiredArg("name", "The name of the new instance", ArgTypes.STRING);
+    }
+
+    @Override
+    protected void executeSync(@Nonnull CommandContext ctx) {
+        UUID playerUUID = ctx.sender().getUuid();
+        PlayerRef playerRef = Universe.get().getPlayer(playerUUID);
+        World world = Universe.get().getWorld(playerRef.getWorldUuid());
+
+        ISpawnProvider spawnProvider = world.getWorldConfig().getSpawnProvider();
+        Transform returnPoint = spawnProvider != null ? spawnProvider.getSpawnPoint(world, playerRef.getUuid()) : new Transform();
+
+        world.execute(() -> {
+            World instanceWorld = InstancesPlugin.get().spawnInstance(this.nameArg.get(ctx), world, returnPoint).join();
+            Universe.get().sendMessage(Message.raw("Instance spawned: " + instanceWorld.getName()));
+        });
+    }
+}
+```
+
+---
+
+### Remove Instance Command
+
+```java
+public class ExampleRemoveInstanceCommand extends CommandBase {
+    private final RequiredArg<String> worldArg;
+
+    public ExampleRemoveInstanceCommand() {
+        super("removeinstance", "Safely removes an instance");
+        this.worldArg = this.withRequiredArg("world", "The world to remove", ArgTypes.STRING);
+    }
+
+    @Override
+    protected void executeSync(@Nonnull CommandContext ctx) {
+        String worldName = ctx.get(this.worldArg);
+        World targetWorld = Universe.get().getWorld(worldName);
+
+        if (targetWorld == null) {
+            ctx.sendMessage(Message.raw("World not found: " + worldName));
+            return;
+        }
+
+        targetWorld.execute(() -> {
+            InstancesPlugin.safeRemoveInstance(targetWorld);
+        });
+    }
+}
+```
+
+---
+
+### Enter Instance Command
+
+```java
+public class ExampleEnterInstanceCommand extends CommandBase {
+    private final RequiredArg<String> nameArg;
+
+    public ExampleEnterInstanceCommand() {
+        super("enterinstance", "Spawns and enters an instance immediately");
+        this.nameArg = this.withRequiredArg("name", "The name of the instance", ArgTypes.STRING);
+    }
+
+    @Override
+    protected void executeSync(@Nonnull CommandContext ctx) {
+        UUID playerUUID = ctx.sender().getUuid();
+        PlayerRef playerRef = Universe.get().getPlayer(playerUUID);
+        World world = Universe.get().getWorld(playerRef.getWorldUuid());
+
+        ISpawnProvider spawnProvider = world.getWorldConfig().getSpawnProvider();
+        Transform returnPoint = spawnProvider != null ? spawnProvider.getSpawnPoint(world, playerRef.getUuid()) : new Transform();
+
+        world.execute(() -> {
+			//World instanceWorld = InstancesPlugin.get().spawnInstance(this.nameArg.get(ctx), world, returnPoint).join();
+            //InstancesPlugin.teleportPlayerToInstance(playerRef.getReference(), playerRef.getReference().getStore(), instanceWorld, (Transform) null);	
+            CompletableFuture<World> worldFuture = InstancesPlugin.get().spawnInstance(this.nameArg.get(ctx), world, returnPoint);
+            InstancesPlugin.teleportPlayerToLoadingInstance(playerRef.getReference(), playerRef.getReference().getStore(), worldFuture, null);
+        });
+    }
+}
+```
+
+---
+
+### Exit Instance Command
+
+```java
+public class ExampleExitInstanceCommand extends CommandBase {
+
+    public ExampleExitInstanceCommand() {
+        super("exitinstance", "Exits the current instance and returns to the previous world");
+    }
+
+    @Override
+    protected void executeSync(@Nonnull CommandContext ctx) {
+        Player player = (Player) ctx.sender();
+        World world = player.getWorld();
+
+        world.execute(() -> {
+            InstancesPlugin.exitInstance(player.getReference(), player.getReference().getStore());
+        });
+    }
+}
+```
diff --git a/content/docs/bg-BG/guides/plugin/inventory-management.mdx b/content/docs/bg-BG/guides/plugin/inventory-management.mdx
new file mode 100644
index 00000000..e38c644f
--- /dev/null
+++ b/content/docs/bg-BG/guides/plugin/inventory-management.mdx
@@ -0,0 +1,125 @@
+---
+title: Inventory Management
+description: Learn how to manage player inventories in your Hytale mod.
+authors:
+  - name: Neil Revin
+    url: https://itsneil.dev
+---
+
+In this guide, you'll learn how to manage player inventories in your Hytale mod.
+
+## Accessing the Player Inventory
+
+To access the Inventory of a `Player`, you can use the `getInventory()` method which returns the `Inventory` object.
+
+```java
+Inventory inventory = player.getInventory();
+```
+
+## Opening Inventories
+
+You can open different types of inventories, these inventories are known as "Pages". You can also add custom pages, this will be covered in a guide later on.
+
+You can use the `Page` enum to reference existing inventories, currently the following pages are available:
+
+- `Page.None`
+- `Page.Bench`
+- `Page.Inventory`
+- `Page.ToolsSettings`
+- `Page.Map`
+- `Page.MachinimaEditor`
+- `Page.ContentCreation`
+- `Page.Custom`
+
+```java
+PageManager pageManager = player.getPageManager();
+Store<EntityStore> store = player.getWorld().getEntityStore().getStore();
+pageManager.setPage(player.getReference(), store, Page.Inventory);
+```
+
+## `ItemStack` Class
+
+You can create and manipulate items in a player's inventory using the `ItemStack` class. This class represents a stack of items, and provides methods for managing the quantity and type of items in the stack.
+
+### Creating an ItemStack
+
+To create an `ItemStack`, you need to specify the material type and the quantity of items in the stack.
+
+```java
+ItemStack item = new ItemStack("Stone");
+ItemStack withQuantity = new ItemStack("Stone", 64);
+```
+
+#### Adding custom metadata
+
+You can also add custom metadata to a `ItemStack` by passing a `BsonDocument` when creating it.
+
+```java
+BsonDocument metadata = new BsonDocument();
+metadata.append("customData", new BsonString("value"));
+ItemStack item = new ItemStack("Stone", 64, metadata);
+```
+
+### Setting a durability
+
+```java
+ItemStack stackWithDurability = new ItemStack(
+    "DiamondSword", // itemId
+    1,              // quantity
+    100.0,          // durability
+    100.0,          // maxDurability
+    metadata        // metadata (optional)
+);
+```
+
+## Getting the `ItemContainer`
+
+The `Inventory` class provides methods to get multiple `ItemContainer` objects, like:
+
+- `.getStorage()`
+- `.getArmor()`
+- `.getBackpack()`
+- `.getHotbar()`
+- `.getUtility()`
+
+There are also combined methods like:
+
+- `.getCombinedEverything()`
+- `.getCombinedArmorHotbarStorage()`
+- `.getCombinedBackpackStorageHotbar()`
+- `.getCombinedHotbarFirst()`
+- `.getCombinedStorageFirst()`
+- `.getCombinedArmorHotbarUtilityStorage()`
+- `.getCombinedHotbarUtilityConsumableStorage()`
+
+## Adding `ItemStack` objects to the Inventory
+
+To add an `ItemStack` to a player's inventory, you can use the `addItemStack()` method of the `ItemContainer` class.
+
+```java
+Inventory inventory = player.getInventory();
+ItemContainer storageContainer = inventory.getStorage();
+storageContainer.addItemStack(item);
+```
+
+Or you can specify a certain slot to add it to:
+
+```java
+storageContainer.addItemStackToSlot((short) 4, stack)
+```
+
+## Removing `ItemStack` objects from the Inventory
+
+To remove an `ItemStack` from a player's inventory, you can use the `removeItemStack()` method of the `Inventory` class.
+
+```java
+Inventory inventory = player.getInventory();
+ItemContainer storageContainer = inventory.getStorage();
+storageContainer.removeItemStack(item);
+```
+
+Or you can specify a certain slot to remove it from:
+
+```java
+storageContainer.removeItemStackFromSlot((short) 4);
+```
diff --git a/content/docs/bg-BG/guides/plugin/item-interaction.mdx b/content/docs/bg-BG/guides/plugin/item-interaction.mdx
new file mode 100644
index 00000000..a3bc75ae
--- /dev/null
+++ b/content/docs/bg-BG/guides/plugin/item-interaction.mdx
@@ -0,0 +1,345 @@
+---
+title: Create Custom Item and Interaction
+description: Learn how you can create a custom item interactions for your custom items
+authors:
+  - name: Marcel-TO
+    url: https://marcel-to.net
+---
+
+import { File, Folder, Files } from 'fumadocs-ui/components/files';
+
+Creating a custom item follows the same setup than the [Creating custom blocks](./creating-block).
+
+## Setup
+
+1. Enable asset packs in `manifest.json` by setting `IncludesAssetPack` to `true`
+2. Create the following folder structure:
+
+<Files>
+  <Folder name="resources" defaultOpen>
+    <Folder name="Server" defaultOpen>
+      <Folder name="Item" defaultOpen>
+        <Folder name="Items" defaultOpen>
+          <File name="my_new_item.json" />
+        </Folder>
+      </Folder>
+    </Folder>
+
+    <Folder name="Common" defaultOpen>
+      <Folder name="Icons" defaultOpen>
+        <Folder name="ItemsGenerated" defaultOpen>
+          <File name="my_new_item_icon.png" />
+        </Folder>
+      </Folder>
+
+      <Folder name="Items" defaultOpen>
+        <Folder name="my_new_item" defaultOpen>
+          <File name="model.blockymodel" />
+
+          <File name="model_texture.png" />
+        </Folder>
+      </Folder>
+    </Folder>
+  </Folder>
+</Files>
+
+The following files are relevant for the item:
+
+| File                 | Location                    | Description                              |
+| -------------------- | --------------------------- | ---------------------------------------- |
+| my_new_item.json     | Server/Item/Items           | Defines the item properties and behavior |
+| my_new_item_icon.png | Common/Icons/ItemsGenerated | Icon for the item in inventory           |
+| model.blockymodel    | Common/Items/my_new_item    | 3D model of the item                     |
+| model_texture.png    | Common/Items/my_new_item    | Texture for the item model               |
+
+## Custom Item Definition
+
+Create `Server/Item/Items/my_new_item.json`:
+
+```json
+{
+  "TranslationProperties": {
+    "Name": "My New Item", // Alternatively, use localization keys
+    "Description": "My New Item Description" // Alternatively, use localization keys
+  },
+   "Id": "My_New_Item",
+  "Icon": "Icons/ItemsGenerated/my_new_item_icon.png",
+  "Model": "Items/my_new_item/model.blockymodel",
+  "Texture": "Items/my_new_item/model_texture.png",
+  "Quality": "Common",
+  "MaxStack": 1,
+  "Categories": [
+    "Items.Example"
+  ]
+}
+```
+
+This JSON file defines a new item with a unique ID, icon, 3D model, texture, quality, maximum stack size, and category.
+Ensure all referenced files exist in their respective folders, and the paths are correct.
+
+## Adding Recipe for the Item
+
+To allow players to craft the new item, you can define a crafting recipe. Inside the metadata for the item, add the following recipe definition:
+
+```json
+{
+  ... // existing item properties from above
+  "Recipe": {
+    "TimeSeconds": 3.5, // Time taken to craft the item
+    "Input": [
+      {
+        "ItemId": "Ingredient_1", // Example ingredient item ID
+        "Quantity": 15
+      },
+      {
+        "ItemId": "Ingredient_2", // Example ingredient item ID
+        "Quantity": 15
+      },
+      {
+        "ItemId": "Ingredient_3", // Example ingredient item ID
+        "Quantity": 15
+      }
+    ],
+    "BenchRequirement": [
+      {
+        "Id": "Workbench", // What type of crafting bench is required
+        "Type": "Crafting",
+        "Categories": [
+          "Workbench_Survival" // Which category of workbench tab
+        ]
+      }
+    ]
+  }
+}
+```
+
+This recipe allows players to craft "My New Item" using specified ingredients at a workbench.
+
+## Item Interaction
+
+To create a custom interaction, you will need to define the interaction behavior in your plugin code. This typically involves handling events when the item is used by the player. Inherit from `SimpleInstantInteraction` and override the necessary methods to define what happens when the item is used.
+
+### Plugin Code
+
+```java
+public class MyCustomInteraction extends SimpleInstantInteraction {
+    @Override
+    protected void firstRun(@Nonnull InteractionType interactionType, @Nonnull InteractionContext interactionContext, @Nonnull CooldownHandler cooldownHandler) {
+        // Custom behavior when the item is used
+    }
+}
+```
+
+What is missing is a custom CODEC to link the interaction to the item.
+
+<Callout type="info">
+  Each variable you want to store in your component must have its own Codec field defined in the BuilderCodec.
+  For more information on how to create custom Codecs, check out the [ECS Codec Guide](../ecs/hytale-ecs-theory#codec).
+</Callout>
+
+```java
+public class MyCustomInteraction extends SimpleInstantInteraction {
+    public static final BuilderCodec<MyCustomInteraction> CODEC = BuilderCodec.builder(
+            MyCustomInteraction.class, MyCustomInteraction::new, SimpleInstantInteraction.CODEC
+    ).build();
+
+    @Override
+    protected void firstRun(@Nonnull InteractionType interactionType, @Nonnull InteractionContext interactionContext, @Nonnull CooldownHandler cooldownHandler) {
+        // Custom behavior when the item is used
+    }
+}
+```
+
+Finally, register the interaction in your plugin's main class:
+
+```java
+public class MyPlugin extends JavaPlugin {
+    public MyPlugin(@Nonnull JavaPluginInit init) {
+        super(init);
+    }
+
+    @Override
+    protected void setup() {
+        this.getCodecRegistry(Interaction.CODEC).register("my_custom_interaction_id", MyCustomInteraction.class, MyCustomInteraction.CODEC);
+    }
+}
+```
+
+This code registers the custom interaction with a unique ID, allowing the game to recognize and use it when any item with with this interaction id is used.
+
+### Linking Interaction to Item
+
+To link the custom interaction to the item, add the following property to the item JSON definition:
+
+```json
+{
+  ... // existing item properties from above
+  "Interactions": {
+    "Secondary": { // depending on the type of interaction you want
+      "Interactions": [
+        {
+          "Type": "my_custom_interaction_id",
+        }
+      ]
+    }
+  }
+}
+```
+
+## Full Interaction Example
+
+Here is a complete example of a custom interaction that sends a message with the item ID to the player when the item is used:
+
+```java
+public class SendMessageInteraction extends SimpleInstantInteraction {
+    public static final BuilderCodec<SendMessageInteraction> CODEC = BuilderCodec.builder(
+            SendMessageInteraction.class, SendMessageInteraction::new, SimpleInstantInteraction.CODEC
+    ).build();
+
+    public static final HytaleLogger LOGGER = HytaleLogger.forEnclosingClass();
+
+    @Override
+    protected void firstRun(@Nonnull InteractionType interactionType, @Nonnull InteractionContext interactionContext, @Nonnull CooldownHandler cooldownHandler) {
+        CommandBuffer<EntityStore> commandBuffer = interactionContext.getCommandBuffer();
+        if (commandBuffer == null) {
+            interactionContext.getState().state = InteractionState.Failed;
+            LOGGER.atInfo().log("CommandBuffer is null");
+            return;
+        }
+
+        World world = commandBuffer.getExternalData().getWorld(); // just to show how to get the world if needed
+        Store<EntityStore> store = commandBuffer.getExternalData().getStore(); // just to show how to get the store if needed
+        Ref<EntityStore> ref = interactionContext.getEntity();
+        Player player = commandBuffer.getComponent(ref, Player.getComponentType());
+        if (player == null) {
+            interactionContext.getState().state = InteractionState.Failed;
+            LOGGER.atInfo().log("Player is null");
+            return;
+        }
+
+        ItemStack itemStack = interactionContext.getHeldItem();
+        if (itemStack == null) {
+            interactionContext.getState().state = InteractionState.Failed;
+            LOGGER.atInfo().log("ItemStack is null");
+            return;
+        }
+
+        player.sendMessage(Message.raw("You have used the custom item +" + itemStack.getItemId()));
+    }
+}
+```
+
+## Advanced Interaction Features
+
+Interactions are highly flexible. Since they are nested, you can combine multiple interactions to create complex behaviors. For example, you could have an interaction that first checks certain conditions (like player health or environment) before executing another interaction. Afterwards, you can chain interactions to create a sequence of actions triggered by a single item use. Or you could create interactions that need to be charged over time before they activate.
+
+To get your creative juices flowing, here are some examples of interaction types:
+
+1. **Condition**: Check specific conditions before allowing the interaction to proceed (e.g., only if player crouches):
+
+```json
+{
+    "Type": "Condition",
+    "Crouching": true, // only allow if player is crouching example
+    "Failed": "Block_Secondary",
+    "Next": {
+        ... // next interaction to run if condition is met
+    }
+}
+```
+
+2. **Charge**: Require the player to hold the interaction for a certain duration before it activates (This behavior for example is called if the player eats food):
+
+```json
+{
+    "Type": "Charging",
+    "FailsOnDamage": true, // cancel if player takes damage
+    "HorizontalSpeedMultiplier": 0.4, // reduce speed while charging
+    "Next": {
+        "2.5" : {  // interaction after 2.5 seconds of charging
+            ... // interaction to run after charge time
+        },
+    },
+    "Failed": {
+        ... // interaction to run if charging fails
+    }
+}
+```
+
+3. **Serial**: Execute a series of interactions in order, one after the other:
+
+```json
+{
+    "Type": "Serial",
+    "Interactions": [
+        {
+            ... // first interaction
+        },
+        {
+            ... // second interaction
+        }
+    ]
+}
+```
+
+4. **Replace**: Replace the default behavior of the item (e.g., inherited from parent) with a custom interaction:
+
+```json
+{
+    "Type": "Replace",
+    "Var": "Item_Default_Interaction",
+    "DefaultValue": {
+        "Interactions": [
+            {
+                ... // default interaction that replaces the original
+            }
+        ]
+    }
+}
+```
+
+5. **Simple**: Simple Interaction that performs a single action, such as sending a message or applying an effect:
+
+```json
+{
+    "Type": "Simple"
+}
+```
+
+### Advanced Interaction Example
+
+Here is an example of a more complex interaction that requires the player to crouch and charge for 2.5 seconds before executing the custom action:
+
+```json
+{
+    ... // existing item properties from above
+    "Interactions": {
+        "Secondary": {
+            "Interactions": [
+                {
+                    "Type": "Condition",
+                    "Crouching": true,
+                    "Failed": "Block_Secondary",
+                    "Next": {
+                        "Type": "Charging",
+                        "FailsOnDamage": true,
+                        "HorizontalSpeedMultiplier": 0.5,
+                        "Next": {
+                            "2.5": {
+                                "Type": "my_custom_interaction_id",
+                            }
+                        },
+                        "Failed": {
+                            "Type": "Simple"
+                        }
+                    }
+                }
+            ]
+        }
+    }
+}
+```
+
+## Conclusion
+
+You have now created a custom item with a unique interaction in your Hytale plugin. You can expand upon this foundation to create more complex items and interactions as needed for your mod. Keep experimenting, chain interactions, and explore the possibilities to enhance gameplay!
diff --git a/content/docs/bg-BG/guides/plugin/item-registry.mdx b/content/docs/bg-BG/guides/plugin/item-registry.mdx
new file mode 100644
index 00000000..9a0fd53a
--- /dev/null
+++ b/content/docs/bg-BG/guides/plugin/item-registry.mdx
@@ -0,0 +1,95 @@
+---
+title: Working with the Item Registry
+description: Learn how to access and query the game's item registry to list all items, check if items exist, and retrieve item properties.
+authors:
+  - name: Denis
+---
+
+In this guide, you'll learn how to work with Hytale's Item Registry system. This is useful when you need to programmatically list all available items, validate item IDs, or retrieve item properties at runtime.
+
+## Prerequisites
+
+Before diving in, you should be familiar with:
+
+- [Setting up your development environment](./setting-up-env)
+- [Creating commands](./creating-commands) (optional, for testing)
+
+## Required Imports
+
+To work with the Item Registry, you'll need the following imports:
+
+```java
+import com.hypixel.hytale.assetstore.map.DefaultAssetMap;
+import com.hypixel.hytale.server.core.asset.type.item.config.Item;
+```
+
+## Getting the Item Registry
+
+The Item Registry is accessed through the `Item.getAssetMap()` method, which returns a `DefaultAssetMap<String, Item>` containing all registered items in the game:
+
+```java
+DefaultAssetMap<String, Item> itemMap = Item.getAssetMap();
+```
+
+## Listing All Items
+
+To iterate through all items in the registry, you can get the underlying map and loop through its entries:
+
+```java
+DefaultAssetMap<String, Item> itemMap = Item.getAssetMap();
+var map = itemMap.getAssetMap();
+
+for (var entry : map.entrySet()) {
+    String itemId = String.valueOf(entry.getKey());
+    Item item = entry.getValue();
+    
+    // Do something with the item
+    LOGGER.atInfo().log("Item ID: " + itemId);
+}
+```
+
+You can also get the total count of registered items:
+
+```java
+int totalItems = map.size();
+```
+
+## Checking if an Item Exists
+
+To check if a specific item exists in the registry, use `getAsset()` and verify the result:
+
+```java
+public boolean itemExists(String itemId) {
+    var assetMap = Item.getAssetMap();
+    if (assetMap != null) {
+        Item item = assetMap.getAsset(itemId);
+        return item != null && item != Item.UNKNOWN;
+    }
+    return false;
+}
+```
+
+<Callout type="info">
+  The `Item.UNKNOWN` constant represents an invalid or unrecognized item. Always check for both `null` and `Item.UNKNOWN` when validating items.
+</Callout>
+
+## Accessing Item Properties
+
+Once you have an `Item` instance, you can access various properties:
+
+```java
+var assetMap = Item.getAssetMap();
+Item item = assetMap.getAsset("Soil_Grass");
+
+if (item != null && item != Item.UNKNOWN) {
+    String id = item.getId(); // Soil_Grass
+    int maxStack = item.getMaxStack(); // 100
+    boolean isBlock = item.hasBlockType(); // true
+    boolean isConsumable = item.isConsumable(); // false
+}
+```
+
+## Related Guides
+
+- [Inventory Management](./inventory-management) - Learn how to add and remove items from player inventories
+- [Create Custom Item and Interaction](./item-interaction) - Learn how to create your own custom items
diff --git a/content/docs/bg-BG/guides/plugin/listening-to-packets.mdx b/content/docs/bg-BG/guides/plugin/listening-to-packets.mdx
new file mode 100644
index 00000000..deb14622
--- /dev/null
+++ b/content/docs/bg-BG/guides/plugin/listening-to-packets.mdx
@@ -0,0 +1,296 @@
+---
+title: Listening to Packets
+description: Learn how to listen to packets that are sent or received from the Client
+authors:
+  - name: Neil Revin
+    url: https://itsneil.dev
+  - name: musava_ribica
+    url: https://forum.hytalemodding.dev/u/musava_ribica
+  - name: Drakon
+    url: https://github.com/Drakonkinst
+---
+
+In this guide, you'll learn how to listen to packets that are being sent or received from the Client.
+
+Packets are defined in `com.hypixel.hytale.protocol` and organized by category in `com.hypixel.hytale.protocol.packets`. Base class is `Packet` and the sub-packages contain actual packet classes. The low-level Netty handler is `com.hypixel.hytale.server.core.io.netty.PlayerChannelHandler`, it delegates packet processing logic to `com.hypixel.hytale.server.core.io.adapter.PacketAdapters`.
+
+The server has a built-in adapter system that makes injection very straightforward. You don't need to hook into Netty manually. You can use the `PacketAdapters` class to register inbound (Client -> Server) and outbound (Server -> Client) watchers. The process for registering inbound packets is the same as for outbound.
+
+The `PacketAdapters` class provides several `registerInbound` method overloads. Possible argument types are `PacketWatcher`, `PacketFilter`, `PlayerPacketWatcher` and `PlayerPacketFilter`.
+
+The difference between `PacketWatcher` and `PacketFilter` is that the `PacketFilter` can prevent packet processing and block the packet from reaching the server (for inbound) or reaching the player (for outbound).
+
+## Player Packet Tracker (Utility)
+
+To get a better understanding of how packets are sent to/from players, you can add this snippet below to track packets sent to/from players:
+
+```java
+public class PlayerPacketTracker {
+    private static final HytaleLogger LOGGER = HytaleLogger.forEnclosingClass();
+
+    private static class PlayerStats {
+        final Map<String, AtomicInteger> sent = new ConcurrentHashMap<>();
+        final Map<String, AtomicInteger> received = new ConcurrentHashMap<>();
+    }
+    private static final Map<String, PlayerStats> stats = new ConcurrentHashMap<>();
+
+    private static String getPlayerName(PacketHandler handler) {
+        if (handler instanceof GamePacketHandler gpHandler) {
+            return gpHandler.getPlayerRef().getUsername();
+        }
+        return null;
+    }
+
+    public static void registerPacketCounters() {
+        PacketAdapters.registerInbound((PacketHandler handler, Packet packet) -> {
+            String playerName = getPlayerName(handler);
+            if (playerName != null) {
+                stats.computeIfAbsent(playerName, k -> new PlayerStats())
+                        .received.computeIfAbsent(packet.getClass().getSimpleName(), k -> new AtomicInteger(0))
+                        .incrementAndGet();
+            }
+        });
+
+        // Listener for sent packets (Outbound)
+        PacketAdapters.registerOutbound((PacketHandler handler, Packet packet) -> {
+            String playerName = getPlayerName(handler);
+            if (playerName != null) {
+                stats.computeIfAbsent(playerName, k -> new PlayerStats())
+                        .sent.computeIfAbsent(packet.getClass().getSimpleName(), k -> new AtomicInteger(0))
+                        .incrementAndGet();
+            }
+        });
+
+        // Schedule logging every 3 seconds
+        HytaleServer.SCHEDULED_EXECUTOR.scheduleAtFixedRate(() -> {
+            if (stats.isEmpty()) return;
+
+            for (Map.Entry<String, PlayerStats> entry : stats.entrySet()) {
+                String player = entry.getKey();
+                PlayerStats pStats = entry.getValue();
+
+                StringBuilder sb = new StringBuilder();
+
+                // Build Sent string
+                List<String> sentLogs = new ArrayList<>();
+                pStats.sent.forEach((type, atomic) -> {
+                    int count = atomic.getAndSet(0);
+                    if (count > 0) {
+                        sentLogs.add(type + " x" + count);
+                    }
+                });
+
+                if (!sentLogs.isEmpty()) {
+                    sb.append("Sent ").append(String.join(", ", sentLogs));
+                }
+
+                // Build Received string
+                List<String> recvLogs = new ArrayList<>();
+                pStats.received.forEach((type, atomic) -> {
+                    int count = atomic.getAndSet(0);
+                    if (count > 0) {
+                        recvLogs.add(type + " x" + count);
+                    }
+                });
+
+                if (!recvLogs.isEmpty()) {
+                    if (!sb.isEmpty()) sb.append("\n");
+                    sb.append("Received ").append(String.join(", ", recvLogs));
+                }
+
+                if (!sb.isEmpty()) {
+                    LOGGER.atInfo().log("To " + player + ":\n" + sb);
+                }
+            }
+        }, 3, 3, TimeUnit.SECONDS);
+    }
+}
+```
+
+Then call `PlayerPacketTracker.registerPacketCounters();` in your `setup()` function.
+
+## Injecting our own function to the PacketAdapter.
+
+We can inject our own function to the PacketAdapter by using one of the methods mentioned above, here is an example that prints all packets sent from the server to the client.
+
+```java
+PacketAdapters.registerOutbound((PacketHandler handler, Packet packet) -> {
+    var handlerName = handler.getClass().getSimpleName();
+    var packetName = packet.getClass().getSimpleName();
+
+    // some common packets excluded to reduce spam
+    if (!"EntityUpdates".equals(packetName) && !"CachedPacket".equals(packetName)) {
+        logger.at(Level.INFO)
+              .log("[" + handlerName + "] Sent packet id=" + packet.getId() + ": " + packetName);
+    }
+});
+```
+
+## Modfying an incoming packet
+
+In the following example, we modify a incoming packet containing skin data to remove that data from the packet. With this, every player will have default skin.
+
+```java
+PacketAdapters.registerInbound((PacketHandler handler, Packet packet) -> {
+    if (packet instanceof PlayerOptions skinPacket) {
+        skinPacket.skin = null;
+    }
+});
+```
+
+### Player packet handling
+
+We can use another method in `PacketAdapter` to specifically target packets send by a player.
+In this method, returning `true` cancels the packet while returning `false` allows the packet to pass through.
+This allows you to add your own logic to packets.
+
+<Callout type="warning">
+  While you can cancel packets entirely, client-side prediction still occurs and the targeted client will still see
+  their movement inputs work as normal. This requires extra work (guide pending) to prevent the player from taking
+  certain actions; cancelling packets is likely not the right approach.
+</Callout>
+
+```java
+PacketAdapters.registerInbound((PlayerPacketFilter) (player,  packet) -> {
+    if (packet instanceof ClientMovement movementPacket) {
+        // Do some logic here, then return true to cancel the packet
+        return true;
+    }
+    return false;
+});
+```
+
+## Packet handlers
+
+Packet Handlers and the incoming packet types and corresponding packet ids of the packets they handle. Packets can be present in multiple handlers. If any other type of packet comes in during wrong phase, the handler will disconnect the sender. These are serverbound (inbound) packets. Some packets are used in both directions, such as SyncInteractionChains. Packets not mentioned here are likely clientbound (outbound), but will be added soon.
+
+### InitialPacketHandler
+
+- Connect (0)
+- Disconnect (1)
+
+### HandshakeHandler
+
+This is a superclass of `AuthenticationPacketHandler`.
+
+- Disconect (1)
+- AuthToken (12)
+
+### PasswordPacketHandler
+
+- Disconnect (1)
+- PasswordResponse (15)
+
+### SetupPacketHandler
+
+- Disconnect (1)
+- RequestAssets (23)
+- ViewRadius (32)
+- PlayerOptions (33)
+
+### GamePacketHandler
+
+- Disconnect (1)
+- Pong (3)
+- ClientMovement (108)
+- ChatMessage (211)
+- RequestAssets (23)
+- CustomPageEvent (219)
+- ViewRadius (32)
+- UpdateLanguage (232)
+- MouseInteraction (111)
+- UpdateServerAccess (251)
+- SetServerAccess (252)
+- ClientOpenWindow (204)
+- SendWindowAction (203)
+- CloseWindow (202)
+- RequestMachinimaActorModel (260)
+- UpdateMachinimaScene (262)
+- ClientReady (105)
+- MountMovement (166)
+- SyncPlayerPreferences (116)
+- ClientPlaceBlock (117)
+- RemoveMapMarker (119)
+- UpdateWorldMapVisible (243)
+- TeleportToWorldMapMarker (244)
+- TeleportToWorldMapPosition (245)
+- SyncInteractionChains (290)
+- SetPaused (158)
+- RequestFlyCameraMode (282)
+
+The following are so called sub packet handlers, they serve as additional functionality to the GamePacketHandler:
+
+#### AssetEditorPacketHandler
+
+- Disconnect (1)
+- Pong (3)
+- AssetEditorRequestChildrenList (321)
+- AssetEditorUpdateAsset (324)
+- AssetEditorUpdateJsonAsset (323)
+- AssetEditorSelectAsset (336)
+- AssetEditorFetchAsset (310)
+- AssetEditorFetchJsonAssetWithParents (311)
+- AssetEditorCreateAsset (327)
+- AssetEditorCreateDirectory (307)
+- AssetEditorRequestDataset (333)
+- AssetEditorFetchAutoCompleteData (331)
+- AssetEditorActivateButton (335)
+- AssetEditorDeleteAsset (329)
+- AssetEditorRenameAsset (328)
+- AssetEditorDeleteDirectory (308)
+- AssetEditorRenameDirectory (309)
+- AssetEditorExportAssets (342)
+- AssetEditorFetchLastModifiedAssets (338)
+- AssetEditorUndoChanges (349)
+- AssetEditorRedoChanges (350)
+- AssetEditorSubscribeModifiedAssetsChanges (341)
+- AssetEditorSetGameTime (352)
+- AssetEditorUpdateWeatherPreviewLock (354)
+- AssetEditorCreateAssetPack (316)
+- AssetEditorUpdateAssetPack (315)
+- AssetEditorDeleteAssetPack (317)
+
+#### BuilderToolsPacketHandler
+
+- LoadHotbar (106)
+- SaveHotbar (107)
+- BuilderToolArgUpdate (400)
+- BuilderToolEntityAction (401)
+- BuilderToolGeneralAction (412)
+- BuilderToolSelectionUpdate (409)
+- BuilderToolExtrudeAction (403)
+- BuilderToolRotateClipboard (406)
+- BuilderToolPasteClipboard (407)
+- BuilderToolOnUseInteraction (413)
+- BuilderToolSelectionToolAskForClipboard (410)
+- BuilderToolLineAction (414)
+- BuilderToolSetEntityTransform (402)
+- BuilderToolSetEntityScale (420)
+- BuilderToolSelectionTransform (405)
+- BuilderToolStackArea (404)
+- BuilderToolSetTransformationModeState (408)
+- PrefabUnselectPrefab (417)
+- BuilderToolSetEntityPickupEnabled (421)
+- BuilderToolSetEntityLight (422)
+- BuilderToolSetNPCDebug (423)
+
+#### InventoryPacketHandler
+
+- SetCreativeItem (171)
+- DropCreativeItem (172)
+- SmartGiveCreativeItem (173)
+- DropItemStack (174)
+- MoveItemStack (175)
+- SmartMoveItemStack (176)
+- SetActiveSlot (177)
+- SwitchHotbarBlockSet (178)
+- InventoryAction (179)
+
+#### AssetEditorGamePacketHandler
+
+- AssetEditorInitialize (302)
+- AssetEditorUpdateJsonAsset (323)
+
+#### MountGamePacketHandler
+
+- DismountNPC (294)
diff --git a/content/docs/bg-BG/guides/plugin/logging.mdx b/content/docs/bg-BG/guides/plugin/logging.mdx
new file mode 100644
index 00000000..23cd8ef3
--- /dev/null
+++ b/content/docs/bg-BG/guides/plugin/logging.mdx
@@ -0,0 +1,73 @@
+---
+title: Logging
+description: Learn how to log messages on the server using Hytale's server logging.
+authors:
+  - name: LucasVinicius314
+    url: https://github.com/LucasVinicius314
+---
+
+One way of logging messages is by using Hytale's own logging class `HytaleLogger`, which extends `com.google.common.flogger.AbstractLogger`. The logs will appear in the same log file that the Hytale server uses to write logs, in the server's log folder `{Hytale's install folder}/UserData/Saves/{World}/logs`.
+
+The logger allows you to add a name to it, when calling `HytaleLogger.get("<logger name>")`. The name of the logger will be added before the log message, so it's more easily identifiable inside the log file.
+
+There is a method `.forEnclosingClass()` that you can use to automatically get the logger for the file you are working in without having to change it every time.
+
+An example of how to use the Hytale logging class to log messages, through a static attribute in your plugin's main class:
+
+```java
+import com.hypixel.hytale.logger.HytaleLogger;
+
+public class ExamplePlugin extends JavaPlugin {
+
+  public static final HytaleLogger LOGGER = HytaleLogger.forEnclosingClass();
+
+  @Override
+  protected void setup() {
+    LOGGER.atInfo().log("my example plugin just loaded");
+  }
+}
+```
+
+The logger can then be used anywhere, like this:
+
+```java
+ExamplePlugin.LOGGER.atInfo().log("hello world");
+```
+
+## Log Levels
+
+All log messages have an associated level. The level can be used to categorize messages and configure how they are logged. Using the default configurations, only messages from `Info`, `Warn`, and `Severe` are printed.
+
+```java
+    LOGGER.atInfo().log("Provide high-level information about normal behavior.");
+    LOGGER.atWarning().log("Signal a potential problem or a situation that could lead to an error.");
+    LOGGER.atSevere().log("A serious error that will prevent things from working as expected.");
+```
+
+## Template Arguments
+
+The HytaleLogger uses `printf` style arguments, and should support most of the features and specifiers used by normal string formatting.
+
+```java
+final String name = "World";
+LOGGER.atInfo().log("Hello %s", name);
+// prints: Hello World
+```
+
+Here is a quick overview of some of the more commonly used specifiers:
+
+- `%s`: String
+- `%d`: Integer
+- `%f`: Float/Double
+- `%b`: Boolean
+- `%c`: Char
+
+## Exceptions and Causes
+
+If your log message has an associated exception or you want to include a stack trace, this can be done by setting the cause.
+
+```java
+    catch (IOException e) {
+        LOGGER.atSevere().withCause(e).log("Error!");
+    }
+```
diff --git a/content/docs/bg-BG/guides/plugin/permission-management.mdx b/content/docs/bg-BG/guides/plugin/permission-management.mdx
new file mode 100644
index 00000000..55f06101
--- /dev/null
+++ b/content/docs/bg-BG/guides/plugin/permission-management.mdx
@@ -0,0 +1,578 @@
+---
+title: Permission Management
+description: Learn how to manage permission nodes and groups in your Hytale plugin.
+authors:
+  - name: Neil Revin
+    link: https://itsneil.dev
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+  - name: Craw
+    link: https://discord.com/users/292656109939064833
+  - name: Ivan
+    link: https://discord.com/users/505770451218333717
+  - name: ZenithDevHQ
+    link: https://github.com/ZenithDevHQ
+---
+
+In this guide, you'll learn how to manage permission nodes and groups in your Hytale plugin. Permissions control what actions players can perform on your server, from basic commands to advanced administrative functions.
+
+## What Are Permissions?
+
+Permissions are string identifiers that control access to features and commands. When a player tries to perform an action (like using a command), the server checks if they have the required permission.
+
+**Example permission nodes:**
+
+- `hytale.command.gamemode` - Permission to use the gamemode command
+- `hytale.editor.brush.use` - Permission to use brush tools
+- `myplugin.teleport.home` - A custom permission for your plugin
+
+Permissions follow a hierarchical naming pattern: `namespace.category.action`
+
+## Key Concepts
+
+Before diving into code, let's understand the core concepts:
+
+| Concept             | Description                                                                |
+| ------------------- | -------------------------------------------------------------------------- |
+| **Permission Node** | A string like `myplugin.feature.use` that represents a specific permission |
+| **Group**           | A named collection of permissions (e.g., "Admin", "VIP", "Default")        |
+| **Provider**        | The backend that stores and retrieves permissions                          |
+| **Wildcard**        | A pattern like `*` or `myplugin.*` that matches multiple permissions       |
+
+### How Permissions Are Checked
+
+When checking if a player has a permission, Hytale follows this order:
+
+1. **User's direct permissions** - Permissions granted directly to the player
+2. **Group permissions** - Permissions from groups the player belongs to
+3. **Virtual groups** - Game-mode-based permissions (e.g., Creative mode grants builder tools)
+4. **Default value** - Falls back to `false` if no match found
+
+<Callout type="info">
+  The first definitive match wins. If a player has a permission granted at the user level, group permissions won't override it.
+</Callout>
+
+---
+
+## The `PermissionsModule` Class
+
+The `PermissionsModule` class is the central hub for managing permissions. Access it using the singleton pattern:
+
+```java
+PermissionsModule perms = PermissionsModule.get();
+```
+
+### Available Operations
+
+The module supports these operations:
+
+| Operation                     | Method                                          |
+| ----------------------------- | ----------------------------------------------- |
+| Add permissions to user       | `addUserPermission(uuid, permissions)`          |
+| Remove permissions from user  | `removeUserPermission(uuid, permissions)`       |
+| Add permissions to group      | `addGroupPermission(groupName, permissions)`    |
+| Remove permissions from group | `removeGroupPermission(groupName, permissions)` |
+| Add user to group             | `addUserToGroup(uuid, groupName)`               |
+| Remove user from group        | `removeUserFromGroup(uuid, groupName)`          |
+| Get user's groups             | `getGroupsForUser(uuid)`                        |
+| Check permission              | `hasPermission(uuid, permissionNode)`           |
+
+<Callout type="warning">
+  The module does **not** support:
+
+  - Listing all defined groups
+  - Deleting a group entirely
+
+  Groups are implicitly created when you first add permissions to them.
+</Callout>
+
+---
+
+## Checking Permissions
+
+The most common operation is checking if a player has a permission.
+
+### Basic Permission Check
+
+```java
+// Returns true if player has the permission, false otherwise
+boolean canUse = PermissionsModule.get().hasPermission(playerUUID, "myplugin.feature.use");
+
+if (canUse) {
+    // Player has permission, allow the action
+} else {
+    // Player lacks permission, deny or show error
+}
+```
+
+### Permission Check with Default Value
+
+You can specify what to return when no permission is explicitly set:
+
+```java
+// Returns true by default if no explicit permission is found
+boolean canUse = PermissionsModule.get().hasPermission(playerUUID, "myplugin.feature.use", true);
+```
+
+This is useful for features that should be enabled by default but can be revoked.
+
+### Using PermissionHolder Interface
+
+Players and command senders implement `PermissionHolder`, allowing direct checks:
+
+```java
+// In a command or event handler where you have access to the player
+if (player.hasPermission("myplugin.admin.manage")) {
+    // Player has admin permission
+}
+```
+
+---
+
+## Managing User Permissions
+
+### Adding Permissions to a User
+
+Permissions are additive - new permissions are added on top of existing ones, not replaced.
+
+```java
+PermissionsModule perms = PermissionsModule.get();
+
+// Add a single permission
+perms.addUserPermission(playerUUID, Set.of("myplugin.vip.chat"));
+
+// Add multiple permissions at once
+Set<String> newPerms = Set.of(
+    "myplugin.vip.chat",
+    "myplugin.vip.fly",
+    "myplugin.vip.kit"
+);
+perms.addUserPermission(playerUUID, newPerms);
+```
+
+### Removing Permissions from a User
+
+```java
+PermissionsModule perms = PermissionsModule.get();
+
+// Remove specific permissions
+Set<String> toRemove = Set.of("myplugin.vip.fly");
+perms.removeUserPermission(playerUUID, toRemove);
+```
+
+---
+
+## Managing Groups
+
+Groups let you assign a collection of permissions to multiple players. This is more manageable than assigning permissions individually.
+
+### Adding Permissions to a Group
+
+If the group doesn't exist, it will be created automatically.
+
+```java
+PermissionsModule perms = PermissionsModule.get();
+
+// Create/update the "VIP" group with permissions
+Set<String> vipPerms = Set.of(
+    "myplugin.vip.chat",
+    "myplugin.vip.fly",
+    "myplugin.vip.kit"
+);
+perms.addGroupPermission("VIP", vipPerms);
+```
+
+### Removing Permissions from a Group
+
+```java
+PermissionsModule perms = PermissionsModule.get();
+
+// Remove specific permissions from the group
+Set<String> toRemove = Set.of("myplugin.vip.fly");
+perms.removeGroupPermission("VIP", toRemove);
+```
+
+### Adding a User to a Group
+
+```java
+PermissionsModule perms = PermissionsModule.get();
+
+// Add player to the VIP group - they now have all VIP permissions
+perms.addUserToGroup(playerUUID, "VIP");
+```
+
+### Removing a User from a Group
+
+```java
+PermissionsModule perms = PermissionsModule.get();
+
+// Remove player from VIP group
+perms.removeUserFromGroup(playerUUID, "VIP");
+```
+
+### Getting a User's Groups
+
+```java
+PermissionsModule perms = PermissionsModule.get();
+
+// Get all groups the player belongs to
+Set<String> groups = perms.getGroupsForUser(playerUUID);
+
+for (String group : groups) {
+    System.out.println("Player is in group: " + group);
+}
+```
+
+---
+
+## Built-in Groups
+
+Hytale includes two default groups:
+
+| Group     | Default Permissions   | Purpose                           |
+| --------- | --------------------- | --------------------------------- |
+| `OP`      | `*` (all permissions) | Server operators with full access |
+| `Default` | None                  | Base group for all players        |
+
+Players without any explicit group assignment are automatically part of the `Default` group.
+
+---
+
+## Wildcards
+
+Wildcards let you grant or deny multiple permissions with a single pattern.
+
+### Wildcard Patterns
+
+| Pattern             | Meaning                                          |
+| ------------------- | ------------------------------------------------ |
+| `*`                 | Grants **all** permissions                       |
+| `myplugin.*`        | Grants all permissions starting with `myplugin.` |
+| `-*`                | Denies **all** permissions                       |
+| `-myplugin.admin.*` | Denies all admin permissions in your plugin      |
+
+### Example: Admin Group with Wildcards
+
+```java
+// Grant all permissions to admins
+perms.addGroupPermission("Admin", Set.of("*"));
+
+// Grant all plugin permissions to moderators
+perms.addGroupPermission("Moderator", Set.of("myplugin.*"));
+
+// Grant all permissions except admin commands
+perms.addGroupPermission("Helper", Set.of(
+    "*",
+    "-myplugin.admin.*"  // Deny admin permissions
+));
+```
+
+<Callout type="warning">
+  Negation permissions (starting with `-`) take precedence at each level. Use them carefully to avoid accidentally blocking permissions.
+</Callout>
+
+---
+
+## Built-in Permission Nodes
+
+Hytale provides constants for common permissions in the `HytalePermissions` class:
+
+### Command Permissions
+
+```java
+// Generate permission for a command
+String perm = HytalePermissions.fromCommand("gamemode");
+// Result: "hytale.command.gamemode"
+
+// Generate permission for a subcommand
+String perm = HytalePermissions.fromCommand("gamemode", "creative");
+// Result: "hytale.command.gamemode.creative"
+```
+
+### Common Permission Nodes
+
+| Permission                    | Description                  |
+| ----------------------------- | ---------------------------- |
+| `hytale.command.op.add`       | Add players to OP group      |
+| `hytale.command.op.remove`    | Remove players from OP group |
+| `hytale.editor.brush.use`     | Use brush tools              |
+| `hytale.editor.prefab.use`    | Use prefabs                  |
+| `hytale.editor.selection.use` | Use selection tools          |
+| `hytale.editor.history`       | Undo/redo operations         |
+| `hytale.camera.flycam`        | Use fly camera mode          |
+
+---
+
+## Listening to Permission Events
+
+You can react to permission changes using Hytale's event system.
+
+### Available Events
+
+| Event                                            | Triggered When                   |
+| ------------------------------------------------ | -------------------------------- |
+| `PlayerPermissionChangeEvent.PermissionsAdded`   | Permissions added to a user      |
+| `PlayerPermissionChangeEvent.PermissionsRemoved` | Permissions removed from a user  |
+| `PlayerGroupEvent.Added`                         | User added to a group            |
+| `PlayerGroupEvent.Removed`                       | User removed from a group        |
+| `GroupPermissionChangeEvent.Added`               | Permissions added to a group     |
+| `GroupPermissionChangeEvent.Removed`             | Permissions removed from a group |
+
+### Example: Reacting to Permission Changes
+
+```java
+public class PermissionListener {
+
+    public static void onPermissionsAdded(PlayerPermissionChangeEvent.PermissionsAdded event) {
+        UUID playerUUID = event.getPlayerUuid();
+        Set<String> added = event.getAddedPermissions();
+
+        System.out.println("Permissions added to " + playerUUID + ": " + added);
+
+        // Maybe notify the player or update cached data
+    }
+
+    public static void onGroupAdded(PlayerGroupEvent.Added event) {
+        UUID playerUUID = event.getPlayerUuid();
+        String groupName = event.getGroupName();
+
+        System.out.println("Player " + playerUUID + " joined group: " + groupName);
+    }
+}
+```
+
+### Registering the Events
+
+```java
+public class MyPlugin extends JavaPlugin {
+
+    @Override
+    public void setup() {
+        EventRegistry events = this.getEventRegistry();
+
+        events.registerGlobal(
+            PlayerPermissionChangeEvent.PermissionsAdded.class,
+            PermissionListener::onPermissionsAdded
+        );
+
+        events.registerGlobal(
+            PlayerGroupEvent.Added.class,
+            PermissionListener::onGroupAdded
+        );
+    }
+}
+```
+
+---
+
+## Creating a Custom Permission Provider
+
+For advanced use cases, you can create your own permission provider. This is useful for:
+
+- Database-backed permissions (MySQL, MongoDB, etc.)
+- Cross-server permission synchronization
+- Custom features like permission expiry or contexts
+
+### Implementing PermissionProvider
+
+```java
+public class DatabasePermissionProvider implements PermissionProvider {
+
+    @Nonnull
+    @Override
+    public String getName() {
+        return "DatabasePermissionProvider";
+    }
+
+    // User permission methods
+    @Override
+    public void addUserPermissions(@Nonnull UUID uuid, @Nonnull Set<String> permissions) {
+        // Save to your database
+    }
+
+    @Override
+    public void removeUserPermissions(@Nonnull UUID uuid, @Nonnull Set<String> permissions) {
+        // Remove from your database
+    }
+
+    @Override
+    public Set<String> getUserPermissions(@Nonnull UUID uuid) {
+        // Query your database
+        return Set.of();
+    }
+
+    // Group permission methods
+    @Override
+    public void addGroupPermissions(@Nonnull String group, @Nonnull Set<String> permissions) {
+        // Save to your database
+    }
+
+    @Override
+    public void removeGroupPermissions(@Nonnull String group, @Nonnull Set<String> permissions) {
+        // Remove from your database
+    }
+
+    @Override
+    public Set<String> getGroupPermissions(@Nonnull String group) {
+        // Query your database
+        return Set.of();
+    }
+
+    // User-group membership methods
+    @Override
+    public void addUserToGroup(@Nonnull UUID uuid, @Nonnull String group) {
+        // Save to your database
+    }
+
+    @Override
+    public void removeUserFromGroup(@Nonnull UUID uuid, @Nonnull String group) {
+        // Remove from your database
+    }
+
+    @Override
+    public Set<String> getGroupsForUser(@Nonnull UUID uuid) {
+        // Query your database
+        return Set.of("Default");
+    }
+}
+```
+
+<Callout type="warning">
+  Hytale automatically assigns players to game-mode groups (like `Creative` or `Adventure`) using the first available provider.
+
+  If your provider throws an error when the group doesn't exist, the player will be disconnected! Always handle missing groups gracefully.
+</Callout>
+
+### Registering Your Provider
+
+```java
+public class MyPlugin extends JavaPlugin {
+
+    @Override
+    public void setup() {
+        // Add your provider alongside the default one
+        PermissionsModule.get().addProvider(new DatabasePermissionProvider());
+    }
+}
+```
+
+The `PermissionsModule` aggregates permissions from all registered providers. This means:
+
+- Permission checks query all providers
+- Write operations (add/remove) use the **first** provider
+
+### Replacing the Default Provider
+
+If you want full control, you can remove the default provider:
+
+```java
+public class MyPlugin extends JavaPlugin {
+
+    @Override
+    public void setup() {
+        PermissionsModule perms = PermissionsModule.get();
+
+        // Remove the default provider FIRST
+        perms.removeProvider(perms.getFirstPermissionProvider());
+
+        // Then add your provider
+        perms.addProvider(new DatabasePermissionProvider());
+    }
+}
+```
+
+<Callout type="info">
+  When you remove the default provider, the `/op self` command will stop working since it checks for provider tampering.
+</Callout>
+
+---
+
+## Best Practices
+
+### Permission Naming Conventions
+
+Follow the pattern: `namespace.category.action`
+
+```java
+// Good - clear hierarchy
+"myplugin.admin.ban"
+"myplugin.user.teleport.home"
+"myplugin.vip.chat.color"
+
+// Bad - unclear structure
+"myplugin_ban"
+"teleport"
+"vipChatColor"
+```
+
+### Use Constants for Permissions
+
+Define your permissions as constants to avoid typos:
+
+```java
+public final class MyPermissions {
+    public static final String ADMIN_BAN = "myplugin.admin.ban";
+    public static final String ADMIN_KICK = "myplugin.admin.kick";
+    public static final String USER_HOME = "myplugin.user.home";
+    public static final String VIP_FLY = "myplugin.vip.fly";
+}
+
+// Usage
+if (player.hasPermission(MyPermissions.ADMIN_BAN)) {
+    // ...
+}
+```
+
+### Don't Over-Permission
+
+Only create permissions for actions that genuinely need access control. Not everything needs a permission check.
+
+### Thread Safety
+
+If you create a custom provider, ensure it's thread-safe. Permission checks can occur from multiple threads simultaneously. Use `ReadWriteLock` or `ConcurrentHashMap` for your data structures.
+
+---
+
+## In-Game Commands
+
+Hytale provides built-in commands for managing permissions:
+
+### `/op` Command
+
+| Command               | Description                                                        |
+| --------------------- | ------------------------------------------------------------------ |
+| `/op self`            | Toggle your own OP status (singleplayer or with `--allow-op` flag) |
+| `/op add <player>`    | Add a player to the OP group                                       |
+| `/op remove <player>` | Remove a player from the OP group                                  |
+
+### `/perm` Command
+
+Use `/perm --help` in-game for full usage. Common operations:
+
+| Command                                  | Description                   |
+| ---------------------------------------- | ----------------------------- |
+| `/perm user list <uuid>`                 | List user's permissions       |
+| `/perm user add <uuid> <perm>`           | Add permission to user        |
+| `/perm user remove <uuid> <perm>`        | Remove permission from user   |
+| `/perm user group list <uuid>`           | List user's groups            |
+| `/perm user group add <uuid> <group>`    | Add user to group             |
+| `/perm user group remove <uuid> <group>` | Remove user from group        |
+| `/perm group list <group>`               | List group's permissions      |
+| `/perm group add <group> <perm>`         | Add permission to group       |
+| `/perm group remove <group> <perm>`      | Remove permission from group  |
+| `/perm test <perm>`                      | Test if you have a permission |
+
+---
+
+## Summary
+
+You've learned how to:
+
+- **Check permissions** using `PermissionsModule.hasPermission()`
+- **Manage user permissions** with `addUserPermission()` and `removeUserPermission()`
+- **Work with groups** using `addGroupPermission()`, `addUserToGroup()`, etc.
+- **Use wildcards** like `*` and `myplugin.*` for bulk permissions
+- **Listen to events** for permission changes
+- **Create custom providers** for database-backed permissions
+
+For more advanced permission systems with features like inheritance, expiry, and contexts, we're looking into expanding this guide with advanced permission management techniques in the future.
diff --git a/content/docs/bg-BG/guides/plugin/player-death-event.mdx b/content/docs/bg-BG/guides/plugin/player-death-event.mdx
new file mode 100644
index 00000000..b7f119ee
--- /dev/null
+++ b/content/docs/bg-BG/guides/plugin/player-death-event.mdx
@@ -0,0 +1,129 @@
+---
+title: Player Death Event
+description: Learn how to use the OnDeathSystem.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+---
+
+# Overview
+
+In this guide, you'll learn how to use the OnDeathSystem to detect when a player dies.
+
+## Code Example
+
+```java
+package org.example.plugin.Systems;
+
+import com.hypixel.hytale.component.CommandBuffer;
+import com.hypixel.hytale.component.Ref;
+import com.hypixel.hytale.component.Store;
+import com.hypixel.hytale.component.query.Query;
+import com.hypixel.hytale.server.core.Message;
+import com.hypixel.hytale.server.core.entity.entities.Player;
+import com.hypixel.hytale.server.core.modules.entity.damage.Damage;
+import com.hypixel.hytale.server.core.modules.entity.damage.DeathComponent;
+import com.hypixel.hytale.server.core.modules.entity.damage.DeathSystems;
+import com.hypixel.hytale.server.core.universe.Universe;
+import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
+
+import javax.annotation.Nonnull;
+
+public class TestDeathSystem extends DeathSystems.OnDeathSystem {
+
+    @Nonnull
+    @Override
+    public Query<EntityStore> getQuery() {
+        return Query.and(Player.getComponentType());
+    }
+
+    @Override
+    public void onComponentAdded(@Nonnull Ref ref, @Nonnull DeathComponent component, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+        Player playerComponent = (Player) store.getComponent(ref, Player.getComponentType());
+
+        assert playerComponent != null;
+
+        Universe.get().sendMessage(Message.raw("Death player: " + playerComponent.getDisplayName()));
+        Damage deathInfo = component.getDeathInfo();
+        if (deathInfo != null) {
+            Universe.get().sendMessage(Message.raw("Death info amount: " + deathInfo.getAmount()));
+        }
+    }
+}
+```
+
+## Steps
+
+### 1. Extend the Death System
+
+Start by creating a new class that extends `DeathSystems.OnDeathSystem`. This allows your system to automatically react whenever an entity dies.
+
+```java
+public class TestDeathSystem extends DeathSystems.OnDeathSystem {
+```
+
+---
+
+### 2. Define Which Entities This System Applies To
+
+Override the `getQuery()` method to filter for the entities you want. In this case, we only want **players**:
+
+```java
+@Nonnull
+@Override
+public Query<EntityStore> getQuery() {
+    return Query.and(Player.getComponentType());
+}
+```
+
+<Callout>
+  `Query.and(...)` allows you to combine multiple filters if needed.
+</Callout>
+
+---
+
+### 3. Listen for the Death Event
+
+The `onComponentAdded` method is called automatically whenever a `DeathComponent` is added to an entity matching your query.
+
+```java
+@Override
+public void onComponentAdded(
+        @Nonnull Ref ref,
+        @Nonnull DeathComponent component,
+        @Nonnull Store store,
+        @Nonnull CommandBuffer commandBuffer
+)
+```
+
+---
+
+### 4. Get the Player Component
+
+Use the `Store` to retrieve the `Player` component from the entity that just died:
+
+```java
+Player playerComponent = (Player) store.getComponent(ref, Player.getComponentType());
+```
+
+This lets you access information such as the player's display name.
+
+---
+
+### 5. Get Death Damage Information
+
+The `DeathComponent` contains information about the damage that killed the player:
+
+```java
+Damage deathInfo = component.getDeathInfo();
+```
+
+You can then check:
+
+```java
+if (deathInfo != null) {
+    Universe.get().sendMessage(Message.raw("Damage amount: " + deathInfo.getAmount()));
+}
+```
+
+This provides the **amount of damage** and the **source of the death**.
diff --git a/content/docs/bg-BG/guides/plugin/player-input-guide.mdx b/content/docs/bg-BG/guides/plugin/player-input-guide.mdx
new file mode 100644
index 00000000..c9cc1419
--- /dev/null
+++ b/content/docs/bg-BG/guides/plugin/player-input-guide.mdx
@@ -0,0 +1,68 @@
+---
+title: Player Input Guide
+description: Learn how to handle player input.
+authors:
+  - name: Neil Revin
+    url: https://itsneil.dev
+  - name: Zoon20X
+---
+
+Hytale servers don't receive raw keyboard input. The client interprets keypresses and sends packets describing what action the player wants to perform. You need to intercept these packets or events to create custom behavior.
+
+We can use the `SyncInteractionChains` to check when a player interacts. This has a few InteractionTypes, which are listed at the end of this guide.
+
+We can use the following code to intercept the SyncInteractionChains packet, and run our code whenever a user interacts using the "F" keybind.
+
+```java
+public class PacketListener implements PacketWatcher {
+    @Override
+    public void accept(PacketHandler packetHandler, Packet packet) {
+        if (packet.getId() != 290) {
+            return;
+        }
+        SyncInteractionChains interactionChains = (SyncInteractionChains) packet;
+        SyncInteractionChain[] updates = interactionChains.updates;
+
+        for (SyncInteractionChain item : updates) {
+            PlayerAuthentication playerAuthentication = packetHandler.getAuth();
+            String uuid = playerAuthentication.getUuid().toString();
+            InteractionType interactionType = item.interactionType;
+            if(interactionType == InteractionType.Use){
+                // code here
+            }
+        }
+    }
+}
+```
+
+### Interaction Types
+
+You will majorly use the `Primary`, `Secondary` and `Use` interaction types. The `Primary` Interaction Type is triggered when a player left clicks, `Secondary` is triggered when a player right clicks, and `Use` is triggered when a player uses an item.
+
+Here's a list of all Interaction Types:
+
+- Primary (0)
+- Secondary (1)
+- Ability1 (2)
+- Ability2 (3)
+- Ability3 (4)
+- Use (5)
+- Pick (6)
+- Pickup (7)
+- CollisionEnter (8)
+- CollisionLeave (9)
+- Collision (10)
+- EntityStatEffect (11)
+- SwapTo (12)
+- SwapFrom (13)
+- Death (14)
+- Wielding (15)
+- ProjectileSpawn (16)
+- ProjectileHit (17)
+- ProjectileMiss (18)
+- ProjectileBounce (19)
+- Held (20)
+- HeldOffhand (21)
+- Equipped (22)
+- Dodge (23)
+- GameModeSwap (24)
diff --git a/content/docs/bg-BG/guides/plugin/player-stats.mdx b/content/docs/bg-BG/guides/plugin/player-stats.mdx
new file mode 100644
index 00000000..32f15c6b
--- /dev/null
+++ b/content/docs/bg-BG/guides/plugin/player-stats.mdx
@@ -0,0 +1,113 @@
+---
+title: Player Stats
+description: A simple guide on how to edit player stats.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+---
+
+# Overview
+
+This guide shows you how to read and modify player stats like health and stamina using the `EntityStatMap` component.
+
+## Available Stats
+
+Hytale provides several default stats via `DefaultEntityStatTypes`:
+
+- **Health**: `DefaultEntityStatTypes.getHealth()`
+- **Stamina**: `DefaultEntityStatTypes.getStamina()`
+- **Mana**: `DefaultEntityStatTypes.getMana()`
+- **Oxygen**: `DefaultEntityStatTypes.getOxygen()`
+- **Signature Energy**: `DefaultEntityStatTypes.getSignatureEnergy()`
+- **Ammo**: `DefaultEntityStatTypes.getAmmo()`
+
+---
+
+## Example 1: Heal Command
+
+This command restores the player's health to its maximum value.
+
+```java
+public class HealCommand extends CommandBase {
+    public HealCommand() {
+        super("heal", "Restores your health to maximum.");
+        this.setPermissionGroup(GameMode.Adventure);
+    }
+
+    @Override
+    protected void executeSync(@Nonnull CommandContext ctx) {
+        // 1. Get the player reference
+        Ref<EntityStore> playerRef = ctx.senderAsPlayerRef();
+        if (playerRef == null) return;
+
+        // 2. Get the store and the world
+        Store<EntityStore> store = playerRef.getStore();
+        EntityStore entityStore = store.getExternalData();
+        World world = entityStore.getWorld();
+
+        // 3. Perform modification on the world thread
+        world.execute(() -> {
+            EntityStatMap statMap = (EntityStatMap) store.getComponent(playerRef, EntityStatMap.getComponentType());
+            if (statMap != null) {
+                statMap.maximizeStatValue(DefaultEntityStatTypes.getHealth());
+                ctx.sendMessage(Message.raw("Your health has been restored!"));
+            }
+        });
+    }
+}
+```
+
+---
+
+## Example 2: Damage Self Command
+
+This command removes a specific amount of health from the player.
+
+```java
+public class DamageSelfCommand extends CommandBase {
+    private final Argument amountArg;
+
+    public DamageSelfCommand() {
+        super("damageself", "Damages yourself by a specific amount.");
+        this.setPermissionGroup(GameMode.Adventure);
+        this.amountArg = this.withRequiredArg("amount", "Amount of damage", ArgTypes.FLOAT);
+    }
+
+    @Override
+    protected void executeSync(@Nonnull CommandContext ctx) {
+		// 1. Get the player reference
+        Ref<EntityStore> playerRef = ctx.senderAsPlayerRef();
+        if (playerRef == null) return;
+
+        // 2. Get command arg
+        Float amount = (Float) this.amountArg.get(ctx);
+        if (amount == null) return;
+
+        // 3. Get the store and the world
+        Store<EntityStore> store = playerRef.getStore();
+        EntityStore entityStore = store.getExternalData();
+        World world = entityStore.getWorld();
+        
+        // 4. Perform modification on the world thread
+        world.execute(() -> {
+            EntityStatMap statMap = (EntityStatMap) store.getComponent(playerRef, EntityStatMap.getComponentType());
+            if (statMap != null) {
+                statMap.subtractStatValue(DefaultEntityStatTypes.getHealth(), amount);
+                ctx.sendMessage(Message.raw("Ouch! You took " + amount + " damage."));
+            }
+        });
+    }
+}
+```
+
+---
+
+## Useful Methods
+
+Common methods available on `EntityStatMap`:
+
+- **Set**: `statMap.setStatValue(statIndex, value)`
+- **Add**: `statMap.addStatValue(statIndex, amount)`
+- **Subtract**: `statMap.subtractStatValue(statIndex, amount)`
+- **Maximize**: `statMap.maximizeStatValue(statIndex)`
+- **Reset**: `statMap.resetStatValue(statIndex)`
diff --git a/content/docs/bg-BG/guides/plugin/playing-sounds.mdx b/content/docs/bg-BG/guides/plugin/playing-sounds.mdx
new file mode 100644
index 00000000..7ce614b8
--- /dev/null
+++ b/content/docs/bg-BG/guides/plugin/playing-sounds.mdx
@@ -0,0 +1,64 @@
+---
+title: Playing Sounds
+description: Learn how to Play Sounds with your Hytale Plugin
+authors:
+  - name: Neil Revin
+    link: https://itsneil.dev
+---
+
+In this guide, you will learn how to play sounds to a player.
+
+## Sound Indexes
+
+We currently have a lot of Sounds available to be used as a key in the AssetMap, [click here](../../server/sounds) to see the full list of available sounds.
+
+You can use the `getAssetMap()` method from the `SoundEvent` class to get the index of a specified sound:
+
+```java
+int index = SoundEvent.getAssetMap().getIndex("SFX_Cactus_Large_Hit");
+```
+
+## The Transform Component
+
+The `TransformComponent` is the component that tells Hytale where to play the sound. You can get this in multiple ways.
+
+1. Getting the Transform Component from the `Player` object
+
+```java
+TransformComponent transform = store.getComponent(context.senderAsPlayerRef(), EntityModule.get().getTransformComponentType());
+```
+
+2. Generating a new TransformComponent (although this is not recommended, as if your player is not close enough they won't hear the sound)
+
+```java
+Vector3d vector3d = new Vector3d(0, 0, 0); // position
+Vector3f vector3f = new Vector3f(0, 0, 0); // rotation
+TransformComponent transform = new TransformComponent(vector3d, vector3f);
+```
+
+### PlayerRef
+
+You need a Player Reference, which is a instance of `Ref<EntityStore>`. If you have the `Player` object, you can use the `getReference()` method to get a Player Reference
+
+### World
+
+You need a World reference, as the sound needs to be played inside the `execute()` method from the `World` class.
+
+### SoundCategory
+
+There is a `SoundCategory` enum that defines different sound categories, such as `Music`, `Ambient`, `SFX` and `UI`. You can use these categories to specify the type of sound you are playing.
+
+## Playing Sounds
+
+You can use the `SoundUtil` class to play sounds, using the `playSoundEvent3dToPlayer` method.
+
+```java
+int index = SoundEvent.getAssetMap().getIndex("SFX_Cactus_Large_Hit");
+World world = player.getWorld();
+EntityStore store = world.getEntityStore();
+Ref<EntityStore> playerRef = player.getReference();
+world.execute(() -> {
+    TransformComponent transform = store.getStore().getComponent(playerRef, EntityModule.get().getTransformComponentType());
+    SoundUtil.playSoundEvent3dToPlayer(playerRef, index, SoundCategory.UI, transform.getPosition(), store.getStore());
+});
+```
diff --git a/content/docs/bg-BG/guides/plugin/send-notifications.mdx b/content/docs/bg-BG/guides/plugin/send-notifications.mdx
new file mode 100644
index 00000000..8eafb96e
--- /dev/null
+++ b/content/docs/bg-BG/guides/plugin/send-notifications.mdx
@@ -0,0 +1,48 @@
+---
+title: Sending notifications
+description: Learn how to send notifications (similar to item pickup) with your Hytale Plugin
+authors:
+  - name: BeerBag
+---
+
+## Overview
+
+In this guide, you will learn how to send notifications to players, similar to
+the notification received when picking up an item from the ground.
+
+![notification-example](/assets/guides/notification-example.png)
+
+## Structure of a Notification
+
+A notification consists of three main components:
+
+1. **Primary Message**: The main `Message` displayed in the notification.
+2. **Secondary Message**: Additional `Message`, displayed below the primary message.
+3. **Icon**: An item icon that visually represents the notification, shown on
+   the left side.
+
+## Sending Notifications
+
+You can use the `NotificationUtil` class to send notifications to players.
+You will need access to the `PacketHandler` of the player, which can be obtained
+from the `PlayerRef` using the `getPacketHandler()` method (in this example,
+we get the `PlayerRef` from the `Universe` using the player's UUID).
+
+```java
+public static void onPlayerReady(PlayerReadyEvent event) {
+    var player = event.getPlayer();
+
+    var playerRef = Universe.get().getPlayer(player.getUuid());
+    var packetHandler = playerRef.getPacketHandler();
+
+    var primaryMessage = Message.raw("THIS WORKS!!!").color("#00FF00");
+    var secondaryMessage = Message.raw("This is the secondary message").color("#228B22");
+    var icon = new ItemStack("Weapon_Sword_Mithril", 1).toPacket();
+
+    NotificationUtil.sendNotification(
+        packetHandler,
+        primaryMessage,
+        secondaryMessage,
+        (ItemWithAllMetadata) icon);
+}
+```
diff --git a/content/docs/bg-BG/guides/plugin/setting-up-env.mdx b/content/docs/bg-BG/guides/plugin/setting-up-env.mdx
new file mode 100644
index 00000000..5be5e9e0
--- /dev/null
+++ b/content/docs/bg-BG/guides/plugin/setting-up-env.mdx
@@ -0,0 +1,228 @@
+---
+title: Setting Up Your Development Environment
+description: Learn how to set up your development environment for modding Hytale.
+authors:
+  - name: Neil Revin
+    link: https://itsneil.dev
+  - name: Marcel-TO
+    url: https://marcel-to.net
+  - name: Ádám Liszkai
+    link: https://adaliszk.dev
+---
+
+This guide will walk you through setting up a complete development environment for Hytale modding, including all necessary tools and dependencies.
+
+## Prerequisites
+
+Before we begin, make sure you have:
+
+- A computer running Windows 10/11, macOS, or Linux
+- At least 8GB of RAM
+- 10GB of free disk space
+- Administrative privileges on your system
+
+## Required Software
+
+### Integrated Development Environment (IDE)
+
+We recommend IntelliJ IDEA Community Edition for Hytale modding. If you use IntelliJ IDEA, **almost everything is built-in**. You can clone a template, open a new project, and start working right away!
+
+1. Download from [JetBrains website](https://www.jetbrains.com/idea/download/)
+2. Install with default settings
+3. Launch and complete the initial setup wizard
+
+When opening a project, wait for indexing to finish, then start coding.
+Now, IDEA may say "No JDK configured" at the top of the source file you have.
+In that case, you can click Download JDK and choose JetBrains JDK 25.
+
+<Callout type="success">
+  If IDEA opened the project without errors, your environment is ready.
+</Callout>
+
+More details by [JetBrains](https://www.jetbrains.com/help/idea/2026.1/run-for-the-first-time.html)
+help page, where we recommend that you also check the
+[SDK configuration](https://www.jetbrains.com/help/idea/2026.1/sdk.html) guide.
+
+<Callout type="info">
+  We recommened following
+  [TheNullicorn's](https://gist.github.com/TheNullicorn/90a619796c40f20ae1fcf13094c1a57d) guide to ensure
+  you are using the correct `Nonnull` in your projects.
+</Callout>
+
+#### What the IDE Does for You
+
+When opened in IntelliJ IDEA, the project automatically:
+
+- Detects and configures Gradle or Maven
+- Downloads all dependencies
+- Sets up project structure and classpaths
+- Configures run/build tasks
+
+You do **not** need to manually install or configure Maven or Gradle if you stay inside the IDE.
+
+Skip to the [Setting Up Your Workspace](#setting-up-your-workspace).
+
+### Manual Setup: Java Development Kit (JDK)
+
+For any other setup, you will need to install and configure your system to have and load Java.
+Hytale modding requires Java 25 or later. We recommend using OpenJDK.
+
+#### Windows via Installer
+
+1. Download OpenJDK 25 from [Adoptium](https://adoptium.net/)
+2. Run the installer with default settings
+   - Optionally enable feature `Set or Override JAVA_HOME variable` to resolve version related build issues with your project.
+3. Verify installation by opening Command Prompt and running:
+
+#### Windows via Scoop
+
+1. Install Scoop via PowerShell using [scoop.sh](https://scoop.sh/)
+2. Install OpenJDK 25:
+
+```bash
+scoop bucket add java
+scoop install java/openjdk25
+```
+
+#### macOS
+
+1. Install Brew via Terminal using [brew.sh](https://brew.sh)
+2. Install JDK via Homebrew:
+
+```bash
+brew install openjdk@25
+```
+
+<Callout type="info">
+  If `java --version` shows "Unable to locate a Java Runtime", add OpenJDK to your PATH:
+
+  ```bash
+  echo 'export PATH="$(brew --prefix)/opt/openjdk@25/bin:$PATH"' >> ~/.zshrc
+  source ~/.zshrc
+  ```
+</Callout>
+
+#### Linux (Ubuntu/Debian)
+
+1. Install JDK via the built-in package repository:
+
+```bash
+sudo apt update
+sudo apt install openjdk-25-jdk
+```
+
+### Verify installation:
+
+Run the following command to see what version of Java you have:
+
+```bash
+java -version
+```
+
+### Java Build Tool (Optional)
+
+We recommend using a Gradle Wrapper for managing dependencies and building your Hytale plugins. It provides benefits by eliminating the need for a system-wide Gradle installation and ensuring consistent Gradle versions across different environments. (Alternatively you can use Maven, but this guide focuses on Gradle since it is the default for our plugin template.)
+
+The plugin template in the following sections includes a Gradle Wrapper, so you can skip this step if you plan to use the template.
+
+#### Choosing Gradle (if not using the template)
+
+If you prefer to install Gradle manually, follow these steps:
+
+1. Visit the official website: https://gradle.org/releases/
+2. Download the newest gradle binary: `gradle-9.3.1-bin.zip` (Binary zip archive)
+3. Unzip it
+4. Add the `gradle-9.3.1/bin/` folder to your PATH
+
+You can now try the command `gradle -version` to verify Gradle is installed correctly. Make sure to do this in a fresh new terminal instead of one you had opened from before!
+
+#### Choosing Maven (if not using the template)
+
+If you prefer to use Maven instead of Gradle, follow these steps to install Maven:
+
+1. Visit the official website: https://maven.apache.org/download.cgi
+2. Download this file: `apache-maven-3.9.12-bin.zip` (Binary zip archive)
+3. Unzip it
+4. Add the `apache-maven-3.9.12/bin/` folder to your PATH
+
+You can now try the command `mvn -version` to verify Maven is installed correctly. Make sure to do this in a fresh new terminal instead of one you had opened from before!
+
+## Setting Up Your Workspace
+
+### 1. Clone the Plugin Template
+
+Instead of creating an empty directory, we'll use the official Hytale plugin template:
+
+```bash
+# Clone the template repository
+git clone https://github.com/HytaleModding/plugin-template.git MyFirstMod
+cd MyFirstMod
+```
+
+If you don't have Git installed, you can download the ZIP file from the repository page and extract it to a folder named `MyFirstMod`.
+
+### 2. Open Plugin in your IDE
+
+1. Open Your IDE (e.g., IntelliJ IDEA)
+2. Click "Open" and navigate to your `MyFirstMod` directory
+3. Most IDEs like IntelliJ will automatically detect it as a Gradle project
+4. Wait for the project to index and dependencies to download
+
+## Alternate Approach: Hytale Dependency
+
+If you prefer to set up your project from scratch without using the template and importing the hytale dependencies manually, ensure your build configuration includes the Hytale repositories and dependencies:
+
+For Gradle, add the following to your `build.gradle.kts`:
+
+```kotlin
+repositories {
+    mavenCentral()
+    maven {
+        name = "hytale"
+        url = uri("https://maven.hytale.com/release") // Or "hytale-pre-release" for pre-release versions
+    }
+}
+dependencies {
+    // + here means the latest version, but you can hard-wire any known version!
+    implementation("com.hypixel.hytale:Server:+")
+}
+```
+
+For Maven, add the following to your `pom.xml`:
+
+```xml
+<project>
+    <repositories>
+        <repository>
+            <id>hytale-release</id> <!-- Or "hytale-pre-release" for pre-release versions -->
+            <url>https://maven.hytale.com/release</url> <!-- Or "https://maven.hytale.com/pre-release" -->
+        </repository>
+    </repositories>
+
+    <dependencies>
+        <dependency>
+            <groupId>com.hypixel.hytale</groupId>
+            <artifactId>Server</artifactId>
+            <!-- Replace with latest version, Hytale provides jars for the last five releases -->
+            <version>LATEST_VERSION_HERE</version>
+            <scope>provided</scope>
+        </dependency>
+    </dependencies>
+</project>
+```
+
+## Next Steps
+
+Now that you have your development environment set up with the plugin template:
+
+1. **Customize the template** - Edit the `settings.gradle.kts`, `build.gradle.kts` and `manifest.json` file to change your mod's name and details
+2. **Explore the code structure** - Familiarize yourself with the template's organization
+3. **Start modding** - Begin writing your first Hytale plugin!
+
+Learn how to:
+
+- [Build and Test Your Mod](./build-and-test)
+- [Create Commands](./creating-commands)
+- [Create Events](./creating-events)
+
+and more! Explore the documentation to learn about all available features and best practices.
diff --git a/content/docs/bg-BG/guides/plugin/spawning-entities.mdx b/content/docs/bg-BG/guides/plugin/spawning-entities.mdx
new file mode 100644
index 00000000..15be2fb3
--- /dev/null
+++ b/content/docs/bg-BG/guides/plugin/spawning-entities.mdx
@@ -0,0 +1,165 @@
+---
+title: Spawning Entities
+description: Learn how to spawn Entities in Hytale
+authors:
+  - name: Neil Revin
+    link: https://itsneil.dev
+---
+
+In this guide, you will learn how to spawn entities in Hytale. It is **highly recommended** to familiarize yourself with the Entity Component System (ECS) before proceeding with this guide. You can find the ECS guide [here](./ecs).
+
+## Getting the World Object
+
+You need to first get the `World` object before proceeding with spawning entities. You can get this object in a few ways:
+
+### Using the `Player` Object
+
+You can use the `Player` object to get the `World` object by calling the `getWorld()` method on the `Player` instance.
+
+```java
+World world = player.getWorld();
+```
+
+### Using the `Universe` Class
+
+You can use the `Universe` class to get the `World` object by calling the `getWorld(string UUID)` method on the `Universe` instance.
+
+```java
+World world = Universe.get().getWorld("your-world-uuid");
+```
+
+Once you have the world object, you need to get a instance of `Store<EntityStore>`, you can do so by:
+
+```java
+Store<EntityStore> store = world.getEntityStore().getStore();
+```
+
+## Creating Entities
+
+Once you have the `EntityStore` instance, you can start to create an entity and give it components. Entities are just instances of `Holder<EntityStore>` with several components attached to them.
+
+<Callout type="warning">
+  To interact with the `World` instance, some methods require you to run the code inside the world's execution context.
+  The logic under the hood enqueues each task to be executed in the world's thread. To do this, you can use the `world.execute()` method.
+
+  In our case, we will be using the `world.execute()` method to spawn the entity in the world. For convenience, in this guide we will be putting all the code below inside the lambda function, but it's not required.
+
+  ```java
+  world.execute(() -> {
+      // run all the code below in this context
+  })
+  ```
+</Callout>
+
+Let's start by creating a blank holder:
+
+```java
+Holder<EntityStore> holder = EntityStore.REGISTRY.newHolder();
+```
+
+## Getting a Model
+
+You now need a model for your Entity. You can find a list of all entities [here](../../server/entities), we're going to use the Minecart entity for this example:
+
+```java
+ModelAsset modelAsset = ModelAsset.getAssetMap().getAsset("Minecart");
+Model model = Model.createScaledModel(modelAsset, 1.0f);
+```
+
+### The Transform Component
+
+The `TransformComponent` is the component that tells Hytale where to place your entity, what it's location is. You can get this in multiple ways.
+
+1. Getting the Transform Component from the player - note that this requires fetching the player's EntityStore reference first.
+
+```java
+TransformComponent transform = store.getComponent(playerRef.getReference(), EntityModule.get().getTransformComponentType());
+```
+
+2. Generating a new TransformComponent
+
+```java
+Vector3d vector3d = new Vector3d(0, 0, 0); // position
+Vector3f vector3f = new Vector3f(0, 0, 0); // rotation
+TransformComponent transform = new TransformComponent(vector3d, vector3f);
+```
+
+## Adding Components to our Entity
+
+Now we need to add all the components we made above to our entity, here's all the components we need to add one by one:
+
+```java
+
+holder.addComponent(TransformComponent.getComponentType(), new TransformComponent(vector3d, new Vector3f(0, 0, 0)));
+holder.addComponent(PersistentModel.getComponentType(), new PersistentModel(model.toReference()));
+holder.addComponent(ModelComponent.getComponentType(), new ModelComponent(model));
+holder.addComponent(BoundingBox.getComponentType(), new BoundingBox(model.getBoundingBox()));
+holder.addComponent(NetworkId.getComponentType(), new NetworkId(store.getExternalData().takeNextNetworkId()));
+holder.addComponent(Interactions.getComponentType(), new Interactions()); // you need to add interactions here if you want your entity to be interactable
+```
+
+### Ensuring Hytale's Components are present
+
+These act as "configuration" or "default" components that Hytale expects to be present on all entities.
+
+```java
+holder.ensureComponent(UUIDComponent.getComponentType());
+holder.ensureComponent(Interactable.getComponentType()); // if you want your entity to be interactable
+```
+
+## Spawning the Entity
+
+Finally, we can add the entity to the world by calling the `addEntity` method on the `EntityStore` instance:
+
+<Callout type="warning">
+  As a reminder, a part of the logic is to enqueue the entity spawn task inside the world in its thread. Because of this, this part **needs** to be run inside `world.execute()` method.
+</Callout>
+
+```java
+store.addEntity(holder, AddReason.SPAWN);
+```
+
+## Making the entity persist
+
+Hytale automatically saves all entities, but the `NetworkId` component (required for players to be able to see the entity) needs to be manually added every time the entity is loaded.
+
+### Using a system
+
+If you have a component that is unique to your entities, this can be done by creating and registering a custom system as follows:
+
+```java
+public class AddNetworkIdToMyEntitySystem extends HolderSystem<EntityStore> {
+    private final ComponentType<EntityStore, MyEntityComponent> myEntityComponentType = MyEntityComponent.getComponentType();
+    private final ComponentType<EntityStore, NetworkId> networkIdComponentType = NetworkId.getComponentType();
+    private final Query<EntityStore> query = Query.and(this.myEntityComponentType, Query.not(this.networkIdComponentType));
+
+    @Override
+    public void onEntityAdd(@NotNull Holder<EntityStore> holder, @NotNull AddReason reason, @NotNull Store<EntityStore> store) {
+        if (!holder.getArchetype().contains(NetworkId.getComponentType())) {
+            holder.addComponent(NetworkId.getComponentType(), new NetworkId(store.getExternalData().takeNextNetworkId()));
+        }
+    }
+
+    @Override
+    public void onEntityRemoved(@NotNull Holder<EntityStore> holder, @NotNull RemoveReason reason, @NotNull Store<EntityStore> store) {}
+
+    @Override
+    public @Nullable Query<EntityStore> getQuery() {
+        return query;
+    }
+}
+```
+
+In your plugin's `setup()` function
+
+```java
+this.getEntityStoreRegistry().registerSystem(new AddNetworkIdToMyEntitySystem())
+```
+
+### Using PropComponent
+
+Alternatively you can add `PropComponent` to your entity. Hytale adds `PropComponent` to entities spawned with the Entity Tool, and such entities automatically get `NetworkId` and `PrefabCopyableComponent` (which makes the entity work with prefabs).
+
+<Callout type="warning">
+  There is no guarantee, that Hytale will not add some other behavior to this component in the future, which may break your entity, so be careful if you decide to rely on it.
+</Callout>
diff --git a/content/docs/bg-BG/guides/plugin/spawning-npcs.mdx b/content/docs/bg-BG/guides/plugin/spawning-npcs.mdx
new file mode 100644
index 00000000..8a4e2bda
--- /dev/null
+++ b/content/docs/bg-BG/guides/plugin/spawning-npcs.mdx
@@ -0,0 +1,169 @@
+---
+title: Spawning NPCs
+description: Learn how to easily spawn NPCs using the NPCPlugin helper.
+authors:
+  - name: Corin
+    link: https://github.com/Corin-alt
+---
+
+In this guide, you will learn how to spawn Non-Player Characters (NPCs) using the `NPCPlugin` helper. This is a more convenient alternative to manually spawning entities with `Holder<EntityStore>` as described in the [Spawning Entities](./spawning-entities) guide.
+
+It is **highly recommended** to familiarize yourself with the Entity Component System (ECS) before proceeding. You can find the ECS guide [here](./ecs).
+
+## Using NPCPlugin
+
+The `NPCPlugin` simplifies the process of creating an entity, attaching a model, and handling initial setup. It abstracts away much of the boilerplate required when constructing a `Holder` manually.
+
+### Spawning the NPC
+
+To spawn an NPC, you use the `NPCPlugin.get().spawnNPC(...)` method. This handles the creation of the entity, assigning the model, and positioning it in the world.
+
+```java
+Pair<Ref<EntityStore>, INonPlayerCharacter> result = NPCPlugin.get().spawnNPC(store, "Kweebec_Sapling", null, position, rotation);
+```
+
+**Parameters:**
+
+- `store`: The entity store where the NPC will exist.
+- `"Kweebec_Sapling"`: The key/name of the entity model/type.
+- `null`: Optional configuration (passed as null here).
+- `position`: Where to spawn the NPC.
+- `rotation`: How the NPC is oriented.
+
+### Handling the Result
+
+The method returns a `Pair`. You should always check if the result is `not null` to ensure the spawn was successful.
+
+- `result.first()`: Returns the `Ref<EntityStore>`, which is the reference to the entity in the ECS. You need this to add components or modify the entity later.
+- `result.second()`: Returns the `INonPlayerCharacter` interface, providing NPC-specific methods.
+
+```java
+if (result != null) {
+    Ref<EntityStore> npcRef = result.first();
+    INonPlayerCharacter npc = result.second();
+    
+    // Proceed with customization...
+    setupNPCInventory(npcRef, store);
+}
+```
+
+## Customizing the NPC
+
+Once spawned, you can customize the NPC, for example, by modifying its inventory.
+
+### Accessing the Inventory
+
+First, retrieve the `NPCEntity` component to access inventory settings.
+
+```java
+NPCEntity npcComponent = store.getComponent(npcRef, Objects.requireNonNull(NPCEntity.getComponentType()));
+
+// Initialize inventory size (e.g., 3 rows, 9 columns, 0 offset)
+npcComponent.setInventorySize(3, 9, 0);
+```
+
+### Adding Items
+
+You can then access the `Inventory` object to add items or equip armor.
+
+```java
+Inventory inventory = npcComponent.getInventory();
+
+// Add a Thorium Mace to the first slot of the hotbar
+inventory.getHotbar().addItemStackToSlot((short) 0, new ItemStack("Weapon_Mace_Thorium", 1));
+
+// Equip a Thorium Helmet using the InventoryHelper
+InventoryHelper.useArmor(inventory.getArmor(), "Armor_Thorium_Head");
+```
+
+> **Note:** `InventoryHelper` is a utility class provided directly by the Hytale API.
+
+## Full Example Command
+
+Here is the complete code for a command that spawns a "Kweebec Sapling" NPC at the player's location and sets up its inventory.
+
+```java
+import com.example.npc.NPCPlugin; // Adjust imports as necessary
+import hytale.server.plugin.npc.INonPlayerCharacter;
+import hytale.server.plugin.npc.NPCEntity;
+// ... other imports
+
+public class SpawnNpcCommand extends AbstractPlayerCommand {
+    public SpawnNpcCommand() {
+        // Register the command /npc which will trigger the "spawn npc" action
+        super("npc", "spawn npc");
+    }
+
+    @Override
+    protected void execute(@NonNullDecl CommandContext commandContext,
+            @NonNullDecl Store<EntityStore> store,
+            @NonNullDecl Ref<EntityStore> ref,
+            @NonNullDecl PlayerRef playerRef,
+            @NonNullDecl World world) {
+
+        // Get the player's current position to spawn the NPC at the same location
+        Vector3d position = playerRef.getTransform().getPosition();
+        // Define the initial rotation (facing direction) for the NPC
+        Vector3f rotation = new Vector3f(0, 0, 0);
+
+        // Use the NPCPlugin helper to spawn the NPC.
+        Pair<Ref<EntityStore>, INonPlayerCharacter> result = NPCPlugin.get().spawnNPC(store, "Kweebec_Sapling", null,
+                position, rotation);
+
+        if (result != null) {
+            // Successfully spawned
+            Ref<EntityStore> npcRef = result.first();
+            // Retrieve the NPC interface if needed for further interaction
+            INonPlayerCharacter npc = result.second();
+
+            // Set up the NPC's inventory and equipment
+            setupNPCInventory(npcRef, store);
+        }
+    }
+
+    /**
+     * Configures the inventory for the spawned NPC.
+     */
+    public void setupNPCInventory(Ref<EntityStore> npcRef, Store<EntityStore> store) {
+        // Retrieve the NPCEntity component to access inventory settings
+        NPCEntity npcComponent = store.getComponent(npcRef, Objects.requireNonNull(NPCEntity.getComponentType()));
+        
+        if (npcComponent == null)
+            return;
+
+        // Initialize inventory size (e.g., 3 rows, 9 columns, 0 offset)
+        npcComponent.setInventorySize(3, 9, 0);
+        
+        // Add items to the initialized inventory
+        addItemsToNPCInventory(npcComponent.getInventory());
+    }
+
+    /**
+     * Adds specific items and armor to the NPC's inventory.
+     */
+    public void addItemsToNPCInventory(Inventory inventory) {
+        // Add a Thorium Mace to the first slot of the hotbar
+        inventory.getHotbar().addItemStackToSlot((short) 0, new ItemStack("Weapon_Mace_Thorium", 1));
+        
+        // Equip a Thorium Helmet using the InventoryHelper
+        InventoryHelper.useArmor(inventory.getArmor(), "Armor_Thorium_Head");
+        
+        // Set the active hotbar slot to the weapon
+        inventory.setActiveHotbarSlot((byte) 0);
+    }
+}
+```
+
+## Registering the Command
+
+Finally, do not forget to register the command in your main plugin class:
+
+```java
+public class MyHytaleMod extends JavaPlugin {
+
+    @Override
+    protected void setup() {
+        this.getCommandRegistry().registerCommand(new SpawnNpcCommand());
+    }
+}
+```
diff --git a/content/docs/bg-BG/guides/plugin/store-persistent-data.mdx b/content/docs/bg-BG/guides/plugin/store-persistent-data.mdx
new file mode 100644
index 00000000..1071dff3
--- /dev/null
+++ b/content/docs/bg-BG/guides/plugin/store-persistent-data.mdx
@@ -0,0 +1,171 @@
+---
+title: Storing Persistent Data on the Player
+description: Learn how to save and load persistent data using Components
+authors:
+  - name: Neil Revin
+    url: https://itsneil.dev/
+  - name: ArcticDev
+    url: https://github.com/ArcticRaven
+  - name: oskarscot
+    url: https://oskar.scot
+  - name: JammingEng
+    url: https://github.com/JammingEnd
+---
+
+Here is how to store persistent data using a custom component on a Player.
+
+## Build your Component Class
+
+Creating a custom component class leverages the Component system made with the ECS architecture in mind. For more information on Components, check out the [ECS Guide](../ecs/hytale-ecs-theory#components).
+
+Start by creating your custom component class. This will be extremely similar to how regular components are created, however we'll setup a custom Codec so the server can translate this data to BSON, or the server's internal json encoder.
+
+<Callout type="info">
+  Each variable you want to store in your component must have its own Codec field defined in the BuilderCodec.
+  For more information on how to create custom Codecs, check out the [ECS Codec Guide](../ecs/hytale-ecs-theory#codec).
+</Callout>
+
+```java
+public class YourPlayerData implements Component<EntityStore> {
+
+    // define some vars!
+    private int someInteger;
+    private String someString;
+    private Map<String, String> someMap;
+
+    public static final BuilderCodec<YourPlayerData> CODEC =
+            BuilderCodec.builder(YourPlayerData.class, YourPlayerData::new)
+            .append(new KeyedCodec<>("SomeInteger", Codec.INTEGER),
+                    (data, value) -> data.someInteger = value, // setter
+                    data -> data.someInteger) // getter
+            .addValidator(Validators.nonNull())
+            .add()
+            .append(new KeyedCodec<>("SomeString", Codec.STRING),
+                    (data, value) -> data.someString = value, // setter
+                    data -> data.someString) // getter
+            .add()
+            .append(new KeyedCodec<>("SomeMap",
+                            new MapCodec<>(Codec.STRING, HashMap::new, false)),
+                    (data, value) -> data.someMap = value, // setter
+                    data -> data.someMap) // getter
+            .add()
+            .build();
+
+
+
+    // Getters and Setters are for the purpose of this example omitted.
+
+    // constructor
+    public YourPlayerData() {
+        this.someInteger = 0;
+        this.someString = "";
+        this.someMap = new HashMap<>();
+    }
+
+    // copy constructor for cloning
+    public YourPlayerData(YourPlayerData clone) {
+        this.someInteger = clone.someInteger;
+        this.someString = clone.someString;
+        this.someMap = clone.someMap;
+    }
+
+    @Nonnull
+    @Override
+    public Component<EntityStore> clone() {
+        return new YourPlayerData(this);
+    }
+}
+```
+
+## Register your Component
+
+Inside your main class's `setup()` method, register your new Component.
+
+```java
+public class YourPlugin extends JavaPlugin {
+
+    private ComponentType<EntityStore, YourPlayerData> yourPlayerDataComponent;
+
+    public YourPlugin(@Nonnull JavaPluginInit init) {
+        super(init);
+    }
+
+    @Override
+    protected void setup(){
+        this.yourPlayerDataComponent = this.getEntityStoreRegistry().registerComponent(
+            YourPlayerData.class,
+            "YourPlayerDataComponent",
+            YourPlayerData.CODEC
+        );
+    }
+
+    public ComponentType<EntityStore, YourPlayerData> getYourPlayerDataComponent() {
+        return this.yourPlayerDataComponent;
+    }
+}
+```
+
+## Using your Component
+
+To use your newly created component, you can add the Component to a player using the `addComponent` method, although this only adds it temporarily, meaning when the player/entity leaves the world, the component is removed. You can use `putComponent` to ensure the component persists between sessions.
+
+```java
+// You will need the Ref and Store to apply components
+private void someEntryMethod(@Nonnull Ref<EntityStore> ref, @Nonnull Store<EntityStore> store)
+{
+       // Any entity will work, for now we will use the player
+      Player player = (Player) store.getComponent(ref, Player.getComponentType());
+
+      // since we're using putComponent, it could be useful to check if it already exists on the player in case we want to update it
+     if(store.getComponent(ref, YourPlugin.instance().getYourPlayerDataComponent()) != null)
+     {
+          // here we implement logic that updates the component
+         var comp = store.getComponent(ref, YourPlugin.instance().getYourPlayerDataComponent())
+         // declare public fields or methods in the component class
+         comp.SomeString = "An Updated Field";
+     } else {
+          // Here we put the component
+          var myCustomComp = new CustomComponent();
+          // declare public fields or methods in the component class
+          myCustomComp.SomeString = "Edited String";
+
+          // putComponent allows you to insert declared objects
+          store.putComponent(ref, YourPlugin.instance().getYourPlayerDataComponent(), myCustomComp);
+     }
+}
+```
+
+## Using your Data
+
+Your component will be stored within the `Store<EntityStore>` when added to the player. In the provided example,
+we'll fetch this data off the player using the `ensureAndGetComponent()` method, which will add the component to
+the player if it does not exist with the default values.
+
+```java
+public class IncompleteCustomCommand extends AbstractPlayerCommand {
+
+    public IncompleteCustomCommand() {
+        super("nope", "don't use this command");
+    }
+
+    @Override
+    protected void execute(
+        @NonNullDecl CommandContext commandContext,
+        @NonNullDecl Store<EntityStore> store,
+        @NonNullDecl Ref<EntityStore> ref,
+        @NonNullDecl PlayerRef playerRef,
+        @NonNullDecl World world
+    ) {
+        YourPlayerData customData = store.ensureAndGetComponent(ref, YourPlugin.instance().getYourPlayerDataComponent());
+        // ensureAndGetComponent adds the component to the ref, with the default values defined inside your component.
+ 		// use your data
+    }
+}
+```
+
+And that's it! Your data will now be saved and loaded automatically with the player.
+
+Using custom components to store persistent data on players is a powerful way to maintain state across sessions.
+By following the steps outlined above, you can easily create, register, and utilize your own data structures within the Hytale ECS framework.
+This approach ensures that your data is seamlessly integrated with the game's existing systems.
+For more information about Hytale's Entity Component System visit the [Hytale ECS Theory](https://hytalemodding.dev/en/docs/guides/ecs/hytale-ecs-theory) guide.
diff --git a/content/docs/bg-BG/guides/plugin/teleporting-players.mdx b/content/docs/bg-BG/guides/plugin/teleporting-players.mdx
new file mode 100644
index 00000000..32ce0435
--- /dev/null
+++ b/content/docs/bg-BG/guides/plugin/teleporting-players.mdx
@@ -0,0 +1,32 @@
+---
+title: Teleporting the player
+description: Learn how to teleport the player.
+authors:
+  - name: oskarscot
+    url: https://oskar.scot
+---
+
+Teleporting players in Hytale works by simply attaching a `Teleport` component to a player with the desired world and transform.
+You can only trigger teleports from a world where the player is currently present.
+Teleport itself is a component but it also provides factory methods to configure the Teleport. Just as with any entity component, an EntityStore and a Ref to the EntityStore is required
+
+We can create a simple teleport utility like this:
+
+```java
+public static void teleportPlayer(Ref<EntityStore> ref, Store<EntityStore> store, World targetWorld, double x, double y, double z) {                                                                                       
+    Transform transform = new Transform(x, y, z);                                                                                                                           
+    Teleport teleport = Teleport.createForPlayer(targetWorld, transform);                                                                                                   
+    store.addComponent(ref, Teleport.getComponentType(), teleport);                                                                                                         
+}  
+```
+
+A `Transform` is a representation of a position Vector3d and rotation Vector3f which works in the following way:
+
+```java
+Transform transform = new Transform(
+    new Vector3d(x, y, z),      // Position
+    new Rotation(yaw, pitch, 0) // Rotation, last value seems to always be 0
+);
+Teleport teleport = Teleport.createForPlayer(targetWorld, transform);
+store.addComponent(ref, Teleport.getComponentType(), teleport);
+```
diff --git a/content/docs/bg-BG/guides/plugin/text-hologram.mdx b/content/docs/bg-BG/guides/plugin/text-hologram.mdx
new file mode 100644
index 00000000..0c8cab00
--- /dev/null
+++ b/content/docs/bg-BG/guides/plugin/text-hologram.mdx
@@ -0,0 +1,229 @@
+---
+title: Title Holograms
+description: Learn how to create title holograms.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+---
+
+# Overview
+
+In this guide, you'll learn how to create a **title hologram** using an entity nameplate.
+
+## Steps
+
+1. Open and equip the **Entity Grabber Tool**.
+
+![tile-hologram-1](/assets/guides/tile-hologram-1.png)
+
+<Callout>
+  This tool will be used later to **adjust the position of the nameplate**, so it’s useful to keep it equipped throughout the process.
+</Callout>
+
+---
+
+2. Spawn a **small entity** (for example, rubble or a similar object), then **scale it down** to lowest possible value.
+
+![tile-hologram-2](/assets/guides/tile-hologram-2.png)
+
+---
+
+3. Hover over the entity you just spawned and run the following command:
+
+```
+/entity nameplate "Text Here"
+```
+
+![tile-hologram-3](/assets/guides/tile-hologram-3.png)
+
+---
+
+Your title hologram should now be visible in the world, floating where the entity is placed.
+
+![tile-hologram-4](/assets/guides/tile-hologram-4.png)
+
+---
+
+## Bonus Section - Creating Title Holograms With Code
+
+This section shows how to create the same title hologram using a **server plugin command** instead of in-game tools.
+
+The example below creates a command called `/titlehologram` that spawns an invisible entity with a floating nameplate at the player’s location.
+
+```java
+package org.example.plugin;
+
+import com.hypixel.hytale.component.Holder;
+import com.hypixel.hytale.math.vector.Transform;
+import com.hypixel.hytale.server.core.command.system.CommandContext;
+import com.hypixel.hytale.server.core.command.system.basecommands.CommandBase;
+import com.hypixel.hytale.server.core.entity.UUIDComponent;
+import com.hypixel.hytale.server.core.entity.entities.ProjectileComponent;
+import com.hypixel.hytale.server.core.entity.nameplate.Nameplate;
+import com.hypixel.hytale.server.core.modules.entity.component.TransformComponent;
+import com.hypixel.hytale.server.core.modules.entity.tracker.NetworkId;
+import com.hypixel.hytale.server.core.universe.PlayerRef;
+import com.hypixel.hytale.server.core.universe.Universe;
+import com.hypixel.hytale.server.core.universe.world.World;
+import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
+
+import javax.annotation.Nonnull;
+import java.util.UUID;
+
+public class TitleHologramCommand extends CommandBase {
+
+    public TitleHologramCommand() {
+        super("TitleHologram", "Create a title hologram.");
+    }
+
+    @Override
+    protected void executeSync(@Nonnull CommandContext ctx) {
+
+        UUID playerUUID = ctx.sender().getUuid();
+        PlayerRef playerRef = Universe.get().getPlayer(playerUUID);
+        World world = Universe.get().getWorld(playerRef.getWorldUuid());
+        Transform playerTransform = playerRef.getTransform();
+
+        world.execute(() -> {
+
+            Holder<EntityStore> holder = EntityStore.REGISTRY.newHolder();
+            ProjectileComponent projectileComponent = new ProjectileComponent("Projectile");
+            holder.putComponent(ProjectileComponent.getComponentType(), projectileComponent);
+            holder.putComponent(TransformComponent.getComponentType(), new TransformComponent(playerTransform.getPosition().clone(), playerTransform.getRotation().clone()));
+            holder.ensureComponent(UUIDComponent.getComponentType());
+
+            if (projectileComponent.getProjectile() == null) {
+                projectileComponent.initialize();
+                if (projectileComponent.getProjectile() == null) {
+                    return;
+                }
+            }
+            holder.addComponent(NetworkId.getComponentType(), new NetworkId(world.getEntityStore().getStore().getExternalData().takeNextNetworkId()));
+            holder.addComponent(Nameplate.getComponentType(), new Nameplate("Testing Holograms"));
+
+            world.getEntityStore().getStore().addEntity(holder, com.hypixel.hytale.component.AddReason.SPAWN);
+        });
+    }
+}
+```
+
+---
+
+### 1. Getting the Player and World
+
+```java
+UUID playerUUID = ctx.sender().getUuid();
+PlayerRef playerRef = Universe.get().getPlayer(playerUUID);
+World world = Universe.get().getWorld(playerRef.getWorldUuid());
+Transform playerTransform = playerRef.getTransform();
+```
+
+This retrieves:
+
+| Value             | Purpose                               |
+| ----------------- | ------------------------------------- |
+| `playerUUID`      | The unique ID of the command sender   |
+| `playerRef`       | A server-side reference to the player |
+| `world`           | The world the player is currently in  |
+| `playerTransform` | The player’s position and rotation    |
+
+---
+
+### 2. Spawning on the World Thread
+
+```java
+world.execute(() -> {
+```
+
+All entity operations must run on the world thread.
+Everything inside this block executes safely on the correct game thread.
+
+---
+
+### 3. Creating the Entity
+
+```java
+Holder<EntityStore> holder = EntityStore.REGISTRY.newHolder();
+ProjectileComponent projectileComponent = new ProjectileComponent("Projectile");
+```
+
+The projectile is only used as a valid entity shell. It will never move or behave like a real projectile.
+
+---
+
+### 4. Setting Position & Components
+
+```java
+holder.putComponent(ProjectileComponent.getComponentType(), projectileComponent);
+holder.putComponent(TransformComponent.getComponentType(), new TransformComponent(playerTransform.getPosition().clone(), playerTransform.getRotation().clone()));
+holder.ensureComponent(UUIDComponent.getComponentType());
+```
+
+| Component             | Purpose                                 |
+| --------------------- | --------------------------------------- |
+| `ProjectileComponent` | Provides a valid entity shell           |
+| `TransformComponent`  | Sets the entity’s position and rotation |
+| `UUIDComponent`       | Gives the entity a unique identity      |
+
+The hologram will appear exactly at the player’s position and cannot be interacted with physically.
+
+---
+
+### 5. Initializing the Projectile
+
+```java
+if (projectileComponent.getProjectile() == null) {
+    projectileComponent.initialize();
+    if (projectileComponent.getProjectile() == null) {
+        return;
+    }
+}
+```
+
+This ensures the projectile entity is fully created.
+If initialization fails, the hologram will not spawn.
+
+---
+
+### 6. Setting Network & Nameplate Components
+
+```java
+holder.addComponent(
+    NetworkId.getComponentType(),
+    new NetworkId(
+        world.getEntityStore()
+            .getStore()
+            .getExternalData()
+            .takeNextNetworkId()
+    )
+);
+
+holder.addComponent(
+    Nameplate.getComponentType(),
+    new Nameplate("Testing Holograms")
+);
+```
+
+| Component   | Purpose                        |
+| ----------- | ------------------------------ |
+| `NetworkId` | Allows the entity to be synced |
+| `Nameplate` | The actual hologram text       |
+
+---
+
+### 7. Spawning the Entity
+
+```java
+world.getEntityStore()
+     .getStore()
+     .addEntity(holder, com.hypixel.hytale.component.AddReason.SPAWN);
+```
+
+This inserts the hologram entity into the world, making it active and visible.
+
+---
+
+![tile-hologram-5](/assets/guides/tile-hologram-5.png)
+
+_Thanks to Al3xWarrior and Quito on Discord for initially discovering this feature._
+_And thanks to Elie for the initial code snippet._
diff --git a/content/docs/bg-BG/guides/plugin/tracking-mod-analytics-with-hstats.mdx b/content/docs/bg-BG/guides/plugin/tracking-mod-analytics-with-hstats.mdx
new file mode 100644
index 00000000..45c022e0
--- /dev/null
+++ b/content/docs/bg-BG/guides/plugin/tracking-mod-analytics-with-hstats.mdx
@@ -0,0 +1,65 @@
+---
+title: Tracking Mod Analytics with HStats
+description: Learn how you can track Analytics for your Hytale Mod for Free using hstats.dev
+authors:
+  - name: Al3x
+    url: https://hstats.dev
+---
+
+In this guide, you will learn how to integrate HStats into your Plugin/Mod which will allow you to track how many Servers are using it along with other stats.
+
+<Callout type="info">
+  HStats is a third-party tool and is not affiliated with HytaleModding or Hypixel Studios
+</Callout>
+
+# Step 1: Register your Mod to HStats
+
+Before you touch any code, you will need to add your mod to the HStats website which will give you a UUID for your mod.
+
+- Create or Login to an Account on https://hstats.dev
+- Navigate to the dashboard page (https://hstats.dev/dashboard)
+- On the left, type in your mod's name and click "Add Mod"
+- Keep note of the UUID generated for later.
+
+# Step 2: Add the HStats Class to Your Project
+
+To keep things simple, HStats uses a single Java class file that handles everything for you.
+
+- Download / Copy the File from the GitHub page (https://github.com/hstats-dev/HStatsExamplePlugin/blob/main/src/main/java/com/al3x/HStats.java)
+- Paste into your Project. You should now have a HStats.java file somewhere in your projects directory.
+- Update the package name from com.al3x to whatever fits your project.
+
+# Step 3: Initialize HStats in your code
+
+You only need to add one line of code to your mod's setup method in your main class to start tracking.
+
+`new HStats("YOUR-MOD-UUID", "1.0.0");`
+
+Replace `YOUR-MOD-UUID` with the Mod UUID we made note of earlier and change the `1.0.0` version to whatever version your mod is currently on.
+
+Your setup method should now look something like this:
+
+```java
+@Override
+protected void setup() {
+  super.setup();
+  new HStats("c34a2b2a-afd8-4d6a-821e-7a63e12c5ea6", "1.0.0");
+}
+```
+
+# Extras
+
+Your done! Your mod should now be listed under the Mods page (https://hstats.dev/mods) as well as under your dashboard.
+
+Servers using your mod should now post updates about every minute to HStats which you can view in the Dashboard.
+
+### Embeds
+
+HStats allows you to generate an Embed Card that you can place on your CurseForge or GitHub page. This is useful for server owners to be able to see how many other servers are using your mod.
+
+- In your dashboard, scroll down to the Embed Card section.
+- Customize the appearance (Light/Dark mode, layout, etc).
+- Copy the generated URL to display your "Active Servers" and "Players Online" live on your mod's description page
+
+Heres an example of what they look like:
+![HStats Example](https://api.hstats.dev/api/embed/d52fa672-6966-47b2-b501-1a11bddebac3/card.svg?theme=light\&layout=compact\&size=md\&show_id=true\&dark=false)
diff --git a/content/docs/bg-BG/guides/plugin/ui.mdx b/content/docs/bg-BG/guides/plugin/ui.mdx
new file mode 100644
index 00000000..5948511f
--- /dev/null
+++ b/content/docs/bg-BG/guides/plugin/ui.mdx
@@ -0,0 +1,270 @@
+---
+title: Custom UI
+description: Learn how to show custom UI to the player
+authors:
+  - name: underscore95
+    url: https://github.com/underscore95
+---
+
+## Important Information
+
+- All .ui files must be included in your plugin resources folder, specifically they should be in resources/Common/UI/Custom
+- Ensure your manifest.json contains `"IncludesAssetPack": true`
+- The Hytale client has a "Diagnostic Mode" setting under General, this will give more detailed error messages.
+
+## Useful Resources
+
+Video Tutorials:
+
+- CustomUIHud Tutorial: https://www.youtube.com/watch?v=u4pGShklEKs
+- InteractiveCustomUIPage Tutorial: https://www.youtube.com/watch?v=NOFWQt9wEbk
+- Useful Information & Resources: https://www.youtube.com/watch?v=AaNk_g9vb50
+
+Examples:
+
+- Simple InteractiveCustomUIPage Example: https://github.com/underscore95/Hytale-Sandbox-Plugin/tree/ui-pages
+- Complicated InteractiveCustomUIPage Example: https://github.com/Buuz135/AdminUI/tree/main
+
+Visual UI Editor: https://hytale.ellie.au/
+Create UI from Java: https://www.curseforge.com/hytale/mods/hyui
+
+Show multiple custom HUDs at the same time: https://www.curseforge.com/hytale/mods/multiplehud
+Example MultipleHUD code: https://github.com/underscore95/Hytale-Sandbox-Plugin/tree/multiple-huds
+
+## .ui files
+
+Hytale currently uses .ui files to render UI, these are currently deprecated and Hytale is planning to move to NoesisGUI.
+The transition has not happened yet and .ui files are the only way to render UI.
+
+UI is defined using a .ui file which functions similarly to HTML and CSS.
+
+### UI Elements
+
+A .ui file contains a tree of UI elements, declaring a UI element uses the following syntax:
+
+```
+Group {
+  TextField #MyInput {
+    Style: $Common.@DefaultInputFieldStyle;
+    Background: $Common.@InputBoxBackground;
+    Anchor: (Top: 10, Width: 200, Height: 50);
+  }
+}
+```
+
+`TextField` and `Group` are the types of UI elements.
+
+- A text field is an input where the user can enter text.
+- A group is an empty UI element, similar to a div in HTML.
+
+`#MyInput` is the ID of the TextField UI element, this is required for Java code to access the element later.
+
+### Variables
+
+You can define variables using the following syntax:
+
+```
+@MyTex = PatchStyle(TexturePath: "MyBackground.png");
+```
+
+### Textures
+
+Textures can be loaded using
+
+```
+PatchStyle(TexturePath: "MyBackground.png");
+```
+
+The path is relative to the .ui file.
+Your textures must be included in your resource folder.
+
+If applying a texture as the background of a UI element, you do not need to match size, the texture will automatically be stretched.
+
+### Including other .ui files
+
+You can include other .ui files using `$Common = "Common.ui";`, this allows you to access variables like so: `Style: $Common.@DefaultInputFieldStyle;`
+
+## HUDs
+
+A HUD is an element of UI that stays on the screen all the time, for example the players hot bar or health bar.
+It cannot be interacted with.
+
+### CustomUIHud
+
+Create a Java class that extends `CustomUIHud` and overrides the `build` function.
+
+The `build` function has a `UICommandBuilder` parameter, this allows you to add .ui files to the HUD.
+
+```java
+uiCommandBuilder.append("MyUI.ui"); // This file must be located at resources/Common/UI/Custom/MyUI.ui
+```
+
+### Showing & Hiding UI
+
+You can get the HudManager using `Player#getHudManager`.
+
+- Use `HudManager#setCustomHud` to show UI.
+- Use `HudManager#hideHudComponents` to hide default Hytale UI.
+- Set a custom hud with an empty build method to hide custom UI, or use MultipleHUD
+
+## UI Pages
+
+Pages are another type of UI, these prevent the player from interacting with the game and unlock the players mouse.
+Some examples of pages include: Crafting menu, pause menu
+
+### CustomUIPage
+
+If you do not need user input, you can make a class extending CustomUIPage, this is very similar to CustomUIHud.
+
+### InteractiveCustomUIPage
+
+You must extend InteractiveCustomUIPage to receive events and user input.
+
+The following UI is used for the below code:
+
+```
+$Common = "Common.ui";
+
+@MyTex = PatchStyle(TexturePath: "MyBackground.png");
+
+Group {
+  LayoutMode: Center;
+
+  Group #MyPanel {
+    Background: @MyTex;
+    Anchor: (Width: 800, Height: 1000);
+    LayoutMode: Top;
+
+    Label #MyLabel {
+      Style: (FontSize: 32, Alignment: Center);
+      Anchor: (Top: 50);
+      Text: "MyText";
+      Padding: (Full: 10);
+    }
+
+    TextField #MyInput {
+      Style: $Common.@DefaultInputFieldStyle;
+      Background: $Common.@InputBoxBackground;
+      Anchor: (Top: 10, Width: 200, Height: 50);
+      Padding: (Full: 10);
+    }
+  }
+}
+```
+
+InteractiveCustomUIPage takes a generic argument, this is a class containing any UI data you want the client to send to the server.
+
+<Callout type="info">
+  Each variable you want to store in your component must have its own Codec field defined in the BuilderCodec.
+  For more information on how to create custom Codecs, check out the [ECS Codec Guide](../ecs/hytale-ecs-theory#codec).
+</Callout>
+
+```java
+public static class Data {
+  public static final BuilderCodec<Data> CODEC = BuilderCodec.builder(Data.class, Data::new)
+    .append(new KeyedCodec<>("@MyInput", Codec.STRING), (data, value) -> data.value = value, data -> data.value).add()
+    .build();
+
+  private String value; // Value of the TextField input
+}
+```
+
+InteractiveCustomUIPage constructor takes a PlayerRef, CustomPageLifetime, and `BuilderCodec<Data>`.
+
+- PlayerRef is the player you want to show UI to.
+- CustomPageLifetime is an enum controlling if the player can close the UI or not
+
+`BuilderCodec<Data>` tells the server how to create the Data object from the JSON the client sends.
+Example value in the Data class above.
+
+This passes the Class and a lambda function that constructs the Data object, the server uses this to deserialize the JSON.:
+
+```java
+BuilderCodec.builder(Data.class, Data::new)
+```
+
+This provides a setter and getter lambda function to the field that should contain whatever @MyInput is set to:
+
+```java
+.append(new KeyedCodec<>("@MyInput", Codec.STRING), (data, value) -> data.value = value, data -> data.value).add()
+```
+
+The following build method is used:
+
+```java
+@Override
+public void build(@Nonnull Ref<EntityStore> ref, @Nonnull UICommandBuilder uiCommandBuilder, @Nonnull UIEventBuilder uiEventBuilder, @Nonnull Store<EntityStore> store) {
+  uiCommandBuilder.append("MyUI.ui");
+  uiEventBuilder.addEventBinding(CustomUIEventBindingType.ValueChanged, "#MyInput", EventData.of("@MyInput", "#MyInput.Value"), false);
+}
+```
+
+This says we are listening for whenever the value of #MyInput changes:
+
+```java
+CustomUIEventBindingType.ValueChanged, "#MyInput"
+```
+
+You may be wondering where `@MyInput` in the codec previously came from, it is defined here.
+This creates the codec value `@MyInput` and maps it to `#MyInput.Value`:
+
+```java
+EventData.of("@MyInput", "#MyInput.Value")
+```
+
+The following `handleDataEvent` will be overridden, take care to override the one that has a `Data` parameter rather than `String raw` (this is the raw json).
+
+```java
+@Override
+public void handleDataEvent(@Nonnull Ref<EntityStore> ref, @Nonnull Store<EntityStore> store, Data data) {
+  super.handleDataEvent(ref, store, data);
+
+  System.out.println("EVENT: " + data.value);
+
+  sendUpdate();
+}
+```
+
+You must always either switch to a new UI or call `sendUpdate();` otherwise the Hytale client will display "Loading..." forever and prevent the user from interacting with your UI.
+This will be familiar if you have ever made commands in a Discord bot, where you have to acknowledge interactions.
+
+### Showing & Hiding UI pages
+
+```java
+player.getPageManager().openCustomPage(ref, store, MyUI(playerRef));
+player.getPageManager().setPage(ref, store, Page.None);
+```
+
+## Dynamically Updating UI
+
+In many cases you want to update your UI at run time.
+
+Here is an example of updating a Label's (with id MyLabel) text content, this method should be added to your UI Java class:
+
+```java
+public void updateText(String newText) {
+  UICommandBuilder uiCommandBuilder = new UICommandBuilder();
+  uiCommandBuilder.set("#MyLabel.TextSpans", Message.raw(newText));
+  update(false, uiCommandBuilder); // false = don't clear existing UI
+}
+```
+
+## Common Issues
+
+### Failed to apply Custom UI HUD commands
+
+This means your .ui file has something wrong with it.
+Enabling Diagnostic Mode in Hytale settings might give more information.
+
+### Could not find document XXXXX for Custom UI Append command
+
+This means your .ui file wasn't in the location your Java code said it was, double check that your path is correct.
+
+## IntelliJ Plugin for UI-Files
+
+There is also a community plugin, which enables syntax highlighting, color picking
+and code-completion for `*.ui` files.
+
+You can look it up here:
+
+https://plugins.jetbrains.com/plugin/29783-hytale-ui-support
diff --git a/content/docs/bg-BG/guides/plugin/world-gen.mdx b/content/docs/bg-BG/guides/plugin/world-gen.mdx
new file mode 100644
index 00000000..7b193ffd
--- /dev/null
+++ b/content/docs/bg-BG/guides/plugin/world-gen.mdx
@@ -0,0 +1,143 @@
+---
+title: World Generation System
+description: Learn how to create custom world generation features for your Hytale mod.
+authors:
+  - name: Neil Revin
+    url: https://itsneil.dev
+---
+
+# Overview
+
+This section covers Hytale's procedural world generation systems that creates environments, biomes, and structures dynamically as players explore the world.
+
+Hytale’s world generation is organized into three interconnected systems:
+
+- **Zones** - Large-scale regions that define overall world structure
+- **Biomes** - Terrain characteristics and environmental properties within zones
+- **Caves** - Underground structures and networks generated within zones
+
+These systems work together to create a rich, varied world with smooth transitions and coherent regional themes.
+
+## Getting Started
+
+1. Zone System - Large regions
+2. Biome System - Terrain and environment within zones
+3. Cave System - Underground structures and networks within zones
+
+## Implementation Details
+
+### Zone Lookup and Generation
+
+```java
+
+// Get zone at position
+ZonePatternGenerator zoneGen = /* world generator */;
+ZoneGeneratorResult zoneResult = zoneGen.generate(seed, x, z);
+Zone zone = zoneResult.getZone();
+
+// Get biome within zone
+BiomePatternGenerator biomeGen = zone.biomePatternGenerator();
+Biome biome = biomeGen.generateBiomeAt(zoneResult, seed, x, z);
+
+// Check for caves in zone
+CaveGenerator caveGen = zone.caveGenerator();
+if (caveGen != null) {
+    CaveType[] caveTypes = caveGen.getCaveTypes();
+    // Generate caves as needed
+}
+```
+
+### Creating a Custom Zone
+
+```java
+// Configure zone discovery
+ZoneDiscoveryConfig discovery = new ZoneDiscoveryConfig(
+    true,                           // Show notification
+    "Custom Zone",                  // Display name
+    "zone.forest.discover",         // Sound event
+    "icons/forest.png",             // Icon
+    true,                           // Major zone
+    5.0f, 2.0f, 1.5f                // Duration, fade in, fade out
+);
+
+// Create biome pattern
+IPointGenerator biomePoints;
+IWeightedMap<TileBiome> tileBiomes;
+CustomBiome[] customBiomes;
+
+BiomePatternGenerator biomeGen = new BiomePatternGenerator(
+    biomePoints,
+    tileBiomes,
+    customBiomes
+);
+
+// Create cave configuration
+CaveType[] caveTypes; // cave definitions
+CaveGenerator caveGen = new CaveGenerator(caveTypes);
+
+// Assemble the zone
+Zone customZone = new Zone(
+    100,                    // Unique ID
+    "new_custom_zone",      // Internal name
+    discovery,              // Discovery config
+    caveGen,                // Cave generator
+    biomeGen,               // Biome pattern
+    uniquePrefabs           // Unique structures
+);
+```
+
+## System Integration
+
+### Zone & Biome Integration
+
+Each zone defines its own biome pattern:
+
+```java
+Zone zone = zoneGen.generate(seed, x, z).getZone();
+BiomePatternGenerator biomeGen = zone.biomePatternGenerator();
+Biome biome = biomeGen.generateBiomeAt(zoneResult, seed, x, z);
+```
+
+### Zone & Cave Integration
+
+Each zone defines its own cave patterns:
+
+```java
+Zone zone = /* ... */;
+CaveGenerator caveGen = zone.caveGenerator();
+if (caveGen != null) {
+    // This zone has caves
+    CaveType[] types = caveGen.getCaveTypes();
+}
+```
+
+### Biome & Cave Integration
+
+Caves use biome masks for placement control:
+
+```java
+// Cave type with biome restrictions
+Int2FlagsCondition biomeMask = caveType.getBiomeMask();
+int biomeId = biome.getId();
+int flags = biomeMask.eval(biomeId);
+
+// Check if cave can generate in this biome
+if (CaveBiomeMaskFlags.canGenerate(flags)) {
+    // Generate cave
+}
+```
+
+### Border Transitions
+
+All systems respect zone boundaries:
+
+```java
+ZoneGeneratorResult result = zoneGen.generate(seed, x, z);
+double borderDistance = result.getBorderDistance();
+
+// Fade custom biomes near borders
+if (borderDistance < customBiome.getFadeContainer().getMaskFadeSum()) {
+    double factor = customBiome.getFadeContainer().getMaskFactor(result);
+    // Apply fading
+}
+```
diff --git a/content/docs/bg-BG/guides/prefabs.mdx b/content/docs/bg-BG/guides/prefabs.mdx
new file mode 100644
index 00000000..b1a55109
--- /dev/null
+++ b/content/docs/bg-BG/guides/prefabs.mdx
@@ -0,0 +1,92 @@
+---
+title: Prefabs
+description: Documentation about Prefabs in Hytale.
+icon: Box
+authors:
+  - name: Ben Cressman
+    url: https://bencres.dev
+---
+
+# Introduction
+
+Prefabs are Hytale's way of creating reusable structures.
+
+There are a few fundamental concepts to understand about prefabs:
+
+- Users interact with prefabs via a prefab editing world.
+- Prefabs are the physical structures in the game world, and are saved as JSON files.
+
+## How to Create a Prefab
+
+Be sure to check the Known Issues section at the end of this guide if you encounter any problems.
+
+1. `/editprefab new <world name>` to create a new prefab editing world: `/editprefab new my_prefab_world`
+   - Note that `my_prefab` is the name of the _world_, not the prefab itself. Worlds can contain multiple prefabs.
+2. Build whatever you want in the prefab editing world.
+3. Use the selection brush to select the area you want to save as a prefab.
+4. `/prefab save` to save the structure as a prefab.
+5. `/editprefab exit` to exit the prefab editing world.
+6. Using the Paste brush, press 'e' on your keyboard to select the prefab you just created. It will be in the "server" dropdown, which can be selected from the top right of the menu.
+   - You can also select it with `/prefab list` and selecting the prefab you just created.
+
+There is a lot more that you can do with prefabs; this is just the basic flow. Keep reading for more information.
+
+## Commands
+
+There are two main commands for prefabs, `/prefab` and `/editprefab`.
+
+This list does not cover the various options for each command. You can use the `--help` flag at the end of any command to see the available options, e.g. `/prefab save --help`, or use `/help` in game and find the `prefab` and `editprefab` commands.
+
+### `/prefab`
+
+This command allows the user to interact with an existing prefab's file.
+
+Subcommands:
+
+- `save`
+  - Saves the prefab to the file system.
+- `load`
+  - Loads the prefab into the game.
+- `delete`
+  - Deletes the prefab from the file system.
+- `list`
+  - Lists all prefabs in the file system.
+
+### `/editprefab`
+
+The `/editprefab` command is used to create or edit the physical structure in the game the prefab is holding.
+
+Subcommands:
+
+- `exit`
+  - Exits the current prefab editing world.
+- `load`
+  - Creates a new prefab editing world to paste an existing prefab into.
+- `new`
+  - Creates a new prefab editing world to create a new prefab from scratch.
+- `select`
+  - Selects the area of the prefab the user is looking at (within 200 blocks).
+- `save`
+  - Saves the current prefab using the existing area, or the currently selected area.
+- `saveui`
+  - Opens the save UI for the current world, allowing the user to interact with all prefabs that are in the world.
+- `kill`
+  - Despawn all entities in the currently selected prefab.
+- `saveas`
+  - Save the selected prefab into a new file.
+- `setbox`
+  - Set the bounding box of the currently selected prefab.
+- `info`
+  - General information about the currently selected prefab.
+- `tp`
+  - Opens the teleport UI to teleport to a prefab in the current editing world.
+- `modified`
+  - Lists all modified prefabs with unsaved changes in the current editing world.
+
+# Known Issues
+
+- After saving edits to an existing prefab, the prefab does not reflect the changes in the game.
+  - Workaround: exit and re-enter the world.
+- When pasting a prefab, the prefab is not always shown accurately.
+  - Workaround: hit 't' on your keyboard to toggle the material being shown; usually at least one view is accurate.
+- `/prefab delete` errors with `Assert not in thread`.
diff --git a/content/docs/bg-BG/index.mdx b/content/docs/bg-BG/index.mdx
new file mode 100644
index 00000000..e09ace85
--- /dev/null
+++ b/content/docs/bg-BG/index.mdx
@@ -0,0 +1,19 @@
+---
+title: Introduction
+description: Necessary knowledge for modding Hytale.
+---
+
+Hytale is a voxel-based sandbox RPG game by **Hypixel Studios**, as described on the [Hytale website](https://hytale.com/):
+
+> Set out on an adventure built for both creation and play. Hytale blends the freedom
+> of a sandbox with the momentum of an RPG: explore a procedurally generated world full
+> of dungeons, secrets, and a variety of creatures, then shape it block by block.
+
+Hytale has been built from the ground up with modding and user-generated content in mind.
+The goal of **Hytale Modding** is to provide an excellent resource such that anybody
+is able to mod Hytale for themselves, regardless of skill level or specialization.
+
+It is important to note that modding Hytale is not restricted to programming plugins.
+Programming, visual scripting, texturing, 3D modelling, modifying assets, etc. are all modding.
+
+<u>In Hytale, anyone can be a modder.</u>
diff --git a/content/docs/bg-BG/official-documentation/custom-ui/common-styling.mdx b/content/docs/bg-BG/official-documentation/custom-ui/common-styling.mdx
new file mode 100644
index 00000000..c36e3e3a
--- /dev/null
+++ b/content/docs/bg-BG/official-documentation/custom-ui/common-styling.mdx
@@ -0,0 +1,50 @@
+---
+title: Common Styling
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# Common Styling
+
+## Common UI Styling Library
+
+This document describes the shared UI components and styles defined in `Common.ui`.
+
+---
+
+### Styles
+
+We are providing some styles that can be re-used in any custom UI that, provide a cohesive UI experience with the core game UI. These styles are available in the `Common.ui` file.
+
+You can find a list of all the styles defined with live examples by running the `/ui-gallery` command ingame.
+
+<Callout type="warning">
+  This command is not available yet, but will be in a future patch.
+</Callout>
+
+![Gallery](/assets/official-documentation/ui/gallery.png)
+
+### Importing
+
+To use these styles in your UI file:
+
+```
+$Common = "Common.ui";
+
+// Then reference styles and components:
+$Common.@TextButton { @Text = "My Button"; }
+$Common.@Container { ... }
+```
+
+<Callout type="info">
+  The `Common.ui` file is at `Common/UI/Custom/Common.ui` within the Hytale pack. If your custom ui document is in a subfolder of `Common/UI/Custom/`, reference it via relative path traversal:
+
+  ```
+  $Common = "../Common.ui";
+  ```
+
+  You can find more info about paths [here](markup#path).
+</Callout>
diff --git a/content/docs/bg-BG/official-documentation/custom-ui/index.mdx b/content/docs/bg-BG/official-documentation/custom-ui/index.mdx
new file mode 100644
index 00000000..f94c4e88
--- /dev/null
+++ b/content/docs/bg-BG/official-documentation/custom-ui/index.mdx
@@ -0,0 +1,125 @@
+---
+title: Custom UI
+icon: LayoutDashboard
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# Custom UI
+
+## What is Custom UI?
+
+Custom UI is Hytale's framework for creating **custom user interfaces** controlled by the game server. Unlike the built-in Client UI (which is part of the game client and cannot be modified), Server UI allows you to create interactive screens and HUD overlays through Java plugins and asset packs.
+
+As a modder, Custom UI gives you the power to:
+
+- **Create custom interactive pages** - Shop interfaces, quest dialogs, server settings menus, admin panels
+- **Add custom HUD overlays** - Quest trackers, status displays, custom health bars, server information
+- **Design with markup** - Use `.ui` files to define reusable UI templates
+- **Handle user interactions** - Respond to button clicks, form submissions, and other events
+- **Localize your UI** - Support multiple languages using the game's translation system
+
+## How Custom UI Fits Into Hytale's UI
+
+Hytale's user interface is divided into two main categories:
+
+### Client UI (Not Moddable)
+
+Built-in interfaces controlled by the C# game client:
+
+- Main menu and settings
+- Character creation
+- Built-in HUD (health, hotbar, chat)
+- Inventory and crafting screens
+- Development tools
+
+**You cannot modify these** - they are part of the core game client.
+
+### In-Game UI (Moddable via Server)
+
+Server-controlled interfaces that you can create and customize:
+
+#### Custom Pages
+
+Full-screen interactive overlays that appear during gameplay:
+
+- Can be dismissed by the player (ESC key)
+- Capture all input (keyboard and mouse)
+- Support loading states while waiting for server responses
+- Perfect for: shops, dialogs, menus, configuration screens
+
+#### Custom HUDs
+
+Persistent overlay elements drawn on top of the game world:
+
+- Display-only (no user interaction)
+- Always visible during gameplay
+- Lightweight and non-intrusive
+- Perfect for: quest objectives, status indicators, server info panels
+
+## Architecture Overview
+
+Server UI uses a **command-based architecture**:
+
+```
+┌─────────────────────┐         ┌──────────────────────┐
+│   Java Server       │         │    C# Client         │
+│   (Your Plugin)     │         │    (Game)            │
+├─────────────────────┤         ├──────────────────────┤
+│                     │         │                      │
+│ InteractiveCustomUI │         │   CustomPage or      │
+│ Page                │         │   CustomHud          │
+│   ↓ build()         ├────────→│     ↓ Apply          │
+│ UICommandBuilder    │         │   Element Tree       │
+│   - append()        │         │     ↓ Layout         │
+│   - set()           │         │   Rendered UI        │
+│   - clear()         │         │                      │
+│                     │         │                      │
+│ ↓ handleDataEvent() │← Events │   User Interaction   │
+│   Process input     │         │   (click, type, etc) │
+│   sendUpdate()      │         │                      │
+└─────────────────────┘         └──────────────────────┘
+```
+
+**The flow:**
+
+1. Your Java code builds UI using `UICommandBuilder`
+2. Commands are sent to the client as data
+3. Client parses `.ui` markup files and creates visual elements
+4. User interacts with the UI
+5. Events are sent back to your Java code
+6. You process events and send updates back
+
+## Key Principles
+
+### Declarative, Not Imperative
+
+You don't create UI objects directly. Instead, you send **commands** that describe what you want:
+
+- "Append this button template to that container"
+- "Set this label's text to 'Hello World'"
+- "Clear all children from this list"
+
+### Asset-Driven
+
+UI structure is defined in `.ui` markup files (assets), not hardcoded in Java. This enables:
+
+- Designers to modify layouts without touching code
+- Reusable UI components
+- Consistent visual language
+
+### Event-Driven
+
+User interactions trigger events that flow back to your server code. You register event bindings and handle them in `handleDataEvent()`.
+
+### Selector-Based
+
+You target specific UI elements using **selectors:**
+
+- `#MyButton` - Element with ID "MyButton"
+- `#List[0]` - First child of element "List"
+- `#List[0] #Title` - Element with ID "Title" in the first child of element "List"
+- `#Label.TextColor` - The TextColor property of element "Label"
diff --git a/content/docs/bg-BG/official-documentation/custom-ui/layout.mdx b/content/docs/bg-BG/official-documentation/custom-ui/layout.mdx
new file mode 100644
index 00000000..0a24ca09
--- /dev/null
+++ b/content/docs/bg-BG/official-documentation/custom-ui/layout.mdx
@@ -0,0 +1,492 @@
+---
+title: Layout
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# Layout
+
+The layout system determines how UI elements are positioned and sized on screen. Understanding layout is crucial for creating well-structured, responsive interfaces.
+
+## Layout Fundamentals
+
+Every UI element has:
+
+- **Container Rectangle** - The space allocated by the parent
+- **Anchor** - How the element positions/sizes itself within the container
+- **Padding** - Inner spacing that affects child layout
+- **LayoutMode** - How the element arranges its children (if it's a container)
+
+```
+┌─────────────────────────────────────┐
+│  Container Rectangle (from parent)  │
+│  ┌───────────────────────────────┐  │
+│  │  Anchored Rectangle           │  │
+│  │  ┌─────────────────────────┐  │  │
+│  │  │ Padding                 │  │  │
+│  │  │  ┌───────────────────┐  │  │  │
+│  │  │  │  Content Area     │  │  │  │
+│  │  │  └───────────────────┘  │  │  │
+│  │  └─────────────────────────┘  │  │
+│  └───────────────────────────────┘  │
+└─────────────────────────────────────┘
+```
+
+## Anchor
+
+`Anchor` controls how an element positions and sizes itself within its container rectangle.
+
+### Fixed Size
+
+```
+Button {
+    Anchor: (Width: 200, Height: 40);
+}
+```
+
+Creates a 200×40 pixel button.
+
+### Positioning
+
+```
+Label {
+    Anchor: (Top: 10, Left: 20, Width: 100, Height: 30);
+}
+```
+
+- **Top**: 10 pixels from container's top edge
+- **Left**: 20 pixels from container's left edge
+- **Width**: 100 pixels wide
+- **Height**: 30 pixels tall
+
+### Anchoring to Edges
+
+```
+Button {
+    Anchor: (Bottom: 10, Right: 10, Width: 100, Height: 30);
+}
+```
+
+Anchors the button to the bottom-right corner, 10 pixels from each edge.
+
+### Stretching
+
+```
+Group {
+    Anchor: (Top: 0, Bottom: 0, Left: 0, Right: 0);
+}
+```
+
+Stretches to fill the entire container (all edges at 0 pixels).
+
+**Shorthand:**
+
+```
+Group {
+    Anchor: (Full: 0);
+}
+```
+
+### Mixed Anchoring
+
+```
+Panel {
+    Anchor: (Top: 10, Bottom: 10, Left: 20, Width: 300);
+}
+```
+
+- Fixed width of 300 pixels
+- Stretches vertically between top and bottom edges
+- 10 pixels from top and bottom
+- 20 pixels from left
+
+## Padding
+
+`Padding` creates inner spacing, affecting where children are positioned.
+
+### Uniform Padding
+
+```
+Group {
+    Padding: (Full: 20);
+}
+```
+
+20 pixels of padding on all sides.
+
+### Directional Padding
+
+```
+Group {
+    Padding: (Top: 10, Bottom: 20, Left: 15, Right: 15);
+}
+```
+
+Different padding per edge.
+
+### Shorthand
+
+```
+// Horizontal and vertical
+Group {
+    Padding: (Horizontal: 20, Vertical: 10);
+}
+
+// Equivalent to:
+// Top: 10, Bottom: 10, Left: 20, Right: 20
+```
+
+### Effect on Children
+
+```
+Group {
+    Anchor: (Width: 200, Height: 100);
+    Padding: (Full: 10);
+
+    Label {
+        Anchor: (Full: 0);
+    }
+}
+```
+
+The label fills the group, but there's a 10-pixel gap on all sides due to padding.
+
+```
+┌──────────────────────┐
+│ Group (200×100)      │
+│  ┌────────────────┐  │
+│  │ Label          │  │ ← 10px padding all around
+│  │                │  │
+│  └────────────────┘  │
+└──────────────────────┘
+```
+
+## LayoutMode
+
+`LayoutMode` determines how a container arranges its children.
+
+### Top (Vertical Stack)
+
+```
+Group {
+    LayoutMode: Top;
+
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+}
+```
+
+Children stack vertically from top to bottom:
+
+```
+┌──────────┐
+│ Button 1 │
+├──────────┤
+│ Button 2 │
+├──────────┤
+│ Button 3 │
+└──────────┘
+
+
+```
+
+Each child's `Anchor.Bottom` adds spacing between elements:
+
+```
+Button { Anchor: (Height: 30, Bottom: 10); }  // 10px gap after this button
+```
+
+### Bottom (Vertical Stack)
+
+```
+Group {
+    LayoutMode: Bottom;
+
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+}
+```
+
+Children stack vertically from top to bottom but aligned to the bottom edge of the parent:
+
+```
+
+
+
+┌──────────┐
+│ Button 1 │
+├──────────┤
+│ Button 2 │
+├──────────┤
+│ Button 3 │
+└──────────┘
+```
+
+### Left (Horizontal Stack)
+
+```
+Group {
+    LayoutMode: Left;
+
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+}
+```
+
+Children arrange horizontally from left to right:
+
+```
+┌────────┬────────┬────────┐
+│ Button │ Button │ Button │
+│   1    │   2    │   3    │
+└────────┴────────┴────────┘
+```
+
+Use `Anchor.Right` for spacing between elements.
+
+### Right (Horizontal Stack)
+
+```
+Group {
+    LayoutMode: Right;
+
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+}
+```
+
+Children arrange horizontally from left to right but aligned to the right side of the parent:
+
+```
+                                                                 ┌────────┬────────┬────────┐
+                                                                 │ Button │ Button │ Button │
+                                                                 │   1    │   2    │   3    │
+                                                                 └────────┴────────┴────────┘
+```
+
+### Center
+
+```
+Group {
+    LayoutMode: Center;
+
+    Group #Dialog {
+        Anchor: (Width: 400, Height: 300);
+    }
+}
+```
+
+Centers the children horizontally.
+
+### Middle
+
+```
+Group {
+    LayoutMode: Middle;
+
+    Group #Dialog {
+        Anchor: (Width: 400, Height: 300);
+    }
+}
+```
+
+Centers the children vertically.
+
+### CenterMiddle (Horizontal Stack, Fully Centered)
+
+```
+Group {
+    LayoutMode: CenterMiddle;
+
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+}
+```
+
+Children stack horizontally from left to right, centered both horizontally and vertically within the parent:
+
+```
+┌────────────────────────────────────────────┐
+│                                            │
+│                                            │
+│         ┌──────┐ ┌──────┐ ┌──────┐         │
+│         │  B1  │ │  B2  │ │  B3  │         │
+│         └──────┘ └──────┘ └──────┘         │
+│                                            │
+│                                            │
+└────────────────────────────────────────────┘
+```
+
+---
+
+### MiddleCenter (Vertical Stack, Fully Centered)
+
+```
+Group {
+    LayoutMode: MiddleCenter;
+
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+}
+```
+
+Children stack vertically from top to bottom, centered both horizontally and vertically within the parent:
+
+```
+┌────────────────────────────────────────────┐
+│                                            │
+│              ┌──────────┐                  │
+│              │ Button 1 │                  │
+│              ├──────────┤                  │
+│              │ Button 2 │                  │
+│              ├──────────┤                  │
+│              │ Button 3 │                  │
+│              └──────────┘                  │
+│                                            │
+└────────────────────────────────────────────┘
+```
+
+---
+
+### Full
+
+```
+Group {
+    LayoutMode: Full;
+
+    Label {
+        Anchor: (Top: 20, Left: 20, Width: 100, Height: 30);
+    }
+}
+```
+
+Children use absolute positioning via their `Anchor` properties.
+
+### TopScrolling
+
+```
+Group {
+    LayoutMode: TopScrolling;
+    ScrollbarStyle: $Common.@DefaultScrollbar;
+
+    // ... many children
+}
+```
+
+Like `Top`, but adds a scrollbar if content exceeds container height.
+
+Or use `BottomScrolling` for bottom-aligned content.
+
+### LeftScrolling
+
+```
+Group {
+    LayoutMode: LeftScrolling;
+    ScrollbarStyle: $Common.@DefaultScrollbar;
+
+    // ... many children
+}
+```
+
+Like `Left`, but adds a scrollbar for horizontal scrolling.
+
+Or use `RightScrolling` for right-aligned content.
+
+### LeftCenterWrap (Wrapping Horizontal Stack, Horizontally Centered)
+
+```
+Group {
+    LayoutMode: LeftCenterWrap;
+
+    Button { Anchor: (Width: 80, Height: 30); }
+    Button { Anchor: (Width: 80, Height: 30); }
+    Button { Anchor: (Width: 80, Height: 30); }
+    Button { Anchor: (Width: 80, Height: 30); }
+    Button { Anchor: (Width: 80, Height: 30); }
+}
+```
+
+Children flow left to right. When there's no more horizontal space, they wrap to the next row. Each row is horizontally centered within the parent:
+
+```
+┌────────────────────────────────────────────┐
+│                                            │
+│       ┌──────┐ ┌──────┐ ┌──────┐           │
+│       │  B1  │ │  B2  │ │  B3  │           │
+│       └──────┘ └──────┘ └──────┘           │
+│            ┌──────┐ ┌──────┐               │
+│            │  B4  │ │  B5  │               │
+│            └──────┘ └──────┘               │
+│                                            │
+└────────────────────────────────────────────┘
+```
+
+## FlexWeight
+
+`FlexWeight` distributes remaining space among children.
+
+```
+Group {
+    LayoutMode: Left;
+    Anchor: (Width: 400);
+
+    Button {
+        Anchor: (Width: 100);
+    }
+
+    Group {
+        FlexWeight: 1;  // Takes all remaining space
+    }
+
+    Button {
+        Anchor: (Width: 100);
+    }
+}
+```
+
+Result:
+
+- First button: 100px
+- Middle group: 200px (400 - 100 - 100 = 200)
+- Last button: 100px
+
+### Multiple FlexWeights
+
+```
+Group {
+    LayoutMode: Left;
+    Anchor: (Width: 600);
+
+    Group { FlexWeight: 1; }
+    Group { FlexWeight: 2; }
+    Group { FlexWeight: 1; }
+}
+```
+
+Remaining space (600px) is split:
+
+- First group: 600 × (1/4) = 150px
+- Second group: 600 × (2/4) = 300px
+- Third group: 600 × (1/4) = 150px
+
+## Visibility
+
+```
+Button #HiddenButton {
+    Visible: false;
+}
+```
+
+**Effect:**
+
+- Element and its children are not displayed
+- Element is **not included in layout** (doesn't take up space)
diff --git a/content/docs/bg-BG/official-documentation/custom-ui/markup.mdx b/content/docs/bg-BG/official-documentation/custom-ui/markup.mdx
new file mode 100644
index 00000000..564110ed
--- /dev/null
+++ b/content/docs/bg-BG/official-documentation/custom-ui/markup.mdx
@@ -0,0 +1,226 @@
+---
+title: Markup
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# Markup
+
+## Markup
+
+An element is the basic building block of a user interface. There are various types of elements with different properties, which are documented below.
+
+Here's what the syntax looks like:
+
+```
+// Basic declaration of an element
+// with its Anchor property set to attach on all sides of its parent
+// with 10 pixels of margin
+Group { Anchor: (Left: 10, Top: 10, Right: 10, Bottom: 10); }
+
+Group { Anchor: (Full: 10); } // More concise version
+
+// Declaration of a Label with a name
+// (can be used to access the element from game code)
+Label #MyLabel {
+  Style: LabelStyle(FontSize: 16); // or just Style: (FontSize: 16), type can be inferred.
+  Text: "Hi! I am text.";
+}
+
+// Declaration of a Group containing 2 children
+// You can use FlexWeight to distribute any left-over space after explicit widths/heights have been subtracted
+Group {
+  LayoutMode: Left;
+  Label { Text: "Child 1"; FlexWeight: 2; }
+  Label { Text: "Child 2"; FlexWeight: 1; }
+}
+```
+
+### Documents
+
+A UI document (_.ui_ file) contains trees of elements. There can be multiple root elements.
+
+### Named Expressions
+
+Named expressions can be declared at any level of a document (including at the root) and will be scoped to that subtree, though they need to be declared at the top of the block.
+
+```
+// Example of named expressions, declared and used with @ prefix
+@Title = "Hytale";
+@ExtraSpacing = 5;
+
+Label {
+  Text: @Title;
+  Style: (LetterSpacing: 2 + @ExtraSpacing);
+}
+```
+
+You can use the spread operator `...` to reuse a named expression while overriding some of its fields:
+
+```
+@MyBaseStyle = LabelStyle(FontSize: 24, LetterSpacing: 2);
+
+Label {
+  Style: (...@MyBaseStyle, FontSize: 36);
+}
+```
+
+You can even layer multiple named expressions like so:
+
+```
+@TitleStyle = LabelStyle(FontSize: 24, HorizontalAlignment: Center);
+@SpacedTextStyle = LabelStyle(LetterSpacing: 2);
+
+Label {
+  Style: (...@BigTextStyle, ...@SpacedTextStyle);
+}
+```
+
+#### Document references
+
+A document can reference another document and access its named expressions.
+
+```
+// Document references are defined with $ prefix
+$Common = "../Common.ui";
+
+TextButton {
+  Style: $Common.@DefaultButtonStyle;
+}
+```
+
+### Templates
+
+You can declare a reusable bit of interface as a named expression and then instantiate it as many times as you want in the tree while customizing it.
+
+You can override local named expressions as well as insert additional children at any point in the template tree. However, local named expressions must be defined at the very top of the block, before properties and child elements.
+
+```
+// This is the template
+@Row = Group {
+  Anchor: (Height: 50);
+  Label #Label { Anchor: (Left: 0, Width: 100); Text: @LabelText; }
+  Group #Content { Anchor: (Left: 100); }
+};
+
+// Here we'll be using it twice in the document tree
+Group #Rows {
+  LayoutMode: TopScrolling;
+
+  @Row #MyFirstRow {
+    @LabelText = "First row";
+    #Content { TextInput {} }
+  }
+
+  @Row #MySecondRow {
+    @LabelText = "Second row";
+  }
+}
+```
+
+### Property Types
+
+#### Basic Types
+
+- **Boolean**
+  - `Visible: false;`
+  - `Visible: true;`
+- **Int**
+  - `Height: 20;`
+- **Float, Double, Decimal**
+  - `Min: 0.2;`
+- **String**
+  - `Text: "Hi!";`
+- **Char**
+  - `PasswordChar: "*";`
+  - _Note: The syntax is the same as a string, however a value of this type cannot contain more than one character!_
+- **Color**
+  - `Background: #ffffff;`&#x20;
+- **Objects**
+  - `Style: (Background: #ffffff)`
+- **Array**&#x20;
+  - `TextSpans: [(Text: "Hi", IsBold: true)]`
+
+#### Translations
+
+Translation keys can be referenced anywhere in markup where you can provide a string, and they are then converted to a string when an element gets instantiated.
+
+**Example:**
+
+```
+Label {
+  Text: %ui.general.cancel;
+}
+```
+
+#### Colors
+
+A color literal can be written as follows:
+
+- `#rrggbb`: 6-digit hexadecimal representation for red, green, blue (fully opaque)
+- `#rrggbb(a.a)`: 6-digit hexadecimal representation for red, green, blue with alpha between 0 and 1
+- `#rrggbbaa`: 8-digit hexadecimal representation for red, green, blue and alpha
+
+```
+Group {
+  Background: #000000(0.3);
+}
+```
+
+<Callout>
+  The `#rrggbb(a.a)` format is prefered over the `#rrggbbaa` format for
+  readability reasons.
+</Callout>
+
+#### Font Name
+
+Font names can be referenced directly by their string ID. Internally this is using a custom type called `UIFontName`, however strings will be converted automatically to this type in markup.
+
+```
+Label {
+  Text: "Hi";
+  Style: (FontName: "Secondary");
+}
+```
+
+**Available Font Names**
+
+- _Default_ - This is the default font that is used for most text and is always used unless a different option has been specified
+- _Secondary_ - This font is mostly used for headlines or elements that are supposed to stick out
+- _Mono_ - This is only used for development; For things such as profiling or error overlays.
+
+#### Path
+
+We can reference other UI assets with the `UIPath` type. Similar to `UIFontName`_,_ Strings are automatically converted to a `UIPath`. Paths are always relative to the file where they have been declared in. Looking up _MyButton.png_ in _Menu/MyAwesomeMenu.ui_ will result in _Menu/MyButton.png_. If you want to reference a file that is in a parent folder you can go back one directory by writing two dots (_../MyButton.png_).
+
+The markup syntax of a `UIPath` is the same as a String. (e.g. `Path: "Test.png"`)
+
+Here are some more examples:
+
+| UIPath             | .ui File                              | Resulting Path    |
+| ------------------ | ------------------------------------- | ----------------- |
+| MyButton.png       | Menu/MyAwesomeMenu.ui                 | Menu/MyButton.png |
+| ../MyButton.png    | Menu/MyAwesomeMenu.ui                 | MyButton.png      |
+| ../../MyButton.png | Menu/Popup/Templates/MyAwesomeMenu.ui | Menu/MyButton.png |
+
+#### Objects
+
+Objects contain a set of properties. In this example we are assigning an Anchor object to the _Anchor_ property:
+
+```
+Group {
+  Anchor: (
+   Height: 10,
+   Width: 20
+ );
+}
+```
+
+You can find all objects that can be used in markup [here](type-documentation#elements).
+
+## Visual Studio Code Extension
+
+There is an official extension for Visual Studio Code which adds syntax highlighting for .ui files. You can find it [here](https://marketplace.visualstudio.com/items?itemName=HypixelStudiosCanadaInc.vscode-hytaleui).
diff --git a/content/docs/bg-BG/official-documentation/custom-ui/type-documentation/index.mdx b/content/docs/bg-BG/official-documentation/custom-ui/type-documentation/index.mdx
new file mode 100644
index 00000000..69cea406
--- /dev/null
+++ b/content/docs/bg-BG/official-documentation/custom-ui/type-documentation/index.mdx
@@ -0,0 +1,127 @@
+---
+title: Type Documentation
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# Type Documentation
+
+This is a generated list of UI elements accessible by markup. More information about the User Interface framework can be found in the main documentation.
+
+## Elements
+
+- [ActionButton](type-documentation/elements/actionbutton)
+- [AssetImage](type-documentation/elements/assetimage)
+- [BackButton](type-documentation/elements/backbutton)
+- [BlockSelector](type-documentation/elements/blockselector)
+- [Button](type-documentation/elements/button)
+- [CharacterPreviewComponent](type-documentation/elements/characterpreviewcomponent)
+- [CheckBox](type-documentation/elements/checkbox)
+- [CheckBoxContainer](type-documentation/elements/checkboxcontainer)
+- [CircularProgressBar](type-documentation/elements/circularprogressbar)
+- [CodeEditor](type-documentation/elements/codeeditor)
+- [ColorOptionGrid](type-documentation/elements/coloroptiongrid)
+- [ColorPicker](type-documentation/lements/colorpicker)
+- [ColorPickerDropdownBox](type-documentation/elements/colorpickerdropdownbox)
+- [CompactTextField](type-documentation/elements/compacttextfield)
+- [DropdownBox](type-documentation/elements/dropdownbox)
+- [DropdownEntry](type-documentation/elements/dropdownentry)
+- [DynamicPane](type-documentation/elements/dynamicpane)
+- [DynamicPaneContainer](type-documentation/elements/dynamicpanecontainer)
+- [FloatSlider](type-documentation/elements/floatslider)
+- [FloatSliderNumberField](type-documentation/elements/floatslidernumberfield)
+- [Group](type-documentation/elements/group)
+- [HotkeyLabel](type-documentation/elements/hotkeylabel)
+- [ItemGrid](type-documentation/elements/itemgrid)
+- [ItemIcon](type-documentation/elements/itemicon)
+- [ItemPreviewComponent](type-documentation/elements/itempreviewcomponent)
+- [ItemSlot](type-documentation/elements/itemslot)
+- [ItemSlotButton](type-documentation/elements/itemslotbutton)
+- [Label](type-documentation/elements/label)
+- [LabeledCheckBox](type-documentation/elements/labeledcheckbox)
+- [MenuItem](type-documentation/elements/menuitem)
+- [MultilineTextField](type-documentation/elements/multilinetextfield)
+- [NumberField](type-documentation/elements/numberfield)
+- [Panel](type-documentation/elements/panel)
+- [ProgressBar](type-documentation/elements/progressbar)
+- [ReorderableList](type-documentation/elements/reorderablelist)
+- [ReorderableListGrip](type-documentation/elements/reorderablelistgrip)
+- [SceneBlur](type-documentation/elements/sceneblur)
+- [Slider](type-documentation/elements/slider)
+- [SliderNumberField](type-documentation/elements/slidernumberfield)
+- [Sprite](type-documentation/elements/sprite)
+- [TabButton](type-documentation/elements/tabbutton)
+- [TabNavigation](type-documentation/elements/tabnavigation)
+- [TextButton](type-documentation/elements/textbutton)
+- [TextField](type-documentation/elements/textfield)
+- [TimerLabel](type-documentation/elements/timerlabel)
+- [ToggleButton](type-documentation/elements/togglebutton)
+
+## Property Types
+
+- [Anchor](type-documentation/property-types/anchor)
+- [BlockSelectorStyle](type-documentation/property-types/blockselectorstyle)
+- [ButtonSounds](type-documentation/property-types/buttonsounds)
+- [ButtonStyle](type-documentation/property-types/buttonstyle)
+- [ButtonStyleState](type-documentation/property-types/buttonstylestate)
+- [CheckBoxStyle](type-documentation/property-types/checkboxstyle)
+- [CheckBoxStyleState](type-documentation/property-types/checkboxstylestate)
+- [ClientItemStack](type-documentation/property-types/clientitemstack)
+- [ColorOptionGridStyle](type-documentation/property-types/coloroptiongridstyle)
+- [ColorPickerDropdownBoxStateBackground](type-documentation/property-types/colorpickerdropdownboxstatebackground)
+- [ColorPickerDropdownBoxStyle](type-documentation/property-types/colorpickerdropdownboxstyle)
+- [ColorPickerStyle](type-documentation/property-types/colorpickerstyle)
+- [DropdownBoxSearchInputStyle](type-documentation/property-types/dropdownboxsearchinputstyle)
+- [DropdownBoxSounds](type-documentation/property-types/dropdownboxsounds)
+- [DropdownBoxStyle](type-documentation/property-types/dropdownboxstyle)
+- [InputFieldButtonStyle](type-documentation/property-types/inputfieldbuttonstyle)
+- [InputFieldDecorationStyle](type-documentation/property-types/inputfielddecorationstyle)
+- [InputFieldDecorationStyleState](type-documentation/property-types/inputfielddecorationstylestate)
+- [InputFieldIcon](type-documentation/property-types/inputfieldicon)
+- [InputFieldStyle](type-documentation/property-types/inputfieldstyle)
+- [ItemGridSlot](type-documentation/property-types/itemgridslot)
+- [ItemGridStyle](type-documentation/property-types/itemgridstyle)
+- [LabeledCheckBoxStyle](type-documentation/property-types/labeledcheckboxstyle)
+- [LabeledCheckBoxStyleState](type-documentation/property-types/labeledcheckboxstylestate)
+- [LabelSpan](type-documentation/property-types/labelspan)
+- [LabelStyle](type-documentation/property-types/labelstyle)
+- [NumberFieldFormat](type-documentation/property-types/numberfieldformat)
+- [Padding](type-documentation/property-types/padding)
+- [PatchStyle](type-documentation/property-types/patchstyle)
+- [PopupStyle](type-documentation/property-types/popupstyle)
+- [ScrollbarStyle](type-documentation/property-types/scrollbarstyle)
+- [SliderStyle](type-documentation/property-types/sliderstyle)
+- [SoundStyle](type-documentation/property-types/soundstyle)
+- [SpriteFrame](type-documentation/property-types/spriteframe)
+- [SubMenuItemStyle](type-documentation/property-types/submenuitemstyle)
+- [SubMenuItemStyleState](type-documentation/property-types/submenuitemstylestate)
+- [Tab](type-documentation/property-types/tab)
+- [TabNavigationStyle](type-documentation/property-types/tabnavigationstyle)
+- [TabStyle](type-documentation/property-types/tabstyle)
+- [TabStyleState](type-documentation/property-types/tabstylestate)
+- [TextButtonStyle](type-documentation/property-types/textbuttonstyle)
+- [TextButtonStyleState](type-documentation/property-types/textbuttonstylestate)
+- [TextTooltipStyle](type-documentation/property-types/texttooltipstyle)
+- [ToggleButtonStyle](type-documentation/property-types/togglebuttonstyle)
+- [ToggleButtonStyleState](type-documentation/property-types/togglebuttonstylestate)
+
+## Enums
+
+- [ActionButtonAlignment](type-documentation/enums/actionbuttonalignment)
+- [CodeEditorLanguage](type-documentation/enums/codeeditorlanguage)
+- [ColorFormat](type-documentation/enums/colorformat)
+- [DropdownBoxAlign](type-documentation/enums/dropdownboxalign)
+- [InputFieldButtonSide](type-documentation/enums/inputfieldbuttonside)
+- [InputFieldIconSide](type-documentation/enums/inputfieldiconside)
+- [ItemGridInfoDisplayMode](type-documentation/enums/itemgridinfodisplaymode)
+- [LabelAlignment](type-documentation/enums/labelalignment)
+- [LayoutMode](type-documentation/enums/layoutmode)
+- [MouseWheelScrollBehaviourType](type-documentation/enums/mousewheelscrollbehaviourtype)
+- [ProgressBarAlignment](type-documentation/enums/progressbaralignment)
+- [ProgressBarDirection](type-documentation/enums/progressbardirection)
+- [ResizeType](type-documentation/enums/resizetype)
+- [TimerDirection](type-documentation/enums/timerdirection)
+- [TooltipAlignment](type-documentation/enums/tooltipalignment)
diff --git a/content/docs/bg-BG/official-documentation/npc-doc.mdx b/content/docs/bg-BG/official-documentation/npc-doc.mdx
new file mode 100644
index 00000000..f075e759
--- /dev/null
+++ b/content/docs/bg-BG/official-documentation/npc-doc.mdx
@@ -0,0 +1,8093 @@
+---
+title: NPC Meta
+description: Official documentation for NPC creation and configuration.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# List of Builders [#top]
+
+|     | Name                                                                                 | Type                       | Description                                                                                                                                            |
+| --- | ------------------------------------------------------------------------------------ | -------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| 1   | [Abstract](#role_abstract)                                                           | Role                       | Generic role for NPC                                                                                                                                   |
+| 2   | [ActionList](#actionlist_actionlist)                                                 | ActionList                 | An array of actions to be executed                                                                                                                     |
+| 3   | [AddToHostileTargetMemory](#action_addtohostiletargetmemory)                         | Action                     | Adds the passed target from the sensor to the hostile target memory                                                                                    |
+| 4   | [AdjustPosition](#sensor_adjustposition)                                             | Sensor                     | Perform adjustments to the wrapped sensor&#x27;s returned position                                                                                     |
+| 5   | [Age](#sensor_age)                                                                   | Sensor                     | Triggers when the age of the NPC falls between a certain range                                                                                         |
+| 6   | [Aim](#headmotion_aim)                                                               | HeadMotion                 | Aim at target                                                                                                                                          |
+| 7   | [AimCharge](#bodymotion_aimcharge)                                                   | BodyMotion                 | Aim the NPC at a target position for performing a charge based on aiming information and ensure that the charge is possible before it&#x27;s executed. |
+| 8   | [Alarm](#sensor_alarm)                                                               | Sensor                     | Check the state of a named alarm                                                                                                                       |
+| 9   | [Altitude](#ientityfilter_altitude)                                                  | IEntityFilter              | Matches targets if they&#x27;re within the defined range above the ground                                                                              |
+| 10  | [And](#sensor_and)                                                                   | Sensor                     | Logical AND of list of sensors                                                                                                                         |
+| 11  | [And](#ientityfilter_and)                                                            | IEntityFilter              | Logical AND of a list of filters                                                                                                                       |
+| 12  | [Animation](#sensor_animation)                                                       | Sensor                     | Check if a given animation is being played                                                                                                             |
+| 13  | [Any](#sensor_any)                                                                   | Sensor                     | Return always true                                                                                                                                     |
+| 14  | [Appearance](#action_appearance)                                                     | Action                     | Set model displayed for NPC                                                                                                                            |
+| 15  | [ApplyEntityEffect](#action_applyentityeffect)                                       | Action                     | Applies an entity effect to the target or self                                                                                                         |
+| 16  | [Attack](#action_attack)                                                             | Action                     | Starts attack                                                                                                                                          |
+| 17  | [Attitude](#isensorentityprioritiser_attitude)                                       | ISensorEntityPrioritiser   | Prioritises return entities by attitude                                                                                                                |
+| 18  | [Attitude](#ientityfilter_attitude)                                                  | IEntityFilter              | Matches the attitude towards the locked target                                                                                                         |
+| 19  | [Beacon](#action_beacon)                                                             | Action                     | Send Beacon Message                                                                                                                                    |
+| 20  | [Beacon](#sensor_beacon)                                                             | Sensor                     | Checks to see if any messages have been broadcasted by nearby NPCs                                                                                     |
+| 21  | [Block](#sensor_block)                                                               | Sensor                     | Checks for one of a set of blocks in the nearby area                                                                                                   |
+| 22  | [BlockChange](#sensor_blockchange)                                                   | Sensor                     | Matches when a block from a blockset within a certain range is changed or interacted with                                                              |
+| 23  | [BlockType](#sensor_blocktype)                                                       | Sensor                     | Checks if the block at the given position matches the provided block set                                                                               |
+| 24  | [CanInteract](#sensor_caninteract)                                                   | Sensor                     | Checks whether or not the player being iterated by the interaction instruction can interact with this NPC                                              |
+| 25  | [CanPlaceBlock](#sensor_canplaceblock)                                               | Sensor                     | Test if the currently set block can be placed at the relative position given direction and offset                                                      |
+| 26  | [Combat](#ientityfilter_combat)                                                      | IEntityFilter              | Check the target&#x27;s combat state                                                                                                                   |
+| 27  | [CombatAbility](#action_combatability)                                               | Action                     | Starts the combat ability selected by the combat action evaluator.                                                                                     |
+| 28  | [CombatActionEvaluator](#sensor_combatactionevaluator)                               | Sensor                     | A sensor which handles funnelling information to actions and motions from the combat action evaluator.                                                 |
+| 29  | [CombatTargets](#isensorentitycollector_combattargets)                               | ISensorEntityCollector     | A collector which processes matched friendly and hostile targets and adds them to the NPC&#x27;s short-term combat memory.                             |
+| 30  | [CompleteTask](#action_completetask)                                                 | Action                     | Complete a task                                                                                                                                        |
+| 31  | [Count](#sensor_count)                                                               | Sensor                     | Check if there is a certain number of NPCs or players within a specific range                                                                          |
+| 32  | [Crouch](#action_crouch)                                                             | Action                     | Set NPC crouching state                                                                                                                                |
+| 33  | [Damage](#sensor_damage)                                                             | Sensor                     | Test if NPC suffered damage                                                                                                                            |
+| 34  | [DelayDespawn](#action_delaydespawn)                                                 | Action                     | Delay the despawning cycle for some amount of time                                                                                                     |
+| 35  | [Despawn](#action_despawn)                                                           | Action                     | Trigger the NPC to despawn                                                                                                                             |
+| 36  | [Die](#action_die)                                                                   | Action                     | Kill the NPC                                                                                                                                           |
+| 37  | [DisplayName](#action_displayname)                                                   | Action                     | Set display name.                                                                                                                                      |
+| 38  | [Dive](#motioncontroller_dive)                                                       | MotionController           | Provide diving abilities for NPC                                                                                                                       |
+| 39  | [DropItem](#action_dropitem)                                                         | Action                     | Drop an item                                                                                                                                           |
+| 40  | [DroppedItem](#sensor_droppeditem)                                                   | Sensor                     | Triggers if a given item is within a certain range of the NPC.                                                                                         |
+| 41  | [EntityEvent](#sensor_entityevent)                                                   | Sensor                     | Matches when an entity from a specific NPC group within a certain range is damaged, killed, or interacted with                                         |
+| 42  | [Eval](#sensor_eval)                                                                 | Sensor                     | Evaluate javascript expression and test if true                                                                                                        |
+| 43  | [Flag](#sensor_flag)                                                                 | Sensor                     | Test if a named flag is set or not                                                                                                                     |
+| 44  | [Flee](#bodymotion_flee)                                                             | BodyMotion                 | Move away from target                                                                                                                                  |
+| 45  | [Flock](#bodymotion_flock)                                                           | BodyMotion                 | Flocking - WIP                                                                                                                                         |
+| 46  | [Flock](#ientityfilter_flock)                                                        | IEntityFilter              | Test for flock membership and related properties                                                                                                       |
+| 47  | [FlockBeacon](#action_flockbeacon)                                                   | Action                     | Send beacon message to flock                                                                                                                           |
+| 48  | [FlockCombatDamage](#sensor_flockcombatdamage)                                       | Sensor                     | Test if flock with NPC received combat damage                                                                                                          |
+| 49  | [FlockLeader](#sensor_flockleader)                                                   | Sensor                     | Test for the presence and provide position of the flock leader                                                                                         |
+| 50  | [FlockState](#action_flockstate)                                                     | Action                     | Set state name for flock.                                                                                                                              |
+| 51  | [FlockTarget](#action_flocktarget)                                                   | Action                     | Set or clear locked target for flock.                                                                                                                  |
+| 52  | [Fly](#motioncontroller_fly)                                                         | MotionController           | Flight motion controller                                                                                                                               |
+| 53  | [Generic](#role_generic)                                                             | Role                       | Generic role for NPC                                                                                                                                   |
+| 54  | [HasHostileTargetMemory](#sensor_hashostiletargetmemory)                             | Sensor                     | Checks if there is currently a hostile target in the target memory.                                                                                    |
+| 55  | [HasInteracted](#sensor_hasinteracted)                                               | Sensor                     | Checks whether the currently iterated player in the interaction instruction has interacted with this NPC                                               |
+| 56  | [HasTask](#sensor_hastask)                                                           | Sensor                     | Checks whether or not the player being iterated by the interaction instruction has any of the given tasks                                              |
+| 57  | [HashMap](#hashmap_hashmap)                                                          | HashMap                    | List of motion controllers                                                                                                                             |
+| 58  | [HeightDifference](#ientityfilter_heightdifference)                                  | IEntityFilter              | Matches entities within the given height range                                                                                                         |
+| 59  | [IgnoreForAvoidance](#action_ignoreforavoidance)                                     | Action                     | Set the target slot of an entity that should be ignored during avoidance                                                                               |
+| 60  | [InAir](#sensor_inair)                                                               | Sensor                     | Test if NPC is not on ground                                                                                                                           |
+| 61  | [InWater](#sensor_inwater)                                                           | Sensor                     | Check if NPC is currently in water                                                                                                                     |
+| 62  | [InflictedDamage](#sensor_inflicteddamage)                                           | Sensor                     | Test if an individual or the flock it belongs to inflicted combat damage                                                                               |
+| 63  | [InsideBlock](#ientityfilter_insideblock)                                            | IEntityFilter              | Matches if the entity is inside any of the blocks in the BlockSet                                                                                      |
+| 64  | [Instruction](#instruction_instruction)                                              | Instruction                | An instruction with Sensor, and Motions and Actions, or a list of nested instructions.                                                                 |
+| 65  | [InteractionContext](#sensor_interactioncontext)                                     | Sensor                     | Checks whether the currently iterated player in the interaction instruction has interacted with this NPC in the given context                          |
+| 66  | [Inventory](#action_inventory)                                                       | Action                     | Add or remove items from inventory.                                                                                                                    |
+| 67  | [Inventory](#ientityfilter_inventory)                                                | IEntityFilter              | Test various conditions relating to entity inventory                                                                                                   |
+| 68  | [IsBackingAway](#sensor_isbackingaway)                                               | Sensor                     | Test if the NPC is currently backing away from something.                                                                                              |
+| 69  | [IsBusy](#sensor_isbusy)                                                             | Sensor                     | Tests if an NPC is in one of the defined Busy States.                                                                                                  |
+| 70  | [ItemInHand](#ientityfilter_iteminhand)                                              | IEntityFilter              | Check if entity is holding an item                                                                                                                     |
+| 71  | [JoinFlock](#action_joinflock)                                                       | Action                     | Join/build a flock with other entity                                                                                                                   |
+| 72  | [Kill](#sensor_kill)                                                                 | Sensor                     | Test if NPC made a kill                                                                                                                                |
+| 73  | [Land](#bodymotion_land)                                                             | BodyMotion                 | Try to land at the given position                                                                                                                      |
+| 74  | [Leash](#sensor_leash)                                                               | Sensor                     | Triggers when the NPC is outside a specified range from the leash point                                                                                |
+| 75  | [Leave](#bodymotion_leave)                                                           | BodyMotion                 | Leave place                                                                                                                                            |
+| 76  | [LeaveFlock](#action_leaveflock)                                                     | Action                     | Leave flock.                                                                                                                                           |
+| 77  | [Light](#sensor_light)                                                               | Sensor                     | Check the light levels of the block an entity is standing on                                                                                           |
+| 78  | [LineOfSight](#ientityfilter_lineofsight)                                            | IEntityFilter              | Matches if there is line of sight to the target                                                                                                        |
+| 79  | [LockOnInteractionTarget](#action_lockoninteractiontarget)                           | Action                     | Locks on to the currently iterated player in the interaction instruction                                                                               |
+| 80  | [Log](#action_log)                                                                   | Action                     | Log a message to console.                                                                                                                              |
+| 81  | [MaintainDistance](#bodymotion_maintaindistance)                                     | BodyMotion                 | Maintain distance from a given position                                                                                                                |
+| 82  | [MakePath](#action_makepath)                                                         | Action                     | Constructs a transient path for the NPC based on a series of rotations and distances                                                                   |
+| 83  | [MatchLook](#bodymotion_matchlook)                                                   | BodyMotion                 | Make NPC body rotate to match look direction                                                                                                           |
+| 84  | [Mob](#sensor_mob)                                                                   | Sensor                     | Test if entity matching specific attributes and filters is in range                                                                                    |
+| 85  | [ModelAttachment](#action_modelattachment)                                           | Action                     | Set an attachment on the current NPC model                                                                                                             |
+| 86  | [MotionController](#sensor_motioncontroller)                                         | Sensor                     | Test if specific motion controller is active.                                                                                                          |
+| 87  | [Mount](#action_mount)                                                               | Action                     | Enable the player to mount the entity                                                                                                                  |
+| 88  | [MovementState](#ientityfilter_movementstate)                                        | IEntityFilter              | Check if the entity is in the given movement state                                                                                                     |
+| 89  | [NPCGroup](#ientityfilter_npcgroup)                                                  | IEntityFilter              | Returns whether the entity matches one of the provided NPCGroups                                                                                       |
+| 90  | [Nav](#sensor_nav)                                                                   | Sensor                     | Queries navigation state                                                                                                                               |
+| 91  | [Not](#sensor_not)                                                                   | Sensor                     | Invert sensor test                                                                                                                                     |
+| 92  | [Not](#ientityfilter_not)                                                            | IEntityFilter              | Invert filter test                                                                                                                                     |
+| 93  | [Nothing](#action_nothing)                                                           | Action                     | Do nothing                                                                                                                                             |
+| 94  | [Nothing](#bodymotion_nothing)                                                       | BodyMotion                 | Do nothing                                                                                                                                             |
+| 95  | [Nothing](#headmotion_nothing)                                                       | HeadMotion                 | Do nothing                                                                                                                                             |
+| 96  | [Notify](#action_notify)                                                             | Action                     | Directly notifies a target NPC with a beacon message                                                                                                   |
+| 97  | [Observe](#headmotion_observe)                                                       | HeadMotion                 | Observe surroundings in various ways.                                                                                                                  |
+| 98  | [OnGround](#sensor_onground)                                                         | Sensor                     | Test if NPC is on ground                                                                                                                               |
+| 99  | [OpenBarterShop](#action_openbartershop)                                             | Action                     | Open the barter shop UI for the current player                                                                                                         |
+| 100 | [OpenShop](#action_openshop)                                                         | Action                     | Open the shop UI for the current player                                                                                                                |
+| 101 | [Or](#sensor_or)                                                                     | Sensor                     | Logical OR of list of sensors                                                                                                                          |
+| 102 | [Or](#ientityfilter_or)                                                              | IEntityFilter              | Logical OR of a list of filters                                                                                                                        |
+| 103 | [OverrideAltitude](#action_overridealtitude)                                         | Action                     | Temporarily override the preferred altitude of a flying NPC                                                                                            |
+| 104 | [OverrideAttitude](#action_overrideattitude)                                         | Action                     | Override this NPCs attitude towards the provided target for a given duration                                                                           |
+| 105 | [ParentState](#action_parentstate)                                                   | Action                     | Set the main state of NPC from within a component                                                                                                      |
+| 106 | [Path](#path_path)                                                                   | Path                       | List of transient path points                                                                                                                          |
+| 107 | [Path](#sensor_path)                                                                 | Sensor                     | Find a path based on various criteria                                                                                                                  |
+| 108 | [Path](#bodymotion_path)                                                             | BodyMotion                 | Walk along a path                                                                                                                                      |
+| 109 | [PickUpItem](#action_pickupitem)                                                     | Action                     | Pick up an item                                                                                                                                        |
+| 110 | [PlaceBlock](#action_placeblock)                                                     | Action                     | Place a block (chosen by another action) at a position returned by a Sensor if close enough                                                            |
+| 111 | [PlayAnimation](#action_playanimation)                                               | Action                     | Play an animation                                                                                                                                      |
+| 112 | [PlaySound](#action_playsound)                                                       | Action                     | Plays a sound to players within a specified range.                                                                                                     |
+| 113 | [Player](#sensor_player)                                                             | Sensor                     | Test if player matching specific attributes and filters is in range                                                                                    |
+| 114 | [Random](#action_random)                                                             | Action                     | Execute a single random action from a list of weighted actions.                                                                                        |
+| 115 | [Random](#sensor_random)                                                             | Sensor                     | Alternates between returning true and false for specified random durations                                                                             |
+| 116 | [Random](#instruction_random)                                                        | Instruction                | Randomised list of weighted instructions.                                                                                                              |
+| 117 | [ReadPosition](#sensor_readposition)                                                 | Sensor                     | Read a stored position with some conditions                                                                                                            |
+| 118 | [RecomputePath](#action_recomputepath)                                               | Action                     | Force recomputation of path finder solution                                                                                                            |
+| 119 | [Reference](#instruction_reference)                                                  | Instruction                | Prioritized instruction list that can be referenced from elsewhere in the file                                                                         |
+| 120 | [RelativeWaypointDefinition](#relativewaypointdefinition_relativewaypointdefinition) | RelativeWaypointDefinition | A simple path waypoint definition where each waypoint is relative to the previous                                                                      |
+| 121 | [ReleaseTarget](#action_releasetarget)                                               | Action                     | Clear locked target                                                                                                                                    |
+| 122 | [Remove](#action_remove)                                                             | Action                     | Erase the target entity from the world (no death animation).                                                                                           |
+| 123 | [ResetBlockSensors](#action_resetblocksensors)                                       | Action                     | Resets a specific block sensor by name, or all block sensors                                                                                           |
+| 124 | [ResetInstructions](#action_resetinstructions)                                       | Action                     | Force reset instructionList                                                                                                                            |
+| 125 | [ResetPath](#action_resetpath)                                                       | Action                     | Resets the current patrol path this NPC follows.                                                                                                       |
+| 126 | [ResetSearchRays](#action_resetsearchrays)                                           | Action                     | Resets a specific search ray sensor cached position by name, or all search ray sensors                                                                 |
+| 127 | [Role](#action_role)                                                                 | Action                     | Change the Role of the NPC                                                                                                                             |
+| 128 | [SearchRay](#sensor_searchray)                                                       | Sensor                     | Fire a ray at a specific angle to see if what it hits matches a given sought block                                                                     |
+| 129 | [Seek](#bodymotion_seek)                                                             | BodyMotion                 | Chase target                                                                                                                                           |
+| 130 | [Self](#sensor_self)                                                                 | Sensor                     | Test if the NPC itself matches a set of entity filters                                                                                                 |
+| 131 | [Sequence](#action_sequence)                                                         | Action                     | List of actions.                                                                                                                                       |
+| 132 | [Sequence](#bodymotion_sequence)                                                     | BodyMotion                 | (Looped)Sequence of motions                                                                                                                            |
+| 133 | [Sequence](#headmotion_sequence)                                                     | HeadMotion                 | (Looped)Sequence of motions                                                                                                                            |
+| 134 | [SetAlarm](#action_setalarm)                                                         | Action                     | Set a named alarm on the NPC                                                                                                                           |
+| 135 | [SetBlockToPlace](#action_setblocktoplace)                                           | Action                     | Set the block type the NPC will place                                                                                                                  |
+| 136 | [SetFlag](#action_setflag)                                                           | Action                     | Set a named flag to a boolean value                                                                                                                    |
+| 137 | [SetInteractable](#action_setinteractable)                                           | Action                     | Set whether the currently iterated player in the interaction instruction should be able to interact with this NPC                                      |
+| 138 | [SetLeashPosition](#action_setleashposition)                                         | Action                     | Sets the NPCs current position to the spawn/leash position                                                                                             |
+| 139 | [SetMarkedTarget](#action_setmarkedtarget)                                           | Action                     | Explicitly sets a marked target in a given slot.                                                                                                       |
+| 140 | [SetStat](#action_setstat)                                                           | Action                     | Sets (or adds to) an entity stat on the NPC.                                                                                                           |
+| 141 | [Spawn](#action_spawn)                                                               | Action                     | Spawn an NPC                                                                                                                                           |
+| 142 | [SpawnParticles](#action_spawnparticles)                                             | Action                     | Spawn particle system visible within a given range with an offset relative to npc heading                                                              |
+| 143 | [SpotsMe](#ientityfilter_spotsme)                                                    | IEntityFilter              | Checks if the entity can view the NPC in a given view sector or cone and without obstruction.                                                          |
+| 144 | [StandingOnBlock](#ientityfilter_standingonblock)                                    | IEntityFilter              | Matches the block directly beneath the entity against a BlockSet                                                                                       |
+| 145 | [StartObjective](#action_startobjective)                                             | Action                     | Start the given objective for the currently iterated player in the interaction instruction                                                             |
+| 146 | [Stat](#ientityfilter_stat)                                                          | IEntityFilter              | Match stat values of the entity                                                                                                                        |
+| 147 | [State](#action_state)                                                               | Action                     | Set state of NPC                                                                                                                                       |
+| 148 | [State](#sensor_state)                                                               | Sensor                     | Test for a specific state                                                                                                                              |
+| 149 | [StateTransition](#statetransition_statetransition)                                  | StateTransition            | An entry containing a list of actions to execute when moving from one state to another                                                                 |
+| 150 | [StateTransitionController](#statetransitioncontroller_statetransitioncontroller)    | StateTransitionController  | A list of state transitions                                                                                                                            |
+| 151 | [StateTransitionEdges](#statetransitionedges_statetransitionedges)                   | StateTransitionEdges       | Sets of from and to states defining state transitions                                                                                                  |
+| 152 | [StorePosition](#action_storeposition)                                               | Action                     | Store the position from the attached sensor                                                                                                            |
+| 153 | [Switch](#sensor_switch)                                                             | Sensor                     | Check if a computed boolean is true                                                                                                                    |
+| 154 | [TakeOff](#bodymotion_takeoff)                                                       | BodyMotion                 | Switch NPC from walking to flying motion controller                                                                                                    |
+| 155 | [Target](#sensor_target)                                                             | Sensor                     | Test if given target matches a series of criteria and optional entity filters                                                                          |
+| 156 | [Teleport](#bodymotion_teleport)                                                     | BodyMotion                 | Teleport NPC to a position given by a sensor                                                                                                           |
+| 157 | [Test](#action_test)                                                                 | Action                     | Test action to exercise attribute evaluation (DO NOT USE)                                                                                              |
+| 158 | [TestProbe](#bodymotion_testprobe)                                                   | BodyMotion                 | Debugging - Test probing                                                                                                                               |
+| 159 | [Time](#sensor_time)                                                                 | Sensor                     | Check if the day/year time is within some specified time.                                                                                              |
+| 160 | [Timeout](#action_timeout)                                                           | Action                     | Delay an action, or insert a delay in a sequence of actions                                                                                            |
+| 161 | [Timer](#sensor_timer)                                                               | Sensor                     | Tests if a timer exists and the value is within a certain range                                                                                        |
+| 162 | [Timer](#bodymotion_timer)                                                           | BodyMotion                 | Execute a Motion for a specific maximum time                                                                                                           |
+| 163 | [Timer](#headmotion_timer)                                                           | HeadMotion                 | Execute a Motion for a specific maximum time                                                                                                           |
+| 164 | [TimerContinue](#action_timercontinue)                                               | Action                     | Continue a timer                                                                                                                                       |
+| 165 | [TimerModify](#action_timermodify)                                                   | Action                     | Modify values of a timer                                                                                                                               |
+| 166 | [TimerPause](#action_timerpause)                                                     | Action                     | Pause a timer                                                                                                                                          |
+| 167 | [TimerRestart](#action_timerrestart)                                                 | Action                     | Restart a timer                                                                                                                                        |
+| 168 | [TimerStart](#action_timerstart)                                                     | Action                     | Start a timer                                                                                                                                          |
+| 169 | [TimerStop](#action_timerstop)                                                       | Action                     | Stop a timer                                                                                                                                           |
+| 170 | [ToggleStateEvaluator](#action_togglestateevaluator)                                 | Action                     | Enable or disable the NPC&#x27;s state evaluator                                                                                                       |
+| 171 | [TriggerSpawnBeacon](#action_triggerspawnbeacon)                                     | Action                     | Trigger the nearest spawn beacon matching the configuration id                                                                                         |
+| 172 | [TriggerSpawners](#action_triggerspawners)                                           | Action                     | Trigger all, or up to a certain number of manual spawn markers in a radius around the NPC                                                              |
+| 173 | [ValueProviderWrapper](#sensor_valueproviderwrapper)                                 | Sensor                     | Wraps a sensor and passes down some additional parameter overrides pulled from the value store                                                         |
+| 174 | [ValueToParameterMapping](#valuetoparametermapping_valuetoparametermapping)          | ValueToParameterMapping    | An entry containing a list of actions to execute when moving from one state to another                                                                 |
+| 175 | [Variant](#role_variant)                                                             | Role                       | Create a variant from an existing NPC JSON file                                                                                                        |
+| 176 | [ViewSector](#ientityfilter_viewsector)                                              | IEntityFilter              | Matches entities within the given view sector                                                                                                          |
+| 177 | [Walk](#motioncontroller_walk)                                                       | MotionController           | Provide walk on ground abilities for NPC                                                                                                               |
+| 178 | [Wander](#bodymotion_wander)                                                         | BodyMotion                 | Random movement                                                                                                                                        |
+| 179 | [WanderInCircle](#bodymotion_wanderincircle)                                         | BodyMotion                 | Random movement in circle around spawn position                                                                                                        |
+| 180 | [WanderInRect](#bodymotion_wanderinrect)                                             | BodyMotion                 | Random movement in rectangle around spawn position                                                                                                     |
+| 181 | [Watch](#headmotion_watch)                                                           | HeadMotion                 | Rotate to target                                                                                                                                       |
+| 182 | [Weather](#sensor_weather)                                                           | Sensor                     | Matches the current weather at the NPCs position against a set of weather globs                                                                        |
+| 183 | [WeightedAction](#weightedaction_weightedaction)                                     | WeightedAction             | A wrapped and weighted action intended to be used for Random action lists.                                                                             |
+
+# List of Roles
+
+## Abstract: Role (Stable) [#role_abstract]
+
+Generic role for NPC with a core planner and list of Motion controllers.
+
+### Attributes
+
+#### - MaxHealth (Stable)
+
+- Max health
+- **Type**: `Integer`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (WorkInProgress)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * Appearance (Stable)
+
+- Model to use for rendering
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * DisplayNames (Stable)
+
+- List of possible display names to choose from
+- **Type**: `StringList`, **Optional** (Default: null)
+- **Constraint**: Strings in array must not be empty
+
+#### * NameTranslationKey (Stable)
+
+- The translation key for this NPC's name
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * OpaqueBlockSet (Stable)
+
+- Blocks blocking line of sight
+- **Type**: `Asset`, **Optional** (Default: Opaque)
+
+#### * Inertia (Experimental)
+
+- Inertia
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0.1
+
+#### * KnockbackScale (Stable)
+
+- Scale factor for knockback. Values greater 1 increase knockback. Smaller values decrease it.
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * InventorySize (Stable)
+
+- Number of available inventory slots
+- **Type**: `Integer`, **Optional** (Default: 0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 36
+
+#### * HotbarSize (Stable)
+
+- Number of available hotbar slots
+- **Type**: `Integer`, **Optional** (Default: 3)
+- **Constraint**: Value must be greater or equal than 3 and less or equal than 8
+
+#### * OffHandSlots (Stable)
+
+- The number of slots for off-hand items
+- **Type**: `Integer`, **Optional** (Default: 0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 4
+
+#### * HotbarItems (Stable)
+
+- Hotbar items (e.g. primary weapon, secondary weapon, etc)
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+#### * OffHandItems (Stable)
+
+- Off-hand items (e.g. shields, torches, etc)
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+#### * PossibleInventoryItems (Stable)
+
+- A droplist defining the possible items the NPCs inventory could contain
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * DefaultOffHandSlot (Stable)
+
+- The default off-hand item slot (-1 is empty)
+- **Type**: `Integer`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 4
+
+#### * Armor (WorkInProgress)
+
+- Armor items
+- **Type**: `AssetArray`, **Optional** (Default: null), **Element Type**: Item
+
+#### * DropList (Stable)
+
+- Drop list to spawn when killed
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * StartState (Stable)
+
+- Initial state
+- **Type**: `String`, **Optional** (Default: start)
+- **Constraint**: String must be not empty
+
+#### * DefaultSubState (Stable)
+
+- The default sub state to reference when transitioning to a main state without a specified sub state
+- **Type**: `String`, **Optional** (Default: Default)
+- **Constraint**: String must be not empty
+
+#### * CollisionDistance (Stable)
+
+- Collision lookahead
+- **Type**: `Double`, **Optional** (Default: 5.0)
+- **Constraint**: Value must be greater than 0
+
+#### * CollisionForceFalloff (Experimental)
+
+- Falloff rate for collision force
+- **Type**: `Double`, **Optional** (Default: 2.0)
+- **Constraint**: Value must be greater than 0
+
+#### * CollisionRadius (Experimental)
+
+- Collision radius override
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * CollisionViewAngle (Experimental)
+
+- Collision detection view cone
+- **Type**: `Double`, **Optional** (Default: 320.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * SeparationDistance (Experimental)
+
+- Desired separation distance
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SeparationWeight (Experimental)
+
+- Blend factor separation
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SeparationDistanceTarget (Experimental)
+
+- Desired separation distance when close to target
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SeparationNearRadiusTarget (Experimental)
+
+- Distance when using SeparationDistanceTarget
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SeparationFarRadiusTarget (Experimental)
+
+- Use normal separation distance from further than this distance
+- **Type**: `Double`, **Optional** (Default: 5.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * ApplyAvoidance (Experimental)
+
+- Apply avoidance steering force
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ApplySeparation (Experimental)
+
+- Apply separation steering force
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * AvoidanceMode (Experimental)
+
+- Abilities to use for avoidance
+- **Type**: `Flag`, **Optional** (Default: Any)
+- **Flag Values**:
+  - `Evade`: Only evade
+  - `Slowdown`: Only slow down NPC
+  - `Any`: Any avoidance allowed
+
+#### * EntityAvoidanceStrength (Experimental)
+
+- Blending factor avoidance
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * StayInEnvironment (Experimental)
+
+- Stay in spawning environment
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * AllowedEnvironments (Experimental)
+
+- Allowed environment to walk in
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * FlockSpawnTypes (WorkInProgress)
+
+- Types of NPC this flock should consist off
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+#### * FlockSpawnTypesRandom (WorkInProgress)
+
+- Create a randomized flock if true else spawn in order of FlockSpawnTypes
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * FlockAllowedNPC (Experimental)
+
+- List of NPCs allowed in flock
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+#### * FlockCanLead (Experimental)
+
+- This NPC can be flock leader
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * FlockWeightAlignment (Experimental)
+
+- Blending flock alignment
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockWeightSeparation (Experimental)
+
+- Blending flock separation
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockWeightCohesion (Experimental)
+
+- Blending flock cohesion
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockInfluenceRange (Experimental)
+
+- Influence radius flock forces
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * DisableDamageFlock (WorkInProgress)
+
+- If true disables combat damage from flock members
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * DisableDamageGroups (WorkInProgress)
+
+- Members in this list of group won't cause damage
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: TagSet
+
+#### * BusyStates (Stable)
+
+- States during which this NPC is busy and can't be interacted with
+- **Type**: `StringList`, **Required**
+- **Constraint**: String must be a valid state string. A main state must be included before the period (e.g. Main.Test). State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+#### * CombatConfig (Stable)
+
+- The combat configuration providing optional combat action evaluator
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * Invulnerable (Stable)
+
+- Makes NPC ignore damage
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * BreathesInAir (WorkInProgress)
+
+- Can breath in air
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BreathesInWater (WorkInProgress)
+
+- Can breath in fluid/water
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * PickupDropOnDeath (Stable)
+
+- Drop last picked item on death
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * DeathAnimationTime (Experimental)
+
+- How long to let the death animation play before removing
+- **Type**: `Double`, **Optional** (Default: 5.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DeathInteraction (Experimental)
+
+- Interaction to run on death
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * DespawnAnimationTime (Experimental)
+
+- How long to let the despawn animation play before removing
+- **Type**: `Double`, **Optional** (Default: 0.800000011920929)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SpawnParticles (Experimental)
+
+- Particle system when spawning
+- **Type**: `String`, **Optional** (Default: null)
+
+#### * SpawnParticlesOffset (Experimental)
+
+- Displacement from foot point to spawn relative to NPC heading
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Double
+
+#### * SpawnViewDistance (Experimental)
+
+- View distance for spawn particle
+- **Type**: `Double`, **Optional** (Default: 75.0)
+- **Constraint**: Value must be greater than 0
+
+#### * DefaultPlayerAttitude (Stable)
+
+- The default attitude of this NPC towards players
+- **Type**: `Flag`, **Optional** (Default: HOSTILE), **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+#### * DefaultNPCAttitude (Stable)
+
+- The default attitude of this NPC towards other NPCs
+- **Type**: `Flag`, **Optional** (Default: NEUTRAL), **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+#### * AttitudeGroup (Stable)
+
+- The attitude group towards other NPCs this NPC belongs to (often species related)
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * ItemAttitudeGroup (Stable)
+
+- This NPC's item attitudes
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * CorpseStaysInFlock (Stable)
+
+- Whether the NPC should stay in the flock until corpse removal or be removed at the moment of death
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * OverrideHeadPitchAngle (Experimental)
+
+- Whether to override the head pitch angle range
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * HeadPitchAngleRange (Experimental)
+
+- Head rotation pitch range to be used instead of model camera settings
+- **Type**: `Array`, **Optional** (Default: [-89.0, 89.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -90, less or equal than 90and in weakly ascending order
+
+#### * MotionControllerList (Stable)
+
+- Motion controllers
+- **Type**: `ObjectRef`, **Required**, **Object Type**: HashMap
+
+#### * Instructions (WorkInProgress)
+
+- List of instructions
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Instruction
+
+#### * InteractionInstruction (Stable)
+
+- An instruction designed to evaluate and set which players can interact with an NPC, along with setting correct states upon interaction
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Instruction
+
+#### * DeathInstruction (Stable)
+
+- An instruction which will run only when the NPC is dead until they are removed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Instruction
+
+#### * StateTransitions (Stable)
+
+- A set of state transitions and the actions that will be executed during them
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: StateTransitionController
+
+#### * StateEvaluator (Stable)
+
+- A state evaluator
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * InitialMotionController (Stable)
+
+- The initial motion controller to set. If omitted and there are multiple, one will be chosen at random.
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * InteractionVars (Stable)
+
+- Interaction vars to be used in interactions.
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * IsMemory (Stable)
+
+- Used to define if the NPC has a Memory to record.
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * MemoriesCategory (Stable)
+
+- Category to put the NPC in, as part of the Memories Plugin
+- **Type**: `String`, **Optional** (Default: Other), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * MemoriesNameOverride (Stable)
+
+- Overrides the Memory name when set.
+- **Type**: `String`, **Optional** (Default: ), **Computable**
+
+#### * SpawnLockTime (Stable)
+
+- How long the NPC should be locked and unable to perform behavior when first spawned
+- **Type**: `Double`, **Optional** (Default: 1.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+### Constraints
+
+- At least one of BreathesInAir, BreathesInWater must be true
+
+[(Top)](#top)
+
+## Generic: Role (Stable) [#role_generic]
+
+Generic role for NPC with a core planner and list of Motion controllers.
+
+### Attributes
+
+#### - MaxHealth (Stable)
+
+- Max health
+- **Type**: `Integer`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (WorkInProgress)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * Appearance (Stable)
+
+- Model to use for rendering
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * DisplayNames (Stable)
+
+- List of possible display names to choose from
+- **Type**: `StringList`, **Optional** (Default: null)
+- **Constraint**: Strings in array must not be empty
+
+#### * NameTranslationKey (Stable)
+
+- The translation key for this NPC's name
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * OpaqueBlockSet (Stable)
+
+- Blocks blocking line of sight
+- **Type**: `Asset`, **Optional** (Default: Opaque)
+
+#### * Inertia (Experimental)
+
+- Inertia
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0.1
+
+#### * KnockbackScale (Stable)
+
+- Scale factor for knockback. Values greater 1 increase knockback. Smaller values decrease it.
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * InventorySize (Stable)
+
+- Number of available inventory slots
+- **Type**: `Integer`, **Optional** (Default: 0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 36
+
+#### * HotbarSize (Stable)
+
+- Number of available hotbar slots
+- **Type**: `Integer`, **Optional** (Default: 3)
+- **Constraint**: Value must be greater or equal than 3 and less or equal than 8
+
+#### * OffHandSlots (Stable)
+
+- The number of slots for off-hand items
+- **Type**: `Integer`, **Optional** (Default: 0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 4
+
+#### * HotbarItems (Stable)
+
+- Hotbar items (e.g. primary weapon, secondary weapon, etc)
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+#### * OffHandItems (Stable)
+
+- Off-hand items (e.g. shields, torches, etc)
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+#### * PossibleInventoryItems (Stable)
+
+- A droplist defining the possible items the NPCs inventory could contain
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * DefaultOffHandSlot (Stable)
+
+- The default off-hand item slot (-1 is empty)
+- **Type**: `Integer`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 4
+
+#### * Armor (WorkInProgress)
+
+- Armor items
+- **Type**: `AssetArray`, **Optional** (Default: null), **Element Type**: Item
+
+#### * DropList (Stable)
+
+- Drop list to spawn when killed
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * StartState (Stable)
+
+- Initial state
+- **Type**: `String`, **Optional** (Default: start)
+- **Constraint**: String must be not empty
+
+#### * DefaultSubState (Stable)
+
+- The default sub state to reference when transitioning to a main state without a specified sub state
+- **Type**: `String`, **Optional** (Default: Default)
+- **Constraint**: String must be not empty
+
+#### * CollisionDistance (Stable)
+
+- Collision lookahead
+- **Type**: `Double`, **Optional** (Default: 5.0)
+- **Constraint**: Value must be greater than 0
+
+#### * CollisionForceFalloff (Experimental)
+
+- Falloff rate for collision force
+- **Type**: `Double`, **Optional** (Default: 2.0)
+- **Constraint**: Value must be greater than 0
+
+#### * CollisionRadius (Experimental)
+
+- Collision radius override
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * CollisionViewAngle (Experimental)
+
+- Collision detection view cone
+- **Type**: `Double`, **Optional** (Default: 320.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * SeparationDistance (Experimental)
+
+- Desired separation distance
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SeparationWeight (Experimental)
+
+- Blend factor separation
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SeparationDistanceTarget (Experimental)
+
+- Desired separation distance when close to target
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SeparationNearRadiusTarget (Experimental)
+
+- Distance when using SeparationDistanceTarget
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SeparationFarRadiusTarget (Experimental)
+
+- Use normal separation distance from further than this distance
+- **Type**: `Double`, **Optional** (Default: 5.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * ApplyAvoidance (Experimental)
+
+- Apply avoidance steering force
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ApplySeparation (Experimental)
+
+- Apply separation steering force
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * AvoidanceMode (Experimental)
+
+- Abilities to use for avoidance
+- **Type**: `Flag`, **Optional** (Default: Any)
+- **Flag Values**:
+  - `Evade`: Only evade
+  - `Slowdown`: Only slow down NPC
+  - `Any`: Any avoidance allowed
+
+#### * EntityAvoidanceStrength (Experimental)
+
+- Blending factor avoidance
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * StayInEnvironment (Experimental)
+
+- Stay in spawning environment
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * AllowedEnvironments (Experimental)
+
+- Allowed environment to walk in
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * FlockSpawnTypes (WorkInProgress)
+
+- Types of NPC this flock should consist off
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+#### * FlockSpawnTypesRandom (WorkInProgress)
+
+- Create a randomized flock if true else spawn in order of FlockSpawnTypes
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * FlockAllowedNPC (Experimental)
+
+- List of NPCs allowed in flock
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+#### * FlockCanLead (Experimental)
+
+- This NPC can be flock leader
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * FlockWeightAlignment (Experimental)
+
+- Blending flock alignment
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockWeightSeparation (Experimental)
+
+- Blending flock separation
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockWeightCohesion (Experimental)
+
+- Blending flock cohesion
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0
+
+#### * FlockInfluenceRange (Experimental)
+
+- Influence radius flock forces
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * DisableDamageFlock (WorkInProgress)
+
+- If true disables combat damage from flock members
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * DisableDamageGroups (WorkInProgress)
+
+- Members in this list of group won't cause damage
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: TagSet
+
+#### * BusyStates (Stable)
+
+- States during which this NPC is busy and can't be interacted with
+- **Type**: `StringList`, **Required**
+- **Constraint**: String must be a valid state string. A main state must be included before the period (e.g. Main.Test). State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+#### * CombatConfig (Stable)
+
+- The combat configuration providing optional combat action evaluator
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * Invulnerable (Stable)
+
+- Makes NPC ignore damage
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * BreathesInAir (WorkInProgress)
+
+- Can breath in air
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BreathesInWater (WorkInProgress)
+
+- Can breath in fluid/water
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * PickupDropOnDeath (Stable)
+
+- Drop last picked item on death
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * DeathAnimationTime (Experimental)
+
+- How long to let the death animation play before removing
+- **Type**: `Double`, **Optional** (Default: 5.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DeathInteraction (Experimental)
+
+- Interaction to run on death
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * DespawnAnimationTime (Experimental)
+
+- How long to let the despawn animation play before removing
+- **Type**: `Double`, **Optional** (Default: 0.800000011920929)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SpawnParticles (Experimental)
+
+- Particle system when spawning
+- **Type**: `String`, **Optional** (Default: null)
+
+#### * SpawnParticlesOffset (Experimental)
+
+- Displacement from foot point to spawn relative to NPC heading
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Double
+
+#### * SpawnViewDistance (Experimental)
+
+- View distance for spawn particle
+- **Type**: `Double`, **Optional** (Default: 75.0)
+- **Constraint**: Value must be greater than 0
+
+#### * DefaultPlayerAttitude (Stable)
+
+- The default attitude of this NPC towards players
+- **Type**: `Flag`, **Optional** (Default: HOSTILE), **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+#### * DefaultNPCAttitude (Stable)
+
+- The default attitude of this NPC towards other NPCs
+- **Type**: `Flag`, **Optional** (Default: NEUTRAL), **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+#### * AttitudeGroup (Stable)
+
+- The attitude group towards other NPCs this NPC belongs to (often species related)
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * ItemAttitudeGroup (Stable)
+
+- This NPC's item attitudes
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * CorpseStaysInFlock (Stable)
+
+- Whether the NPC should stay in the flock until corpse removal or be removed at the moment of death
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * OverrideHeadPitchAngle (Experimental)
+
+- Whether to override the head pitch angle range
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * HeadPitchAngleRange (Experimental)
+
+- Head rotation pitch range to be used instead of model camera settings
+- **Type**: `Array`, **Optional** (Default: [-89.0, 89.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -90, less or equal than 90and in weakly ascending order
+
+#### * MotionControllerList (Stable)
+
+- Motion controllers
+- **Type**: `ObjectRef`, **Required**, **Object Type**: HashMap
+
+#### * Instructions (WorkInProgress)
+
+- List of instructions
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Instruction
+
+#### * InteractionInstruction (Stable)
+
+- An instruction designed to evaluate and set which players can interact with an NPC, along with setting correct states upon interaction
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Instruction
+
+#### * DeathInstruction (Stable)
+
+- An instruction which will run only when the NPC is dead until they are removed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Instruction
+
+#### * StateTransitions (Stable)
+
+- A set of state transitions and the actions that will be executed during them
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: StateTransitionController
+
+#### * StateEvaluator (Stable)
+
+- A state evaluator
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * InitialMotionController (Stable)
+
+- The initial motion controller to set. If omitted and there are multiple, one will be chosen at random.
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * InteractionVars (Stable)
+
+- Interaction vars to be used in interactions.
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+#### * IsMemory (Stable)
+
+- Used to define if the NPC has a Memory to record.
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * MemoriesCategory (Stable)
+
+- Category to put the NPC in, as part of the Memories Plugin
+- **Type**: `String`, **Optional** (Default: Other), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * MemoriesNameOverride (Stable)
+
+- Overrides the Memory name when set.
+- **Type**: `String`, **Optional** (Default: ), **Computable**
+
+#### * SpawnLockTime (Stable)
+
+- How long the NPC should be locked and unable to perform behavior when first spawned
+- **Type**: `Double`, **Optional** (Default: 1.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+### Constraints
+
+- At least one of BreathesInAir, BreathesInWater must be true
+
+[(Top)](#top)
+
+## Variant: Role (WorkInProgress) [#role_variant]
+
+Create a variant from an existing NPC JSON file
+
+[(Top)](#top)
+
+# List of Motion Controllers
+
+## Dive: MotionController (WorkInProgress) [#motioncontroller_dive]
+
+Provide diving abilities for NPC
+
+### Attributes
+
+#### - Type (Stable)
+
+- Type field
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+#### * EpsilonSpeed (Experimental)
+
+- Minimum speed considered non 0
+- **Type**: `Double`, **Optional** (Default: 1.0E-5)
+- **Constraint**: Value must be greater than 0
+
+#### * EpsilonAngle (Experimental)
+
+- Minimum angle difference considered non 0 in degrees
+- **Type**: `Double`, **Optional** (Default: 3.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxHeadRotationSpeed (Stable)
+
+- Maximum rotation speed of the head in degrees
+- **Type**: `Double`, **Optional** (Default: 360.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * ForceVelocityDamping (Experimental)
+
+- Damping of external force/velocity over time
+- **Type**: `Double`, **Optional** (Default: 0.5)
+- **Constraint**: Value must be greater than 0
+
+#### * RunThreshold (WorkInProgress)
+
+- Relative threshold when running animation should be used
+- **Type**: `Double`, **Optional** (Default: 0.7), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * RunThresholdRange (WorkInProgress)
+
+- Relative threshold range for switching between running/walking
+- **Type**: `Double`, **Optional** (Default: 0.15)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MaxSwimSpeed (Stable)
+
+- Maximum horizontal speed
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxDiveSpeed (Stable)
+
+- Maximum vertical speed
+- **Type**: `Double`, **Optional** (Default: 8.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxFallSpeed (Stable)
+
+- Terminal velocity falling in air
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSinkSpeed (Stable)
+
+- Terminal velocity sinking in water
+- **Type**: `Double`, **Optional** (Default: 4.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Gravity (Stable)
+
+- Gravity
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Acceleration (Stable)
+
+- Acceleration
+- **Type**: `Double`, **Optional** (Default: 3.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxRotationSpeed (Stable)
+
+- Maximum rotational speed in degrees
+- **Type**: `Double`, **Optional** (Default: 360.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSwimTurnAngle (WorkInProgress)
+
+- Maximum angle NPC can walk without explicit turning in degrees
+- **Type**: `Double`, **Optional** (Default: 90.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * FastSwimThreshold (WorkInProgress)
+
+- Relative threshold when fast swimming animation should be used
+- **Type**: `Double`, **Optional** (Default: 0.6)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * SwimDepth (WorkInProgress)
+
+- 0 is at eye height, -1 is bottom of bounding box, +1 top of bounding box. other values between -1 and +1 scale linear
+- **Type**: `Double`, **Optional** (Default: 0.4)
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * SinkRatio (WorkInProgress)
+
+- Relative sink or climb speed while wandering
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinDiveDepth (Unknown)
+
+- null
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxDiveDepth (WorkInProgress)
+
+- Maximum dive depth below surface desired
+- **Type**: `Double`, **Optional** (Default: 1.7976931348623157E308)
+- **Constraint**: Value must be greater than 0
+
+#### * MinDepthAboveGround (WorkInProgress)
+
+- Minimum distance from ground desired
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinDepthBelowSurface (WorkInProgress)
+
+- Minimum distance from water surface desired
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinWaterDepth (Unknown)
+
+- null
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxWaterDepth (Unknown)
+
+- null
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DesiredDepthWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast.
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+### Constraints
+
+- MinSwimSpeed must be less or equal than MaxSwimSpeed
+
+[(Top)](#top)
+
+## Fly: MotionController (WorkInProgress) [#motioncontroller_fly]
+
+Flight motion controller
+
+### Attributes
+
+#### - Type (Stable)
+
+- Type field
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+#### * EpsilonSpeed (Experimental)
+
+- Minimum speed considered non 0
+- **Type**: `Double`, **Optional** (Default: 1.0E-5)
+- **Constraint**: Value must be greater than 0
+
+#### * EpsilonAngle (Experimental)
+
+- Minimum angle difference considered non 0 in degrees
+- **Type**: `Double`, **Optional** (Default: 3.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxHeadRotationSpeed (Stable)
+
+- Maximum rotation speed of the head in degrees
+- **Type**: `Double`, **Optional** (Default: 360.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * ForceVelocityDamping (Experimental)
+
+- Damping of external force/velocity over time
+- **Type**: `Double`, **Optional** (Default: 0.5)
+- **Constraint**: Value must be greater than 0
+
+#### * RunThreshold (WorkInProgress)
+
+- Relative threshold when running animation should be used
+- **Type**: `Double`, **Optional** (Default: 0.7), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * RunThresholdRange (WorkInProgress)
+
+- Relative threshold range for switching between running/walking
+- **Type**: `Double`, **Optional** (Default: 0.15)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MinAirSpeed (WorkInProgress)
+
+- Minimum in air speed
+- **Type**: `Double`, **Optional** (Default: 0.1)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxHorizontalSpeed (Stable)
+
+- Maximum horizontal speed
+- **Type**: `Double`, **Optional** (Default: 8.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxClimbSpeed (Stable)
+
+- Maximum climbing speed
+- **Type**: `Double`, **Optional** (Default: 6.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSinkSpeed (Stable)
+
+- Maximum sink/drop speed
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxFallSpeed (Stable)
+
+- Maximum fall speed
+- **Type**: `Double`, **Optional** (Default: 40.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSinkSpeedFluid (Stable)
+
+- Maximum sink/fall speed in fluids
+- **Type**: `Double`, **Optional** (Default: 4.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxClimbAngle (Stable)
+
+- Maximum climb angle
+- **Type**: `Double`, **Optional** (Default: 45.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSinkAngle (Stable)
+
+- Maximum sink angle
+- **Type**: `Double`, **Optional** (Default: 85.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Acceleration (Stable)
+
+- Maximum Acceleration
+- **Type**: `Double`, **Optional** (Default: 4.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Deceleration (Stable)
+
+- Maximum deceleration
+- **Type**: `Double`, **Optional** (Default: 4.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Gravity (Stable)
+
+- Gravity
+- **Type**: `Double`, **Optional** (Default: 40.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxTurnSpeed (Stable)
+
+- Maximum turn speed in degrees per second
+- **Type**: `Double`, **Optional** (Default: 180.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxRollAngle (Stable)
+
+- Maximum roll angle in degrees
+- **Type**: `Double`, **Optional** (Default: 45.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxRollSpeed (Stable)
+
+- Maximum roll speed in degrees per second
+- **Type**: `Double`, **Optional** (Default: 180.0)
+- **Constraint**: Value must be greater than 0
+
+#### * RollDamping (Stable)
+
+- Roll damping
+- **Type**: `Double`, **Optional** (Default: 0.8999999761581421)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MinHeightOverGround (Stable)
+
+- Minimum height over ground
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxHeightOverGround (Stable)
+
+- Maximum height over ground
+- **Type**: `Double`, **Optional** (Default: 20.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * FastFlyThreshold (WorkInProgress)
+
+- Relative threshold when fast flying animation should be used
+- **Type**: `Double`, **Optional** (Default: 0.6)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * AutoLevel (Stable)
+
+- Set pitch to 0 when no steering forces applied
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast.
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+[(Top)](#top)
+
+## Walk: MotionController (WorkInProgress) [#motioncontroller_walk]
+
+Provide walk on ground abilities for NPC
+
+### Attributes
+
+#### - Type (Stable)
+
+- Type field
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+#### * EpsilonSpeed (Experimental)
+
+- Minimum speed considered non 0
+- **Type**: `Double`, **Optional** (Default: 1.0E-5)
+- **Constraint**: Value must be greater than 0
+
+#### * EpsilonAngle (Experimental)
+
+- Minimum angle difference considered non 0 in degrees
+- **Type**: `Double`, **Optional** (Default: 3.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxHeadRotationSpeed (Stable)
+
+- Maximum rotation speed of the head in degrees
+- **Type**: `Double`, **Optional** (Default: 360.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * ForceVelocityDamping (Experimental)
+
+- Damping of external force/velocity over time
+- **Type**: `Double`, **Optional** (Default: 0.5)
+- **Constraint**: Value must be greater than 0
+
+#### * RunThreshold (WorkInProgress)
+
+- Relative threshold when running animation should be used
+- **Type**: `Double`, **Optional** (Default: 0.7), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * RunThresholdRange (WorkInProgress)
+
+- Relative threshold range for switching between running/walking
+- **Type**: `Double`, **Optional** (Default: 0.15)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MaxWalkSpeed (Stable)
+
+- Maximum horizontal speed
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinWalkSpeed (WorkInProgress)
+
+- Minimum horizontal speed
+- **Type**: `Double`, **Optional** (Default: 0.1)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxFallSpeed (Stable)
+
+- Maximum fall speed
+- **Type**: `Double`, **Optional** (Default: 8.0)
+- **Constraint**: Value must be greater than 0
+
+#### * MaxSinkSpeedFluid (Stable)
+
+- Maximum sink speed in fluids
+- **Type**: `Double`, **Optional** (Default: 4.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Gravity (Stable)
+
+- Gravity
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Acceleration (Stable)
+
+- Acceleration
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxRotationSpeed (Stable)
+
+- Maximum rotational speed in degrees
+- **Type**: `Double`, **Optional** (Default: 360.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxWalkTurnAngle (WorkInProgress)
+
+- Maximum angle NPC can walk without explicit turning in degrees
+- **Type**: `Double`, **Optional** (Default: 90.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * BlendRestTurnAngle (WorkInProgress)
+
+- When NPC is blending heading and turn angle required is larger than this value speed is reduced
+- **Type**: `Double`, **Optional** (Default: 60.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * BlendRestRelativeSpeed (WorkInProgress)
+
+- When NPC is blending heading relative speed used when reducing speed
+- **Type**: `Double`, **Optional** (Default: 0.2), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MaxClimbHeight (Stable)
+
+- Maximum height NPC can climb
+- **Type**: `Double`, **Optional** (Default: 1.3), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * JumpHeight (Experimental)
+
+- How high the NPC jumps above climb height
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinJumpHeight (Experimental)
+
+- Minimum height above which a jump will be attempted
+- **Type**: `Double`, **Optional** (Default: 0.6), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinJumpDistance (Experimental)
+
+- Minimum distance above which a jump will be executed
+- **Type**: `Double`, **Optional** (Default: 0.2), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * JumpForce (Experimental)
+
+- The force multiplier for the upward motion of the jump
+- **Type**: `Double`, **Optional** (Default: 1.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * JumpBlending (Experimental)
+
+- The blending of the upward jump pattern. 0 is more curved and 1 is linear
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * JumpDescentBlending (Experimental)
+
+- The blending of the jump descent pattern. 0 is linear while higher values become more curved
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * JumpDescentSteepness (Experimental)
+
+- The steepness of the descent portion of the jump
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AscentAnimationType (Stable)
+
+- The animation to play when walking up a block
+- **Type**: `Flag`, **Optional** (Default: Walk), **Computable**
+- **Flag Values**:
+  - `Walk`: Play walk animation
+  - `Fly`: Play fly animation
+  - `Idle`: Play idle animation
+  - `Climb`: Play climb animation
+  - `Jump`: Play jump animation
+
+#### * ClimbSpeedMult (WorkInProgress)
+
+- Climb speed multiplier (const + multiplier \* walkspeed \*\* power)
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+
+#### * ClimbSpeedPow (WorkInProgress)
+
+- Climb speed power (const + multiplier \* walkspeed \*\* power)
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+
+#### * ClimbSpeedConst (WorkInProgress)
+
+- Climb speed constant (const + multiplier \* walkspeed \*\* power)
+- **Type**: `Double`, **Optional** (Default: 5.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinDescentAnimationHeight (Stable)
+
+- The min drop distance to switch from the standard walking animation to the specified descent animation
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DescendFlatness (WorkInProgress)
+
+- Relative scale how fast NPC moves forward while climbing down
+- **Type**: `Double`, **Optional** (Default: 0.7), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * DescendSpeedCompensation (WorkInProgress)
+
+- Factor to compensate forward speed reduction while moving downwards
+- **Type**: `Double`, **Optional** (Default: 0.9), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * DescentAnimationType (Experimental)
+
+- The animation to play when moving down a block
+- **Type**: `Flag`, **Optional** (Default: Fall), **Computable**
+- **Flag Values**:
+  - `Walk`: Play walk animation
+  - `Idle`: Play idle animation
+  - `Fall`: Play fall animation
+
+#### * DescentSteepness (Experimental)
+
+- The relative steepness of the descent
+- **Type**: `Double`, **Optional** (Default: 1.4), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * DescentBlending (Experimental)
+
+- The blending of the descent pattern. 0 is linear, while higher values become more curved
+- **Type**: `Double`, **Optional** (Default: 1.8), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxDropHeight (WorkInProgress)
+
+- Maximum height NPC considers drop safe
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * FenceBlockSet (Stable)
+
+- Unclimbable blocks
+- **Type**: `Asset`, **Optional** (Default: Fence)
+
+#### * JumpRange (WorkInProgress)
+
+- Jump distance range
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 10and in weakly ascending order
+
+#### * MinHover (WorkInProgress)
+
+- Minimum hover height over ground
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinHoverClimb (WorkInProgress)
+
+- Minimum hover height over ground when climbing
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinHoverDrop (WorkInProgress)
+
+- Minimum hover height over ground when dropping
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * FloatsDown (WorkInProgress)
+
+- If true NPC floats down when hovering enabled else gravity decides
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * MaxHover (WorkInProgress)
+
+- Maximum hover height over ground
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * HoverFreq (WorkInProgress)
+
+- Hover frequency
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MinHitSlowdown (Stable)
+
+- The minimum percentage to slow down by when attacked from behind
+- **Type**: `Double`, **Optional** (Default: 0.1)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+### Constraints
+
+- MinHover must be less or equal than MaxHover
+- MinHoverClimb must be less or equal than MinHover
+- MinHoverDrop must be less or equal than MinHover
+- MinWalkSpeed must be less or equal than MaxWalkSpeed
+
+[(Top)](#top)
+
+# List of Misc Parts
+
+## ActionList: ActionList (Stable) [#actionlist_actionlist]
+
+An array of actions to be executed
+
+- List of actions
+- **Type**: `Array`, **Required**, **Element Type**: Action
+
+[(Top)](#top)
+
+## Aim: HeadMotion (Stable) [#headmotion_aim]
+
+Aim at target considering weapon in hand.
+
+### Attributes
+
+#### - Spread (Experimental)
+
+- Random targeting error
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 5
+
+#### * HitProbability (Experimental)
+
+- Probability of shot being straight on target
+- **Type**: `Double`, **Optional** (Default: 0.33), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * Deflection (Experimental)
+
+- Compute deflection for moving targets
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelativeTurnSpeed (Stable)
+
+- The relative turn speed modifier
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## AimCharge: BodyMotion (Stable) [#bodymotion_aimcharge]
+
+Aim the NPC at a target position for performing a charge based on aiming information and ensure that the charge is possible before it's executed.
+
+### Attributes
+
+#### - RelativeTurnSpeed (Stable)
+
+- The relative turn speed modifier
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## Altitude: IEntityFilter (Stable) [#ientityfilter_altitude]
+
+Matches targets if they're within the defined range above the ground
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AltitudeRange (Stable)
+
+- The range above the ground to match
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+[(Top)](#top)
+
+## And: IEntityFilter (Stable) [#ientityfilter_and]
+
+Logical AND of a list of filters
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Filters (Stable)
+
+- List of filters
+- **Type**: `Array`, **Required**, **Element Type**: IEntityFilter
+- **Constraint**: Array must not be empty
+
+[(Top)](#top)
+
+## Attitude: ISensorEntityPrioritiser (Stable) [#isensorentityprioritiser_attitude]
+
+Prioritises return entities by attitude
+
+### Attributes
+
+#### - AttitudesByPriority (Stable)
+
+- A prioritised list of attitudes
+- **Type**: `FlagArray`, **Required**, **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+- **Constraint**: Array must not contain duplicates
+
+[(Top)](#top)
+
+## Attitude: IEntityFilter (Stable) [#ientityfilter_attitude]
+
+Matches the attitude towards the locked target
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Attitudes (Stable)
+
+- The attitudes to match
+- **Type**: `FlagSet`, **Required**, **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+### Constraints
+
+[(Top)](#top)
+
+## Combat: IEntityFilter (Stable) [#ientityfilter_combat]
+
+Check the target's combat state. This includes whether they're attacking at all, if they're using a particular attack, etc
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sequence (Stable)
+
+- The attack ID to check for.
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * TimeElapsedRange (Stable)
+
+- The acceptable elapsed time range in seconds.
+- **Type**: `Array`, **Optional** (Default: [0.0, 3.4028234663852886E38]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 3.4028234663852886e+38and in weakly ascending order
+
+#### * Mode (Stable)
+
+- Type of combat to trigger on
+- **Type**: `Flag`, **Optional** (Default: Attacking), **Computable**
+- **Flag Values**:
+  - `Ranged`: Ranged
+  - `Charging`: Weapon charging
+  - `Melee`: Melee
+  - `Blocking`: Blocking
+  - `Sequence`: Combat sequence
+  - `Attacking`: Attacking
+  - `Any`: Any
+  - `None`: None
+
+### Constraints
+
+- If Mode is Sequence, the asset Sequencemust be provided
+
+[(Top)](#top)
+
+## CombatTargets: ISensorEntityCollector (Stable) [#isensorentitycollector_combattargets]
+
+A collector which processes matched friendly and hostile targets and adds them to the NPC's short-term combat memory.
+
+[(Top)](#top)
+
+## Flee: BodyMotion (Experimental) [#bodymotion_flee]
+
+Move away from a target using path finding or steering
+
+### Attributes
+
+#### - RelativeSpeed (Stable)
+
+- Maximum relative speed the NPC should move
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * RelativeSpeedWaypoint (Stable)
+
+- Maximum relative speed the NPC should move close to waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * WaypointRadius (Stable)
+
+- Radius to slow down around waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0.1
+
+#### * UseBestPath (Stable)
+
+- Use best partial path if goal can't be reached
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ThrottleDelayRange (Stable)
+
+- Time to delay after no path finding solution found
+- **Type**: `Array`, **Optional** (Default: [3.0, 5.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * ThrottleIgnoreCount (Stable)
+
+- How often no valid path solution can be found before throttling delay is applied
+- **Type**: `Integer`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * BuildOptimisedPath (Stable)
+
+- Try to reduce number of nodes of generated path
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlendHeading (Stable)
+
+- Relative rotation angle into next waypoint when arriving at current waypoint
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * PathSmoothing (Stable)
+
+- Try to smooth followed path. Larger values smooth more.
+- **Type**: `Integer`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * RejectionWeight (Stable)
+
+- Weight of rejection vector pushing entity closer to original path
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * UseSteering (Stable)
+
+- Use simple/cheap steering if available
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * SkipSteering (Experimental)
+
+- Skip steering if target not reachable
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * UsePathfinder (Stable)
+
+- Use path finder
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MinPathLength (Experimental)
+
+- Minimum length of path required when not able to reach target (should be greater equal 2)
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DiagonalMoves (Stable)
+
+- Allow diagonal moves
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * StepsPerTick (Stable)
+
+- Steps per iteration
+- **Type**: `Integer`, **Optional** (Default: 50.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxPathLength (Stable)
+
+- Max path steps before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxOpenNodes (Stable)
+
+- Max open nodes before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxTotalNodes (Stable)
+
+- Max total node before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 900.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (Stable)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * WaitDistance (Experimental)
+
+- Minimum distance target needs to move before recomputing path when no path can be found
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * RecomputeDistance (Experimental)
+
+- Maximum distance target can move before path is recomputed or 0 to supress recomputation
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * ReprojectDistance (Experimental)
+
+- Maximum distance target can move before position is reprojected
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * AdjustRangeByHitboxSize (Stable)
+
+- Correct range by hitbox sizes of involved entities
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * RecomputeConeAngle (Experimental)
+
+- Recompute path when target leaves cone from initial position to target
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * SlowDownDistance (Stable)
+
+- Distance from target when NPC should start to slowdown
+- **Type**: `Double`, **Optional** (Default: 8.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance from target when NPC should halt
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Falloff (Stable)
+
+- Rate how fast the slowdown should happen relative to distance
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * HoldDirectionTimeRange (Stable)
+
+- How often to change heading
+- **Type**: `Array`, **Optional** (Default: [2.0, 5.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * ChangeDirectionViewSector (Stable)
+
+- The view sector the NPC uses to decide if it should switch direction
+- **Type**: `Double`, **Optional** (Default: 230.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * DirectionJitter (Stable)
+
+- How much jitter in degrees to add to the heading the NPC uses
+- **Type**: `Double`, **Optional** (Default: 45.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * ErraticDistance (Stable)
+
+- If the player is closer than this distance, the NPC will behave more erratically using the additional jitter parameter
+- **Type**: `Double`, **Optional** (Default: 4.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * ErraticExtraJitter (Stable)
+
+- Extra jitter to add to the NPC heading on top of the standard when the target is too close
+- **Type**: `Double`, **Optional** (Default: 45.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * ErraticChangeDurationMultiplier (Stable)
+
+- A multiplier to decrease the duration between direction changes when the target is too close
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+- SlowDownDistance must be less or equal than StopDistance
+
+[(Top)](#top)
+
+## Flock: BodyMotion (Experimental) [#bodymotion_flock]
+
+Flocking - WIP
+
+### Constraints
+
+[(Top)](#top)
+
+## Flock: IEntityFilter (Stable) [#ientityfilter_flock]
+
+Test for flock membership and related properties
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * FlockStatus (Stable)
+
+- Test for NPC status in relation to flock
+- **Type**: `Flag`, **Optional** (Default: Any)
+- **Flag Values**:
+  - `Leader`: Is leader of a flock
+  - `Follower`: Is part of a flock but not leader
+  - `NotMember`: Is not part of a flock
+  - `Member`: Is part of a flock
+  - `Any`: Don't care
+
+#### * FlockPlayerStatus (Stable)
+
+- Test for Player status for flock NPC is member
+- **Type**: `Flag`, **Optional** (Default: Any)
+- **Flag Values**:
+  - `NotMember`: Player is not member of a flock
+  - `Member`: Player is member of a flock
+  - `Any`: Don't care
+
+#### * Size (Stable)
+
+- Check for a certain range of NPCs in the flock
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: integer
+
+#### * CheckCanJoin (Stable)
+
+- If true, will filter entities in a flock the executor can join
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## HashMap: HashMap (Stable) [#hashmap_hashmap]
+
+Non-empty list of motion controllers.
+
+- List of motion controllers
+- **Type**: `Array`, **Required**, **Element Type**: MotionController
+- **Constraint**: Array must not be empty
+
+[(Top)](#top)
+
+## HeightDifference: IEntityFilter (Stable) [#ientityfilter_heightdifference]
+
+Matches entities within the given height range
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * HeightDifference (Stable)
+
+- The height range to test entities in. Extends into negatives for positions below the NPC
+- **Type**: `Array`, **Optional** (Default: [-1.7976931348623157E308, 1.7976931348623157E308]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -1.7976931348623157e+308, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * UseEyePosition (Stable)
+
+- Use eye position for height difference checks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## InsideBlock: IEntityFilter (Stable) [#ientityfilter_insideblock]
+
+Matches if the entity is inside any of the blocks in the BlockSet
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlockSet (Stable)
+
+- The BlockSet to match against
+- **Type**: `Asset`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## Instruction: Instruction (WorkInProgress) [#instruction_instruction]
+
+An instruction with Sensor, and Motions and Actions, or a list of nested instructions.
+
+### Attributes
+
+#### - Name (Stable)
+
+- Optional name for descriptor
+- **Type**: `String`, **Optional** (Default: null)
+
+#### * Tag (Experimental)
+
+- Internal identifier tag for debugging
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * Enabled (Stable)
+
+- Whether this instruction should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor for testing if instruction can be applied. If not supplied, will always match
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Sensor
+
+#### * BodyMotion (Stable)
+
+- Body motion to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: BodyMotion
+
+#### * HeadMotion (Stable)
+
+- Head motion to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: HeadMotion
+
+#### * Actions (Stable)
+
+- Actions to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ActionList
+
+#### * ActionsBlocking (Stable)
+
+- Do not execute an action unless the previous action could execute
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ActionsAtomic (Stable)
+
+- Only execute actions if all actions can be executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Instructions (Stable)
+
+- Optional nested list of instructions
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Instruction
+
+#### * Continue (WorkInProgress)
+
+- Continue after this instruction was executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Weight (Stable)
+
+- Weighted chance of picking this instruction in a random instruction
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TreeMode (Stable)
+
+- Whether this instruction and its contents should be treated like a traditional behaviour tree, i.e. will continue if all child instructions fail
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * InvertTreeModeResult (Stable)
+
+- Whether or not to invert the result of TreeMode evaluation when passing up to parent TreeMode instructions
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Constraints
+
+- At most one or none of BodyMotion, Instructions must be provided
+- At most one or none of HeadMotion, Instructions must be provided
+- At most one or none of Actions, Instructions must be provided
+- If TreeMode is true, Continue must be false
+
+[(Top)](#top)
+
+## Inventory: IEntityFilter (Stable) [#ientityfilter_inventory]
+
+Test various conditions relating to entity inventory. This includes whether it contains a specific item, item count, and free slots
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Items (Stable)
+
+- A list of glob item patterns to match
+- **Type**: `AssetArray`, **Optional** (Default: [\*]), **Computable**, **Element Type**: Item
+
+#### * CountRange (Stable)
+
+- The range of number of items that need to match the patterns
+- **Type**: `Array`, **Optional** (Default: [1, 2147483647]), **Computable**, **Element Type**: integer
+- **Constraint**: Values must be greater or equal than 0, less or equal than 2147483647and in weakly ascending order
+
+#### * FreeSlotRange (Stable)
+
+- The range designating the number of required free slots. Setting min and max to zero would check if full
+- **Type**: `Array`, **Optional** (Default: [0, 2147483647]), **Computable**, **Element Type**: integer
+- **Constraint**: Values must be greater or equal than 0, less or equal than 2147483647and in weakly ascending order
+
+[(Top)](#top)
+
+## ItemInHand: IEntityFilter (Stable) [#ientityfilter_iteminhand]
+
+Check if entity is holding an item
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Items (Stable)
+
+- A list of glob item patterns to match
+- **Type**: `AssetArray`, **Required**, **Computable**, **Element Type**: Item
+
+#### * Hand (Stable)
+
+- Which hand to check
+- **Type**: `Flag`, **Optional** (Default: Both), **Computable**
+- **Flag Values**:
+  - `OffHand`: The off-hand
+  - `Main`: The main hand
+  - `Both`: Both hands
+
+[(Top)](#top)
+
+## Land: BodyMotion (Experimental) [#bodymotion_land]
+
+Try to land at the given position using a seek like motion
+
+### Attributes
+
+#### - RelativeSpeed (Stable)
+
+- Maximum relative speed the NPC should move
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * RelativeSpeedWaypoint (Stable)
+
+- Maximum relative speed the NPC should move close to waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * WaypointRadius (Stable)
+
+- Radius to slow down around waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0.1
+
+#### * UseBestPath (Stable)
+
+- Use best partial path if goal can't be reached
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ThrottleDelayRange (Stable)
+
+- Time to delay after no path finding solution found
+- **Type**: `Array`, **Optional** (Default: [3.0, 5.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * ThrottleIgnoreCount (Stable)
+
+- How often no valid path solution can be found before throttling delay is applied
+- **Type**: `Integer`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * BuildOptimisedPath (Stable)
+
+- Try to reduce number of nodes of generated path
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlendHeading (Stable)
+
+- Relative rotation angle into next waypoint when arriving at current waypoint
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * PathSmoothing (Stable)
+
+- Try to smooth followed path. Larger values smooth more.
+- **Type**: `Integer`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * RejectionWeight (Stable)
+
+- Weight of rejection vector pushing entity closer to original path
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * UseSteering (Stable)
+
+- Use simple/cheap steering if available
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * SkipSteering (Experimental)
+
+- Skip steering if target not reachable
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * UsePathfinder (Stable)
+
+- Use path finder
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MinPathLength (Experimental)
+
+- Minimum length of path required when not able to reach target (should be greater equal 2)
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DiagonalMoves (Stable)
+
+- Allow diagonal moves
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * StepsPerTick (Stable)
+
+- Steps per iteration
+- **Type**: `Integer`, **Optional** (Default: 50.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxPathLength (Stable)
+
+- Max path steps before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxOpenNodes (Stable)
+
+- Max open nodes before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxTotalNodes (Stable)
+
+- Max total node before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 900.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (Stable)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * WaitDistance (Experimental)
+
+- Minimum distance target needs to move before recomputing path when no path can be found
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * RecomputeDistance (Experimental)
+
+- Maximum distance target can move before path is recomputed or 0 to supress recomputation
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * ReprojectDistance (Experimental)
+
+- Maximum distance target can move before position is reprojected
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * AdjustRangeByHitboxSize (Stable)
+
+- Correct range by hitbox sizes of involved entities
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * RecomputeConeAngle (Experimental)
+
+- Recompute path when target leaves cone from initial position to target
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * Reachable (Experimental)
+
+- Target must be reachable so that hitboxes can overlap
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * HeightDifference (Experimental)
+
+- Height difference allowed to target
+- **Type**: `Array`, **Optional** (Default: [-1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -1.7976931348623157e+308, less or equal than 1.7976931348623157e+308and in strictly ascending order
+
+#### * SlowDownDistance (Stable)
+
+- Distance when to slow down when approaching
+- **Type**: `Double`, **Optional** (Default: 8.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance to stop at
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AbortDistance (Stable)
+
+- Distance to abort behaviour
+- **Type**: `Double`, **Optional** (Default: 96.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Falloff (Stable)
+
+- Deceleration when approaching target
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SwitchToSteeringDistance (Stable)
+
+- Distance below NPC can test if target is reachable and abort existing path
+- **Type**: `Double`, **Optional** (Default: 20.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * GoalLenience (Experimental)
+
+- The distance from the target landing point that is acceptable to land at
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+- SlowDownDistance must be greater or equal than StopDistance
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## Leave: BodyMotion (Experimental) [#bodymotion_leave]
+
+Get away from current position using path finding
+
+### Attributes
+
+#### - RelativeSpeed (Stable)
+
+- Maximum relative speed the NPC should move
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * RelativeSpeedWaypoint (Stable)
+
+- Maximum relative speed the NPC should move close to waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * WaypointRadius (Stable)
+
+- Radius to slow down around waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0.1
+
+#### * UseBestPath (Stable)
+
+- Use best partial path if goal can't be reached
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ThrottleDelayRange (Stable)
+
+- Time to delay after no path finding solution found
+- **Type**: `Array`, **Optional** (Default: [3.0, 5.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * ThrottleIgnoreCount (Stable)
+
+- How often no valid path solution can be found before throttling delay is applied
+- **Type**: `Integer`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * BuildOptimisedPath (Stable)
+
+- Try to reduce number of nodes of generated path
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlendHeading (Stable)
+
+- Relative rotation angle into next waypoint when arriving at current waypoint
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * PathSmoothing (Stable)
+
+- Try to smooth followed path. Larger values smooth more.
+- **Type**: `Integer`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * RejectionWeight (Stable)
+
+- Weight of rejection vector pushing entity closer to original path
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinPathLength (Experimental)
+
+- Minimum length of path required when not able to reach target (should be greater equal 2)
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DiagonalMoves (Stable)
+
+- Allow diagonal moves
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * StepsPerTick (Stable)
+
+- Steps per iteration
+- **Type**: `Integer`, **Optional** (Default: 50.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxPathLength (Stable)
+
+- Max path steps before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxOpenNodes (Stable)
+
+- Max open nodes before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxTotalNodes (Stable)
+
+- Max total node before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 900.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (Stable)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * Distance (Experimental)
+
+- Minimum distance required
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+[(Top)](#top)
+
+## LineOfSight: IEntityFilter (Stable) [#ientityfilter_lineofsight]
+
+Matches if there is line of sight to the target
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## MaintainDistance: BodyMotion (Stable) [#bodymotion_maintaindistance]
+
+Maintain distance from a given position
+
+### Attributes
+
+#### - DesiredDistanceRange (Stable)
+
+- The desired distance to remain at.
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -1.7976931348623157e+308, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * TargetDistanceFactor (Stable)
+
+- A factor used to decide what distance to move to within the target range when the target falls outside of it. 0 will result in moving the shortest distance to fall within the range, 1 the furthest distance, and 0.5 roughly the middle of the range.
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * MoveThreshold (Stable)
+
+- An extra threshold distance on either side of the desired range before the NPC will trigger movement.
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * RelativeForwardsSpeed (Stable)
+
+- Maximum relative speed for the NPC moving forwards
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * RelativeBackwardsSpeed (Stable)
+
+- Maximum relative speed for the NPC moving backwards
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * MoveTowardsSlowdownThreshold (Stable)
+
+- The distance away from the target stopping point at which the NPC will start to slow down while moving towards the target
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * StrafingDurationRange (Stable)
+
+- How long to strafe for (moving left or right around the target). If set to [ 0, 0 ], will not move horizontally at all.
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * StrafingFrequencyRange (Stable)
+
+- How frequently to execute strafing
+- **Type**: `Array`, **Optional** (Default: [2.0, 2.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## MatchLook: BodyMotion (Stable) [#bodymotion_matchlook]
+
+Make NPC body rotate to match look direction
+
+### Constraints
+
+[(Top)](#top)
+
+## MovementState: IEntityFilter (Stable) [#ientityfilter_movementstate]
+
+Check if the entity is in the given movement state
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * State (Stable)
+
+- The movement state to check
+- **Type**: `Flag`, **Required**
+- **Flag Values**:
+  - `WALKING`: Walking
+  - `FLYING`: Flying
+  - `RUNNING`: Running
+  - `FALLING`: Falling
+  - `IDLE`: Idle
+  - `SPRINTING`: Sprinting
+  - `CROUCHING`: Crouching
+  - `CLIMBING`: Climbing
+  - `ANY`: Any
+  - `JUMPING`: Jumping
+
+[(Top)](#top)
+
+## NPCGroup: IEntityFilter (Stable) [#ientityfilter_npcgroup]
+
+Returns whether the entity matches one of the provided NPCGroups
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * IncludeGroups (Stable)
+
+- A set of NPCGroups to include in the match
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: TagSet
+
+#### * ExcludeGroups (Stable)
+
+- A set of NPCGroups to exclude from the match
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: TagSet
+
+### Constraints
+
+- One (and only one) of IncludeGroups, ExcludeGroups must be provided
+
+[(Top)](#top)
+
+## Not: IEntityFilter (WorkInProgress) [#ientityfilter_not]
+
+Invert filter test
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Filter (Stable)
+
+- Filter to test
+- **Type**: `ObjectRef`, **Required**, **Object Type**: IEntityFilter
+
+[(Top)](#top)
+
+## Nothing: BodyMotion (Stable) [#bodymotion_nothing]
+
+Do nothing
+
+### Constraints
+
+[(Top)](#top)
+
+## Nothing: HeadMotion (Stable) [#headmotion_nothing]
+
+Do nothing
+
+### Constraints
+
+[(Top)](#top)
+
+## Observe: HeadMotion (Stable) [#headmotion_observe]
+
+Observe surroundings in various ways. This includes looking in random directions within an angle, or sweeping the head left and right, etc. Angles are relative to body angle at any given time.
+
+### Attributes
+
+#### - AngleRange (Stable)
+
+- The angle range to observe in degrees, offset from facing forwards
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -180, less or equal than 180and in weakly ascending order
+
+#### * PauseTimeRange (Stable)
+
+- How long to continue looking in a given direction
+- **Type**: `Array`, **Optional** (Default: [2.0, 2.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * PickRandomAngle (Stable)
+
+- Whether to pick random angles within the range. If false, will instead sweep across the range, pausing at either end.
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * ViewSegments (Stable)
+
+- The number of distinct segments to stop at when sweeping from left to right
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * RelativeTurnSpeed (Stable)
+
+- The relative turn speed modifier
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+### Constraints
+
+[(Top)](#top)
+
+## Or: IEntityFilter (Stable) [#ientityfilter_or]
+
+Logical OR of a list of filters
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Filters (Stable)
+
+- List of filters
+- **Type**: `Array`, **Required**, **Element Type**: IEntityFilter
+- **Constraint**: Array must not be empty
+
+[(Top)](#top)
+
+## Path: Path (Stable) [#path_path]
+
+List of transient path points
+
+### Attributes
+
+#### - Waypoints (Stable)
+
+- List of transient path points
+- **Type**: `Array`, **Required**, **Element Type**: RelativeWaypointDefinition
+
+#### * Scale (Stable)
+
+- Overall path scale
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+[(Top)](#top)
+
+## Path: BodyMotion (Stable) [#bodymotion_path]
+
+Walk along a path.
+
+### Attributes
+
+#### - StartAtNearestNode (Stable)
+
+- Start at closest warp point
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * PathWidth (Experimental)
+
+- Walking corridor width
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * NodeWidth (Experimental)
+
+- Radius of warp point node
+- **Type**: `Double`, **Optional** (Default: 0.2)
+- **Constraint**: Value must be greater than 0
+
+#### * MinRelSpeed (Stable)
+
+- Minimum relative walk speed
+- **Type**: `Double`, **Optional** (Default: 0.5)
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * MaxRelSpeed (Stable)
+
+- Maximum relative walk speed
+- **Type**: `Double`, **Optional** (Default: 0.5)
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * MinWalkDistance (Experimental)
+
+- Minimum walk distance when PathWidth greater 0
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxWalkDistance (Experimental)
+
+- Maximum walk distance when PathWidth greater 0
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * Direction (Stable)
+
+- Walking direction relative to order of nodes
+- **Type**: `Flag`, **Optional** (Default: FORWARD)
+- **Flag Values**:
+  - `BACKWARD`: Start visiting nodes in reverse order
+  - `RANDOM`: Can change direction between nodes and randomly pick target node in Points shape mode
+  - `FORWARD`: Start visiting nodes in order
+  - `ANY`: Pick any start direction
+
+#### * Shape (Stable)
+
+- Shape of Path
+- **Type**: `Flag`, **Optional** (Default: LOOP), **Computable**
+- **Flag Values**:
+  - `CHAIN`: Nodes form an open path of line segments and will chain together with the next nearest path upon reaching the final node
+  - `LINE`: Nodes form an open path of line segments
+  - `LOOP`: Nodes form a closed loop of line segments (last node leads to first node)
+  - `POINTS`: Any path between nodes is possible
+
+#### * MinNodeDelay (Stable)
+
+- Minimum resting time at a node
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxNodeDelay (Stable)
+
+- Maximum resting time at a node
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * UseNodeViewDirection (Stable)
+
+- Look into next node direction at node
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * NodePauseScaleRange (Stable)
+
+- The range from which to pick a value that defines the portion of the total node pause time that should be spent facing a direction before turning
+- **Type**: `Array`, **Optional** (Default: [0.2, 0.4]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * NodePauseExtraPercentRange (Stable)
+
+- A range from which to pick the additional percentage of the directional pause time to add to it
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.2]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1and in weakly ascending order
+
+#### * PickRandomAngle (Stable)
+
+- Whether to sweep left and right using the observation angle, or pick a random angle within the sector each time
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ViewSegments (Stable)
+
+- The number of distinct segments to stop at when sweeping from left to right using the observation angle
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+- MinRelativeSpeed must be less or equal than MaxRelativeSpeed
+- MinWalkDistance must be less or equal than MaxWalkDistance
+- MinNodeDelay must be less or equal than MaxNodeDelay
+- Must be attached to a sensor that provides one of path
+
+[(Top)](#top)
+
+## Random: Instruction (Stable) [#instruction_random]
+
+Randomised list of weighted instructions. One will be selected at random and executed until the NPC state changes.
+
+### Attributes
+
+#### - Name (Stable)
+
+- Optional name for descriptor
+- **Type**: `String`, **Optional** (Default: null)
+
+#### * Tag (Experimental)
+
+- Internal identifier tag for debugging
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * Enabled (Stable)
+
+- Whether this instruction should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor for testing if instruction can be applied. If not supplied, will always match
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Sensor
+
+#### * Instructions (Stable)
+
+- List of weighted instructions to select from
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Instruction
+
+#### * Continue (WorkInProgress)
+
+- Continue after this instruction was executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Weight (Stable)
+
+- Weighted chance of picking this instruction in a random instruction
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TreeMode (Stable)
+
+- Whether this instruction and its contents should be treated like a traditional behaviour tree, i.e. will continue if all child instructions fail
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * InvertTreeModeResult (Stable)
+
+- Whether or not to invert the result of TreeMode evaluation when passing up to parent TreeMode instructions
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * ResetOnStateChange (Stable)
+
+- Whether to reset when NPC state changes
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ExecuteFor (Stable)
+
+- How long to execute the chosen instruction before picking another
+- **Type**: `Array`, **Optional** (Default: [1.7976931348623157E308, 1.7976931348623157E308]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+### Constraints
+
+- If TreeMode is true, Continue must be false
+
+[(Top)](#top)
+
+## Reference: Instruction (Stable) [#instruction_reference]
+
+Prioritized instruction list that can be referenced from elsewhere in the file. Otherwise works like the default
+
+### Attributes
+
+#### - Parameters (Stable)
+
+- The parameter block for defining variables
+- **Type**: `Parameters`, **Optional** (Default: )
+
+#### * Name (Stable)
+
+- Name for referencing
+- **Type**: `String`, **Required**
+
+#### * Tag (Experimental)
+
+- Internal identifier tag for debugging
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * Enabled (Stable)
+
+- Whether this instruction should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor for testing if instruction can be applied. If not supplied, will always match
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Sensor
+
+#### * BodyMotion (Stable)
+
+- Body motion to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: BodyMotion
+
+#### * HeadMotion (Stable)
+
+- Head motion to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: HeadMotion
+
+#### * Actions (Stable)
+
+- Actions to be executed
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ActionList
+
+#### * ActionsBlocking (Stable)
+
+- Do not execute an action unless the previous action could execute
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ActionsAtomic (Stable)
+
+- Only execute actions if all actions can be executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Instructions (Stable)
+
+- Optional nested list of instructions
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: Instruction
+
+#### * Continue (WorkInProgress)
+
+- Continue after this instruction was executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Weight (Stable)
+
+- Weighted chance of picking this instruction in a random instruction
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TreeMode (Stable)
+
+- Whether this instruction and its contents should be treated like a traditional behaviour tree, i.e. will continue if all child instructions fail
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * InvertTreeModeResult (Stable)
+
+- Whether or not to invert the result of TreeMode evaluation when passing up to parent TreeMode instructions
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Constraints
+
+- At most one or none of BodyMotion, Instructions must be provided
+- At most one or none of HeadMotion, Instructions must be provided
+- At most one or none of Actions, Instructions must be provided
+- If TreeMode is true, Continue must be false
+
+[(Top)](#top)
+
+## RelativeWaypointDefinition: RelativeWaypointDefinition (Stable) [#relativewaypointdefinition_relativewaypointdefinition]
+
+A simple path waypoint definition where each waypoint is relative to the previous
+
+### Attributes
+
+#### - Rotation (Stable)
+
+- Rotation to turn from previous waypoint
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater than -360 and less than 360
+
+#### * Distance (Stable)
+
+- A distance to move from the previous waypoint
+- **Type**: `Double`, **Required**
+- **Constraint**: Value must be greater than 0
+
+[(Top)](#top)
+
+## Seek: BodyMotion (Experimental) [#bodymotion_seek]
+
+Move towards a target using path finding or steering
+
+### Attributes
+
+#### - RelativeSpeed (Stable)
+
+- Maximum relative speed the NPC should move
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * RelativeSpeedWaypoint (Stable)
+
+- Maximum relative speed the NPC should move close to waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1
+
+#### * WaypointRadius (Stable)
+
+- Radius to slow down around waypoints
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0.1
+
+#### * UseBestPath (Stable)
+
+- Use best partial path if goal can't be reached
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ThrottleDelayRange (Stable)
+
+- Time to delay after no path finding solution found
+- **Type**: `Array`, **Optional** (Default: [3.0, 5.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * ThrottleIgnoreCount (Stable)
+
+- How often no valid path solution can be found before throttling delay is applied
+- **Type**: `Integer`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * BuildOptimisedPath (Stable)
+
+- Try to reduce number of nodes of generated path
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlendHeading (Stable)
+
+- Relative rotation angle into next waypoint when arriving at current waypoint
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 1
+
+#### * PathSmoothing (Stable)
+
+- Try to smooth followed path. Larger values smooth more.
+- **Type**: `Integer`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * RejectionWeight (Stable)
+
+- Weight of rejection vector pushing entity closer to original path
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * UseSteering (Stable)
+
+- Use simple/cheap steering if available
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * SkipSteering (Experimental)
+
+- Skip steering if target not reachable
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * UsePathfinder (Stable)
+
+- Use path finder
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MinPathLength (Experimental)
+
+- Minimum length of path required when not able to reach target (should be greater equal 2)
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * DiagonalMoves (Stable)
+
+- Allow diagonal moves
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * StepsPerTick (Stable)
+
+- Steps per iteration
+- **Type**: `Integer`, **Optional** (Default: 50.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxPathLength (Stable)
+
+- Max path steps before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxOpenNodes (Stable)
+
+- Max open nodes before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 200.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MaxTotalNodes (Stable)
+
+- Max total node before aborting path finding
+- **Type**: `Integer`, **Optional** (Default: 900.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Debug (Stable)
+
+- Debugging flags
+- **Type**: `String`, **Optional** (Default: )
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * WaitDistance (Experimental)
+
+- Minimum distance target needs to move before recomputing path when no path can be found
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * RecomputeDistance (Experimental)
+
+- Maximum distance target can move before path is recomputed or 0 to supress recomputation
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * ReprojectDistance (Experimental)
+
+- Maximum distance target can move before position is reprojected
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * AdjustRangeByHitboxSize (Stable)
+
+- Correct range by hitbox sizes of involved entities
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * RecomputeConeAngle (Experimental)
+
+- Recompute path when target leaves cone from initial position to target
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * Reachable (Experimental)
+
+- Target must be reachable so that hitboxes can overlap
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * HeightDifference (Experimental)
+
+- Height difference allowed to target
+- **Type**: `Array`, **Optional** (Default: [-1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -1.7976931348623157e+308, less or equal than 1.7976931348623157e+308and in strictly ascending order
+
+#### * SlowDownDistance (Stable)
+
+- Distance when to slow down when approaching
+- **Type**: `Double`, **Optional** (Default: 8.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance to stop at
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AbortDistance (Stable)
+
+- Distance to abort behaviour
+- **Type**: `Double`, **Optional** (Default: 96.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Falloff (Stable)
+
+- Deceleration when approaching target
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SwitchToSteeringDistance (Stable)
+
+- Distance below NPC can test if target is reachable and abort existing path
+- **Type**: `Double`, **Optional** (Default: 20.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+- SlowDownDistance must be greater or equal than StopDistance
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## Sequence: BodyMotion (Stable) [#bodymotion_sequence]
+
+Sequence of motions. Can be used in conjunction with 'Timer' to model more complex motions.
+
+### Attributes
+
+#### - Looped (Stable)
+
+- When true restart after last motion is finished
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * RestartOnActivate (Experimental)
+
+- Restart from first motion when NPC is activated.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Motions (Stable)
+
+- Array of motions
+- **Type**: `Array`, **Required**, **Element Type**: BodyMotion
+- **Constraint**: Array must not be empty
+
+### Constraints
+
+[(Top)](#top)
+
+## Sequence: HeadMotion (Stable) [#headmotion_sequence]
+
+Sequence of motions. Can be used in conjunction with 'Timer' to model more complex motions.
+
+### Attributes
+
+#### - Looped (Stable)
+
+- When true restart after last motion is finished
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * RestartOnActivate (Experimental)
+
+- Restart from first motion when NPC is activated.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Motions (Stable)
+
+- Array of motions
+- **Type**: `Array`, **Required**, **Element Type**: HeadMotion
+- **Constraint**: Array must not be empty
+
+### Constraints
+
+[(Top)](#top)
+
+## SpotsMe: IEntityFilter (Stable) [#ientityfilter_spotsme]
+
+Checks if the entity can view the NPC in a given view sector or cone and without obstruction.
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ViewAngle (Stable)
+
+- Angle used for view sector and view cone test
+- **Type**: `Double`, **Optional** (Default: 90.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * ViewTest (Stable)
+
+- Check if the entity is in the view cone, view sector, or neither
+- **Type**: `Flag`, **Optional** (Default: VIEW_SECTOR)
+- **Flag Values**:
+  - `VIEW_SECTOR`: View_Sector
+  - `NONE`: None
+  - `VIEW_CONE`: View_Cone
+
+#### * TestLineOfSight (Stable)
+
+- Check if view to the npc is not obstructed
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+### Constraints
+
+[(Top)](#top)
+
+## StandingOnBlock: IEntityFilter (Stable) [#ientityfilter_standingonblock]
+
+Matches the block directly beneath the entity against a BlockSet
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * BlockSet (Stable)
+
+- The BlockSet to match against
+- **Type**: `Asset`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## Stat: IEntityFilter (Stable) [#ientityfilter_stat]
+
+Match stat values of the entity
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Stat (Stable)
+
+- The stat value to check
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * StatTarget (Stable)
+
+- The stat target
+- **Type**: `Flag`, **Required**, **Computable**
+- **Flag Values**:
+  - `Min`: Min value
+  - `Max`: Max value
+  - `Value`: Current value
+
+#### * RelativeTo (Stable)
+
+- The stat value to check against
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * RelativeToTarget (Stable)
+
+- The stat target
+- **Type**: `Flag`, **Required**, **Computable**
+- **Flag Values**:
+  - `Min`: Min value
+  - `Max`: Max value
+  - `Value`: Current value
+
+#### * ValueRange (Stable)
+
+- The fractional range within which to trigger, with 1 being equal
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+[(Top)](#top)
+
+## StateTransition: StateTransition (Stable) [#statetransition_statetransition]
+
+An entry containing a list of actions to execute when moving from one state to another
+
+### Attributes
+
+#### - States (Stable)
+
+- List of state transitions
+- **Type**: `Array`, **Required**, **Element Type**: StateTransitionEdges
+
+#### * Actions (Stable)
+
+- List of actions
+- **Type**: `ObjectRef`, **Required**, **Object Type**: ActionList
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## StateTransitionController: StateTransitionController (Stable) [#statetransitioncontroller_statetransitioncontroller]
+
+A list of state transitions
+
+- A list of state transition entries with lists of actions
+- **Type**: `Array`, **Required**, **Element Type**: StateTransition
+
+[(Top)](#top)
+
+## StateTransitionEdges: StateTransitionEdges (Stable) [#statetransitionedges_statetransitionedges]
+
+Sets of from and to states defining state transitions
+
+### Attributes
+
+#### - Priority (Stable)
+
+- Priority for the actions in this transition
+- **Type**: `Integer`, **Optional** (Default: 0)
+- **Constraint**: Value must be greater or equal than 0
+
+#### * From (Stable)
+
+- A set of from states
+- **Type**: `StringList`, **Required**
+- **Constraint**: Strings in array must not be empty
+
+#### * To (Stable)
+
+- A set of to states
+- **Type**: `StringList`, **Required**
+- **Constraint**: Strings in array must not be empty
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## TakeOff: BodyMotion (Experimental) [#bodymotion_takeoff]
+
+Switch NPC from walking to flying motion controller
+
+### Attributes
+
+#### - JumpSpeed (Experimental)
+
+- Speed to jump off
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0
+
+### Constraints
+
+[(Top)](#top)
+
+## Teleport: BodyMotion (Experimental) [#bodymotion_teleport]
+
+Teleport NPC to a position given by a sensor or to a random position nearby with an optional minimum offset up to a maximum offset
+
+### Attributes
+
+#### - OffsetRange (Experimental)
+
+- The minimum and maximum offset the NPC can be spawned from the target position
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * MaxYOffset (Experimental)
+
+- Maximum vertical offset from the target position in case of terrain obstacles
+- **Type**: `Double`, **Optional** (Default: 5.0)
+- **Constraint**: Value must be greater than 0
+
+#### * OffsetSector (Experimental)
+
+- The sector around the target in which to teleport to. The origin point is directly between the target and the NPC teleporting
+- **Type**: `Double`, **Optional** (Default: 0.0)
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * Orientation (Experimental)
+
+- The direction to face after teleporting
+- **Type**: `Flag`, **Optional** (Default: Unchanged)
+- **Flag Values**:
+  - `UseTarget`: Use the target's orientation
+  - `TowardsTarget`: Face towards the target
+  - `Unchanged`: Do not change orientation
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+- If Orientation is UseTarget, must be attached to a sensor that provides one of player target, NPC target, dropped item target
+
+[(Top)](#top)
+
+## TestProbe: BodyMotion (Experimental) [#bodymotion_testprobe]
+
+Debugging - Test probing
+
+### Attributes
+
+#### - AdjustX (Experimental)
+
+- X block position adjustment
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * AdjustZ (Experimental)
+
+- Y block position adjustment
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * AdjustDistance (Experimental)
+
+- Set probe direction length for debugging
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * SnapAngle (Experimental)
+
+- Snap angle to multiples of value for debugging
+- **Type**: `Double`, **Optional** (Default: -1.0)
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+[(Top)](#top)
+
+## Timer: BodyMotion (Stable) [#bodymotion_timer]
+
+Execute a Motion for a specific maximum time. If the motion finishes earlier the Timer also finishes.
+
+### Attributes
+
+#### - Time (Stable)
+
+- Range of time from which the random timer length can be chosen
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Motion (Stable)
+
+- Motion to execute
+- **Type**: `ObjectRef`, **Required**, **Object Type**: BodyMotion
+
+### Constraints
+
+[(Top)](#top)
+
+## Timer: HeadMotion (Stable) [#headmotion_timer]
+
+Execute a Motion for a specific maximum time. If the motion finishes earlier the Timer also finishes.
+
+### Attributes
+
+#### - Time (Stable)
+
+- Range of time from which the random timer length can be chosen
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Motion (Stable)
+
+- Motion to execute
+- **Type**: `ObjectRef`, **Required**, **Object Type**: HeadMotion
+
+### Constraints
+
+[(Top)](#top)
+
+## ValueToParameterMapping: ValueToParameterMapping (Stable) [#valuetoparametermapping_valuetoparametermapping]
+
+An entry containing a list of actions to execute when moving from one state to another
+
+### Attributes
+
+#### - ValueType (Stable)
+
+- The type of the value being mapped
+- **Type**: `Flag`, **Required**
+- **Flag Values**:
+  - `String`: String value
+  - `Double`: Double value
+  - `Int`: Integer value
+
+#### * FromValue (Stable)
+
+- The value to read from the value store
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+#### * ToParameter (Stable)
+
+- The parameter name to override
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## ViewSector: IEntityFilter (Stable) [#ientityfilter_viewsector]
+
+Matches entities within the given view sector
+
+### Attributes
+
+#### - Enabled (Stable)
+
+- Whether this entity filter should be enabled
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ViewSector (Stable)
+
+- View sector to test entities in
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+### Constraints
+
+[(Top)](#top)
+
+## Wander: BodyMotion (Stable) [#bodymotion_wander]
+
+Random movement in short linear pieces.
+
+### Attributes
+
+#### - MinWalkTime (Stable)
+
+- Minimum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxWalkTime (Stable)
+
+- Maximum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 4.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinHeadingChange (Stable)
+
+- Approximate minimum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * MaxHeadingChange (Stable)
+
+- Approximate maximum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 90.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * RelaxHeadingChange (Stable)
+
+- Allow other directions when preferred directions blocked
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelativeSpeed (Stable)
+
+- Relative wander speed
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * MinMoveDistance (Stable)
+
+- Minimum distance to move in a segment
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance to stop at target
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TestsPerTick (Stable)
+
+- Direction tests per tick
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+### Constraints
+
+- MinWalkTime must be less or equal than MaxWalkTime
+- MinHeadingChange must be less or equal than MaxHeadingChange
+
+[(Top)](#top)
+
+## WanderInCircle: BodyMotion (Stable) [#bodymotion_wanderincircle]
+
+Random movement in short linear pieces inside circle around spawn position.
+
+### Attributes
+
+#### - MinWalkTime (Stable)
+
+- Minimum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxWalkTime (Stable)
+
+- Maximum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 4.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinHeadingChange (Stable)
+
+- Approximate minimum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * MaxHeadingChange (Stable)
+
+- Approximate maximum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 90.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * RelaxHeadingChange (Stable)
+
+- Allow other directions when preferred directions blocked
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelativeSpeed (Stable)
+
+- Relative wander speed
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * MinMoveDistance (Stable)
+
+- Minimum distance to move in a segment
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance to stop at target
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TestsPerTick (Stable)
+
+- Direction tests per tick
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * Radius (Stable)
+
+- Radius of circle to wander in
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Flock (Experimental)
+
+- Do not use
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * UseSphere (Stable)
+
+- Use a sphere instead of circle cylinder
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+- MinWalkTime must be less or equal than MaxWalkTime
+- MinHeadingChange must be less or equal than MaxHeadingChange
+
+[(Top)](#top)
+
+## WanderInRect: BodyMotion (Stable) [#bodymotion_wanderinrect]
+
+Random movement in short linear pieces inside rectangle around spawn position.
+
+### Attributes
+
+#### - MinWalkTime (Stable)
+
+- Minimum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 2.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxWalkTime (Stable)
+
+- Maximum time to wander for a segment.
+- **Type**: `Double`, **Optional** (Default: 4.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * MinHeadingChange (Stable)
+
+- Approximate minimum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * MaxHeadingChange (Stable)
+
+- Approximate maximum heading change between segments
+- **Type**: `Double`, **Optional** (Default: 90.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 180
+
+#### * RelaxHeadingChange (Stable)
+
+- Allow other directions when preferred directions blocked
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelativeSpeed (Stable)
+
+- Relative wander speed
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+#### * MinMoveDistance (Stable)
+
+- Minimum distance to move in a segment
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StopDistance (Stable)
+
+- Distance to stop at target
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TestsPerTick (Stable)
+
+- Direction tests per tick
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AvoidBlockDamage (Stable)
+
+- Should avoid environmental damage from blocks
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * RelaxedMoveConstraints (Stable)
+
+- NPC can do movements like wading (depends on motion controller type)
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * DesiredAltitudeWeight (Stable)
+
+- How much this NPC prefers being within the desired height range. 0 means it doesn't care much, 1 means it will do its best to get there fast. Values below 0 mean the default in the motion controller will be used.
+- **Type**: `Double`, **Optional** (Default: -1.0), **Computable**
+- **Constraint**: Value must be greater or equal than -1 and less or equal than 1
+
+#### * Width (Stable)
+
+- Rectangle width
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+#### * Depth (Stable)
+
+- Rectangle depth
+- **Type**: `Double`, **Optional** (Default: 10.0)
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+- MinWalkTime must be less or equal than MaxWalkTime
+- MinHeadingChange must be less or equal than MaxHeadingChange
+
+[(Top)](#top)
+
+## Watch: HeadMotion (Stable) [#headmotion_watch]
+
+Rotate to target.
+
+### Attributes
+
+#### - RelativeTurnSpeed (Stable)
+
+- The relative turn speed modifier
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 2
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+## WeightedAction: WeightedAction (Stable) [#weightedaction_weightedaction]
+
+A wrapped and weighted action intended to be used for Random action lists.
+
+### Attributes
+
+#### - Action (Stable)
+
+- The action to run
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Action
+
+#### * Weight (Stable)
+
+- The weight representing how likely this action is to run
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+[(Top)](#top)
+
+# List of Core Components (audiovisual)
+
+## Animation: Sensor (Stable) [#sensor_animation]
+
+Check if a given animation is being played
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Slot (Stable)
+
+- The animation slot to check
+- **Type**: `Flag`, **Required**, **Computable**
+- **Flag Values**:
+  - `Status`: Status
+  - `Action`: Action
+  - `Face`: Face
+
+#### * Animation (Stable)
+
+- The animation ID to check for
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Appearance: Action (Stable) [#action_appearance]
+
+Change model of NPC to given appearance.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Appearance (Stable)
+
+- Model name to use
+- **Type**: `Asset`, **Required**
+
+[(Top)](#top)
+
+## DisplayName: Action (Stable) [#action_displayname]
+
+Set the name displayed above NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * DisplayName (Stable)
+
+- Name to display above NPC
+- **Type**: `String`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## ModelAttachment: Action (Stable) [#action_modelattachment]
+
+Set an attachment on the current NPC model
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Slot (Stable)
+
+- The attachment slot to set
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Attachment (Stable)
+
+- The attachment to set, or empty to remove
+- **Type**: `String`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## PlayAnimation: Action (Experimental) [#action_playanimation]
+
+Play an animation
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Slot (Stable)
+
+- The animation slot to play on
+- **Type**: `Flag`, **Required**
+- **Flag Values**:
+  - `Status`: Status
+  - `Action`: Action
+  - `Face`: Face
+
+#### * Animation (Stable)
+
+- The animation ID to play
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+
+[(Top)](#top)
+
+## PlaySound: Action (Stable) [#action_playsound]
+
+Plays a sound to players within a specified range.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * SoundEventId (Stable)
+
+- The sound event to play
+- **Type**: `Asset`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## SpawnParticles: Action (WorkInProgress) [#action_spawnparticles]
+
+Spawn particle system visible within a given range with an offset relative to npc heading
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ParticleSystem (Stable)
+
+- Particle system to spawn
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * Range (Stable)
+
+- Maximum visibility range
+- **Type**: `Double`, **Optional** (Default: 75.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Offset (Stable)
+
+- Offset relative to footpoint in view direction of NPC
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: Double
+
+[(Top)](#top)
+
+# List of Core Components (combat)
+
+## ApplyEntityEffect: Action (Stable) [#action_applyentityeffect]
+
+Applies an entity effect to the target or self
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * EntityEffect (Stable)
+
+- The entity effect to apply
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * UseTarget (Stable)
+
+- Use the sensor-provided target for the action, self otherwise
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+- If UseTarget is true, must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## Attack: Action (Experimental) [#action_attack]
+
+Let NPC start an attack. When an attack is running no new attack is started.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Attack (Experimental)
+
+- Attack pattern to use. If omitted, will cancel current attack
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * AttackType (Stable)
+
+- The interaction type to use
+- **Type**: `Flag`, **Optional** (Default: Primary), **Computable**
+- **Flag Values**:
+  - `Secondary`: Secondary attack
+  - `Ability3`: Ability 3
+  - `Primary`: Primary attack
+  - `Ability2`: Ability 2
+  - `Ability1`: Ability 1
+
+#### * ChargeFor (Stable)
+
+- How long to charge for. 0 indicates no charging. Also doubles as how long to block for
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * AttackPauseRange (Stable)
+
+- Range of minimum pause between attacks
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * AimingTimeRange (Stable)
+
+- A range from which to pick a random value denoting the max time the NPC will wait for aiming before launching the attack.
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * LineOfSight (Experimental)
+
+- Check Line of Sight before firing
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * AvoidFriendlyFire (Experimental)
+
+- Tries to avoid friendly fire if true
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * BallisticMode (WorkInProgress)
+
+- Trajectory to use
+- **Type**: `Flag`, **Optional** (Default: Short)
+- **Flag Values**:
+  - `Random`: Random long or short
+  - `Long`: Longer flight curve
+  - `Short`: Shorter flight curve
+  - `Alternate`: Alternate between long and short
+
+#### * MeleeConeAngle (WorkInProgress)
+
+- Cone angle considered for on target for melee
+- **Type**: `Double`, **Optional** (Default: 30.0)
+- **Constraint**: Value must be greater than 0 and less or equal than 360
+
+#### * DamageFriendlies (Stable)
+
+- Whether this attack should bypass ignored damage groups and deal damage to the target
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * SkipAiming (Stable)
+
+- Whether aiming should be skipped an the attack just executed immediately.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ChargeDistance (Stable)
+
+- If this is a charge attack, the distance required for the charge
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * InteractionVars (Stable)
+
+- Set of interaction vars for modifying the interaction
+- **Type**: `CodecObject`, **Optional** (Default: null)
+
+### Constraints
+
+- If SkipAiming is true, LineOfSight, AvoidFriendlyFire must be false
+
+[(Top)](#top)
+
+## Damage: Sensor (Stable) [#sensor_damage]
+
+Test if NPC suffered damage. A position is only returned when NPC suffered combat damage.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Combat (Stable)
+
+- Test for combat damage
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * Friendly (Stable)
+
+- Test for damage from usually disabled damage groups
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Drowning (Stable)
+
+- Test for damage from drowning
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Environment (Stable)
+
+- Test for damage from environment
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Other (Stable)
+
+- Test for other damage
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The slot to use for locking on the target if damage is taken. If omitted, target will not be locked
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+### Constraints
+
+- At least one of Combat, Drowning, Environment, Other must be true
+- If TargetSlot is true, Drowning, Environment, Other must be false
+
+### Provides
+
+- Player target
+- NPC target
+- Dropped item target
+
+[(Top)](#top)
+
+## IsBackingAway: Sensor (Stable) [#sensor_isbackingaway]
+
+Test if the NPC is currently backing away from something.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+# List of Core Components (corecomponents)
+
+## AddToHostileTargetMemory: Action (Stable) [#action_addtohostiletargetmemory]
+
+Adds the passed target from the sensor to the hostile target memory
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## CombatAbility: Action (Stable) [#action_combatability]
+
+Starts the combat ability selected by the combat action evaluator.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## CombatActionEvaluator: Sensor (Experimental) [#sensor_combatactionevaluator]
+
+A sensor which handles funnelling information to actions and motions from the combat action evaluator. Delivers the current attack target and desired range for supported direct child motions.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * TargetInRange (Stable)
+
+- Whether to match on target being in or out of range.
+- **Type**: `Boolean`, **Required**, **Computable**
+
+#### * AllowableDeviation (Stable)
+
+- The allowable deviation from the desired attack range
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## FlockBeacon: Action (Experimental) [#action_flockbeacon]
+
+Let the NPC send out a message to the flock members
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Message (Stable)
+
+- Message to send to targets
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * SendTargetSlot (Stable)
+
+- The marked target slot to send. If omitted, sends own position
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * ExpirationTime (Stable)
+
+- The number of seconds that the message should last and be acknowledged by the receiving NPC. -1 represents infinite time.
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0 or equal -1
+
+#### * SendToSelf (Stable)
+
+- Send the message to self
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * SendToLeaderOnly (Stable)
+
+- Only send the message to the leader of the flock
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## FlockCombatDamage: Sensor (Stable) [#sensor_flockcombatdamage]
+
+Return true if flock with NPC received combat damage. Target position is entity which did most damage.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * LeaderOnly (Stable)
+
+- Only test for damage to flock leader
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## FlockLeader: Sensor (Stable) [#sensor_flockleader]
+
+Test for the presence and provide position of the flock leader
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## FlockState: Action (Stable) [#action_flockstate]
+
+Sets the state name for the flock the NPC is member of.The flock leader is explicitly excluded from this operation.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * State (Stable)
+
+- State name to set
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be a valid state string. A main state must be included before the period (e.g. Main.Test). State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+### Constraints
+
+[(Top)](#top)
+
+## FlockTarget: Action (Stable) [#action_flocktarget]
+
+Sets or clears the locked target for the flock the NPC is member of. If Clear flag is true, the locked target is cleared otherwise it is set to the the target.The flock leader is explicitly excluded from this operation.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Clear (Stable)
+
+- If true, clear locked target. If false, set to current target.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The target slot to use
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String must be not empty
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## HasHostileTargetMemory: Sensor (Stable) [#sensor_hashostiletargetmemory]
+
+Checks if there is currently a hostile target in the target memory.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## InflictedDamage: Sensor (Stable) [#sensor_inflicteddamage]
+
+Return true if an individual or the flock it belongs to inflicted combat damage. Target position is entity which received most damage.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Target (Stable)
+
+- Who to check has inflicted damage
+- **Type**: `Flag`, **Optional** (Default: Self)
+- **Flag Values**:
+  - `FlockLeader`: Check flock leader only
+  - `Self`: Check self
+  - `Flock`: Check flock
+
+#### * FriendlyFire (Stable)
+
+- Consider friendly fire too
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## JoinFlock: Action (Stable) [#action_joinflock]
+
+Tries to build/join flock with target. Fails if both NPC and target are in a flock. If either NPC or target are in a flock, the one not in flock tries to join existing flock.If NPC and target are both not in a flock, a new flock with NPC is created and target is tried to be joined.Joining the flock can be rejected if the joining entity does have the correct type or the flock is full. This can be overridden by setting the ForceJoin flag to true.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ForceJoin (Stable)
+
+- Disables checking flock join conditions test and forces joining flock.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## LeaveFlock: Action (Stable) [#action_leaveflock]
+
+NPC leaves flock currently in. Does nothing when not in flock.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## TriggerSpawnBeacon: Action (Stable) [#action_triggerspawnbeacon]
+
+Trigger the nearest spawn beacon matching the configuration id
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * BeaconSpawn (Stable)
+
+- The beacon spawn config ID
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * Range (Stable)
+
+- The distance to search for a beacon to trigger
+- **Type**: `Integer`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TargetSlot (Stable)
+
+- A slot to use as the target for the spawned NPC. If omitted the NPC itself will be used
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+[(Top)](#top)
+
+# List of Core Components (debug)
+
+## Log: Action (Stable) [#action_log]
+
+Log a message to console.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Message (Stable)
+
+- Text to print to console.
+- **Type**: `String`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## Test: Action (Experimental) [#action_test]
+
+Test action to exercise attribute evaluation (DO NOT USE)
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Boolean (Deprecated)
+
+- Boolean True
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Double (Deprecated)
+
+- Double 0
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+
+#### * Float (Deprecated)
+
+- Float 0
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+
+#### * Int (Deprecated)
+
+- Int 0
+- **Type**: `Integer`, **Optional** (Default: 0.0), **Computable**
+
+#### * String (Deprecated)
+
+- String Test
+- **Type**: `String`, **Optional** (Default: Test), **Computable**
+
+#### * Enum (Deprecated)
+
+- Enum RoleDebugFlags Collisions
+- **Type**: `Flag`, **Optional** (Default: Collisions), **Computable**
+- **Flag Values**:
+  - `Overlaps`: Log overlapping blocks when validating position
+  - `ProbeBlockCollisions`: Trace collisions down to block level when probing
+  - `SteeringRole`: Debug blended steering behaviour from role like avoidance/separation
+  - `DisplayInternalId`: Display the internal server ID for this entity
+  - `Pathfinder`: Display pathfinder status
+  - `DisplayStamina`: Display NPC Stamina as numerical values
+  - `FlockDamage`: Trace flock damage events
+  - `Collisions`: Trace collision information of motion controllers
+  - `DisplayFreeSlots`: Display free inventory slots
+  - `DisplayTime`: Set display name to day time
+  - `DisplayName`: Display the role name for this entity
+  - `DisplayLightLevel`: Display light levels
+  - `DisplayAnim`: Display animation state
+  - `TraceSensorFailures`: Trace failing sensors
+  - `DisplayHP`: Display NPC HP as numerical values
+  - `DisplayFlock`: Set display name to flock state
+  - `DisplaySpeed`: Display speed of entity
+  - `ValidateMath`: Validate (some) math computations in movement
+  - `VisSeparation`: Visualize separation vector
+  - `DisplayState`: Set display name to contents of state
+  - `TraceSuccess`: Trace matched instructions
+  - `MotionControllerMove`: Trace movement activity of motion controllers
+  - `TraceFail`: Trace failed instructions
+  - `DisplayCustom`: Display custom debug information (generated by debug components)
+  - `VisAvoidance`: Visualize avoidance vectors
+  - `Flock`: Trace flock events
+  - `MotionControllerSteer`: Trace steering activity of motion controllers
+  - `BlockCollisions`: Trace collisions down to block level
+  - `ValidatePositions`: Validate computed movement positions are not intersecting blocks
+  - `DisplayTarget`: Set display name to locked target type
+  - `BeaconMessages`: Enable debugging of beacon message sending and receiving
+
+#### * EnumSet (Deprecated)
+
+- EnumSet Collisions Flock
+- **Type**: `FlagSet`, **Optional** (Default: [Flock, Collisions]), **Computable**
+- **Flag Values**:
+  - `Overlaps`: Log overlapping blocks when validating position
+  - `ProbeBlockCollisions`: Trace collisions down to block level when probing
+  - `SteeringRole`: Debug blended steering behaviour from role like avoidance/separation
+  - `DisplayInternalId`: Display the internal server ID for this entity
+  - `Pathfinder`: Display pathfinder status
+  - `DisplayStamina`: Display NPC Stamina as numerical values
+  - `FlockDamage`: Trace flock damage events
+  - `Collisions`: Trace collision information of motion controllers
+  - `DisplayFreeSlots`: Display free inventory slots
+  - `DisplayTime`: Set display name to day time
+  - `DisplayName`: Display the role name for this entity
+  - `DisplayLightLevel`: Display light levels
+  - `DisplayAnim`: Display animation state
+  - `TraceSensorFailures`: Trace failing sensors
+  - `DisplayHP`: Display NPC HP as numerical values
+  - `DisplayFlock`: Set display name to flock state
+  - `DisplaySpeed`: Display speed of entity
+  - `ValidateMath`: Validate (some) math computations in movement
+  - `VisSeparation`: Visualize separation vector
+  - `DisplayState`: Set display name to contents of state
+  - `TraceSuccess`: Trace matched instructions
+  - `MotionControllerMove`: Trace movement activity of motion controllers
+  - `TraceFail`: Trace failed instructions
+  - `DisplayCustom`: Display custom debug information (generated by debug components)
+  - `VisAvoidance`: Visualize avoidance vectors
+  - `Flock`: Trace flock events
+  - `MotionControllerSteer`: Trace steering activity of motion controllers
+  - `BlockCollisions`: Trace collisions down to block level
+  - `ValidatePositions`: Validate computed movement positions are not intersecting blocks
+  - `DisplayTarget`: Set display name to locked target type
+  - `BeaconMessages`: Enable debugging of beacon message sending and receiving
+
+#### * Asset (Deprecated)
+
+- Asset Sheep
+- **Type**: `Asset`, **Optional** (Default: Sheep), **Computable**
+
+#### * DoubleArray (Deprecated)
+
+- DoubleArray [1,2] 0-10
+- **Type**: `Array`, **Optional** (Default: [1.0, 2.0]), **Computable**, **Element Type**: Double
+
+#### * StringArray (Deprecated)
+
+- StringArray [a,b] 0-10
+- **Type**: `Array`, **Optional** (Default: [a, b]), **Computable**, **Element Type**: String
+
+[(Top)](#top)
+
+# List of Core Components (entity)
+
+## Beacon: Sensor (Stable) [#sensor_beacon]
+
+Checks to see if any messages have been broadcasted by nearby NPCs.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Message (Experimental)
+
+- The message to listen for
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Range (Experimental)
+
+- The max distance beacons should be received from
+- **Type**: `Double`, **Optional** (Default: 64.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * TargetSlot (Stable)
+
+- A slot to store the sender as a target. If omitted no target will be stored
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+#### * ConsumeMessage (Stable)
+
+- Whether the message should be consumed by this sensor
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+### Provides
+
+- Player target
+- NPC target
+- Dropped item target
+
+[(Top)](#top)
+
+## Count: Sensor (Stable) [#sensor_count]
+
+Check if there is a certain number of NPCs or players within a specific range
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Count (Stable)
+
+- Specifies the allowed number of entities (inclusive)
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: integer
+- **Constraint**: Values must be greater or equal than 0, less or equal than 2147483647and in weakly ascending order
+
+#### * Range (Stable)
+
+- Range to find entities in (inclusive)
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * IncludeGroups (Stable)
+
+- Match for NPCs in these groups
+- **Type**: `AssetArray`, **Optional** (Default: null), **Element Type**: TagSet
+
+#### * ExcludeGroups (Stable)
+
+- Never match NPCs in these groups
+- **Type**: `AssetArray`, **Optional** (Default: null), **Element Type**: TagSet
+
+[(Top)](#top)
+
+## IgnoreForAvoidance: Action (Stable) [#action_ignoreforavoidance]
+
+Set the target slot of an entity that should be ignored during avoidance
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The target slot containing the entity to be ignored
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Kill: Sensor (Stable) [#sensor_kill]
+
+Return true if NPC made a kill. Target position is killed entity position.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * TargetSlot (Stable)
+
+- The target slot to check if killed. If omitted, will accept any entity killed
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## Mob: Sensor (Stable) [#sensor_mob]
+
+Return true if entity matching specific attributes and filters is in range. Target is entity.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MinRange (Stable)
+
+- Minimum range to test entities in
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * Range (Stable)
+
+- Maximum range to test entities in
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * LockOnTarget (Stable)
+
+- Matched target becomes locked target
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * LockedTargetSlot (Stable)
+
+- The target slot to use for locking on or unlocking
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * AutoUnlockTarget (Stable)
+
+- Unlock locked target when sensor not matching it anymore
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * OnlyLockedTarget (Stable)
+
+- Test only locked target
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * IgnoredTargetSlot (Stable)
+
+- The target slot to use for ignoring
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * UseProjectedDistance (Stable)
+
+- Use the projected movement direction vector for distance, rather than the Euclidean distance
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * Prioritiser (Stable)
+
+- A prioritiser for selecting results based on additional parameters
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ISensorEntityPrioritiser
+
+#### * Collector (Stable)
+
+- A collector which can process all checked entities and act on them based on whether they match or not
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ISensorEntityCollector
+
+#### * Filters (Stable)
+
+- A series of entity filter sensors to test
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: IEntityFilter
+
+#### * GetPlayers (Stable)
+
+- Test players
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * GetNPCs (Stable)
+
+- Test mobs/NPCs
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ExcludeOwnType (Stable)
+
+- Exclude NPCs of same type as current NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+- Range must be greater or equal than MinRange
+- At least one of GetPlayers, GetNPCs must be true
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## OverrideAttitude: Action (Stable) [#action_overrideattitude]
+
+Override this NPCs attitude towards the provided target for a given duration
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Attitude (Stable)
+
+- The attitude to set
+- **Type**: `Flag`, **Required**, **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+#### * Duration (Stable)
+
+- The duration to override for
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## Player: Sensor (Stable) [#sensor_player]
+
+Return true if player matching specific attributes and filters is in range. Target is player.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MinRange (Stable)
+
+- Minimum range to test entities in
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * Range (Stable)
+
+- Maximum range to test entities in
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * LockOnTarget (Stable)
+
+- Matched target becomes locked target
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * LockedTargetSlot (Stable)
+
+- The target slot to use for locking on or unlocking
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * AutoUnlockTarget (Stable)
+
+- Unlock locked target when sensor not matching it anymore
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * OnlyLockedTarget (Stable)
+
+- Test only locked target
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * IgnoredTargetSlot (Stable)
+
+- The target slot to use for ignoring
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * UseProjectedDistance (Stable)
+
+- Use the projected movement direction vector for distance, rather than the Euclidean distance
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * Prioritiser (Stable)
+
+- A prioritiser for selecting results based on additional parameters
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ISensorEntityPrioritiser
+
+#### * Collector (Stable)
+
+- A collector which can process all checked entities and act on them based on whether they match or not
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: ISensorEntityCollector
+
+#### * Filters (Stable)
+
+- A series of entity filter sensors to test
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: IEntityFilter
+
+### Constraints
+
+- Range must be greater or equal than MinRange
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## ReleaseTarget: Action (Stable) [#action_releasetarget]
+
+Clear locked target for NPC.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The target slot to release
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Self: Sensor (Stable) [#sensor_self]
+
+Test if the NPC itself matches a set of entity filters
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Filters (Stable)
+
+- A series of entity filter sensors to test
+- **Type**: `Array`, **Required**, **Element Type**: IEntityFilter
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## SetMarkedTarget: Action (Stable) [#action_setmarkedtarget]
+
+Explicitly sets a marked target in a given slot.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The target slot to set a target to.
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String must be not empty
+
+### Constraints
+
+- Must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## SetStat: Action (Stable) [#action_setstat]
+
+Sets (or adds to) an entity stat on the NPC.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Stat (Stable)
+
+- The entity stat to affect.
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * Value (Stable)
+
+- The value to set the stat to.
+- **Type**: `Double`, **Required**, **Computable**
+
+#### * Add (Stable)
+
+- Add the value to the existing value instead of setting it.
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+[(Top)](#top)
+
+## Target: Sensor (Stable) [#sensor_target]
+
+Test if given target matches a series of criteria and optional entity filters
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * TargetSlot (Stable)
+
+- The target slot to check
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String must be not empty
+
+#### * Range (Stable)
+
+- Maximum range of locked target
+- **Type**: `Double`, **Optional** (Default: 1.7976931348623157E308), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AutoUnlockTarget (Stable)
+
+- Unlock locked target if match fails
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * Filters (Stable)
+
+- A series of entity filter sensors to test
+- **Type**: `Array`, **Optional** (Default: null), **Element Type**: IEntityFilter
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+# List of Core Components (interaction)
+
+## CanInteract: Sensor (Stable) [#sensor_caninteract]
+
+Checks whether or not the player being iterated by the interaction instruction can interact with this NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * ViewSector (Stable)
+
+- View sector to test the player in
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * Attitudes (Stable)
+
+- A set of attitudes to match
+- **Type**: `FlagSet`, **Optional** (Default: [NEUTRAL, FRIENDLY, REVERED]), **Computable**
+- **Flag Values**:
+  - `HOSTILE`: is hostile towards the target
+  - `REVERED`: reveres the target
+  - `FRIENDLY`: is friendly towards the target
+  - `IGNORE`: is ignoring the target
+  - `NEUTRAL`: is neutral towards the target
+
+### Constraints
+
+[(Top)](#top)
+
+## HasInteracted: Sensor (Stable) [#sensor_hasinteracted]
+
+Checks whether the currently iterated player in the interaction instruction has interacted with this NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## InteractionContext: Sensor (Stable) [#sensor_interactioncontext]
+
+Checks whether the currently iterated player in the interaction instruction has interacted with this NPC in the given context
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Context (Stable)
+
+- The context of the interaction
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+### Constraints
+
+[(Top)](#top)
+
+## LockOnInteractionTarget: Action (Stable) [#action_lockoninteractiontarget]
+
+Locks on to the currently iterated player in the interaction instruction
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * TargetSlot (Stable)
+
+- The target slot to use
+- **Type**: `String`, **Optional** (Default: LockedTarget), **Computable**
+- **Constraint**: String must be not empty
+
+### Constraints
+
+[(Top)](#top)
+
+## SetInteractable: Action (Stable) [#action_setinteractable]
+
+Set whether the currently iterated player in the interaction instruction should be able to interact with this NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Interactable (Stable)
+
+- Toggle whether the currently iterated player in the interaction instruction should be able to interact with this NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Hint (Stable)
+
+- The interaction hint translation key to show for this player (e.g. 'interactionHints.trade')
+- **Type**: `String`, **Optional** (Default: null)
+
+#### * ShowPrompt (Stable)
+
+- Whether to show the F-key interaction prompt. Set to false for contextual-only interactions (e.g. shearing with tools). Defaults to true.
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+### Constraints
+
+[(Top)](#top)
+
+# List of Core Components (items)
+
+## DropItem: Action (Stable) [#action_dropitem]
+
+Drop an item. Can be a specific item, or from a drop table
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Delay (Stable)
+
+- Range of time to delay in seconds
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Item (Stable)
+
+- A specific item to drop
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * DropList (Stable)
+
+- A reference to an item drop list
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * ThrowSpeed (Stable)
+
+- The throw speed to use
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater than 0 and less or equal than 3.4028234663852886e+38
+
+#### * Distance (Stable)
+
+- The range from which to pick a distance to throw the item
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * DropSector (Stable)
+
+- The sector to spread drops in relative to view direction of NPC in degrees.
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Element Type**: Double
+- **Constraint**: Values must be greater or equal than -360, less or equal than 360and in weakly ascending order
+
+#### * PitchHigh (Stable)
+
+- Whether to pitch high or pitch low instead
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+- One (and only one) of Item, DropList must be provided
+
+[(Top)](#top)
+
+## DroppedItem: Sensor (Stable) [#sensor_droppeditem]
+
+Triggers if a given item is within a certain range of the NPC. Will match anything if Items and Attitudes are not defined, otherwise will match items meeting either criteria.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Range (Stable)
+
+- The range within which to look
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * ViewSector (Stable)
+
+- View sector in which to look
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * LineOfSight (Stable)
+
+- Requires line of sight to item
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * Items (Stable)
+
+- A list of glob item patterns to match. If omitted, will match any item
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+#### * Attitudes (Stable)
+
+- Attitudes to match
+- **Type**: `FlagSet`, **Optional** (Default: []), **Computable**
+- **Flag Values**:
+  - `Neutral`: Neutral
+  - `Ignore`: Ignore
+  - `Like`: Like
+  - `Love`: Love
+  - `Dislike`: Dislike
+
+### Provides
+
+- Dropped item target
+
+[(Top)](#top)
+
+## Inventory: Action (Stable) [#action_inventory]
+
+Add or remove a number of items from an inventory. Can also be used to equip them.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Operation (Stable)
+
+- Operation to perform
+- **Type**: `Flag`, **Optional** (Default: Add), **Computable**
+- **Flag Values**:
+  - `Add`: Add items to inventory
+  - `RemoveHeldItem`: Destroy the held item
+  - `SetHotbar`: Sets the hotbar item in a specific slot
+  - `Equip`: Equip item as weapon or armour
+  - `ClearHeldItem`: Clear the held item
+  - `EquipOffHand`: Equips the item from a specific off-hand slot
+  - `Remove`: Remove items from inventory
+  - `EquipHotbar`: Equips the item from a specific hotbar slot
+  - `SetOffHand`: Sets the off-hand item in a specific slot
+
+#### * Count (Stable)
+
+- Number of items to add/remove
+- **Type**: `Integer`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Item (Stable)
+
+- Item type to add, remove, or equip
+- **Type**: `Asset`, **Optional** (Default: ), **Computable**
+
+#### * UseTarget (Stable)
+
+- Use the sensor-provided target for the action
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Slot (Stable)
+
+- The hotbar or off-hand to effect. Only valid for Hotbar/OffHand Set/Equip operations
+- **Type**: `Integer`, **Optional** (Default: 0.0), **Computable**
+
+### Constraints
+
+- If UseTarget is true, must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## PickUpItem: Action (Stable) [#action_pickupitem]
+
+Pick up an item. In hoover mode, will match to the Item array. Otherwise, requires a target to be provided e.g. by a DroppedItemSensor
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Delay (Stable)
+
+- Range of time to delay in seconds
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Range (Stable)
+
+- The range the item will be picked up from
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * StorageTarget (Experimental)
+
+- Where to prioritise putting the item
+- **Type**: `Flag`, **Optional** (Default: Hotbar), **Computable**
+- **Flag Values**:
+  - `Destroy`: Destroy the item
+  - `Hotbar`: Prioritise hotbar
+  - `Inventory`: Prioritise inventory
+
+#### * Hoover (Stable)
+
+- Suck up all items in range with optional cooldown. Can be filtered with a list of glob patterns. Ignored outside hoover mode
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Items (Stable)
+
+- A list of glob item patterns to match for hoover mode. If omitted, will match any item. Ignored outside hoover mode
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: Item
+
+### Constraints
+
+- If Hoover is false, must be attached to a sensor that provides dropped item target
+
+[(Top)](#top)
+
+# List of Core Components (lifecycle)
+
+## Age: Sensor (Stable) [#sensor_age]
+
+Triggers when the age of the NPC falls between a certain range. Range is defined in terms of period (e.g. 1Y2M3W4D - 1 year, 2 months, 3 weeks, 4 days) or duration (e.g. 2DT3H4M - 2 days, 3 hours, 4 minutes)
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * AgeRange (Stable)
+
+- The age range within which to trigger
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: TemporalAmount
+- **Constraint**: Values must be greater or equal than a few seconds, less or equal than 5879611 years, in strictly ascending order and either all Periods or all Durations
+
+[(Top)](#top)
+
+## DelayDespawn: Action (Stable) [#action_delaydespawn]
+
+Delay the despawning cycle for some amount of time
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Time (Stable)
+
+- How long to set the to delay
+- **Type**: `Double`, **Required**
+- **Constraint**: Value must be greater than 0
+
+#### * Shorten (Stable)
+
+- Set the delay to either the current delay or the given time. Whatever is smaller.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## Despawn: Action (Stable) [#action_despawn]
+
+Trigger the NPC to start the despawning cycle. If the script contains a despawn sensor it will run that action/motion before removing.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Force (Stable)
+
+- Force the NPC to remove automatically
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## Die: Action (Stable) [#action_die]
+
+Kill the NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## Remove: Action (Stable) [#action_remove]
+
+Erase the target entity from the world (no death animation).
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * UseTarget (Stable)
+
+- Use the sensor-provided target for the action
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+- If UseTarget is true, must be attached to a sensor that provides one of player target, NPC target
+
+[(Top)](#top)
+
+## Role: Action (Stable) [#action_role]
+
+Change the Role of the NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Role (Stable)
+
+- The name of the Role to change to
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * ChangeAppearance (Stable)
+
+- Whether the appearance of the new Role should be used
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * State (Stable)
+
+- State name to set
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String must be a valid state string. A main state must be included before the period (e.g. Main.Test). State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+[(Top)](#top)
+
+## Spawn: Action (Experimental) [#action_spawn]
+
+Spawn an NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * SpawnDirection (Experimental)
+
+- Direction of spawn cone relative to view direction (in degrees)
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than -180 and less or equal than 180
+
+#### * SpawnAngle (Experimental)
+
+- Cone width of spawn direction (in degrees)
+- **Type**: `Double`, **Optional** (Default: 360.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * FanOut (Experimental)
+
+- Fan NPCs out equally over angle
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * DistanceRange (Stable)
+
+- Distance from spawner to spawn
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 128and in weakly ascending order
+
+#### * CountRange (Stable)
+
+- Number of NPCs to spawn
+- **Type**: `Array`, **Optional** (Default: [5, 5]), **Computable**, **Element Type**: integer
+- **Constraint**: Values must be greater than 0, less or equal than 100and in weakly ascending order
+
+#### * DelayRange (Stable)
+
+- Time between consecutive spawns in seconds
+- **Type**: `Array`, **Optional** (Default: [0.25, 0.25]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Kind (Experimental)
+
+- NPC role to spawn
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Flock (Stable)
+
+- Flock definition to spawn
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * LaunchAtTarget (WorkInProgress)
+
+- Launch the spawned NPC at target position/entity
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * PitchHigh (Stable)
+
+- If launching at a target, use high pitch
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * LaunchSpread (Stable)
+
+- The radius of the circle centred on the target within which to spread thrown NPCs
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * JoinFlock (Stable)
+
+- Whether to join the parent NPC's flock
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * SpawnState (Stable)
+
+- An optional state to set on the spawned NPC if it exists
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * SpawnSubState (Stable)
+
+- An optional substate to set on the spawned NPC if it exists
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+### Constraints
+
+- If LaunchAtTarget is true, must be attached to a sensor that provides one of player target, NPC target, dropped item target, vector position
+
+[(Top)](#top)
+
+# List of Core Components (message)
+
+## Beacon: Action (Experimental) [#action_beacon]
+
+Let the NPC send out a message to a target group of entities within a certain distance.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Message (Experimental)
+
+- Message to send to targets
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Range (Experimental)
+
+- The maximum range to send the message
+- **Type**: `Double`, **Optional** (Default: 64.0)
+- **Constraint**: Value must be greater than 0
+
+#### * TargetGroups (Experimental)
+
+- The target group(s) to send the message to
+- **Type**: `AssetArray`, **Required**, **Computable**, **Element Type**: TagSet
+
+#### * SendTargetSlot (Stable)
+
+- The target slot of the marked entity to send. Omit to send own position
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * ExpirationTime (Experimental)
+
+- The number of seconds that the message should last and be acknowledged by the receiving NPC. -1 represents infinite time.
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0 or equal -1
+
+#### * SendCount (Experimental)
+
+- Tne number of entities to send the message to. -1 will send to all. Entities will be chosen with a roughly even random distribution using reservoir sampling
+- **Type**: `Integer`, **Optional** (Default: -1)
+- **Constraint**: Value must be greater than 0 or equal -1
+
+[(Top)](#top)
+
+## Notify: Action (Stable) [#action_notify]
+
+Directly notifies a target NPC with a beacon message
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Message (Stable)
+
+- The message to send
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * ExpirationTime (Experimental)
+
+- The number of seconds that the message should last and be acknowledged by the receiving NPC. -1 represents infinite time.
+- **Type**: `Double`, **Optional** (Default: 1.0)
+- **Constraint**: Value must be greater or equal than 0 or equal -1
+
+#### * UseTargetSlot (Stable)
+
+- A marked target to send to instead of the target provided by a sensor. Omit to use the target provided by the sensor.
+- **Type**: `String`, **Optional** (Default: null)
+- **Constraint**: String value must be either null or not empty
+
+### Constraints
+
+- If UseTargetSlot is false, must be attached to a sensor that provides NPC target
+
+[(Top)](#top)
+
+# List of Core Components (movement)
+
+## Crouch: Action (Stable) [#action_crouch]
+
+Set NPC crouching state
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Crouch (Stable)
+
+- True for crouching, false for non-crouching
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## InAir: Sensor (Stable) [#sensor_inair]
+
+Return true if NPC is not on ground. No target is returned.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## MotionController: Sensor (Experimental) [#sensor_motioncontroller]
+
+Test if specific motion controller is active.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * MotionController (Experimental)
+
+- Motion controller name to test for
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Nav: Sensor (Stable) [#sensor_nav]
+
+Queries navigation state
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * NavStates (Stable)
+
+- Trigger when path finder is in one of the states or empty to match all
+- **Type**: `FlagSet`, **Optional** (Default: []), **Computable**
+- **Flag Values**:
+  - `PROGRESSING`: Moving or computing a path
+  - `INIT`: Doing nothing
+  - `AT_GOAL`: Reached target
+  - `BLOCKED`: Can't advance any further
+  - `ABORTED`: Search stopped but target not reached
+  - `DEFER`: Delaying/unable to advance
+
+#### * ThrottleDuration (Stable)
+
+- Minimum time in seconds the path finder isn't able to reach target or 0 to ignore
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * TargetDelta (Stable)
+
+- Minimum distance target has moved since path was computed or 0 to ignore
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+[(Top)](#top)
+
+## OnGround: Sensor (Stable) [#sensor_onground]
+
+Return true if NPC is on ground. No target is returned.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## OverrideAltitude: Action (Stable) [#action_overridealtitude]
+
+Temporarily override the preferred altitude of a flying NPC. Must be refreshed each tick
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * DesiredAltitudeRange (Stable)
+
+- The desired altitude range
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+[(Top)](#top)
+
+## RecomputePath: Action (Stable) [#action_recomputepath]
+
+Force recomputation of path finder solution
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+# List of Core Components (npc)
+
+## CompleteTask: Action (Stable) [#action_completetask]
+
+Complete a task. Tasks are picked based on those provided to SensorCanInteract.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Slot (Stable)
+
+- The animation slot to play on
+- **Type**: `Flag`, **Required**
+- **Flag Values**:
+  - `Status`: Status
+  - `Action`: Action
+  - `Face`: Face
+
+#### * Animation (Stable)
+
+- The animation ID to play
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+
+#### * PlayAnimation (Stable)
+
+- Whether or not to play the animation associated with completing this task
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## HasTask: Sensor (Stable) [#sensor_hastask]
+
+Checks whether or not the player being iterated by the interaction instruction has any of the given tasks
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * TasksById (Stable)
+
+- Completable tasks to match by name
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: String
+- **Constraint**: String array must not be empty
+
+### Constraints
+
+[(Top)](#top)
+
+## Mount: Action (Stable) [#action_mount]
+
+Enable the player to mount the entity
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * AnchorX (Stable)
+
+- The X anchor pos
+- **Type**: `Double`, **Required**, **Computable**
+
+#### * AnchorY (Stable)
+
+- The Y anchor pos
+- **Type**: `Double`, **Required**, **Computable**
+
+#### * AnchorZ (Stable)
+
+- The Z anchor pos
+- **Type**: `Double`, **Required**, **Computable**
+
+#### * MovementConfig (Stable)
+
+- The MovementConfig to use for this mount
+- **Type**: `String`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## OpenBarterShop: Action (Stable) [#action_openbartershop]
+
+Open the barter shop UI for the current player
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Shop (Stable)
+
+- The barter shop to open
+- **Type**: `Asset`, **Required**, **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## OpenShop: Action (Stable) [#action_openshop]
+
+Open the shop UI for the current player
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Shop (Stable)
+
+- The shop to open
+- **Type**: `Asset`, **Required**, **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+## StartObjective: Action (Stable) [#action_startobjective]
+
+Start the given objective for the currently iterated player in the interaction instruction
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Objective (Stable)
+
+- The task to start
+- **Type**: `Asset`, **Required**, **Computable**
+
+### Constraints
+
+[(Top)](#top)
+
+# List of Core Components (path)
+
+## MakePath: Action (WorkInProgress) [#action_makepath]
+
+Constructs a transient path for the NPC based on a series of rotations and distances
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Path (WorkInProgress)
+
+- A transient path definition
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Path
+
+[(Top)](#top)
+
+## Path: Sensor (Stable) [#sensor_path]
+
+Find a path based on various criteria. Provides the position of the nearest waypoint and the path itself
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Path (Stable)
+
+- The name of the path. If left blank, will find the nearest path
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+
+#### * Range (Stable)
+
+- The range to test to nearest waypoint. 0 is unlimited
+- **Type**: `Double`, **Optional** (Default: 10.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * PathType (Stable)
+
+- The type of path to search for
+- **Type**: `Flag`, **Optional** (Default: AnyPrefabPath), **Computable**
+- **Flag Values**:
+  - `CurrentPrefabPath`: a path from the prefab the NPC spawned in
+  - `TransientPath`: a transient path (testing purposes only)
+  - `AnyPrefabPath`: a path from any prefab
+  - `WorldPath`: named world path
+
+### Constraints
+
+- If PathType is WorldPath, the following must apply to Path: String must be not empty
+
+### Provides
+
+- Vector position
+- Path
+
+[(Top)](#top)
+
+# List of Core Components (statemachine)
+
+## IsBusy: Sensor (Stable) [#sensor_isbusy]
+
+Tests if an NPC is in one of the defined Busy States.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## ParentState: Action (Stable) [#action_parentstate]
+
+Set the main state of NPC from within a component
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * State (Stable)
+
+- The alias of the external state to set, as defined by _ImportStates in parameters
+- **Type**: `String`, **Required**
+- **Constraint**: String must be a valid state string. A main state must be included before the period (e.g. Main.Test). Only the main state can be included.
+
+### Constraints
+
+- May only be included within a component
+
+[(Top)](#top)
+
+## State: Action (Stable) [#action_state]
+
+Set state of NPC. The state can be queried with a sensor later on.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * State (Stable)
+
+- State name to set
+- **Type**: `String`, **Required**
+- **Constraint**: String must be a valid state string. State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+#### * ClearState (Stable)
+
+- Clear the state of things like set once flags on transition
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+### Constraints
+
+[(Top)](#top)
+
+## State: Sensor (Stable) [#sensor_state]
+
+Signal if NPC is set to specific state.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * State (Stable)
+
+- State to compare to
+- **Type**: `String`, **Required**
+- **Constraint**: String must be a valid state string. State strings consist of a main state and a sub state (e.g. Main.Test). If nested within a substate, the main state may be omitted (e.g. .Test) when referencing.
+
+#### * IgnoreMissingSetState (Stable)
+
+- Override and ignore checks for matching setter action that sets this state. Intended for use in cases such as the FlockState action which sets the state via another NPC
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## ToggleStateEvaluator: Action (Stable) [#action_togglestateevaluator]
+
+Enable or disable the NPC's state evaluator
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether or not to enable the state evaluator
+- **Type**: `Boolean`, **Required**
+
+[(Top)](#top)
+
+# List of Core Components (timer)
+
+## Alarm: Sensor (Stable) [#sensor_alarm]
+
+Check the state of a named alarm and optionally clear it if the time has passed
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Name (Stable)
+
+- The name of the alarm to check
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * State (Stable)
+
+- The state to check for
+- **Type**: `Flag`, **Required**, **Computable**
+- **Flag Values**:
+  - `SET`: Set
+  - `UNSET`: Not set
+  - `PASSED`: Passed
+
+#### * Clear (Stable)
+
+- Whether to clear the alarm (unset it) if it has passed
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+[(Top)](#top)
+
+## SetAlarm: Action (Stable) [#action_setalarm]
+
+Set a named alarm on the NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the alarm to set
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * DurationRange (Stable)
+
+- The duration range from which to pick a duration to set the alarm for. [ "P0D", "P0D" ] will unset the alarm
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: TemporalAmount
+- **Constraint**: Values must be greater or equal than a few seconds, less or equal than 5879611 years, in weakly ascending order and either all Periods or all Durations
+
+[(Top)](#top)
+
+## Timer: Sensor (Stable) [#sensor_timer]
+
+Tests if a timer exists and the value is within a certain range.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * State (Stable)
+
+- The timer's state to check
+- **Type**: `Flag`, **Optional** (Default: ANY)
+- **Flag Values**:
+  - `PAUSED`: Paused
+  - `RUNNING`: Running
+  - `STOPPED`: Stopped
+  - `ANY`: Any
+
+#### * TimeRemainingRange (Stable)
+
+- The acceptable remaining time on the timer.
+- **Type**: `Array`, **Optional** (Default: [0.0, 1.7976931348623157E308]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+[(Top)](#top)
+
+## TimerContinue: Action (Stable) [#action_timercontinue]
+
+Continue a timer
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## TimerModify: Action (Stable) [#action_timermodify]
+
+Modify values of a timer
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * AddValue (Stable)
+
+- Add value to the timer
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * MaxValue (Stable)
+
+- Set the restart value range the timer can have. If [ 0, 0 ] (default) it will be ignored
+- **Type**: `Array`, **Optional** (Default: [0.0, 0.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308
+
+#### * Rate (Stable)
+
+- Set the rate at which the timer will decrease. If 0 (default) it will be ignored
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * SetValue (Stable)
+
+- Set the value of the timer. If 0 (default) it will be ignored
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * Repeating (Stable)
+
+- Whether to repeat the timer when countdown finishes
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+[(Top)](#top)
+
+## TimerPause: Action (Stable) [#action_timerpause]
+
+Pause a timer
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## TimerRestart: Action (Stable) [#action_timerrestart]
+
+Restart a timer. Will be set to the original initial values.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## TimerStart: Action (Stable) [#action_timerstart]
+
+Start a timer
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * StartValueRange (Stable)
+
+- The range from which to pick an initial value to start at
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * RestartValueRange (Stable)
+
+- The range from which to pick a value when the timer is restarted. The upper bound is also the timer max
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * Rate (Stable)
+
+- The rate at which the timer will decrease
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Repeating (Stable)
+
+- Whether to repeat the timer when countdown finishes
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+[(Top)](#top)
+
+## TimerStop: Action (Stable) [#action_timerstop]
+
+Stop a timer
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the timer
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+# List of Core Components (utility)
+
+## AdjustPosition: Sensor (Stable) [#sensor_adjustposition]
+
+Perform adjustments to the wrapped sensor's returned position
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor to wrap
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Sensor
+
+#### * Offset (Stable)
+
+- The offset to apply to the returned position from the sensor
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## And: Sensor (Stable) [#sensor_and]
+
+Evaluate all sensors and execute action only when all sensor signal true. Target is provided by first sensor.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensors (Stable)
+
+- List of sensors
+- **Type**: `Array`, **Required**, **Element Type**: Sensor
+- **Constraint**: Array must not be empty
+
+#### * AutoUnlockTargetSlot (Stable)
+
+- A target slot to unlock when sensor doesn't match anymore
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+[(Top)](#top)
+
+## Any: Sensor (Stable) [#sensor_any]
+
+Sensor always signals true but doesn't return a target.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## Eval: Sensor (Experimental) [#sensor_eval]
+
+Evaluate javascript expression and test truth value. Current values accessible are 'health' and 'blocked'.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Expression (Experimental)
+
+- Javascript expression
+- **Type**: `String`, **Required**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Flag: Sensor (Stable) [#sensor_flag]
+
+Test if a named flag is set or not
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Name (Stable)
+
+- The name of the flag
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Set (Stable)
+
+- Whether the flag should be set or not
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## Not: Sensor (WorkInProgress) [#sensor_not]
+
+Return true when the given sensor test fails.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor to test
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Sensor
+
+#### * UseTargetSlot (Stable)
+
+- A locked target slot to feed to action (if available)
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * AutoUnlockTargetSlot (Stable)
+
+- A target slot to unlock when sensor doesn't match anymore
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+[(Top)](#top)
+
+## Nothing: Action (Stable) [#action_nothing]
+
+Do nothing. Used often as placeholder.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## Or: Sensor (Stable) [#sensor_or]
+
+Evaluate sensors and execute action when at least one sensor signals true. Target is provided by first sensor signalling true.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensors (Stable)
+
+- List of sensors
+- **Type**: `Array`, **Required**, **Element Type**: Sensor
+- **Constraint**: Array must not be empty
+
+#### * AutoUnlockTargetSlot (Stable)
+
+- A target slot to unlock when sensor doesn't match anymore
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+[(Top)](#top)
+
+## Random: Action (Stable) [#action_random]
+
+Execute a single random action from a list of weighted actions.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Actions (Stable)
+
+- List of possible actions
+- **Type**: `Array`, **Required**, **Element Type**: WeightedAction
+
+[(Top)](#top)
+
+## Random: Sensor (Stable) [#sensor_random]
+
+Alternates between returning true and false for specified random durations
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * TrueDurationRange (Stable)
+
+- The duration range to pick a random period to return true
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * FalseDurationRange (Stable)
+
+- The duration range to pick a random period to return false
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+[(Top)](#top)
+
+## ResetInstructions: Action (Stable) [#action_resetinstructions]
+
+Force reset instructionList, either by name, or as a whole
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Instructions (Stable)
+
+- The instructionList to reset. If left empty, will reset all instructionList
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+[(Top)](#top)
+
+## Sequence: Action (Stable) [#action_sequence]
+
+Execute list of actions.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Blocking (Stable)
+
+- Do not execute an action unless the previous action could execute
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Atomic (Stable)
+
+- Only execute actions if all actions can be executed
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Actions (Stable)
+
+- List of actions
+- **Type**: `ObjectRef`, **Required**, **Object Type**: ActionList
+
+[(Top)](#top)
+
+## SetFlag: Action (Stable) [#action_setflag]
+
+Set a named flag to a boolean value
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Name (Stable)
+
+- The name of the flag
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * SetTo (Stable)
+
+- The value to set the flag to
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## Switch: Sensor (Stable) [#sensor_switch]
+
+Check if a computed boolean is true
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Switch (Stable)
+
+- The switch to check
+- **Type**: `Boolean`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## Timeout: Action (Stable) [#action_timeout]
+
+Delay an action by a time which is randomly picked between a given minimum and maximum value.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Delay (Stable)
+
+- Range of time to delay in seconds
+- **Type**: `Array`, **Optional** (Default: [1.0, 1.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 1.7976931348623157e+308and in weakly ascending order
+
+#### * DelayAfter (Stable)
+
+- Delay after executing the action
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Action (Stable)
+
+- Optional action to delay
+- **Type**: `ObjectRef`, **Optional** (Default: null), **Object Type**: Action
+
+[(Top)](#top)
+
+## ValueProviderWrapper: Sensor (Stable) [#sensor_valueproviderwrapper]
+
+Wraps a sensor and passes down some additional parameter overrides pulled from the value store
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * PassValues (Stable)
+
+- Used to enable/disable passing of values in components
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor to wrap
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Sensor
+
+#### * ValueToParameterMappings (Stable)
+
+- The mappings of values to override parameters
+- **Type**: `Array`, **Required**, **Element Type**: ValueToParameterMapping
+- **Constraint**: Array must not be empty
+
+[(Top)](#top)
+
+# List of Core Components (world)
+
+## Block: Sensor (Experimental) [#sensor_block]
+
+Checks for one of a set of blocks in the nearby area and caches the result until explicitly reset or the targeted block changes/is removed. All block sensors with the same sought blockset share the same targeted block once found
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Range (Stable)
+
+- The range to search for the blocks in
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1.7976931348623157e+308
+
+#### * MaxHeight (Stable)
+
+- The vertical range to search for the blocks in
+- **Type**: `Double`, **Optional** (Default: 4.0), **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 1.7976931348623157e+308
+
+#### * Blocks (Stable)
+
+- The set of blocks to search for
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * Random (Stable)
+
+- Whether to pick at random from within the matched blocks or pick the closest
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+#### * Reserve (Stable)
+
+- Whether to reserve the found block to prevent other NPCs selecting it
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## BlockChange: Sensor (Stable) [#sensor_blockchange]
+
+Matches when a block from a blockset within a certain range is changed or interacted with
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Range (Stable)
+
+- Max range to listen in
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SearchType (Stable)
+
+- Whether to listen for events triggered by players, npcs, or both in a certain order
+- **Type**: `Flag`, **Optional** (Default: PlayerOnly), **Computable**
+- **Flag Values**:
+  - `NpcOnly`: search only for events triggered by npcs
+  - `PlayerFirst`: search for events triggered by players first
+  - `PlayerOnly`: search only for events triggered by players
+  - `NpcFirst`: search for events triggered by npcs first
+
+#### * TargetSlot (Stable)
+
+- A target slot to place the target in. If omitted, no slot will be used
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * BlockSet (Stable)
+
+- Block set to listen for
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * EventType (Stable)
+
+- The event type to listen for
+- **Type**: `Flag`, **Optional** (Default: DAMAGE), **Computable**
+- **Flag Values**:
+  - `DESTRUCTION`: On block destruction
+  - `INTERACTION`: On block use interaction
+  - `DAMAGE`: On block damage
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## BlockType: Sensor (Stable) [#sensor_blocktype]
+
+Checks if the block at the given position matches the provided block set
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Sensor (Stable)
+
+- Sensor to wrap
+- **Type**: `ObjectRef`, **Required**, **Object Type**: Sensor
+
+#### * BlockSet (Stable)
+
+- Block set to check against
+- **Type**: `Asset`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## CanPlaceBlock: Sensor (Stable) [#sensor_canplaceblock]
+
+Test if the currently set block can be placed at the relative position given direction and offset
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Direction (Stable)
+
+- The direction to place relative to heading
+- **Type**: `Flag`, **Optional** (Default: Forward), **Computable**
+- **Flag Values**:
+  - `Left`: Left
+  - `Backward`: Backward
+  - `Right`: Right
+  - `Forward`: Forward
+
+#### * Offset (Stable)
+
+- The offset to place at
+- **Type**: `Flag`, **Optional** (Default: BodyPosition), **Computable**
+- **Flag Values**:
+  - `BodyPosition`: BodyPosition
+  - `FootPosition`: FootPosition
+  - `HeadPosition`: HeadPosition
+
+#### * RetryDelay (Stable)
+
+- The amount of time to delay if a placement fails before trying to place something again
+- **Type**: `Double`, **Optional** (Default: 5.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AllowEmptyMaterials (Stable)
+
+- Whether it should be possible to replace blocks that have empty material
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## EntityEvent: Sensor (Stable) [#sensor_entityevent]
+
+Matches when an entity from a specific NPC group within a certain range is damaged, killed, or interacted with
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Range (Stable)
+
+- Max range to listen in
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * SearchType (Stable)
+
+- Whether to listen for events triggered by players, npcs, or both in a certain order
+- **Type**: `Flag`, **Optional** (Default: PlayerOnly), **Computable**
+- **Flag Values**:
+  - `NpcOnly`: search only for events triggered by npcs
+  - `PlayerFirst`: search for events triggered by players first
+  - `PlayerOnly`: search only for events triggered by players
+  - `NpcFirst`: search for events triggered by npcs first
+
+#### * TargetSlot (Stable)
+
+- A target slot to place the target in. If omitted, no slot will be used
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+#### * NPCGroup (Stable)
+
+- NPC group to listen for
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * EventType (Stable)
+
+- The event type to listen for
+- **Type**: `Flag`, **Optional** (Default: DAMAGE), **Computable**
+- **Flag Values**:
+  - `DEATH`: On dying
+  - `INTERACTION`: On use interaction
+  - `DAMAGE`: On taking damage
+
+#### * FlockOnly (Stable)
+
+- Whether to only listen for flock events
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Provides
+
+- Player target
+- NPC target
+
+[(Top)](#top)
+
+## InWater: Sensor (Stable) [#sensor_inwater]
+
+Check if NPC is currently in water
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+[(Top)](#top)
+
+## Leash: Sensor (Stable) [#sensor_leash]
+
+Triggers when the NPC is outside a specified range from the leash point
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Range (Stable)
+
+- The farthest distance allowed from the leash point
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## Light: Sensor (Stable) [#sensor_light]
+
+Check the light levels of the block an entity is standing on. Can test light intensity, sky light or block channel levels.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * LightRange (Stable)
+
+- The light intensity percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * SkyLightRange (Stable)
+
+- The sky light percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * SunlightRange (Stable)
+
+- The sunlight percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * RedLightRange (Stable)
+
+- The red light percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * GreenLightRange (Stable)
+
+- The green light percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * BlueLightRange (Stable)
+
+- The blue light percentage range
+- **Type**: `Array`, **Optional** (Default: [0.0, 100.0]), **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 100and in weakly ascending order
+
+#### * UseTargetSlot (Stable)
+
+- A target slot to check. If omitted, will check self
+- **Type**: `String`, **Optional** (Default: null), **Computable**
+- **Constraint**: String value must be either null or not empty
+
+[(Top)](#top)
+
+## PlaceBlock: Action (Stable) [#action_placeblock]
+
+Place a block (chosen by another action) at a position returned by a Sensor if close enough
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Range (Stable)
+
+- The range to target position before block will be placed
+- **Type**: `Double`, **Optional** (Default: 3.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * AllowEmptyMaterials (Stable)
+
+- Whether it should be possible to replace blocks that have empty material
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Constraints
+
+- Must be attached to a sensor that provides one of vector position
+
+[(Top)](#top)
+
+## ReadPosition: Sensor (Stable) [#sensor_readposition]
+
+Read a stored position with some conditions
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Slot (Stable)
+
+- The slot to read the position from
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * MinRange (Stable)
+
+- Minimum range from stored position
+- **Type**: `Double`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+#### * Range (Stable)
+
+- Maximum range from stored position
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * UseMarkedTarget (Stable)
+
+- Whether to read from a marked target slot instead of a position slot
+- **Type**: `Boolean`, **Optional** (Default: false), **Computable**
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## ResetBlockSensors: Action (Stable) [#action_resetblocksensors]
+
+Resets a specific block sensor by name, or all block sensors by clearing the current targeted block
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * BlockSets (Stable)
+
+- The searched blocksets to reset block sensors for. If left empty, will reset all block sensors and found blocks
+- **Type**: `AssetArray`, **Optional** (Default: null), **Computable**, **Element Type**: BlockSet
+
+[(Top)](#top)
+
+## ResetPath: Action (Stable) [#action_resetpath]
+
+Resets the current patrol path this NPC follows.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+[(Top)](#top)
+
+## ResetSearchRays: Action (Stable) [#action_resetsearchrays]
+
+Resets a specific search ray sensor cached position by name, or all search ray sensors
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Names (Stable)
+
+- The search ray sensor ids. If left empty, will reset all search ray sensors
+- **Type**: `Array`, **Optional** (Default: null), **Computable**, **Element Type**: String
+- **Constraint**: Strings in array must not be empty
+
+[(Top)](#top)
+
+## SearchRay: Sensor (Stable) [#sensor_searchray]
+
+Fire a ray at a specific angle to see if what it hits matches a given sought block
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Name (Stable)
+
+- The id of this search ray sensor so the position can be cached
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+#### * Angle (Stable)
+
+- Angle to fire the ray. Horizontal is 0. Positive is downwards
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater or equal than -90 and less or equal than 90
+
+#### * Range (Stable)
+
+- How far to search
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0 and less or equal than 96
+
+#### * Blocks (Stable)
+
+- The blockset to search for
+- **Type**: `Asset`, **Required**, **Computable**
+
+#### * MinRetestAngle (Stable)
+
+- The minimum change in NPC rotation before rays stop being throttled
+- **Type**: `Double`, **Optional** (Default: 5.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0 and less or equal than 360
+
+#### * MinRetestMove (Stable)
+
+- The minimum distance the NPC needs to move while facing the same direction before rays stop being throttled
+- **Type**: `Double`, **Optional** (Default: 1.0), **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * ThrottleTime (Stable)
+
+- The delay between retests when an NPC is facing the same direction
+- **Type**: `Double`, **Optional** (Default: 0.5), **Computable**
+- **Constraint**: Value must be greater than 0
+
+### Provides
+
+- Vector position
+
+[(Top)](#top)
+
+## SetBlockToPlace: Action (Stable) [#action_setblocktoplace]
+
+Set the block type the NPC will place
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Block (Stable)
+
+- The block item type
+- **Type**: `Asset`, **Required**, **Computable**
+
+[(Top)](#top)
+
+## SetLeashPosition: Action (Stable) [#action_setleashposition]
+
+Sets the NPCs current position to the spawn/leash position to be used with the Leash Sensor.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ToCurrent (Stable)
+
+- Set to the NPCs current position.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ToTarget (Stable)
+
+- Set to the target position.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+### Constraints
+
+- At least one of ToCurrent, ToTarget must be true
+- If ToTarget is true, must be attached to a sensor that provides one of player target, NPC target, dropped item target
+
+[(Top)](#top)
+
+## StorePosition: Action (Stable) [#action_storeposition]
+
+Store the position from the attached sensor
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Slot (Stable)
+
+- The slot to store the position in
+- **Type**: `String`, **Required**, **Computable**
+- **Constraint**: String must be not empty
+
+[(Top)](#top)
+
+## Time: Sensor (Stable) [#sensor_time]
+
+Check if the day/year time is within some specified time. If you want to check a range of time which crosses through midnight and switches to the next day, use the greater time as the min value and the lesser value as the max value.
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Period (Stable)
+
+- The time period to trigger within
+- **Type**: `Array`, **Required**, **Computable**, **Element Type**: Double
+- **Constraint**: Values must be greater or equal than 0, less or equal than 24
+
+#### * CheckDay (Stable)
+
+- Check the day time. When using a double the values go from [.00, .99]. Don't get confused with there only being 60 minutes in an hour.
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+#### * CheckYear (WorkInProgress)
+
+- Check the year time. When using a double the values go from [.00, .99]. Don't get confused with there only being 60 minutes in an hour.
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * ScaleDayTimeRange (Stable)
+
+- Whether to use a relative scale for the day time. Sunrise will be at relative 6, Noon at 12, and Sunset at 18, regardless of actual in-game time
+- **Type**: `Boolean`, **Optional** (Default: true)
+
+[(Top)](#top)
+
+## TriggerSpawners: Action (Stable) [#action_triggerspawners]
+
+Trigger all, or up to a certain number of manual spawn markers in a radius around the NPC
+
+### Attributes
+
+#### - Once (Stable)
+
+- Execute only once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * SpawnMarker (Stable)
+
+- The spawn marker type to trigger
+- **Type**: `Asset`, **Optional** (Default: null), **Computable**
+
+#### * Range (Stable)
+
+- The range within which to trigger spawn markers
+- **Type**: `Double`, **Required**, **Computable**
+- **Constraint**: Value must be greater than 0
+
+#### * Count (Stable)
+
+- The number of markers to randomly trigger (0 will trigger all matching validators)
+- **Type**: `Integer`, **Optional** (Default: 0.0), **Computable**
+- **Constraint**: Value must be greater or equal than 0
+
+[(Top)](#top)
+
+## Weather: Sensor (Stable) [#sensor_weather]
+
+Matches the current weather at the NPCs position against a set of weather globs
+
+### Attributes
+
+#### - Once (Stable)
+
+- Sensor only triggers once
+- **Type**: `Boolean`, **Optional** (Default: false)
+
+#### * Enabled (Stable)
+
+- Whether this sensor should be enabled on the NPC
+- **Type**: `Boolean`, **Optional** (Default: true), **Computable**
+
+#### * Weathers (Stable)
+
+- The glob patterns to match against weather
+- **Type**: `AssetArray`, **Required**, **Computable**, **Element Type**: Weather
+
+[(Top)](#top)
diff --git a/content/docs/bg-BG/official-documentation/npc/1-know-your-enemy.mdx b/content/docs/bg-BG/official-documentation/npc/1-know-your-enemy.mdx
new file mode 100644
index 00000000..233d9caf
--- /dev/null
+++ b/content/docs/bg-BG/official-documentation/npc/1-know-your-enemy.mdx
@@ -0,0 +1,90 @@
+---
+title: 1 - Know Your Enemy
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+Constructing NPCs largely always follows the same set of initial steps:
+
+1. Read through any design documentation.
+2. Figure out how the behaviour breaks down into distinct states.
+3. Identify which parts of the behaviour already exist in predefined components.
+4. Identify any parts of the behaviour that are likely to be reused across other similar templates.
+5. (Optional) Identify any particularly complex parts of the behaviour that are likely to become generally reusable.
+
+For this tutorial, we're looking at the **Goblin Ogre**.
+
+**Minimum design requirements we were given:**
+
+1. A big and slow NPC with a lot of health, found in specific POIs.
+2. Can follow a pre-determined path and guard that position.
+3. Can sleep and if other goblins annoy the Ogre, there will be a special "sleepy" reaction to that.
+4. Can summon rats to eat.
+5. Has a melee attack
+
+**Note:** For the purposes of this tutorial, we'll stick to this design brief, though it may no longer reflect the NPC used in-game.
+
+---
+
+### Step 1: Read the documentation!
+
+This is also a strong suggestion to take a look through the NPC core element documentation and component documentation [here](../npc-doc), if you haven't already. It provides an overview of all core elements available as sensors/actions/motions/etc. Refer to it anytime you want to know if something is possible and what's needed to achieve it (e.g. picking up items). This will also be updated over time as more features are added!
+
+### Step 2: Decide on the states!
+
+The Goblin Ogre isn't too complicated in this regard. We start with the main top-level states:
+
+- An **Idle** state where it mostly remains stationary at a specific point.
+  - This can also encompass its general 'observed' flavour actions.
+  - In many cases, we can include some inter-NPC behaviours here too, unless they require a more complex sequence of actions.
+- A **Sleep** state.
+  - Sleep states are often best kept separate from the idle state, both to take advantage of mechanisms for handling the transition from the state to others (e.g. playing wake up animations) and to accommodate slight changes to the NPC's detection capabilities.
+- An **Eat** state.
+  - With the same reasoning as Sleep.
+- An **Alerted** state.
+  - Almost all NPCs end up having one of these in some form, though they often vary a bit in their intent.
+- A **Combat** state.
+  - While not always the case, it often makes sense to roll all combat into a single distinct state.
+- A **ReturnHome** state.
+  - This applies particularly to NPCs that have stationary guard points.
+  - Essentially handles getting them home again.
+
+Some of these might break down into a set of additional substates handling individual parts of the behavioural logic. For example,
+
+- **Idle**
+  - **.Default** (stand guard and do nothing else)
+  - **.FindFood** (go search for some nearby food if it exists)
+  - **.EatRat** (murder an innocent nearby rat)
+
+Now we have a rough idea of how this NPC is going to be structured at the highest level. With this in mind, we can also see some potential for **state transitions** that make sense.
+
+- **Any State -> Sleep**
+  - Play a laydown animation
+- **Sleep -> Any State**
+  - Play a get up animation
+- **Any State -> Eat**
+  - Prepare items for eating
+- **Eat -> Any State**
+  - Pull out weapons again
+
+These particular state transitions are pretty generic and commonly used, but at this stage, I don't see the need for any others.
+
+### Step 3: Find existing components we can reuse so we can save ourselves some work!
+
+Straight away, there are a few pre-existing components that will make our lives significantly easier.
+
+- We need to chase and attack other targets.
+  - `Component_Instruction_Intelligent_Chase` is built for exactly this purpose and abstracts away a lot of complicated logic needed to make an NPC smartly try to track down a target based on its last seen position.
+  - `Component_Sensor_Standard_Detection` will help setting up NPC senses, like vision and hearing.
+  - `Component_Instruction_Soft_Leash` will make sure the ogre doesn't chase its target to the far reaches of Orbis and will eventually give up if the player is just running away.
+
+These will handle a chunk of our generic combat logic. We also need to add supporting files, like an **Appearance** file that describes what model and animations are to be used and an **Attack Interaction** for combat.
+
+The ogre does more than just attack though! Unfortunately, the bulk of the other behaviour is quite specific to the ogre itself. There are existing components for handling sleep states, but this creature needs to be able to swat at other goblins in its sleep so we can't make use of them. The general idle components aren't much use either, but we might be able to handle the simple standing guard by using `Component_Instruction_Intelligent_Idle_Motion_Follow_Path`. There are also some general utility components that might prove useful as we build up the template, such as `Component_Instruction_Damage_Check`.
+
+### Step 4 & 5: Identify parts we can reuse in other goblins (or are generally useful to have)
+
+There is a small chance that eating rats and searching for food might be reusable for other goblins, but owing to the uncertainty here, it makes sense to build the NPC without worrying too much about it and then extract the logic out into a component later if required.
diff --git a/content/docs/bg-BG/official-documentation/npc/10-attack-a-player.mdx b/content/docs/bg-BG/official-documentation/npc/10-attack-a-player.mdx
new file mode 100644
index 00000000..8752d5fc
--- /dev/null
+++ b/content/docs/bg-BG/official-documentation/npc/10-attack-a-player.mdx
@@ -0,0 +1,323 @@
+---
+title: 10 - Attacking a Player
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+There are actually two parts to dealing with the player in this design description and the resulting state machine. We have the initial **Alerted** state, followed by combat itself. For now, we'll start with implementing all the awareness checks and the **Alerted** state, which acts as a transitional state to the combat behaviours themselves.
+
+First we'll just create the empty **Alerted** state after the **CallRat** state with a timeout to send it back to **Idle**. The template will stop compiling until we add references to it via the awareness checks, but that's fine.
+
+```json
+{
+  "Sensor": {
+    "Type": "State",
+    "State": "Alerted"
+  },
+  "Instructions": [
+    {
+      "Reference": "Component_Instruction_State_Timeout",
+      "Modify": {
+        "_ExportStates": ["Idle"],
+        "Delay": [10, 15]
+      }
+    }
+  ]
+}
+```
+
+There are a number of good components for handling awareness checks. For this we are going to use a handy Sensor component: **Component_Sensor_Standard_Detection**. To make this work, we'll set up an attitude group (**Goblin**) that will likely be shared by all other goblins too and references a pre-existing **Goblin NPC group**. We can detect different NPCs depending on the attitude and react accordingly.
+
+```json
+{
+  "Groups": {
+    "Friendly": ["Goblin"],
+    "Hostile": []
+  }
+}
+```
+
+We don't actually have much in it for now since there aren't many other related NPCs implemented yet, but when there are, we can add any hostiles as hostile. We'll reference this in the parameters and assign it to the attitude group for the ogre, as well as adding a default attitude towards the player (and ignoring most NPCs by default). I'm not really expecting 'friendly' ogres, so I won't bother making the default player attitude a parameter for now.
+
+```json
+"Parameters": {
+	...
+    "AttitudeGroup": {
+        "Value": "Empty",
+        "Description": "This NPCs attitude group"
+    },
+	...
+},
+...
+"DefaultPlayerAttitude": "Hostile",
+"DefaultNPCAttitude": "Ignore",
+"AttitudeGroup": { "Compute": "AttitudeGroup" }
+
+```
+
+In order to configure 'sight' and 'hearing' on the ogre, we also need to add a few more parameters relating to this.
+
+```json
+"Parameters": {
+	...
+    "ViewRange": {
+        "Value": 15,
+        "Description": "View range in blocks"
+    },
+    "ViewSector": {
+        "Value": 180,
+        "Description": "View sector in degrees"
+    },
+    "HearingRange": {
+        "Value": 8,
+        "Description": "Hearing range in blocks"
+    },
+    "AlertedRange": {
+        "Value": 30,
+        "Description": "A range within which the player can be seen/sensed when the NPC is alerted to their presence"
+    },
+    "AbsoluteDetectionRange": {
+        "Value": 4,
+        "Description": "The range at which a target is guaranteed to be detected. If zero, absolute detection will be disabled."
+    },
+	...
+}
+
+```
+
+These parameters are pretty self explanatory, but the **ViewRange/ViewSector** handle how far the ogre can see and his view cone, **HearingRange** handles how far his hearing extends, and **AlertedRange** handles how far away the target can go while still being tracked after the ogre has been alerted to their presence. **AbsoluteDetectionRange** allows us to set a distance at which the Ogre will definitely react to us, regardless of any other conditions.
+
+This Sensor has a few other parameters, for example we can explicitly exclude NPC groups from detection too! But for our purposes, just a simple Attitude filter will work.
+
+Let's talk for a moment about how this works. The sensor has different checks:
+
+- First it checks if there is something in **absolute detection range**, then if nothing satisfies the filter, it checks further.
+- It then **checks if there is a potential target in ViewRange/Sector**. If there's a target within the view cone and range and there's an unobstructed line of sight to it, then we can 'see' it.
+- If the NPC couldn't see anything, it will **try to 'listen'.** This is a little more specific - if a target is walking or running and isn't crouching, we can 'hear' it, regardless of most other factors (though it won't 'hear' through walls). This makes it pretty perceptive, which is why we tend to use it with a much lower detection radius than the view range.
+
+```json
+{
+    "$Comment": "Check for any hostile targets in range that could alert the NPC",
+    "Sensor": {
+        "Reference": "Component_Sensor_Standard_Detection",
+        "Modify": {
+            "ViewRange": { "Compute": "ViewRange" },
+            "ViewSector": { "Compute": "ViewSector" },
+            "HearingRange": { "Compute": "HearingRange" },
+            "ThroughWalls": false,
+            "AbsoluteDetectionRange": { "Compute": "AbsoluteDetectionRange" },
+            "Attitudes": ["Hostile"]
+        }
+    },
+	"Actions": [
+		{
+			"Type": "State",
+			"State": "Alerted"
+		}
+	]
+},
+{
+	"Sensor": {
+		"Type": "State",
+		"State:" ".Default"
+	},
+...
+
+```
+
+At this point, the template will compile again and we can observe in-game that approaching the ogre in various ways results in it switching to the **Alerted** state.
+
+![npc tutorial 5](/assets/official-documentation/npc/npc-tutorial-5.jpg)
+
+We want to add this component to the other idle states too, like sleeping and eating, but we probably want to reduce their detection capabilities a little bit in both cases. Let's add some kind of factor as a parameter.
+
+```json
+"Parameters": {
+	...
+    "DistractedPenalty": {
+        "Value": 2,
+        "Description": "A factor by which view range and hearing range will be divided when this NPC is distracted"
+    },
+	...
+}
+
+```
+
+Then we'll use the previous configuration for the **CallRat** state, but a modified version for both the **Sleep** and **Eat** state. Only the **Sleep** state is shown in this next snippet but the others should follow suit as required. We usually place these checks immediately after any instructions that trigger only **Once** and **Continue** (these are basically initialisation instructions).
+
+```json
+{
+  "Sensor": {
+    "Type": "State",
+    "State": "Sleep"
+  },
+  "Instructions": [
+    {
+      "$Comment": "Check for any hostile targets in range that could alert the NPC",
+      "Sensor": {
+        "Reference": "Component_Sensor_Standard_Detection",
+        "Modify": {
+          "ViewRange": { "Compute": "ViewRange / DistractedPenalty" },
+          "ViewSector": { "Compute": "ViewSector" },
+          "HearingRange": { "Compute": "ViewRange / DistractedPenalty" },
+          "ThroughWalls": false,
+          "AbsoluteDetectionRange": { "Compute": "AbsoluteDetectionRange" },
+          "Attitudes": ["Hostile"]
+        }
+      },
+      "Actions": [
+        {
+          "Type": "State",
+          "State": "Alerted"
+        }
+      ]
+    }
+  ]
+}
+```
+
+Here we can see a feature we haven't used before - the computed value actually encompasses a computation: we're dividing the **ViewRange** and **HearingRange** by the **DistractedPenalty** to result in a restricted detection radius.
+
+Now, regardless of state, the ogre can react to any threats! Next we'll flesh out the **Alerted** state a bit so it actually does what's required of it. Let's recap what that was:
+
+- Stand up if seated (this is covered by the state transitions already)
+- Roar, ordering nearby goblin scrappers to attack
+- Start slowly walking towards the player to attack (we'll consider this part of combat)
+
+In that case, all we need to do here is make the ogre look at its target, play a roaring animation and maybe some particles, and send out a beacon to alert nearby goblin scrappers. First we need a quick **NPC group** (**Goblin_Scrapper**) to define goblin scrappers so that we send our beacon to them specifically.
+
+```json
+{
+  "IncludeRoles": ["Goblin_Scrapper"]
+}
+```
+
+We'll add a parameter referencing this too.
+
+```json
+"Parameters": {
+	...
+    "WarnGroups": {
+        "Value": ["Goblin_Scrapper"],
+        "Description": "The groups to warn when spotting an enemy"
+    }
+	...
+}
+
+```
+
+And then implement the basic parts of the **Alerted** state, ending in a transition into a **Combat** state for combat.
+
+```json
+{
+	"Sensor": {
+		"Type": "State",
+		"State": "Alerted"
+	},
+	"Instructions": [
+		{
+			"Reference": "Component_Instruction_Play_Animation",
+			"Modify": {
+				"Animation": "Alerted"
+			}
+		},
+		{
+			"Continue": true,
+			"Sensor": {
+				"Type": "Target",
+				"Range": { "Compute": "AlertedRange" },
+				"Filters": [
+					{
+						"Type": "LineOfSight"
+					}
+				]
+			},
+			"HeadMotion": {
+				"Type": "Watch"
+			}
+		},
+		{
+			"Sensor": {
+				"Type": "Target",
+				"Range": { "Compute": "AlertedRange" }
+			},
+			"ActionsBlocking": true,
+			"Actions": [
+				{
+					"Type": "Timeout",
+					"Delay": [1, 1]
+				},
+				{
+					"Type": "State",
+					"State": "Combat"
+				}
+			]
+		},
+		{
+			"Actions": [
+				{
+					"Type": "State",
+					"State": "Idle"
+				}
+			]
+		}
+	]
+},
+{
+	"Sensor": {
+		"Type": "State",
+		"State": "Combat"
+	},
+	"Instructions": []
+}
+```
+
+There's a fair bit of logic involved, but it's pretty straightforward. We play an animation, then we watch the target as long as there's line of sight to it. We then have a very short delay before switching to the **Combat** state. We'll handle actually sending the beacon message out to the other goblins using a state transition (and clear the animation at the same time).
+
+```json
+{
+  "States": [
+    {
+      "From": [],
+      "To": ["Combat"]
+    }
+  ],
+  "Actions": [
+    {
+      "Type": "PlayAnimation",
+      "Slot": "Status"
+    },
+    {
+      "Type": "Beacon",
+      "Message": "Goblin_Ogre_Warn",
+      "TargetGroups": { "Compute": "WarnGroups" },
+      "SendTargetSlot": "LockedTarget"
+    }
+  ]
+}
+```
+
+Before we move on to the actual combat behaviours in the **Combat** state, there's one more type of awareness check we need to implement: **damage**. It wouldn't do if a player could just hide away somewhere and snipe at our ogre without him reacting.
+
+We can accomplish this very easily using the `Component_Instruction_Damage_Check` component, which is designed to assess if the NPC has received damage and respond accordingly. If the target is known and within a reasonable distance, it switches to the combat **Chase** state, otherwise it switches to a **Panic** state. Our ogre is pretty tough and has an important job, so we won't actually make him panic - if he takes damage, he's just going to switch to **Alerted** to warn others nearby and then run in and smash the threat!
+
+Though only one instance is shown in the example, we place this in each of the places where we put the sight/sound checks, and we give it a higher priority by putting it first.
+
+```json
+{
+    "Reference": "Component_Instruction_Damage_Check",
+    "Modify": {
+        "_ExportStates": ["Alerted", "Alerted"],
+        "AlertedRange": { "Compute": "AlertedRange" }
+    }
+},
+{
+	"$Comment": "Check for any hostile targets in range that could alert the NPC",
+    "Sensor": {
+		...
+```
+
+With that done, our ogre should respond to everything we need it to! Now we can focus on getting it to actually attack its target!
diff --git a/content/docs/bg-BG/official-documentation/npc/11-melee-combat.mdx b/content/docs/bg-BG/official-documentation/npc/11-melee-combat.mdx
new file mode 100644
index 00000000..49ddd394
--- /dev/null
+++ b/content/docs/bg-BG/official-documentation/npc/11-melee-combat.mdx
@@ -0,0 +1,476 @@
+---
+title: 11 - Melee Combat
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+For the purpose of this Tutorial we'll focus only on the melee attack. We'll start by making an **attack sequence**. Our NPCs can attack using smart decision making with a feature called the Combat Action Evaluator (CAE), but for this tutorial we'll just stick to simple sequences.
+
+This will also allow for a quick look into the adjacent Interactions system. First we need to create a **Root Interaction** in **HytaleAssets/Server/Item/RootInteractions**, together with other Root interactions. Let's make a **Root_NPC_Goblin_Ogre_Attack** interaction:
+
+```json
+{
+  "Interactions": [
+    {
+      "Type": "Chaining",
+      "ChainId": "Slashes",
+      "ChainingAllowance": 15,
+      "Next": [
+        "Goblin_Ogre_Swing_Left",
+        "Goblin_Ogre_Swing_Right",
+        "Goblin_Ogre_Swing_Down"
+      ]
+    }
+  ],
+  "Tags": {
+    "Attack": ["Melee"]
+  }
+}
+```
+
+This is a simple chaining Interaction where the ogre will perform **Swing_Left** and, so long as the next attack happens within 15 seconds, he will use **Swing_Right**. If he then manages to attack us a third time within 15 seconds he'll use the **Swing_Down** attack.
+
+These swing interactions need to be created in the **HytaleAssets/Server/Item/Interactions** folder. Let's make the **Goblin_Ogre_Swing_Left** interaction:
+
+```json
+{
+  "Type": "Simple",
+  "Effects": {
+    "ItemPlayerAnimationsId": "Goblin_Club",
+    "ItemAnimationId": "SwingLeft"
+  },
+  "$Comment": "Prepare Delay",
+  "RunTime": 0.2,
+  "Next": {
+    "Type": "Selector",
+    "$Comment": "Length of Combat",
+    "RunTime": 0.25,
+    "Selector": {
+      "Id": "Horizontal",
+      "Direction": "ToLeft",
+      "TestLineOfSight": true,
+      "ExtendTop": 0.5,
+      "ExtendBottom": 2,
+      "StartDistance": 0.1,
+      "EndDistance": 3.5,
+      "Length": 60,
+      "RollOffset": 0,
+      "YawStartOffset": -30
+    },
+    "HitEntity": {
+      "Interactions": [
+        {
+          "Parent": "DamageEntityParent",
+          "DamageCalculator": {
+            "BaseDamage": {
+              "Physical": 8
+            }
+          },
+          "DamageEffects": {
+            "Knockback": {
+              "Force": 0.5,
+              "RelativeX": -5,
+              "RelativeZ": -5,
+              "VelocityY": 5
+            },
+            "WorldSoundEventId": "SFX_Unarmed_Impact",
+            "WorldParticles": [
+              {
+                "SystemId": "Impact_Blade_01"
+              }
+            ]
+          }
+        }
+      ]
+    },
+    "Next": {
+      "Type": "Simple",
+      "$Comment": "Pad the interaction length",
+      "RunTime": 0.1
+    }
+  }
+}
+```
+
+Now we need to approach the target and use our fancy attack sequence. Again, there are a few components that will make most of this much simpler to do:
+
+- `Component_Instruction_Soft_Leash` will work in conjunction with an external **ReturnHome** state to send the ogre back to his start point if we get him too far away.
+- `Component_Instruction_Intelligent_Chase` will handle smartly chasing the target based on its last known position and will trigger pathfinding where necessary. We might want to add an extra **Search** state for this.
+
+Let's create the states we need. First, Combat itself, but since we're going to be using `Component_Instruction_Intelligent_Chase`, this component needs to know where to switch when the Target is lost or if the NPC is too far away. Let's create two states: **Search** and **ReturnHome** that will be used there.
+
+```json
+{
+	"Sensor": {
+		"Type": "State",
+		"State": "Combat"
+	},
+	"Instructions": [],
+},
+{
+	"Sensor": {
+		"Type": "State",
+		"State": "ReturnHome"
+	},
+	"Instructions": []
+},
+{
+	"Sensor": {
+		"Type": "State",
+		"State": "Search"
+	},
+	"Instructions": []
+}
+```
+
+Let's start with chasing the target. We wrap that behavior in sub state **.Chase** so we can fall back to it when the target gets out of attack range and the NPC needs to run after it in a somewhat intelligent manner.
+
+```json
+{
+  "Sensor": {
+    "Type": "State",
+    "State": "Combat"
+  },
+  "Instructions": [
+    {
+      "Sensor": {
+        "Type": "State",
+        "State": ".Chase"
+      },
+      "Instructions": [
+        {
+          "Sensor": {
+            "Type": "Target",
+            "Range": { "Compute": "AttackDistance" },
+            "Filters": [
+              {
+                "Type": "LineOfSight"
+              }
+            ]
+          },
+          "Actions": [
+            {
+              "Type": "State",
+              "State": ".Default"
+            }
+          ]
+        },
+        {
+          "Reference": "Component_Instruction_Soft_Leash",
+          "Modify": {
+            "_ExportStates": ["ReturnHome"],
+            "LeashDistance": { "Compute": "LeashDistance" },
+            "LeashMinPlayerDistance": { "Compute": "LeashMinPlayerDistance" },
+            "LeashTimer": { "Compute": "LeashTimer" },
+            "HardLeashDistance": { "Compute": "HardLeashDistance" }
+          }
+        },
+        {
+          "Reference": "Component_Instruction_Intelligent_Chase",
+          "Modify": {
+            "_ExportStates": ["Search", "Search", "ReturnHome"],
+            "ViewRange": { "Compute": "AlertedRange * 2" },
+            "HearingRange": { "Compute": "HearingRange * 2" },
+            "StopDistance": 0.1,
+            "RelativeSpeed": 0.5
+          }
+        }
+      ]
+    }
+  ]
+}
+```
+
+- First, it checks if the target is within AttackDistance. If so, we switch to the default combat state.
+- If the NPC gets too far away from its leash position (often the spawn position), we use `Component_Instruction_Soft_Leash` to send it home. We put this sensor in front of the chase state so that we don't continue chasing if the leash kicks in. There's a **Leash Timer** on this component that decides when it's time to give up.
+- And finally the chase component itself, which performs 'intelligent' chasing of the target.
+
+When the Target is within the **AttackDistance**, we perform the attack, otherwise we switch to the chase state. Let's start with the case where the target is within a melee range.
+
+```json
+{
+	"Sensor": {
+		"Type": "State",
+		"State": "Combat"
+	},
+	"Instructions": [
+		{
+			"Sensor": {
+				"Type": "State",
+				"State": ".Chase"
+			},
+			"Instructions": [ ... ]
+		},
+		{
+			"$Comment": "NPC melee attack",
+			"Sensor": {
+				"Type": "Target",
+				"Range": { "Compute": "AttackDistance" },
+				"Filters": [
+					{
+						"Type": "LineOfSight"
+					}
+				]
+			},
+			"ActionsBlocking": true,
+			"Actions": [
+				{
+					"Type": "Attack",
+					"Attack": { "Compute": "Attack" },
+					"AttackPauseRange": { "Compute": "AttackPauseRange" }
+				},
+				{
+					"Comment": "Brief delay to prevent the NPC potentially strafing/backing away and missing the shot.",
+					"Type": "Timeout",
+					"Delay": [0.2, 0.2]
+				}
+			],
+			"HeadMotion": {
+				"Type": "Aim",
+				"RelativeTurnSpeed": { "Compute": "CombatRelativeTurnSpeed" }
+			}
+		},
+		{
+			"Actions": [
+				{
+					"Type": "State",
+					"State": ".Chase"
+				}
+			]
+		}
+	]
+},
+```
+
+The important things to note here are the **AttackDistance**, **AttackPauseRange** and **CombatRelativeTurnSpeed**. We're going to configure both of these via the template itself.
+
+**AttackDistance** refers to the distance at which the ogre will attempt to perform melee attacks to hit the target (though the actual range of the attack itself is defined in the **Attack** interaction). **CombatRelativeTurnSpeed** allows us to define how quickly (or slowly) the ogre rotates while in combat. **AttackPauseRange** defines how often the attacks will be performed a bit like an attack cooldown.
+
+Let's make sure we have all these parameters added in the list:
+
+```json
+"Attack": {
+    "Value": "Root_NPC_Goblin_Ogre_Attack",
+    "Description": "The attack to use."
+},
+"AttackDistance": {
+    "Value": 2,
+    "Description": "The distance at which an NPC will execute attacks"
+},
+"AttackPauseRange": {
+    "Value": [1.5, 2],
+    "Description": "the range for absolute minimum time before an NPC can execute a second attack (or block)."
+},
+"CombatRelativeTurnSpeed": {
+    "Value": 1.5,
+    "Description": "Modifier that decides turn speed difference in combat."
+},
+"LeashDistance": {
+    "Value": 20,
+    "Description": "The range after which an NPC will start to want to return to their spawn point."
+},
+"LeashMinPlayerDistance": {
+    "Value": 4,
+    "Description": "The minimum distance from the player before the NPC will be willing to give up on the chase."
+},
+"LeashTimer": {
+    "Value": [3, 5],
+    "Description": "How long the NPC must be more than the minimum distance form the player and too far from leash before giving up."
+},
+"HardLeashDistance": {
+    "Value": 60,
+    "Description": "An absolute maximum from the the leash position the NPC can go before turning back."
+},
+
+```
+
+Now the NPC will attack, but we still need to add **Search** and **ReturnHome** logic. We can do that right away, so we have a fully functional melee ogre.
+
+```json
+{
+	"Sensor": {
+		"Type": "State",
+		"State": "ReturnHome"
+	},
+	"Instructions": [
+		{
+			"Sensor": {
+				"Type": "And",
+				"Sensors": [
+					{
+						"Type": "Damage",
+						"Combat": true,
+						"TargetSlot": "LockedTarget"
+					},
+					{
+						"Enabled": { "Compute": "AbsoluteDetectionRange > 0" },
+						"Type": "Target",
+						"TargetSlot": "LockedTarget",
+						"Range": { "Compute": "AbsoluteDetectionRange" }
+					}
+				]
+			},
+			"Actions": [
+				{
+					"Type": "State",
+					"State": "Combat"
+				}
+			]
+		},
+		{
+			"Sensor": {
+				"Type": "Leash",
+				"Range": { "Compute": "LeashDistance * 0.3" }
+			},
+			"BodyMotion": {
+				"Type": "Seek",
+				"SlowDownDistance": { "Compute": "LeashDistance * 0.4" },
+				"StopDistance": { "Compute": "LeashDistance * 0.2" },
+				"RelativeSpeed": 0.8,
+				"UsePathfinder": true
+			}
+		},
+		{
+			"Actions": [
+				{
+					"Type": "SetStat",
+					"Stat": "Health",
+					"Value": 1000000
+				},
+				{
+					"Type": "State",
+					"State": "Idle"
+				}
+			]
+		}
+	]
+},
+```
+
+There are 3 parts to this state: first, it checks if there is incoming combat damage and will switch to Combat if so. We don't want to leave NPCs exploitable as they're running home by having them ignore all attacks. If there's no incoming damage it will find its way home using **BodyMotion: Seek**. We need to be careful here though, since it might become expensive due to **"UsePathfinder": true** turning on complex pathfinding. The last block simply heals the NPC to full health and moves it to idle once it's found its home spot again.
+
+The Search state makes use of `Component_Sensor_Lost_Target_Detection`.
+
+```json
+{
+  "Sensor": {
+    "Type": "State",
+    "State": "Search"
+  },
+  "Instructions": [
+    {
+      "Sensor": {
+        "Type": "Damage",
+        "Combat": true,
+        "TargetSlot": "LockedTarget"
+      },
+      "Actions": [
+        {
+          "Type": "State",
+          "State": "Alerted"
+        }
+      ]
+    },
+    {
+      "Instructions": [
+        {
+          "Sensor": {
+            "Reference": "Component_Sensor_Lost_Target_Detection",
+            "Modify": {
+              "ViewRange": { "Compute": "ViewRange" },
+              "ViewSector": { "Compute": "ViewSector" },
+              "HearingRange": { "Compute": "HearingRange" },
+              "AbsoluteDetectionRange": { "Compute": "AbsoluteDetectionRange" },
+              "TargetSlot": "LockedTarget"
+            }
+          },
+          "Actions": [
+            {
+              "Type": "State",
+              "State": "Combat"
+            }
+          ]
+        },
+        {
+          "Sensor": {
+            "Reference": "Component_Sensor_Standard_Detection",
+            "Modify": {
+              "ViewRange": { "Compute": "ViewRange" },
+              "ViewSector": { "Compute": "ViewSector" },
+              "HearingRange": { "Compute": "HearingRange" },
+              "AbsoluteDetectionRange": { "Compute": "AbsoluteDetectionRange" },
+              "Attitudes": ["Hostile", "Neutral"]
+            }
+          },
+          "Actions": [
+            {
+              "Type": "State",
+              "State": "Alerted"
+            }
+          ]
+        },
+        {
+          "BodyMotion": {
+            "Type": "Sequence",
+            "Motions": [
+              {
+                "Type": "Timer",
+                "Time": [3, 6],
+                "Motion": {
+                  "Type": "Wander",
+                  "MaxHeadingChange": 1,
+                  "RelativeSpeed": 0.5
+                }
+              },
+              {
+                "Type": "Sequence",
+                "Looped": true,
+                "Motions": [
+                  {
+                    "Type": "Timer",
+                    "Time": [3, 6],
+                    "Motion": {
+                      "Type": "WanderInCircle",
+                      "Radius": 10,
+                      "MaxHeading Change": 60,
+                      "RelativeSpeed": 0.5
+                    }
+                  },
+                  {
+                    "Type": "Timer",
+                    "Time": [2, 3],
+                    "Motion": {
+                      "Type": "Nothing"
+                    }
+                  }
+                ]
+              }
+            ]
+          },
+          "ActionsBlocking": true,
+          "Actions": [
+            {
+              "Type": "Timeout",
+              "Delay": [4, 5]
+            },
+            {
+              "Type": "State",
+              "State": "Idle"
+            }
+          ]
+        }
+      ]
+    }
+  ]
+}
+```
+
+The search state will first check if there is incoming damage and will switch to the alerted state if so. If not it'll execute the next block of instructions using pre-existing components:
+
+- Check if the lost target is detected with the **Lost Target detection sensor**. If so, switch to combat.
+- Check if any other target is available through the **Standard detection sensor**. If so, switch to the alerted state.
+- Otherwise the NPC will move around using the **Wander** motion, stopping briefly in between until it gives up and...
+- ...goes back to being idle.
diff --git a/content/docs/bg-BG/official-documentation/npc/12-appendix.mdx b/content/docs/bg-BG/official-documentation/npc/12-appendix.mdx
new file mode 100644
index 00000000..fdb07289
--- /dev/null
+++ b/content/docs/bg-BG/official-documentation/npc/12-appendix.mdx
@@ -0,0 +1,1035 @@
+---
+title: 12 - Appendix
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Template_Goblin_Ogre_Tutorial
+
+(dependant on Root_NPC_Goblin_Ogre_Attack - you need this file to exist, because template is referencing it)
+
+```json
+{
+  "$Comment": "Debug: DisplayState",
+  "Debug": "DisplayState",
+  "Type": "Abstract",
+  "Parameters": {
+    "Appearance": {
+      "Value": "Bear_Grizzly",
+      "Description": "Model to be used"
+    },
+    "DropList": {
+      "Value": "Empty",
+      "Description": "Drop Items"
+    },
+    "MaxHealth": {
+      "Value": 100,
+      "Description": "Max health for the NPC"
+    },
+    "EatItem": {
+      "Value": "Food_Beef_Raw",
+      "Description": "The item this NPC will find when it rummages for food"
+    },
+    "SleepingAttack": {
+      "Value": "Root_NPC_Attack_Melee",
+      "Description": "Attack to use on NPCs that annoy it while sleeping"
+    },
+    "FoodNPCGroups": {
+      "Value": ["Edible_Rat"],
+      "Description": "The groups of edible NPCs that will come from triggering the beacon"
+    },
+    "FoodNPCBeacon": {
+      "Value": "Edible_Rat",
+      "Description": "The spawn beacon to trigger to create an edible NPC"
+    },
+    "FoodNPCItem": {
+      "Value": "Food_Cheese",
+      "Description": "The edible NPC in item form"
+    },
+    "ViewRange": {
+      "Value": 15,
+      "Description": "View range in blocks"
+    },
+    "ViewSector": {
+      "Value": 180,
+      "Description": "View sector in degrees"
+    },
+    "HearingRange": {
+      "Value": 8,
+      "Description": "Hearing range in blocks"
+    },
+    "AlertedRange": {
+      "Value": 30,
+      "Description": "A range within which the player can be seen/sensed when the NPC is alerted to their presence"
+    },
+    "DistractedPenalty": {
+      "Value": 2,
+      "Description": "A factor by which view range and hearing range will be divided when this NPC is distracted"
+    },
+    "AbsoluteDetectionRange": {
+      "Value": 4,
+      "Description": "The range at which a target is guaranteed to be detected. If zero, absolute detection will be disabled."
+    },
+    "WarnGroups": {
+      "Value": ["Goblin_Scrapper"],
+      "Description": "The groups to warn when spotting an enemy"
+    },
+    "AttitudeGroup": {
+      "Value": "Empty",
+      "Description": "This NPCs attitude group"
+    },
+    "Attack": {
+      "Value": "Root_NPC_Goblin_Ogre_Attack",
+      "Description": "The attack to use."
+    },
+    "AttackDistance": {
+      "Value": 2,
+      "Description": "The distance at which an NPC will execute attacks"
+    },
+    "AttackPauseRange": {
+      "Value": [1.5, 2],
+      "Description": "The range for absolute minimum time before an NPC can execute a second attack (or block)."
+    },
+    "CombatRelativeTurnSpeed": {
+      "Value": 1.5,
+      "Description": "Modifier that decides turn speed difference in combat."
+    },
+    "LeashDistance": {
+      "Value": 20,
+      "Description": "The range after which an NPC will start to want to return to their spawn point."
+    },
+    "LeashMinPlayerDistance": {
+      "Value": 4,
+      "Description": "The minimum distance from the player before the NPC will be willing to give up on the chase."
+    },
+    "LeashTimer": {
+      "Value": [3, 5],
+      "Description": "How long the NPC must be more than the minimum distance form the player and too far from leash before giving up."
+    },
+    "HardLeashDistance": {
+      "Value": 60,
+      "Description": "An absolute maximum from the the leash position the NPC can go before turning back."
+    },
+    "NameTranslationKey": {
+      "Value": "server.npcRoles.Template.name",
+      "Description": "Translation key for NPC name display"
+    }
+  },
+  "Appearance": { "Compute": "Appearance" },
+  "DropList": { "Compute": "DropList" },
+  "MaxHealth": { "Compute": "MaxHealth" },
+  "StartState": "Idle",
+  "DefaultPlayerAttitude": "Hostile",
+  "DefaultNPCAttitude": "Ignore",
+  "AttitudeGroup": { "Compute": "AttitudeGroup" },
+  "KnockbackScale": 0.5,
+  "MotionControllerList": [
+    {
+      "Type": "Walk",
+      "MaxWalkSpeed": 3,
+      "Gravity": 10,
+      "MaxFallSpeed": 8,
+      "Acceleration": 10
+    }
+  ],
+  "InteractionVars": {
+    "Melee_Damage": {
+      "Interactions": [
+        {
+          "$Comment": "Config for a successful melee hit, default values for Effects and Hitshape are not overwritten here, see each NPC_ file",
+          "Parent": "NPC_Attack_Melee_Damage",
+          "DamageCalculator": {
+            "Type": "Absolute",
+            "BaseDamage": {
+              "Physical": 10
+            },
+            "RandomPercentageModifier": 0.1
+          }
+        }
+      ]
+    }
+  },
+  "StateTransitions": [
+    {
+      "States": [
+        {
+          "From": ["Idle"],
+          "To": ["Sleep"]
+        }
+      ],
+      "Actions": [
+        {
+          "Type": "PlayAnimation",
+          "Slot": "Status",
+          "Animation": "Laydown"
+        },
+        {
+          "Type": "Timeout",
+          "Delay": [1, 1]
+        }
+      ]
+    },
+    {
+      "States": [
+        {
+          "From": ["Sleep"],
+          "To": []
+        }
+      ],
+      "Actions": [
+        {
+          "Type": "PlayAnimation",
+          "Slot": "Status",
+          "Animation": "Wake"
+        },
+        {
+          "Type": "Timeout",
+          "Delay": [1, 1]
+        }
+      ]
+    },
+    {
+      "States": [
+        {
+          "From": ["Idle"],
+          "To": ["Eat"]
+        }
+      ],
+      "Actions": [
+        {
+          "Type": "Inventory",
+          "Operation": "SetHotbar",
+          "Item": { "Compute": "EatItem" },
+          "Slot": 2,
+          "UseTarget": false
+        },
+        {
+          "Type": "Inventory",
+          "Operation": "EquipHotbar",
+          "Slot": 2,
+          "UseTarget": false
+        }
+      ]
+    },
+    {
+      "States": [
+        {
+          "From": ["CallRat"],
+          "To": ["Eat"]
+        }
+      ],
+      "Actions": [
+        {
+          "Type": "Inventory",
+          "Operation": "SetHotbar",
+          "Item": { "Compute": "FoodNPCItem" },
+          "Slot": 2,
+          "UseTarget": false
+        },
+        {
+          "Type": "Inventory",
+          "Operation": "EquipHotbar",
+          "Slot": 2,
+          "UseTarget": false
+        }
+      ]
+    },
+    {
+      "States": [
+        {
+          "From": ["Eat"],
+          "To": []
+        }
+      ],
+      "Actions": [
+        {
+          "Type": "PlayAnimation",
+          "Slot": "Status"
+        },
+        {
+          "Type": "Inventory",
+          "Operation": "EquipHotbar",
+          "Slot": 0,
+          "UseTarget": false
+        }
+      ]
+    },
+    {
+      "States": [
+        {
+          "From": [],
+          "To": ["Combat"]
+        }
+      ],
+      "Actions": [
+        {
+          "Type": "PlayAnimation",
+          "Slot": "Status"
+        },
+        {
+          "Type": "Beacon",
+          "Message": "Goblin_Ogre_Warn",
+          "TargetGroups": { "Compute": "WarnGroups" },
+          "SendTargetSlot": "LockedTarget"
+        }
+      ]
+    }
+  ],
+  "Instructions": [
+    {
+      "Sensor": {
+        "Type": "State",
+        "State": "Idle"
+      },
+      "Instructions": [
+        {
+          "Continue": true,
+          "Sensor": {
+            "Type": "Any",
+            "Once": true
+          },
+          "Actions": [
+            {
+              "Type": "Inventory",
+              "Operation": "EquipHotbar",
+              "Slot": 0,
+              "UseTarget": false
+            }
+          ]
+        },
+        {
+          "Reference": "Component_Instruction_Damage_Check",
+          "Modify": {
+            "_ExportStates": ["Alerted", "Alerted"],
+            "AlertedRange": { "Compute": "AlertedRange" }
+          }
+        },
+        {
+          "$Comment": "Check for any hostile targets in range that could alert the NPC",
+          "Sensor": {
+            "Reference": "Component_Sensor_Standard_Detection",
+            "Modify": {
+              "ViewRange": { "Compute": "ViewRange" },
+              "ViewSector": { "Compute": "ViewSector" },
+              "HearingRange": { "Compute": "HearingRange" },
+              "ThroughWalls": false,
+              "AbsoluteDetectionRange": { "Compute": "AbsoluteDetectionRange" },
+              "Attitudes": ["Hostile"]
+            }
+          },
+          "Actions": [
+            {
+              "Type": "State",
+              "State": "Alerted"
+            }
+          ]
+        },
+        {
+          "Sensor": {
+            "Type": "State",
+            "State": ".Default"
+          },
+          "Instructions": [
+            {
+              "Actions": [
+                {
+                  "Type": "Random",
+                  "Actions": [
+                    {
+                      "Weight": 10,
+                      "Action": {
+                        "Type": "State",
+                        "State": ".Guard"
+                      }
+                    },
+                    {
+                      "Weight": 10,
+                      "Action": {
+                        "Type": "State",
+                        "State": "Sleep"
+                      }
+                    },
+                    {
+                      "Weight": 10,
+                      "Action": {
+                        "Type": "State",
+                        "State": "Eat"
+                      }
+                    },
+                    {
+                      "Weight": 10,
+                      "Action": {
+                        "Type": "State",
+                        "State": "CallRat"
+                      }
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        },
+        {
+          "Sensor": {
+            "Type": "State",
+            "State": ".Guard"
+          },
+          "Instructions": [
+            {
+              "Continue": true,
+              "ActionsBlocking": true,
+              "Actions": [
+                {
+                  "Type": "Timeout",
+                  "Delay": [5, 10]
+                },
+                {
+                  "Type": "State",
+                  "State": ".Default"
+                }
+              ]
+            },
+            {
+              "Reference": "Component_Instruction_Intelligent_Idle_Motion_Follow_Path"
+            }
+          ]
+        }
+      ]
+    },
+    {
+      "Sensor": {
+        "Type": "State",
+        "State": "Sleep"
+      },
+      "Instructions": [
+        {
+          "Reference": "Component_Instruction_Damage_Check",
+          "Modify": {
+            "_ExportStates": ["Alerted", "Alerted"],
+            "AlertedRange": { "Compute": "AlertedRange" }
+          }
+        },
+        {
+          "$Comment": "Check for any hostile targets in range that could alert the NPC",
+          "Sensor": {
+            "Reference": "Component_Sensor_Standard_Detection",
+            "Modify": {
+              "ViewRange": { "Compute": "ViewRange / DistractedPenalty" },
+              "ViewSector": { "Compute": "ViewSector" },
+              "HearingRange": { "Compute": "ViewRange / DistractedPenalty" },
+              "ThroughWalls": false,
+              "AbsoluteDetectionRange": { "Compute": "AbsoluteDetectionRange" },
+              "Attitudes": ["Hostile"]
+            }
+          },
+          "Actions": [
+            {
+              "Type": "State",
+              "State": "Alerted"
+            }
+          ]
+        },
+        {
+          "Reference": "Component_Instruction_Play_Animation_In_State_For_Duration",
+          "Modify": {
+            "_ExportStates": ["Idle.Default"],
+            "Animation": "Sleep",
+            "Duration": [5, 6]
+          }
+        },
+        {
+          "Sensor": {
+            "Type": "Beacon",
+            "Message": "Annoy_Ogre",
+            "Range": 5
+          },
+          "Actions": [
+            {
+              "Type": "Attack",
+              "Attack": { "Compute": "SleepingAttack" },
+              "AttackPauseRange": [1, 2]
+            }
+          ]
+        }
+      ]
+    },
+    {
+      "Sensor": {
+        "Type": "State",
+        "State": "Eat"
+      },
+      "Instructions": [
+        {
+          "Reference": "Component_Instruction_Damage_Check",
+          "Modify": {
+            "_ExportStates": ["Alerted", "Alerted"],
+            "AlertedRange": { "Compute": "AlertedRange" }
+          }
+        },
+        {
+          "$Comment": "Check for any hostile targets in range that could alert the NPC",
+          "Sensor": {
+            "Reference": "Component_Sensor_Standard_Detection",
+            "Modify": {
+              "ViewRange": { "Compute": "ViewRange / DistractedPenalty" },
+              "ViewSector": { "Compute": "ViewSector" },
+              "HearingRange": { "Compute": "ViewRange / DistractedPenalty" },
+              "ThroughWalls": false,
+              "AbsoluteDetectionRange": { "Compute": "AbsoluteDetectionRange" },
+              "Attitudes": ["Hostile"]
+            }
+          },
+          "Actions": [
+            {
+              "Type": "State",
+              "State": "Alerted"
+            }
+          ]
+        },
+        {
+          "Reference": "Component_Instruction_Play_Animation_In_State_For_Duration",
+          "Modify": {
+            "_ExportStates": ["Idle.Default"],
+            "Animation": "Eat",
+            "Duration": [5, 6]
+          }
+        }
+      ]
+    },
+    {
+      "Sensor": {
+        "Type": "State",
+        "State": "CallRat"
+      },
+      "Instructions": [
+        {
+          "Continue": true,
+          "Sensor": {
+            "Type": "Any",
+            "Once": true
+          },
+          "Actions": [
+            {
+              "Type": "TriggerSpawnBeacon",
+              "BeaconSpawn": { "Compute": "FoodNPCBeacon" },
+              "Range": 15
+            }
+          ]
+        },
+        {
+          "Reference": "Component_Instruction_Damage_Check",
+          "Modify": {
+            "_ExportStates": ["Alerted", "Alerted"],
+            "AlertedRange": { "Compute": "AlertedRange" }
+          }
+        },
+        {
+          "$Comment": "Check for any hostile targets in range that could alert the NPC",
+          "Sensor": {
+            "Reference": "Component_Sensor_Standard_Detection",
+            "Modify": {
+              "ViewRange": { "Compute": "ViewRange" },
+              "ViewSector": { "Compute": "ViewSector" },
+              "HearingRange": { "Compute": "HearingRange" },
+              "ThroughWalls": false,
+              "AbsoluteDetectionRange": { "Compute": "AbsoluteDetectionRange" },
+              "Attitudes": ["Hostile"]
+            }
+          },
+          "Actions": [
+            {
+              "Type": "State",
+              "State": "Alerted"
+            }
+          ]
+        },
+        {
+          "Sensor": {
+            "Type": "Mob",
+            "Range": 2.5,
+            "Filters": [
+              {
+                "Type": "NPCGroup",
+                "IncludeGroups": { "Compute": "FoodNPCGroups" }
+              },
+              {
+                "Type": "LineOfSight"
+              }
+            ]
+          },
+          "HeadMotion": {
+            "Type": "Watch"
+          },
+          "ActionsBlocking": true,
+          "Actions": [
+            {
+              "Type": "PlayAnimation",
+              "Slot": "Status",
+              "Animation": "Swipe"
+            },
+            {
+              "Type": "Timeout",
+              "Delay": [0.1, 0.1],
+              "Action": {
+                "Type": "Sequence",
+                "Actions": [
+                  {
+                    "Type": "Remove"
+                  },
+                  {
+                    "Type": "State",
+                    "State": "Eat"
+                  }
+                ]
+              }
+            }
+          ]
+        },
+        {
+          "Continue": true,
+          "Sensor": {
+            "Type": "Mob",
+            "Range": 5,
+            "Filters": [
+              {
+                "Type": "NPCGroup",
+                "IncludeGroups": { "Compute": "FoodNPCGroups" }
+              },
+              {
+                "Type": "LineOfSight"
+              }
+            ]
+          },
+          "HeadMotion": {
+            "Type": "Watch"
+          }
+        },
+        {
+          "Reference": "Component_Instruction_State_Timeout",
+          "Modify": {
+            "_ExportStates": ["Idle"],
+            "Delay": [10, 15]
+          }
+        }
+      ]
+    },
+    {
+      "Sensor": {
+        "Type": "State",
+        "State": "Alerted"
+      },
+      "Instructions": [
+        {
+          "Reference": "Component_Instruction_Play_Animation",
+          "Modify": {
+            "Animation": "Alerted"
+          }
+        },
+        {
+          "Continue": true,
+          "Sensor": {
+            "Type": "Target",
+            "Range": { "Compute": "AlertedRange" },
+            "Filters": [
+              {
+                "Type": "LineOfSight"
+              }
+            ]
+          },
+          "HeadMotion": {
+            "Type": "Watch"
+          }
+        },
+        {
+          "Sensor": {
+            "Type": "Target",
+            "Range": { "Compute": "AlertedRange" }
+          },
+          "ActionsBlocking": true,
+          "Actions": [
+            {
+              "Type": "Timeout",
+              "Delay": [1, 1]
+            },
+            {
+              "Type": "State",
+              "State": "Combat"
+            }
+          ]
+        }
+      ]
+    },
+    {
+      "Sensor": {
+        "Type": "State",
+        "State": "Combat"
+      },
+      "Instructions": [
+        {
+          "Sensor": {
+            "Type": "State",
+            "State": ".Chase"
+          },
+          "Instructions": [
+            {
+              "Sensor": {
+                "Type": "Target",
+                "Range": { "Compute": "AttackDistance" },
+                "Filters": [
+                  {
+                    "Type": "LineOfSight"
+                  }
+                ]
+              },
+              "Actions": [
+                {
+                  "Type": "State",
+                  "State": ".Default"
+                }
+              ]
+            },
+            {
+              "Reference": "Component_Instruction_Soft_Leash",
+              "Modify": {
+                "_ExportStates": ["ReturnHome"],
+                "LeashDistance": { "Compute": "LeashDistance" },
+                "LeashMinPlayerDistance": {
+                  "Compute": "LeashMinPlayerDistance"
+                },
+                "LeashTimer": { "Compute": "LeashTimer" },
+                "HardLeashDistance": { "Compute": "HardLeashDistance" }
+              }
+            },
+            {
+              "Reference": "Component_Instruction_Intelligent_Chase",
+              "Modify": {
+                "_ExportStates": ["Search", "Search", "ReturnHome"],
+                "ViewRange": { "Compute": "AlertedRange * 2" },
+                "HearingRange": { "Compute": "HearingRange * 2" },
+                "StopDistance": 0.1,
+                "RelativeSpeed": 0.5
+              }
+            }
+          ]
+        },
+        {
+          "$Comment": "NPC melee attack",
+          "Sensor": {
+            "Type": "Target",
+            "Range": { "Compute": "AttackDistance" },
+            "Filters": [
+              {
+                "Type": "LineOfSight"
+              }
+            ],
+            "ActionsBlocking": true,
+            "Actions": [
+              {
+                "Type": "Attack",
+                "Attack": { "Compute": "Attack" },
+                "AttackPauseRange": { "Compute": "AttackPauseRange" }
+              },
+              {
+                "$Comment": "Brief delay to prevent the NPC potentially strafing/backing away and missing the shot.",
+                "Type": "Timeout",
+                "Delay": [0.2, 0.2]
+              }
+            ],
+            "HeadMotion": {
+              "Type": "Aim",
+              "RelativeTurnSpeed": { "Compute": "CombatRelativeTurnSpeed" }
+            }
+          },
+          "Actions": [
+            {
+              "Type": "State",
+              "State": ".Chase"
+            }
+          ]
+        }
+      ]
+    },
+    {
+      "Sensor": {
+        "Type": "State",
+        "State": "ReturnHome"
+      },
+      "Instructions": [
+        {
+          "Sensor": {
+            "Type": "And",
+            "Sensors": [
+              {
+                "Type": "Damage",
+                "Combat": true,
+                "TargetSlot": "LockedTarget",
+                "Enabled": { "Compute": "AbsoluteDetectionRange > 0" }
+              },
+              {
+                "Type": "Target",
+                "TargetSlot": "LockedTarget",
+                "Range": { "Compute": "AbsoluteDetectionRange" }
+              }
+            ]
+          },
+          "Actions": [
+            {
+              "Type": "State",
+              "State": "Combat"
+            }
+          ]
+        },
+        {
+          "Sensor": {
+            "Type": "Leash",
+            "Range": { "Compute": "LeashDistance * 0.3" },
+            "BodyMotion": {
+              "Type": "Seek",
+              "SlowDownDistance": { "Compute": "LeashDistance * 0.4" },
+              "StopDistance": { "Compute": "LeashDistance * 0.2" },
+              "RelativeSpeed": 0.8,
+              "UsePathfinder": true
+            }
+          },
+          "Actions": [
+            {
+              "Type": "SetStat",
+              "Stat": "Health",
+              "Value": 1000000
+            },
+            {
+              "Type": "State",
+              "State": "Idle"
+            }
+          ]
+        }
+      ]
+    },
+    {
+      "Sensor": {
+        "Type": "State",
+        "State": "Search"
+      },
+      "Instructions": [
+        {
+          "Sensor": {
+            "Type": "Damage",
+            "Combat": true,
+            "TargetSlot": "LockedTarget"
+          },
+          "Actions": [
+            {
+              "Type": "State",
+              "State": "Alerted"
+            }
+          ]
+        },
+        {
+          "Instructions": [
+            {
+              "Sensor": {
+                "Reference": "Component_Sensor_Lost_Target_Detection",
+                "Modify": {
+                  "ViewRange": { "Compute": "ViewRange" },
+                  "ViewSector": { "Compute": "ViewSector" },
+                  "HearingRange": { "Compute": "HearingRange" },
+                  "AbsoluteDetectionRange": {
+                    "Compute": "AbsoluteDetectionRange"
+                  },
+                  "TargetSlot": "LockedTarget"
+                }
+              },
+              "Actions": [
+                {
+                  "Type": "State",
+                  "State": "Combat"
+                }
+              ]
+            },
+            {
+              "Sensor": {
+                "Reference": "Component_Sensor_Standard_Detection",
+                "Modify": {
+                  "ViewRange": { "Compute": "ViewRange" },
+                  "ViewSector": { "Compute": "ViewSector" },
+                  "HearingRange": { "Compute": "HearingRange" },
+                  "AbsoluteDetectionRange": {
+                    "Compute": "AbsoluteDetectionRange"
+                  },
+                  "Attitudes": ["Hostile", "Neutral"]
+                }
+              },
+              "Actions": [
+                {
+                  "Type": "State",
+                  "State": "Alerted"
+                }
+              ]
+            },
+            {
+              "BodyMotion": {
+                "Type": "Sequence",
+                "Motions": [
+                  {
+                    "Type": "Timer",
+                    "Time": [3, 6],
+                    "Motion": {
+                      "Type": "Wander",
+                      "MaxHeadingChange": 1,
+                      "RelativeSpeed": 0.5
+                    }
+                  },
+                  {
+                    "Type": "Sequence",
+                    "Looped": true,
+                    "Motions": [
+                      {
+                        "Type": "Timer",
+                        "Time": [3, 6],
+                        "Motion": {
+                          "Type": "WanderInCircle",
+                          "Radius": 10,
+                          "MaxHeadingChange": 60,
+                          "RelativeSpeed": 0.5
+                        }
+                      },
+                      {
+                        "Type": "Timer",
+                        "Time": [2, 3],
+                        "Motion": {
+                          "Type": "Nothing"
+                        }
+                      }
+                    ]
+                  }
+                ]
+              },
+              "ActionsBlocking": true,
+              "Actions": [
+                {
+                  "Type": "Timeout",
+                  "Delay": [4, 5]
+                },
+                {
+                  "Type": "State",
+                  "State": "Idle"
+                }
+              ]
+            }
+          ]
+        }
+      ]
+    }
+  ],
+  "NameTranslationKey": { "Compute": "NameTranslationKey" }
+}
+```
+
+### Goblin_Ogre_Tutorial role file
+
+```json
+{
+  "Type": "Variant",
+  "Reference": "Template_Goblin_Ogre_Tutorial",
+  "Modify": {
+    "Appearance": "Goblin",
+    "MaxHealth": 124,
+    "InteractionVars": {
+      "Melee_SwingDown_Damage": {
+        "Interactions": [
+          {
+            "Parent": "Goblin_Ogre_Swing_Down_Damage",
+            "DamageCalculator": {
+              "Type": "Absolute",
+              "BaseDamage": {
+                "Physical": 20
+              }
+            }
+          }
+        ]
+      }
+    },
+    "NameTranslationKey": { "Compute": "NameTranslationKey" }
+  },
+  "Parameters": {
+    "NameTranslationKey": {
+      "Value": "server.npcRoles.Goblin_Ogre.name",
+      "Description": "Translation key for NPC name display"
+    }
+  }
+}
+```
+
+### Goblin_Ogre_Swing_Down file
+
+```json
+{
+  "Type": "Simple",
+  "Effects": {
+    "ItemPlayerAnimationsId": "Goblin_Club",
+    "ItemAnimationId": "SwingDown"
+  },
+  "$Comment": "Prepare Delay",
+  "RunTime": 0.2,
+  "Next": {
+    "Type": "Selector",
+    "$Comment": "Length of Combat",
+    "RunTime": 0.25,
+    "Selector": {
+      "Id": "Horizontal",
+      "Direction": "ToLeft",
+      "TestLineOfSight": true,
+      "ExtendTop": 0.5,
+      "ExtendBottom": 0.5,
+      "StartDistance": 1,
+      "EndDistance": 2.5,
+      "Length": 90,
+      "RollOffset": 60,
+      "YawStartOffset": -45
+    },
+    "HitEntity": {
+      "Interactions": [
+        {
+          "Type": "Replace",
+          "DefaultValue": {
+            "Interactions": ["Goblin_Ogre_Swing_Down_Damage"]
+          },
+          "Var": "Melee_SwingDown_Damage"
+        }
+      ]
+    },
+    "Next": {
+      "Type": "Simple",
+      "$Comment": "Pad the interaction length",
+      "RunTime": 0.1
+    }
+  }
+}
+```
+
+### Root_NPC_Goblin_Ogre_Attack
+
+(you need this file to exist, because template is referencing it)
+
+```json
+{
+  "Interactions": [
+    {
+      "Type": "Chaining",
+      "ChainId": "Slashes",
+      "ChainingAllowance": 15,
+      "Next": [
+        "Goblin_Ogre_Swing_Left",
+        "Goblin_Ogre_Swing_Right",
+        "Goblin_Ogre_Swing_Down"
+      ]
+    }
+  ],
+  "Tags": {
+    "Attack": ["Melee"]
+  }
+}
+```
diff --git a/content/docs/bg-BG/official-documentation/npc/2-getting-started-with-templates.mdx b/content/docs/bg-BG/official-documentation/npc/2-getting-started-with-templates.mdx
new file mode 100644
index 00000000..99d078e0
--- /dev/null
+++ b/content/docs/bg-BG/official-documentation/npc/2-getting-started-with-templates.mdx
@@ -0,0 +1,74 @@
+---
+title: 2 - Getting started with Templates
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+There are no hard and fast rules for making a start on a template. I like to duplicate **BlankTemplate** and start from there because it already provides the basic structure of the file.
+
+This leaves me with the following template (`Template_Goblin_Ogre.json`): (**note: the file could be looking different in the current version of the game**)
+
+```json
+{
+  "Type": "Abstract",
+  "Parameters": {
+    "Appearance": {
+      "Value": "Bear_Grizzly",
+      "Description": "Model to be used"
+    },
+    "DropList": {
+      "Value": "Empty",
+      "Description": "Drop Items"
+    },
+    "MaxHealth": {
+      "Value": 100,
+      "Description": "Max health for the NPC"
+    },
+    "NameTranslationKey": {
+      "Value": "server.npcRoles.Template.name",
+      "Description": "Translation key for NPC name display"
+    }
+  },
+  "Appearance": { "Compute": "Appearance" },
+  "DropList": { "Compute": "DropList" },
+  "MaxHealth": { "Compute": "MaxHealth" },
+  "MotionControllerList": [
+    {
+      "Type": "Walk",
+      "MaxWalkSpeed": 3,
+      "Gravity": 10,
+      "MaxFallSpeed": 8,
+      "Acceleration": 10
+    }
+  ],
+  "Instructions": [
+    {
+      "Sensor": {
+        "Type": "Any"
+      },
+      "BodyMotion": {
+        "Type": "Nothing"
+      }
+    }
+  ],
+  "NameTranslationKey": { "Compute": "NameTranslationKey" }
+}
+```
+
+And the following variant (`Goblin_Ogre.json`) next to the template. There's a translation key in the template used for localisation of the NPC name, but we won't worry about that for now since it's not required for the NPC to work.
+
+```json
+{
+  "Type": "Variant",
+  "Reference": "Template_Goblin_Ogre",
+  "Modify": {
+    "Appearance": "Goblin",
+    "MaxHealth": 124
+  }
+}
+```
+
+Our artists have not yet finished animations for the `Goblin_Ogre`, for that sake of the tutorial I am going to use appearance `Goblin`, because it offers a more complete set of animations that we will need.
diff --git a/content/docs/bg-BG/official-documentation/npc/3-importance-of-being-idle.mdx b/content/docs/bg-BG/official-documentation/npc/3-importance-of-being-idle.mdx
new file mode 100644
index 00000000..a6230e0c
--- /dev/null
+++ b/content/docs/bg-BG/official-documentation/npc/3-importance-of-being-idle.mdx
@@ -0,0 +1,95 @@
+---
+title: 3 - The importance of being idle
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+There's no particular rule for the order in which we should tackle states either, but I like to start with the **Idle** state.
+
+First we need to add the state to the template. We do this in two steps.
+
+1. Set up the **Idle** state in the instructions:
+
+```json
+"Instructions": [
+    {
+        "Sensor": {
+            "Type": "State",
+            "State": "Idle"
+        },
+        "BodyMotion": {
+            "Type": "Nothing"
+        }
+    }
+]
+
+```
+
+Here we've added the state sensor and corresponding instruction that will hold and define the contents of the **Idle** state.
+
+2. Set the default starting state for the NPC:
+
+```json
+"Appearance": { "Compute": "Appearance" },
+"DropList": { "Compute": "DropList" },
+"MaxHealth": { "Compute": "MaxHealth" },
+"StartState": "Idle",
+
+```
+
+This is a simple case of adding the **StartState** line alongside the other header fields and setting it to be the **Idle** state.
+
+Now we add the first substate within this, which we already decided would just be a plain **.Default** substate.
+
+```json
+"Instructions": [
+    {
+        "Sensor": {
+            "Type": "State",
+            "State": "Idle"
+        },
+        "Instructions": [
+            {
+                "Sensor": {
+                    "Type": "State",
+                    "State": ".Default"
+                },
+                "Instructions": []
+            }
+        ]
+    }
+]
+
+```
+
+This functions the same way as its parent **Idle** state, but we don't need to specify it as a starting state anywhere because it's using the default name.
+
+The first behaviour we're adding here is the 'protect the entrance of the Goblin POI' behaviour. We already identified an existing component we can use for this, so let's add that immediately.
+
+```json
+"Instructions": [
+    {
+        "Sensor": {
+            "Type": "State",
+            "State": ".Default"
+        },
+        "Instructions": [
+            {
+                "Reference": "Component_Instruction_Intelligent_Idle_Motion_Follow_Path"
+            }
+        ]
+    }
+]
+
+```
+
+If we want, we can use a **Modify** block to set a range within which to follow this path or a particular way to follow it, but since we only want it to stand guard and expect it to spawn near its target marker, we can ignore both of those for now.
+
+Straight away we can jump in-game and spawn our ogre using **/npc spawn Goblin_Ogre**. If we add a single path marker with **/path new Test**, he'll happily go and stand guard there without doing anything else.
+
+![npc-tutorial](/assets/official-documentation/npc/npc-tutorial-1.jpg)
+
+And there we go! First idle behaviour is now complete!
diff --git a/content/docs/bg-BG/official-documentation/npc/4-drawing-the-ogre.mdx b/content/docs/bg-BG/official-documentation/npc/4-drawing-the-ogre.mdx
new file mode 100644
index 00000000..1d349055
--- /dev/null
+++ b/content/docs/bg-BG/official-documentation/npc/4-drawing-the-ogre.mdx
@@ -0,0 +1,118 @@
+---
+title: 4 - Drawing the rest of the ogre
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+We were fortunate, in a sense, that the initial ogre behaviour was simple to handle with existing components.
+
+Now the real challenge begins! From here on out, it's critical to remember to test, test, and test some more. **Every time we add a new behaviour it should be tested to ensure it works as expected**. Never leave it until everything is implemented - this just results in unnecessary headaches.
+
+First, we have to figure out how we want to randomise these base idle behaviours. There are three we care about right now since they don't involve interacting with any other types of NPC:
+
+- Standing guard (we already did this!)
+- Napping for a while.
+- Going off to find some food.
+
+There are a few ways we can approach this, but we'll be using a Random Action to make the initial pick and then letting the individual behaviour control its length before resetting and picking a new one.
+
+With this in mind, we can see a minor error in our original judgement - the **Idle** state needs **four** substates, not three:
+
+- **.Default** (this now becomes an entry state for picking the random behaviour state to switch to)
+- **.Guard** (this is now our guarding state)
+- **.FindFood** (go search for some nearby food if it exists)
+- **.EatRat** (murder an innocent nearby rat - we ignore this for now since it relies on another NPC)
+
+So let's quickly refactor the existing **Idle** state to reflect this change, and add a **Random Action** that will, for now, only have a single option.
+
+```json
+"Instructions": [
+    {
+        "Sensor": {
+            "Type": "State",
+            "State": ".Default"
+        },
+        "Instructions": [
+            {
+                "Actions": [
+                    {
+                        "Type": "Random",
+                        "Actions": [
+                            {
+                                "Weight": 100,
+                                "Action": {
+                                    "Type": "State",
+                                    "State": ".Guard"
+                                }
+                            }
+                        ]
+                    }
+                ]
+            }
+        ]
+    },
+    {
+        "Sensor": {
+            "Type": "State",
+            "State": ".Guard"
+        },
+        "Instructions": [
+            {
+                "Reference": "Component_Instruction_Intelligent_Idle_Motion_Follow_Path"
+            }
+        ]
+    }
+]
+
+```
+
+Looking at the modified **Idle** state instruction, we now have two substates: **.Default** and **.Guard**.
+
+If we spawn this NPC next to a path marker, it'll act exactly as it did before. The difference now is that it first executes the **Random** action in the **.Default** substate which picks the only available state action and sends the ogre to **.Guard**. We've set the **Weight** to be 100 for now, but it doesn't matter since there are no other choices anyway and we'll balance these better later (perhaps even for months after initial implementation!)
+
+Now that we have more than one substate, it becomes a little harder to understand what the ogre is doing, so we'll add a **Debug** flag at the top of the file that will tell us what state it's in.
+
+```json
+"Debug": "DisplayState",
+```
+
+Now we can be sure our (presently) friendly goblin ogre is in the correct state.
+
+But wait! There's nothing to send the ogre back to try and do something different!
+
+This is actually pretty simple; we'll just add an instruction with **ActionsBlocking**, a **Timeout**, and **Continue** to the **.Guard** substate that will send it back to **.Default** after a randomised amount of time so it can make a new pick.
+
+```json
+{
+  "Sensor": {
+    "Type": "State",
+    "State": ".Guard"
+  },
+  "Instructions": [
+    {
+      "Continue": true,
+      "ActionsBlocking": true,
+      "Actions": [
+        {
+          "Type": "Timeout",
+          "Delay": [15, 30]
+        },
+        {
+          "Type": "State",
+          "State": ".Default"
+        }
+      ]
+    },
+    {
+      "Reference": "Component_Instruction_Intelligent_Idle_Motion_Follow_Path"
+    }
+  ]
+}
+```
+
+The **ActionsBlocking** is important here because it ensures we don't execute the switch between states until the first action is complete (the **Timeout**). So now we'll hang around at the path marker for between **fifteen** and **thirty** seconds before going back to pick something else to do.
+
+...not that there's anything else to do yet, so why don't we address that next?
diff --git a/content/docs/bg-BG/official-documentation/npc/5-sleep-behavior.mdx b/content/docs/bg-BG/official-documentation/npc/5-sleep-behavior.mdx
new file mode 100644
index 00000000..b984f5a5
--- /dev/null
+++ b/content/docs/bg-BG/official-documentation/npc/5-sleep-behavior.mdx
@@ -0,0 +1,68 @@
+---
+title: 5 - NPC Sleep Behavior
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+Let's add a new top level **Sleep** state. For illustrative purposes, the Idle state has been truncated.
+
+```json
+{
+	"Sensor": {
+		"Type": "State",
+		"State": "Idle"
+	},
+	"Instructions": [ ... ],
+},
+{
+	"Sensor": {
+		"Type": "State",
+		"State": "Sleep"
+	},
+	"Instructions": [ ... ]
+}
+
+```
+
+And now we add another action to the **Random** action list to move to the **Sleep** state.
+
+```json
+{
+  "Sensor": {
+    "Type": "State",
+    "State": ".Default"
+  },
+  "Instructions": [
+    {
+      "Actions": [
+        {
+          "Type": "Random",
+          "Actions": [
+            {
+              "Weight": 80,
+              "Action": {
+                "Type": "State",
+                "State": ".Guard"
+              }
+            },
+            {
+              "Weight": 20,
+              "Action": {
+                "Type": "State",
+                "State": "Sleep"
+              }
+            }
+          ]
+        }
+      ]
+    }
+  ]
+}
+```
+
+Notice the weights in this case - there's a 20% chance that the ogre will go to sleep any time it decides to switch behaviour, but an 80% chance that it'll just keep standing guard instead.
+
+We still need to actually add the sleeping behaviour, but first we'll add Instruction with the **Timeout** action to the beginning of the **Sleep** state, just like we did with **.Guard**. We just remove **"Continue": true** because we only have one instruction.
diff --git a/content/docs/bg-BG/official-documentation/npc/6-a-brief-interlude.mdx b/content/docs/bg-BG/official-documentation/npc/6-a-brief-interlude.mdx
new file mode 100644
index 00000000..789c4f7e
--- /dev/null
+++ b/content/docs/bg-BG/official-documentation/npc/6-a-brief-interlude.mdx
@@ -0,0 +1,70 @@
+---
+title: 6 - A brief interlude
+description: "or: how I learned to stop worrying and love building NPC components"
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+We already have the logic to build this component - it's already contained within the **.Guard** state we created earlier. All we need to do is identify which parts of it we need to expose to whoever might want to use this component in the future.
+
+That's pretty simple too - we have two:
+
+- The duration of the delay before switching state.
+- The state to switch to.
+
+So we put together our new component (`Component_Instruction_State_Timeout`).
+
+```json
+{
+  "Type": "Component",
+  "Class": "Instruction",
+  "Parameters": {
+    "_ImportStates": ["Main"],
+    "Delay": {
+      "Value": [3, 5],
+      "Description": "The amount of time to wait before transitioning"
+    }
+  },
+  "Content": {
+    "Continue": true,
+    "ActionsBlocking": true,
+    "Actions": [
+      {
+        "Type": "Timeout",
+        "Delay": { "Compute": "Delay" }
+      },
+      {
+        "Type": "ParentState",
+        "State": "Main"
+      }
+    ]
+  }
+}
+```
+
+The logic here should be very familiar - the only difference is that we've added and described the parameters in the **Parameters** block, and now use a **ParentState** action to signify that this is going to use one of the **_ImportedStates** from the template itself.
+
+If we would update the template and replace the Timeout block with it, it would look like this, for example, in the **Sleep** state.
+
+```json
+{
+  "Sensor": {
+    "Type": "State",
+    "State": "Sleep"
+  },
+  "Instructions": [
+    {
+      "Reference": "Component_Instruction_State_Timeout",
+      "Modify": {
+        "_ExportStates": ["Idle.Default"],
+        "Delay": [30, 45]
+      }
+    }
+  ]
+}
+```
+
+We won't replace this everywhere in the tutorial just yet, but we'll use this knowledge to replace even more code with components.
diff --git a/content/docs/bg-BG/official-documentation/npc/7-sleep-animation.mdx b/content/docs/bg-BG/official-documentation/npc/7-sleep-animation.mdx
new file mode 100644
index 00000000..b9a90c68
--- /dev/null
+++ b/content/docs/bg-BG/official-documentation/npc/7-sleep-animation.mdx
@@ -0,0 +1,104 @@
+---
+title: 7 - Sleep Animations
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+There are still a few more things we need to do before our ogre can get some rest. Until we come to inter-NPC behaviours later, most of this is purely for visual effect and is pretty much entirely restricted to playing animations.
+
+The most basic part is playing the sleep animation. We can use a convenient component for this. Don't forget to put back **"Continue":true**, because now we want to play the animation while the timeout runs.
+
+```json
+{
+  "Sensor": {
+    "Type": "State",
+    "State": "Sleep"
+  },
+  "Instructions": [
+    {
+      "Continue": true,
+      "ActionsBlocking": true,
+      "Actions": [
+        {
+          "Type": "Timeout",
+          "Delay": [5, 10]
+        },
+        {
+          "Type": "State",
+          "State": "Idle"
+        }
+      ]
+    },
+    {
+      "Reference": "Component_Instruction_Play_Animation",
+      "Modify": {
+        "Animation": "Sleep"
+      }
+    }
+  ]
+}
+```
+
+Wait...that's it?
+
+Almost! While our ogre will now happily go to sleep, it's a bit janky. We still need to handle the transitions between states. For this we add a completely new section to the asset above the instructions, called **StateTransitions**.
+
+```json
+"StateTransitions": [
+    {
+        "States": [
+            {
+                "From": ["Idle"],
+                "To": ["Sleep"]
+            }
+        ],
+        "Actions": [
+            {
+                "Type": "PlayAnimation",
+                "Slot": "Status",
+                "Animation": "Laydown"
+            },
+            {
+                "Type": "Timeout",
+                "Delay": [1, 1]
+            }
+        ]
+    },
+    {
+        "States": [
+            {
+                "From": ["Sleep"],
+                "To": []
+            }
+        ],
+        "Actions": [
+            {
+                "Type": "PlayAnimation",
+                "Slot": "Status",
+                "Animation": "Wake"
+            },
+            {
+                "Type": "Timeout",
+                "Delay": [1, 1]
+            }
+        ]
+    }
+],
+"Instructions": [
+	...
+]
+
+```
+
+State transitions are a bit verbose but relatively simple. Each transition represents a set of actions that will be performed in sequence before we actually start executing the logic of the state itself.
+
+An empty array represents all existing states. In this instance, our ogre will play the **Laydown** animation when switching from **Idle** to **Sleep** and the **Wake** animation when switching from **Sleep** to any other state.
+
+We currently have to define a **Timeout** action with a delay the length of the animation to ensure that we don't do anything else until the animation completes. In the future, we might be able to automatically find out the length of the animation and block for its duration, but that's not currently possible.
+
+But that's all for the **Sleep** state for now. Really this time.
+
+![npc tutorial](/assets/official-documentation/npc/npc-tutorial-2.jpg)
diff --git a/content/docs/bg-BG/official-documentation/npc/8-food.mdx b/content/docs/bg-BG/official-documentation/npc/8-food.mdx
new file mode 100644
index 00000000..30cd8d58
--- /dev/null
+++ b/content/docs/bg-BG/official-documentation/npc/8-food.mdx
@@ -0,0 +1,320 @@
+---
+title: 8 - Feeding the Ogre
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+Lest we forget, there was another significantly more complex idle behaviour we have to implement:
+
+- Standing guard (we already did this!)
+- Napping for a while (this one too!)
+- **Going off to find some food.**
+
+This one might be a bit trickier. When we pick this behaviour we need to scan the area to see if there is any food. If we find it, we head over, pretend to grab it, and then set to eating.
+
+But what if we _don't_ find any food? We should probably still pretend to go looking for it - it's not like this ogre is omniscient and already knows there's no food where it expects it because the sensor said there wasn't..._right?_
+
+We start by creating our **.FindFood** substate immediately after **.Guard**.
+
+```json
+{
+	"Sensor": {
+		"Type": "State",
+		"State": ".Guard"
+	},
+	"Instructions": [ ... ],
+},
+{
+	"Sensor": {
+		"Type": "State",
+		"State": ".FindFood"
+	},
+	"Instructions": [ ... ]
+}
+```
+
+We then add it to our list of random actions.
+
+```json
+"Type": "Random",
+"Actions": [
+    {
+        "Weight": 70,
+        "Action": {
+            "Type": "State",
+            "State": ".Guard"
+        }
+    },
+    {
+        "Weight": 20,
+        "Action": {
+            "Type": "State",
+            "State": "Sleep"
+        }
+    },
+    {
+        "Weight": 10,
+        "Action": {
+            "Type": "State",
+            "State": ".FindFood"
+        }
+    }
+]
+
+```
+
+Next we want to perform the actual search for food. But what _is_ food? And not in a philosophical sense. What kinds of food does this ogre look for? This is another point where we might want to have a chat with the designers. Do they want it to go after multiple different things? Or is there one particular type of food a goblin ogre is interested in?
+
+A quick discussion with our designers reveals we've been working under an incorrect assumption and highlights the importance of ensuring that we thoroughly understand both the contents of the design specifications, and the _intent behind them_. This ogre is meant to be a guard and shouldn't leave his post. He should never actively set off to find food, but rather whip something out of a pocket and eat it on the spot.
+
+Okay. That makes things significantly easier! We can now cross off one of our idle substates:
+
+- .Default (pick the random behaviour state to switch to)
+- .Guard (stand guard)
+- ~~.FindFood (go search for some nearby food if it exists)~~
+- .EatRat (murder an innocent nearby rat - we're still ignoring this for now)
+
+So let's remove **.FindFood** and jump straight to **Eat**, adding the same logic we added to the other idle states. We also need to remember to update the reference in the list of random actions so that it points to the correct state!
+
+```json
+{
+  "Sensor": {
+    "Type": "State",
+    "State": "Eat"
+  },
+  "Instructions": [
+    {
+      "ActionsBlocking": true,
+      "Actions": [
+        {
+          "Type": "Timeout",
+          "Delay": [5, 10]
+        },
+        {
+          "Type": "State",
+          "State": "Idle"
+        }
+      ]
+    }
+  ]
+}
+```
+
+We don't actually know for sure what food this ogre has in his pockets and it's probably something that might get changed in the future, or be nice to make easily changeable in variants.
+
+To accommodate that, let's add an **EatItem** parameter and accompanying description to the parameters block.
+
+```json
+"Parameters": {
+    "Appearance": {
+        "Value": "Bear_Grizzly",
+        "Description": "Model to be used"
+    },
+    "EatItem": {
+        "Value": "Food_Beef_Raw",
+        "Description": "The item this NPC will find when it rummages for food"
+    },
+    "DropList": {
+        "Value": "Empty",
+        "Description": "Drop Items"
+    }
+}
+
+```
+
+Now we just need to set up another **PlayAnimation** action, much like in the **Sleep** state, to handle the eating itself.
+
+```json
+{
+  "Sensor": {
+    "Type": "State",
+    "State": "Eat"
+  },
+  "Instructions": [
+    {
+      "Continue": true,
+      "ActionsBlocking": true,
+      "Actions": [
+        {
+          "Type": "Timeout",
+          "Delay": [5, 10]
+        },
+        {
+          "Type": "State",
+          "State": "Idle"
+        }
+      ]
+    },
+    {
+      "Reference": "Component_Instruction_Play_Animation",
+      "Modify": {
+        "Animation": "Eat"
+      }
+    }
+  ]
+}
+```
+
+This looks _awfully_ familiar... Could this be something we want to do often in many NPCs? Might we frequently want to play an animation for a specific random duration? I'd say yes, so let's make it a component!
+
+```json
+{
+  "Type": "Component",
+  "Class": "Instruction",
+  "Parameters": {
+    "_ImportStates": ["Main"],
+    "Animation": {
+      "Value": "",
+      "Description": "The animation to play"
+    },
+    "Duration": {
+      "Value": [3, 5],
+      "Description": "The amount of time to wait before transitioning"
+    }
+  },
+  "Content": {
+    "Continue": true,
+    "Instructions": [
+      {
+        "Reference": "Component_Instruction_State_Timeout",
+        "Modify": {
+          "_ExportStates": ["Main"],
+          "Delay": { "Compute": "Duration" }
+        }
+      },
+      {
+        "Reference": "Component_Instruction_Play_Animation",
+        "Modify": {
+          "Animation": { "Compute": "Animation" }
+        }
+      }
+    ]
+  }
+}
+```
+
+I'm calling this one `Component_Instruction_Play_Animation_In_State_For_Duration`. The Timeout instruction is replaced with the component made in the previous interlude.
+
+Now we need to apply it to both places in the ogre template.
+
+```json
+"Sensor": {
+    "Type": "State",
+    "State": "Eat"
+},
+"Instructions": [
+    {
+        "Reference": "Component_Instruction_Play_Animation_In_State_For_Duration",
+        "Modify": {
+            "_ExportStates": ["Idle.Default"],
+            "Animation": "Eat",
+            "Duration": [15, 20]
+        }
+    }
+]
+
+```
+
+Only **Eat** is pictured here, but you can imagine the same changes being made to **Sleep** too.
+
+Now why aren't we converting the whole state itself into a component? There's a pretty good reason behind that: we haven't added entity detection yet and we almost surely will. This will need to live in the state alongside the other logic, so we can't exactly push the whole state itself into a component.
+
+There's one last thing we need to do to make this ogre actually eat - take out the food and put it away again. Since we don't want to somehow risk ending up in a state where the ogre is trying to beat its enemies with a chunk of meat or eat its own weapon, we'll do this with state transitions.
+
+```json
+"StateTransitions": [
+    ...
+    {
+        "States": [
+            {
+                "From": ["Idle"],
+                "To": ["Eat"]
+            }
+        ],
+        "Actions": [
+            {
+                "Type": "Inventory",
+                "Operation": "SetHotbar",
+                "Item": { "Compute": "EatItem" },
+                "Slot": 2,
+                "UseTarget": false
+            },
+            {
+                "Type": "Inventory",
+                "Operation": "EquipHotbar",
+                "Slot": 2,
+                "UseTarget": false
+            }
+        ]
+    }
+]
+
+```
+
+There's a few important things to note here. This combination of actions will place the item from the **EatItem** parameter we defined earlier into slot 2 of its hotbar, and then switch to using that slot. We have to define it as **UseTarget: false** to ensure that it acts on the ogre itself.
+
+By default, NPCs have three hotbar slots, so we've set it to use the last slot for this purpose (slots are numbered starting from zero).
+
+So this handles actually pulling out the food to eat it, but not putting it away again afterwards. Let's add that too.
+
+```json
+{
+  "States": [
+    {
+      "From": ["Eat"],
+      "To": []
+    }
+  ],
+  "Actions": [
+    {
+      "Type": "PlayAnimation",
+      "Slot": "Status"
+    },
+    {
+      "Type": "Inventory",
+      "Operation": "EquipHotbar",
+      "Slot": 0,
+      "UseTarget": false
+    }
+  ]
+}
+```
+
+Now our ogre will happily pull out a chunk of meat, start eating it, and then put it away again when it's done!
+
+![npc-tutorial 3](/assets/official-documentation/npc/npc-tutorial-3.jpg)
+
+Perfect! The last thing we'll do, just to be sure we don't end up in any strange states if the goblin unloads while eating, is make sure we also switch to the correct weapon at the beginning of the idle state.
+
+```json
+{
+	"Sensor": {
+		"Type": "State",
+		"State": "Idle"
+	},
+	"Instructions": [
+		{
+			"Continue": true,
+			"Sensor": {
+				"Type": "Any",
+				"Once": true
+			},
+			"Actions": [
+				{
+					"Type": "Inventory",
+					"Operation": "EquipHotbar",
+					"Slot": 0,
+					"UseTarget": false
+				}
+			]
+		},
+		...
+	]
+}
+
+```
+
+With that, we have all the idle behaviours that don't rely on other NPCs set up. We'll deal with that next!
diff --git a/content/docs/bg-BG/official-documentation/npc/9-inter-npc-interaction.mdx b/content/docs/bg-BG/official-documentation/npc/9-inter-npc-interaction.mdx
new file mode 100644
index 00000000..240975b8
--- /dev/null
+++ b/content/docs/bg-BG/official-documentation/npc/9-inter-npc-interaction.mdx
@@ -0,0 +1,479 @@
+---
+title: 9 - Inter-NPC Interaction
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+Now we need to start thinking about how to get our ogre to respond to other NPCs in the world. We won't think about combat or dealing with players yet, but there are a couple of other inter-NPC behaviours described in the design specification:
+
+- Whack annoying goblin scrappers while sleeping.
+- Grab and eat rats that come too close.
+
+We'll start with the first because there are a number of problems that are going to come into play when we tackle the second.
+
+Whacking goblins takes place during the **Sleep** state, so we'll be doing all our editing there. We don't actually need to add any detection for this, because we're going to trust the goblin scrappers to _tell_ us they're being annoying. This is something pretty neat about using beacons to communicate between NPCs.
+
+When one of the NPCs sends a message, it can trigger behaviour in the other. Basically, this means that the **Goblin Scrapper** is going to handle the bulk of this behaviour. When they go into annoy mode, they'll approach the ogre. When they're close enough, they'll send a message telling him they're being annoying, and he'll then randomly swat at them in his sleep.
+
+They're essentially actually annoying him with their message!
+
+```json
+{
+	"Sensor": {
+		"Type": "State",
+		"State": "Sleep"
+	},
+	"Instructions": [
+		...
+		{
+			"Sensor": {
+				"Type": "Beacon",
+				"Message": "Annoy_Ogre",
+				"Range": 5
+			},
+			"Actions": []
+		}
+	]
+}
+```
+
+This sensor listens for the **Annoy_Ogre** message and will perform its actions when receiving it, so long as it comes from an NPC that's close by. The nice thing about this is that it can respond to any NPC that decides to annoy it!
+
+Next we'll add an attack to it. It'll be the animators' responsibility to ensure that this meshes nicely with the sleeping animation, and we'll also expose the attack name as a parameter in the parameters block.
+
+```json
+"Parameters": {
+	...
+    "SleepingAttack": {
+        "Value": "Root_NPC_Attack_Melee",
+        "Description": "Attack to use on NPCs that annoy it while sleeping"
+    },
+    "DropList": {
+        "Value": "Empty",
+        "Description": "Drop Items"
+    }
+}
+```
+
+We use a placeholder attack because we don't have a real one yet.
+
+```json
+{
+  "Sensor": {
+    "Type": "Beacon",
+    "Message": "Annoy_Ogre",
+    "Range": 5
+  },
+  "Actions": [
+    {
+      "Type": "Attack",
+      "Attack": { "Compute": "SleepingAttack" },
+      "AttackPauseRange": [1, 2]
+    }
+  ]
+}
+```
+
+We don't need another NPC to test this - we can use **/npc message Annoy_Ogre** to trigger this behaviour while looking at the ogre.
+
+![npc-tutorial](/assets/official-documentation/npc/npc-tutorial-4.jpg)
+
+Now that our ogre can whack those pesky scrappers, the time has come to address the rat in the room: grabbing other NPCs is **hard**. Just in general. We don't have that kind of capability in tech and there's no guarantee we will either.
+
+A quick chat with our designers resulted in the following specification:
+
+- Spawn a rat at some location.
+- Have it run past the goblin.
+- Have it animate to grab the rat and eat it.
+
+This clarifies things, but doesn't resolve the problems. To do this, we're going to have to be creative.
+
+First we need to actually spawn the rat somewhere near the ogre and get it to head over to be seized and eaten. We can do something like this by using a form of **manual spawn beacon** - an entity type which has to be placed in the world and can be triggered by other nearby NPCs on demand. We'll also need to build a small template for the rat itself to get it to move to the ogre.
+
+This seems like a behaviour that could be pretty reusable, so we'll make this template as simple and generic as possible so that it can be used in conjunction with all sorts of NPCs that are meant to grab small creatures and eat them.
+
+We'll call this `Template_Edible_Critter`.
+
+```json
+{
+  "Type": "Abstract",
+  "KnockbackScale": 0.5,
+  "Parameters": {
+    "Appearance": {
+      "Value": "Rat",
+      "Description": "Model to be used"
+    },
+    "WalkSpeed": {
+      "Value": 3,
+      "Description": "How fast this critter moves"
+    },
+    "SeekRange": {
+      "Value": 40,
+      "Description": "How far this NPC is allowed to be from the target that will eat"
+    },
+    "MaxHealth": {
+      "Value": 100,
+      "Description": "Max health for the NPC"
+    },
+    "NameTranslationKey": {
+      "Value": "server.npcRoles.Template.name",
+      "Description": "Translation key for NPC name display"
+    }
+  },
+  "Appearance": { "Compute": "Appearance" },
+  "StartState": "Idle",
+  "MotionControllerList": [
+    {
+      "Type": "Walk",
+      "MaxWalkSpeed": { "Compute": "WalkSpeed" },
+      "Gravity": 10,
+      "MaxFallSpeed": 8,
+      "Acceleration": 10
+    }
+  ],
+  "MaxHealth": { "Compute": "MaxHealth" },
+  "Instructions": [
+    {
+      "Instructions": [
+        {
+          "Sensor": {
+            "Type": "State",
+            "State": "Idle"
+          },
+          "Instructions": [
+            {
+              "Sensor": {
+                "Type": "Beacon",
+                "Message": "Approach_Target",
+                "TargetSlot": "LockedTarget"
+              },
+              "Actions": [
+                {
+                  "Type": "State",
+                  "State": "Seek"
+                }
+              ]
+            },
+            {
+              "ActionsBlocking": true,
+              "Actions": [
+                {
+                  "Type": "Timeout",
+                  "Delay": [1, 1]
+                },
+                {
+                  "Type": "Despawn"
+                }
+              ]
+            }
+          ]
+        },
+        {
+          "Sensor": {
+            "Type": "State",
+            "State": "Seek"
+          },
+          "Instructions": [
+            {
+              "Sensor": {
+                "Type": "Target",
+                "TargetSlot": "LockedTarget",
+                "Range": { "Compute": "SeekRange" }
+              },
+              "BodyMotion": {
+                "Type": "Seek",
+                "SlowDownDistance": 0.1,
+                "StopDistance": 0.1
+              }
+            },
+            {
+              "ActionsBlocking": true,
+              "Actions": [
+                {
+                  "Type": "Timeout",
+                  "Delay": [1, 1]
+                },
+                {
+                  "Type": "State",
+                  "State": "Idle"
+                }
+              ]
+            }
+          ]
+        }
+      ]
+    }
+  ],
+  "NameTranslationKey": { "Compute": "NameTranslationKey" }
+}
+```
+
+This is a really simple NPC. It allows setting an **Appearance**, **WalkSpeed**, and **SeekRange** so that it can encompass a variety of different critter types. If idle for too long, it'll despawn, otherwise it'll try and seek towards the NPC that's meant to eat it, either from being signalled with a beacon or from being spawned in that specific state with a specific target already defined.
+
+In this case, we want to do the latter, so let's define a **variant** (**Edible_Rat**).
+
+```json
+{
+  "Type": "Variant",
+  "Reference": "Template_Edible_Critter",
+  "Modify": {
+    "Appearance": "Rat",
+    "WalkSpeed": 5,
+    "MaxHealth": 100,
+    "NameTranslationKey": { "Compute": "NameTranslationKey" }
+  },
+  "Parameters": {
+    "NameTranslationKey": {
+      "Value": "server.npcRoles.Rat.name",
+      "Description": "Translation key for NPC name display"
+    }
+  }
+}
+```
+
+...and a **spawn beacon** (also called **Edible_Rat**) that can create it for us.
+
+```json
+{
+  "Environments": [],
+  "NPCs": [
+    {
+      "Weight": 1,
+      "Id": "Edible Rat"
+    }
+  ],
+  "SpawnAfterGameTimeRange": ["PT5M", "PT10M"],
+  "NPCSpawnState": "Seek",
+  "TargetSlot": "LockedTarget"
+}
+```
+
+This simple config will only spawn the rat NPC we defined and will set it to the correct state. The **SpawnAfterGameTimeRange** parameter is required for the configuration to be used in other contexts, but isn't actually useful to us here.
+
+Now, if we use **/spawning beacons add Edible_Rat --manual** we can create this spawn beacon ready for our ogre to use! Level designers who want to use this behaviour will need to add this beacon somewhere in the prefab so that the rats can be spawned, but multiple ogres can share the same beacon for this purpose. We can use **/spawning beacons trigger** to make sure it works!
+
+Now we just need to set up our ogre to actually spawn the rat and fake the interaction between them.
+
+As always, we start by adding the state (**CallRat** - we're actually going to make it a main state instead of using the originally planned **.EatRat** substate to take advantage of some existing states and state transitions as we talked about earlier)...
+
+```json
+{
+	"Sensor": {
+		"Type": "State",
+		"State": "Eat"
+	},
+	...
+},
+{
+	"Sensor": {
+		"Type": "State",
+		"State": "CallRat"
+	},
+	"Instructions": [ ]
+}
+```
+
+...and an action to the random list.
+
+```json
+{
+	"Type": "Random",
+	"Actions": [
+		{
+			"Weight": 60,
+			"Action": {
+				"Type": "State",
+				"State": ".Guard"
+			}
+		},
+		...
+		{
+			"Weight": 10,
+			"Action": {
+				"Type": "State",
+				"State": "CallRat"
+			}
+		}
+	]
+}
+```
+
+Our **CallRat** state will just handle triggering the beacon and then waiting for a little while to see if the rat successfully arrives. If it doesn't, we'll reset and go back to pick another idle state.
+
+Faking picking up and eating the rat we'll handle by **removing** the rat once it gets close enough and then giving the ogre an **item to hold** just like we did with the previous eat state transition.
+
+The only difference here is the item being eaten (and thus the specific transition itself), so we can actually just make use of the previous **Eat** state for handling that side of the logic!
+
+Before we can go any further though, we need to define an **NPC group** (**Edible_Rat** again) containing our edible rat and make it a parameter on the ogre so it can find it!
+
+```json
+{
+  "IncludeRoles": ["Edible_Rat"]
+}
+```
+
+And now we make this an exposed parameter on the ogre template. While we're at it, let's also add a parameter containing the name of the manual spawn beacon we'll trigger.
+
+```json
+"Parameters": {
+	...
+    "FoodNPCGroups": {
+        "Value": ["Edible_Rat"],
+        "Description": "The groups of edible NPCs that will come from triggering the beacon"
+    },
+    "FoodNPCBeacon": {
+        "Value": "Edible_Rat",
+        "Description": "The spawn beacon to trigger to create an edible NPC"
+    },
+	...
+}
+
+```
+
+With this done, we can implement the **CallRat** state logic and test that it works.
+
+```json
+{
+  "Sensor": {
+    "Type": "State",
+    "State": "CallRat"
+  },
+  "Instructions": [
+    {
+      "Continue": true,
+      "Sensor": {
+        "Type": "Any",
+        "Once": true
+      },
+      "Actions": [
+        {
+          "Type": "TriggerSpawnBeacon",
+          "BeaconSpawn": { "Compute": "FoodNPCBeacon" },
+          "Range": 15
+        }
+      ]
+    },
+    {
+      "Sensor": {
+        "Type": "Mob",
+        "Range": 2.5,
+        "Filters": [
+          {
+            "Type": "NPCGroup",
+            "IncludeGroups": { "Compute": "FoodNPCGroups" }
+          },
+          {
+            "Type": "LineOfSight"
+          }
+        ]
+      },
+      "HeadMotion": {
+        "Type": "Watch"
+      },
+      "ActionsBlocking": true,
+      "Actions": [
+        {
+          "Type": "PlayAnimation",
+          "Slot": "Status",
+          "Animation": "Swipe"
+        },
+        {
+          "Type": "Timeout",
+          "Delay": [0.1, 0.1],
+          "Action": {
+            "Type": "Sequence",
+            "Actions": [
+              {
+                "Type": "Remove"
+              },
+              {
+                "Type": "State",
+                "State": "Eat"
+              }
+            ]
+          }
+        }
+      ]
+    },
+    {
+      "Continue": true,
+      "Sensor": {
+        "Type": "Mob",
+        "Range": 5,
+        "Filters": [
+          {
+            "Type": "NPCGroup",
+            "IncludeGroups": { "Compute": "FoodNPCGroups" }
+          },
+          {
+            "Type": "LineOfSight"
+          }
+        ]
+      },
+      "HeadMotion": {
+        "Type": "Watch"
+      }
+    },
+    {
+      "Reference": "Component_Step_State_Timeout",
+      "Modify": {
+        "_ExportStates": ["Idle"],
+        "Delay": [10, 15]
+      }
+    }
+  ]
+}
+```
+
+The logic here is pretty straightforward - we start by triggering the beacon we defined in the parameters exactly once and continuing (as defined by the **Continue** and **Once** flags). We then wait for the edible NPC matching the list of groups we provided in the parameter (which contains only our edible rat in this instance) to get close enough to grab and then play an animation with a brief delay before removing it and moving to the **Eat** state. We watch it for a little bit until it gets close enough so it doesn't look too bad. Note how that last pair of actions (enclosed in a **sequence**) is not marked as blocking - both will execute in the same tick.
+
+If the rat never arrives, we give it about 10-15 seconds before giving up and returning to **Idle**.
+
+Now that it's working, let's implement the state transitions to make this goblin actually 'grab' the rat and start eating it. We don't have the 'rat' item yet, so we'll just use a different item as a placeholder for now.
+
+We need to define this in the parameters too.
+
+```json
+"Parameters": {
+	...
+    "FoodNPCItem": {
+        "Value": "Food_Cheese",
+        "Description": "The edible NPC in item form"
+    },
+	...
+}
+
+```
+
+And then a single state transition from **CallRat** to **Eat**.
+
+```json
+{
+  "States": [
+    {
+      "From": ["CallRat"],
+      "To": ["Eat"]
+    }
+  ],
+  "Actions": [
+    {
+      "Type": "Inventory",
+      "Operation": "SetHotbar",
+      "Item": { "Compute": "FoodNPCItem" },
+      "Slot": 2,
+      "UseTarget": false
+    },
+    {
+      "Type": "Inventory",
+      "Operation": "EquipHotbar",
+      "Slot": 2,
+      "UseTarget": false
+    }
+  ]
+}
+```
+
+This isn't perfect, but it'll do for now and we can always come back and tweak things later. With that, we're done with both the idle and inter-NPC behaviours. Next we move on to combat and reacting to players!
diff --git a/content/docs/bg-BG/official-documentation/worldgen/pack-tutorial/asset-packs.mdx b/content/docs/bg-BG/official-documentation/worldgen/pack-tutorial/asset-packs.mdx
new file mode 100644
index 00000000..dcf1f3b9
--- /dev/null
+++ b/content/docs/bg-BG/official-documentation/worldgen/pack-tutorial/asset-packs.mdx
@@ -0,0 +1,93 @@
+---
+title: Asset Packs
+description: Covers how to create and install Asset Packs
+icon: Bookmark
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# How to modify Hytale?
+
+## What's an Asset Pack?
+
+Hytales gameplay is driven by assets in the game that can be modified by creators. Asset Packs are our solution to let you override or add features to the base game with your own work. These can be the form of zip files of folders, which contain a custom set of assets. This is not the only way for a creator to change Hytale but this is the most accessible form.;
+
+### How do I make an Asset Pack?
+
+<video controls className="my-6 aspect-video w-full rounded-lg border">
+  <source src="https://cdn.internal.hytalemodding.dev/guides/official/how-to-asset-pack.mp4" type="video/mp4" />
+</video>
+
+{/* {% include "../.gitbook/includes/requirements.md" %} */}
+
+An asset pack is typically a zip or folder, with a `manifest.json` inside. This can be created either using our ingame asset editor, or in your file browser. All Asset Packs require a manifest and the assets must be located in the correct folders. For this reason we recommend using the Asset Editor.
+
+```json title="manifest.json"
+{
+  "Group": "My Group",
+  "Name": "Pack Example",
+  "Version": "1.0.0",
+  "Description": "An Example Asset Pack",
+  "Authors": [
+    {
+      "Name": "Me",
+      "Email": "",
+      "Url": ""
+    }
+  ],
+  "Website": "",
+  "Dependencies": {},
+  "OptionalDependencies": {},
+  "LoadBefore": {},
+  "DisabledByDefault": false,
+  "IncludesAssetPack": false,
+  "SubPlugins": []
+}
+```
+
+### Where are they stored?
+
+Asset Packs are stored with other mods in the Mods folder.
+
+```
+C:\Users\<user>\AppData\Roaming\Hytale\UserData\Mods
+```
+
+Mods and Asset Packs are also stored per world, this is where Asset Packs land when created with the Asset Editor.;
+
+```
+C:\Users\<user>\AppData\Roaming\Hytale\UserData\Saves\New World 5\mods
+```
+
+<Callout type="warning">
+  When creating an Asset Pack in-game with the Asset Editor, they are currently
+  stored in that world. This means to access the pack in other worlds you need
+  to copy the pack into your Mods folder.
+</Callout>
+
+---
+
+<video controls className="my-6 aspect-video w-full rounded-lg border">
+  <source src="https://cdn.internal.hytalemodding.dev/guides/official/how-to-install.mp4" type="video/mp4" />
+</video>
+
+When you have Asset Packs or Mods installed, these will appear in the New World menu under the Options menu.;
+
+### How do I change an existing asset?
+
+<video controls className="my-6 aspect-video w-full rounded-lg border">
+  <source src="https://cdn.internal.hytalemodding.dev/guides/official/how-to-asset.mp4" type="video/mp4" />
+</video>
+
+<Callout type="warning">You must create an Asset Pack</Callout>
+
+All creators are free to modify our existing assets, to do so you must create an Asset Pack. Assets that exist inside of Asset Packs override the asset from the base game. You are also able to add new assets the same way.;
+
+### Notes
+
+- Can be downloaded from hosting sites such as CurseForge.
+- Exist entirely on the server.
+  - Only the server or world host has to download Asset Packs and Mods.;
diff --git a/content/docs/bg-BG/official-documentation/worldgen/technical-hytale-generator/assignments.mdx b/content/docs/bg-BG/official-documentation/worldgen/technical-hytale-generator/assignments.mdx
new file mode 100644
index 00000000..a8b7cb65
--- /dev/null
+++ b/content/docs/bg-BG/official-documentation/worldgen/technical-hytale-generator/assignments.mdx
@@ -0,0 +1,137 @@
+---
+title: Assignments
+description: Assigns Props to each position in a Positions field.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Constant
+
+Assigns a Prop to all positions.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Prop",
+     description: "Prop slot",
+   },
+  ]}
+/>
+
+---
+
+### FieldFunction
+
+Allows you to select which props to assign based on a Density field and your configured delimiters. The Density's value at each position determines which delimiter's Prop to assign.;
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FieldFunction",
+     description: "Density slot.",
+   },
+   {
+     name: "Delimiters",
+     description:
+       "list of noise value delimiters attaching Props to value ranges of the Density field.",
+   },
+   {
+     name: "Min",
+     description: "decimal number. Lower inclusive bound of the delimiter.",
+   },
+   {
+     name: "Max",
+     description: "decimal number. Higher exclusive bound of the delimiter.",
+   },
+   {
+     name: "Assignments",
+     description:
+       "Assignments asset slot. The assignment provigint he Props to use.",
+   },
+  ]}
+/>
+
+---
+
+### Sandwich
+
+Allows you to select which props to assign based on their vertical (world Y) position and your configured delimiters. Depending on each position’s height in the world the Prop of the matching delimiter will be assigned.
+
+![Image showcasing sandwich tool](/assets/official-documentation/worldgen/technical-hytale-generator/assignments/sandwich.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Delimiters",
+     description: "list of world height delimiter assets.",
+   },
+   {
+     name: "MinY",
+     description: "decimal number. Lower inclusive bound of the delimiter.",
+   },
+   {
+     name: "MaxY",
+     description: "decimal number. Higher exclusive bound of the delimiter.",
+   },
+   {
+     name: "Assignments",
+     description: "Assignments asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Weighted
+
+Picks which Prop to assign randomly based on weights and a seed.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Seed",
+     description: "string.",
+   },
+   {
+     name: "SkipChance",
+     description:
+       "decimal number between 0.0 and 1.0. Determines the chance to skip a position completely without assigning it a Prop.",
+   },
+   {
+     name: "WeightedAssignments",
+     description: "List of weighted Assignments slots.",
+   },
+   {
+     name: "Assignments",
+     description: "Assignments asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Assignments.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported Assignments.",
+   },
+  ]}
+/>
diff --git a/content/docs/bg-BG/official-documentation/worldgen/technical-hytale-generator/block-mask.mdx b/content/docs/bg-BG/official-documentation/worldgen/technical-hytale-generator/block-mask.mdx
new file mode 100644
index 00000000..13996328
--- /dev/null
+++ b/content/docs/bg-BG/official-documentation/worldgen/technical-hytale-generator/block-mask.mdx
@@ -0,0 +1,47 @@
+---
+title: Block Mask
+description: Determines which Materials get to replace which other Materials when placing content in the world.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+#### Source and Destination Material Explained
+
+If we're trying to place bricks in water, then bricks is the Source Material, and water is the Destination Material.
+
+- Source Material: the Material we're trying to place.
+- Destination Material: the Material that exists where we want to place the Source Material.;
+
+#### DontPlace
+
+If a Source Material is in the DontPlace BlockSet then it will not be placed.
+
+#### DontReplace
+
+By default no Source Material can replace any Destination Materials that belongs to this set. This rule is overridden by the Advanced rules below.
+
+#### Advanced
+
+The Advanced rules override the rules above for specific BlockSets. Each rule is made of a Source BlockSet that identifies the Source Material the rule applies to, and a CanReplace BlockSet that determines the Materials the Source can replace.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "DontPlace",
+     description: "BlockSet slot.",
+   },
+   {
+     name: "DontReplace",
+     description: "BlockSet slot.",
+   },
+   {
+     name: "Advanced",
+     description: "list of rules.",
+   },
+  ]}
+/>
diff --git a/content/docs/bg-BG/official-documentation/worldgen/technical-hytale-generator/curves.mdx b/content/docs/bg-BG/official-documentation/worldgen/technical-hytale-generator/curves.mdx
new file mode 100644
index 00000000..77365350
--- /dev/null
+++ b/content/docs/bg-BG/official-documentation/worldgen/technical-hytale-generator/curves.mdx
@@ -0,0 +1,404 @@
+---
+title: Curves
+description: Curves map decimal values to other decimal values. They enable the basic f(x) = y math expression. These nodes can be used to build the functions you need in world-gen.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Manual
+
+You can plot points that connect with lines to create the curve. The points are connected with straight lines. The function is constant before the first point and after the last point.
+
+![Graph of a manual curve](/assets/official-documentation/worldgen/technical-hytale-generator/curves/manual.png)
+
+The example above shows a function made of 3 points.
+
+---
+
+### DistanceExponential
+
+The DistanceExponential Curve has the following shape depending on the Exponent value. As this curve’s input approaches the Range value it outputs 0.0. At an input of 0.0, this curve outputs 1.0.
+
+![Graph of a distance exponential curve](/assets/official-documentation/worldgen/technical-hytale-generator/curves/distance-exponential.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Exponent",
+     description: "affects the curve's shape like in the diagram above.",
+   },
+   {
+     name: "Range",
+     description: "the value after which the curve outputs a constant 0.0.",
+   },
+  ]}
+/>
+
+---
+
+### DistanceS
+
+The DistanceS Curve combines two DistanceExponent curves to produce a shape similar to the diagram below. As this curve’s input approaches the Range value it outputs 0.0. At an input of 0.0, this curve outputs 1.0. The asset’s parameters allows you to tweak the shape of the curve.
+
+![Graph of a distance S curve](/assets/official-documentation/worldgen/technical-hytale-generator/curves/distance-s-graph.png)
+
+Below are some examples of Positions2D terrain using this curve.
+
+![Example of distance S curve in terrain](/assets/official-documentation/worldgen/technical-hytale-generator/curves/distance-s-example.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ExponentA",
+     description:
+       "floating point value greater than 0.0. Affects the curve's shape in the first half of the range.",
+   },
+   {
+     name: "ExponentB",
+     description:
+       "floating point value greater than 0.0. Affects the curve's shape in the second half of the range.",
+   },
+   {
+     name: "Range",
+     description:
+       "floating point value greater than 0.0. The value after which the curve outputs a constant 0.0.",
+   },
+   {
+     name: "Transition",
+     description:
+       "optional floating point value between 0.0 and 1.0 with a default of 1.0. Values close to 0.0 create a curve with a more sudden transition between the ExponentA and ExponentB. Values of 1.0 transition from ExponentA to ExponentB over the entire curve.",
+   },
+   {
+     name: "TransitionSmooth",
+     description:
+       "optional floating point value between 0.0 and 1.0 with a default of 1.0. Affects the shape of the transition, lower values can result in sharper curve in some situations. Experimenting with different values is encouraged to get a feel for it.",
+   },
+  ]}
+/>
+
+---
+
+### Ceiling
+
+This curve puts a ceiling on the output of the child curve asset.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Ceiling",
+     description: "decimal number. The maximum value this curve will output.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Floor
+
+This curve puts a floor on the output of the child curve asset.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Floor",
+     description: "decimal number. The minimum value this curve will output.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothCeiling
+
+This curve puts a ceiling on the output of the child curve asset. As the curve approaches the ceiling within the provided range it gets smoothed.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Ceiling",
+     description: "decimal number. The maximum value this curve will output.",
+   },
+   {
+     name: "Range",
+     description:
+       "decimal number, greater or equal to 0. The range determines how much smoothing is applied. A good starting value would be ¼ of the known range of your child curve.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothFloor
+
+This curve puts a floor on the output of the child curve asset. As the curve approaches the floor within the provided range it gets smoothed.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Floor",
+     description: "decimal number. The minimum value this curve will output.",
+   },
+   {
+     name: "Range",
+     description:
+       "decimal number, greater or equal to 0. The range determines how much smoothing is applied. A good starting value would be ¼ of the known range of your child curve.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothClamp
+
+This curve limits the range of the child curve asset within the provided walls. As the curve approaches the limits within the provided range it gets smoothed.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WallA",
+     description: "decimal number.",
+   },
+   {
+     name: "WallB",
+     description: "decimal number.",
+   },
+   {
+     name: "Range",
+     description:
+       "decimal number, greater or equal to 0. The range determines how much smoothing is applied. A good starting value would be ¼ of the known range of your child curve.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothMax
+
+This curve retrieves the maximum between the two curves provided. The intersection between the curves is smoothed as their values approach within the provided range.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "decimal number, greater or equal to 0. The range determines how much smoothing is applied. A good starting value would be ¼ of the known range of your child curves.",
+   },
+   {
+     name: "CurveA",
+     description: "curve asset slot.",
+   },
+   {
+     name: "CurveB",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothMin
+
+This curve retrieves the minimum between the two curves provided. The intersection between the curves is smoothed as their values approach within the provided range.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "decimal number, greater or equal to 0. The range determines how much smoothing is applied. A good starting value would be ¼ of the known range of your child curves.",
+   },
+   {
+     name: "CurveA",
+     description: "curve asset slot.",
+   },
+   {
+     name: "CurveB",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Clamp
+
+This clamps the curve between the two wall values provided. The output of this curve will never reach outside the walls.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WallA",
+     description: "decimal number.",
+   },
+   {
+     name: "WallB",
+     description: "decimal number.",
+   },
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Inverter
+
+This inverts the child curve such that positive values become negative and negative values become positive.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Max
+
+This outputs the maximum value of all the child curves.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curves",
+     description: "list of curve asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Min
+
+This outputs the minimum value of all the child curves.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curves",
+     description: "list of curve asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Multiplier
+
+This multiplies all the child curves’ outputs.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curves",
+     description: "list of curve asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Not
+
+This applies a logical NOT operation on the child curve. When the child’s output is 1, this will output 0, and when the child’s output is 0 this will output 1. All numbers in between are scaled accordingly.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description: "curve asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### Sum
+
+This adds the values of all the provided curves.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curves",
+     description: "list of curve asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Curve.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported Density asset.",
+   },
+  ]}
+/>
diff --git a/content/docs/bg-BG/official-documentation/worldgen/technical-hytale-generator/density.mdx b/content/docs/bg-BG/official-documentation/worldgen/technical-hytale-generator/density.mdx
new file mode 100644
index 00000000..993001d5
--- /dev/null
+++ b/content/docs/bg-BG/official-documentation/worldgen/technical-hytale-generator/density.mdx
@@ -0,0 +1,1544 @@
+---
+title: Density
+description: Defines a 3D decimal value field.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Constant
+
+Outputs a constant value.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Value",
+     description: "Decimal number.",
+   },
+  ]}
+/>
+
+---
+
+### SimplexNoise2D
+
+Outputs a value in the range [-1, 1] from a 2D simplex noise field that varies on the x/z plane. For more details on how simplex noise works and what every parameter does to the output you can visit [this page](https://cmaher.github.io/posts/working-with-simplex-noise/).;
+
+This node automatically caches the value per x/z column.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Lacunarity",
+     description:
+       "Positive floating point number. Impacts the scale of each consecutive octave. A good starting value would be 2.0, which results in each consecutive octave having details that are 2x smaller than the previous. Higher values result in grainier noise.",
+   },
+   {
+     name: "Persistence",
+     description:
+       "Positive floating point number. Multiplies the intensity of each consecutive octave. A good starting value would be 0.5, which results in each consecutive octave being half as strong as the previous.",
+   },
+   {
+     name: "Scale",
+     description:
+       "Positive floating point number. Represents the field's period distance in blocks. Greater values stretch the noise field outward. A good starting value would be 50.",
+   },
+   {
+     name: "Octaves",
+     description:
+       "Integer greater than 0. Greater values result in more detail. A good starting value would be 4. Requiring values over 10 are uncommon.",
+   },
+   {
+     name: "Seed",
+     description: "A string.",
+   },
+  ]}
+/>
+
+---
+
+### SimplexNoise3D
+
+Outputs a value in the range [-1, 1] from a 3D simplex noise field that varies on the x/y/z space. For more details on how simplex noise works and what every parameter does to the output you can visit [this page](https://cmaher.github.io/posts/working-with-simplex-noise/).
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Lacunarity",
+     description:
+       "Positive floating point number. Impacts the scale of each consecutive octave. A good starting value would be 2.0, which results in each consecutive octave having details that are 2x smaller than the previous. Higher values result in grainier noise.",
+   },
+   {
+     name: "Persistence",
+     description:
+       "Positive floating point number. Multiplies the intensity of each consecutive octave. A good starting value would be 0.5, which results in each consecutive octave being half as strong as the previous.",
+   },
+   {
+     name: "ScaleXZ",
+     description:
+       "Positive floating point number. Represents the field’s period distance in blocks on the horizontal XZ plane. Greater values stretch the noise field outward. A good starting value would be 50.",
+   },
+   {
+     name: "ScaleY",
+     description:
+       "Positive floating point number. Represents the field’s period distance in blocks on the vertical Y axis. Greater values stretch the noise field outward. A good starting value would be 50.",
+   },
+   {
+     name: "Octaves",
+     description:
+       "Integer greater than 0. Greater values result in more detail. A good starting value would be 4. Requiring values over 10 are uncommon.",
+   },
+   {
+     name: "Seed",
+     description: "A string.",
+   },
+  ]}
+/>
+
+---
+
+### PositionsCellNoise
+
+Produces a 2D/3D density field in which the value is determined by each coordinate’s distance from a field of Positions. You can use this asset to generate advanced Cell noise with control over the exact placement of the Cell’s through the Positions asset. You can also configure how the distance is interpreted to produce the output. You can use the traditional Cell noise ReturnTypes or create your own curves. You can also sample the Cell value from another Density field asset.
+
+![Example of PositionsCellNoise setup](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-cell-noise.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Positions",
+     description:
+       "Positions slot. This provides the Positions of each cell's core.",
+   },
+   {
+     name: "ReturnType",
+     description:
+       "ReturnType slot. This determines how the distance from each Position point is interpreted to produce the density field.",
+   },
+   {
+     name: "DistanceFunction",
+     description:
+       "DistanceFunction slot. This determines how the distance is calculated.",
+   },
+   {
+     name: "MaxDistance",
+     description:
+       "Floating point value. The maximum distance around each Position that it has an effect on the Density field. A good starting value is putting it a bit over half the distance between two of your Position points. Greater values have a greater impact on performance.",
+   },
+  ]}
+/>
+
+#### ReturnType
+
+Determines how each Position point affects the Densty field around it, or how the Cell looks.
+
+Below are the different types you can use.
+
+**CellValue**
+
+The Density value is constant inside each cell and is sampled from the provided Densty field.
+
+The images below show a 2D and a 3D output of the CellValue return type.
+
+![2D CellValue example](/assets/official-documentation/worldgen/technical-hytale-generator/density/cell-value-2d.png)
+
+![3D CellValue example](/assets/official-documentation/worldgen/technical-hytale-generator/density/cell-value-3d.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Density",
+     description:
+       "Density asset slot. The Density value of each cell is sampled from this field at the cell's core Position point.",
+   },
+   {
+     name: "DefaultValue",
+     description:
+       "Floating point number. This value is used outside of cells. This can happen when the field's MaxDistance value is smaller than the distance between some Positions.",
+   },
+  ]}
+/>
+
+**Density**
+
+The cell is populated with a Density field. The Density field is picked from a list of Delimiters. The Delimiters are picked if the ChoiceDensity field is within their range. The ChoiceDensity field’s value is sampled at the origin position of the cell.
+
+Below is a screenshot showing a simple example of how you can anchor any Density field you design to the origin of the cell using the Anchor Density node. Below the screenshot you can see the configuration I used for that.
+
+![Anchored Density example](/assets/official-documentation/worldgen/technical-hytale-generator/density/anchored-density.png)
+
+![Anchored Density configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/anchored-density-configuration.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Density",
+     description:
+       "Density asset slot. The Density value of each cell is sampled from this field at the cell's core Position point.",
+   },
+   {
+     name: "DefaultValue",
+     description:
+       "Floating point number. This value is used outside of cells. This can happen when the field's MaxDistance value is smaller than the distance between some Positions.",
+   },
+  ]}
+/>
+
+**Curve**
+
+The Curve ReturnType allows you to use a Curve asset to define the value of the Density field in terms of its distance from the Positions.
+
+{/* I did double check this one and the link did point to the same image we used above. Maybe accidental? */}
+
+![Example of Curve ReturnType](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-cell-noise.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description:
+       "Curve asset slot. The Density value of each cell is defined by the curve. The curve's input is the distance in blocks between the closest Position, and the Curve's output becomes the field's value.",
+   },
+  ]}
+/>
+
+**Distance**
+
+The Distance ReturnType works like the traditional CellNoise’s “Distance” return type.
+
+![Example of Distance](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance.png)
+
+It has no parameters.
+
+**Distance2**
+
+The Distance2 ReturnType works like the traditional CellNoise’s “Distance2” return type.
+
+![Example of Distance2](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance2.png)
+
+It has no parameters.
+
+**Distance2Add**
+
+The Distance2Add ReturnType works like the traditional CellNoise's "Distance2Add" return type.
+
+![Example of Distance2Add](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance2add.png)
+
+It has no parameters.
+
+**Distance2Sub**
+
+The Distance2Sub ReturnType works like the traditional CellNoise's "Distance2Sub" return type.
+
+![Example of Distance2Sub](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance2sub.png)
+
+It has no parameters.
+
+**Distance2Mul**
+
+The Distance2Mul ReturnType works like the traditional CellNoise's "Distance2Mul" return type.
+
+![Example of Distance2Mul](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance2mul.png)
+
+It has no parameters.
+
+**Distance2Div**
+
+The Distance2Div ReturnType works like the traditional CellNoise's "Distance2Div" return type.
+
+![Example of Distance2Div](/assets/official-documentation/worldgen/technical-hytale-generator/density/distance2div.png)
+
+It has no parameters.
+
+#### DistanceFunction
+
+Determines the way in which the distance to the closest Position is calculated. Currently there are two types: Euclidean and Manhattan.
+
+Below is an example of the Euclidean DistanceFunction:
+
+```json
+{
+  "Type": "Euclidean"
+}
+```
+
+Both types don’t have parameters.
+
+---
+
+### Distance
+
+The Distance outputs a value in function of the distance from the origin {0, 0, 0} of the field. The provided Curve asset maps the distance to the output Density value.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description:
+       "A Curve asset slot, maps the Distance from the origin to a Density value.",
+   },
+  ]}
+/>
+
+---
+
+### Ellipsoid
+
+The Ellipsoid is a deformed Sphere. You can use a Scale vector to stretch and compress the Sphere in different directions. You can spin it by giving it a new Y axis and a spin angle (in degrees).
+
+The order of deformations done to the Sphere is as follows:
+
+1. Stretch and compress using the Scale vector.
+2. Align its Y axis to the provided one.
+3. Spin it around the new Y axis.
+
+Below is an example Ellipsoid and its assets.
+
+![Example of Ellipsoid](/assets/official-documentation/worldgen/technical-hytale-generator/density/ellipsoid.png)
+
+![Example of Ellipsoid configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/ellipsoid-configuration.png)
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description:
+       "A Curve asset slot, maps the Distance from the origin to a Density value.",
+   },
+   {
+     name: "Scale",
+     description:
+       "A 3D vector asset slot. Determines how much to stretch the Sphere in each direction.",
+   },
+   {
+     name: "X",
+     description: "A floating point number.",
+   },
+   {
+     name: "Y",
+     description: "A floating point number.",
+   },
+   {
+     name: "Z",
+     description: "A floating point number.",
+   },
+   {
+     name: "Spin",
+     description:
+       "A floating point number. Determines the angle in degrees by which to spin the Ellipsoid around its Y axis.",
+   },
+  ]}
+/>
+
+---
+
+### Cube
+
+The Cube outputs a Density value in function of the distance from the origin axis of the field. The provided Curve asset maps the distance to the output Density value.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description:
+       "A Curve asset slot, maps the Distance from the origin to a Density value.",
+   },
+  ]}
+/>
+
+---
+
+### Cuboid
+
+The Cuboid is a deformed Cube. You can use a Scale vector to stretch and compress the Cube in different directions. You can spin it by giving it a new Y axis and a spin angle (in degrees).
+
+The order of deformations done to the Cube is as follows:
+
+4. Stretch and compress using the Scale vector.
+5. Align its Y axis to the provided one.
+6. Spin it around the new Y axis.
+
+Below is an example cuboid and its assets.
+
+![Example of Cuboid](/assets/official-documentation/worldgen/technical-hytale-generator/density/cuboid.png)
+
+![Example of Cuboid configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/cuboid-configuration.png)
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description:
+       "A Curve asset slot, maps the Distance from the origin to a Density value.",
+   },
+   {
+     name: "Scale",
+     description:
+       "A 3D vector asset slot. Determines how much to stretch the Cube in each direction.",
+   },
+   {
+     name: "X",
+     description: "A floating point number.",
+   },
+   {
+     name: "Y",
+     description: "A floating point number.",
+   },
+   {
+     name: "Z",
+     description: "A floating point number.",
+   },
+   {
+     name: "Spin",
+     description:
+       "A floating point number. Determines the angle in degrees by which to spin the Ellipsoid around its Y axis.",
+   },
+   {
+     name: "NewYAxis",
+     description:
+       "Point3D asset slot. Let's you rotate the field around its origin.",
+   },
+  ]}
+/>
+
+---
+
+### Cylinder
+
+The Cylinder generates a cylindrical shape, crazy I know. You can spin it by giving it a new Y axis and a spin angle (in degrees).
+
+The AxialCurve determines the Density value along its Y axis (not the world’s Y axis). The AxialCurve takes positive inputs anywhere above the Cylinder’s XZ-plane and it takes negative values anywhere below it.
+
+The RadialCurve determines the Density value in function of the distance from the Y axis. This basically can determine how thick the Cylinder is.
+
+Below is an example cuboid and its assets.
+
+![Example of Cylinder](/assets/official-documentation/worldgen/technical-hytale-generator/density/cylinder.png)
+
+![Example of Cylinder configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/cylinder-configuration.png)
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "AxialCurve",
+     description:
+       "A Curve asset slot, maps the Distance from the Cylinder's XZ-plane to a Density value.",
+   },
+   {
+     name: "RadialCurve",
+     description:
+       "A Curve asset slot, maps the Distance from the Cylinder's Y axis to a Density value.",
+   },
+   {
+     name: "Spin",
+     description:
+       "A floating point number. Determines the angle in degrees by which to spin the Ellipsoid around its original Y axis.",
+   },
+   {
+     name: "NewYAxis",
+     description:
+       "Point3D asset slot. In combination with the spin, this lets you rotate the Cylinder around its origin by aligning its original Y-axis with the provided one.",
+   },
+  ]}
+/>
+
+---
+
+### Axis
+
+The Axis outputs a Density value in function of the distance from a provided Axis line that passes through the origin {0, 0, 0} of the field or through the anchor point if the IsAnchored flag is true. The provided Curve asset maps the distance to the output Density value.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Axis",
+     description:
+       "3D vector asset slot determining the axis from which the distance is used.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+   {
+     name: "Curve",
+     description:
+       "Curve asset slot. Determines the Density value at any distance from the axis.",
+   },
+   {
+     name: "IsAnchored",
+     description:
+       "Boolean. If true, the Axis node will anchor itself to the closest anchor. Although you could use an Anchor node to anchor an Axis Density node, this internal method doesn't produce some artifacts.",
+   },
+  ]}
+/>
+
+---
+
+### Plane
+
+The Plane Density node allows you to define a Density field in function of the distance from a user-defined plane that passes through the field’s origin {0, 0, 0} or through the anchor if the flag `IsAnchored` is enabled. You can granularly define the Density value using a Curve asset. The PlaneNormal vector determines the direction the plane is facing.
+
+![Example of Plane](/assets/official-documentation/worldgen/technical-hytale-generator/density/plane.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "PlaneNormal",
+     description:
+       "3D vector asset slot determining the direction the plane is facing.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+   {
+     name: "Curve",
+     description:
+       "Curve asset slot. Determines the Density value at any distance from the plane.",
+   },
+  ]}
+/>
+
+---
+
+### Shell
+
+The Shell Density node allows you to define regions of the shell around the origin {0, 0, 0} of the field based on the direction and the distance from origin. The angles, thickness and Density values of the shell are fully configurable through Curve assets.
+
+The diagram below shows the anatomy of the Shell node and how its AngleCurve and its DistanceCurve are multiplied to obtain the result in the screenshot.
+
+![Example of Shell](/assets/official-documentation/worldgen/technical-hytale-generator/density/shell.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Axis",
+     description:
+       "3D vector asset slot determining the axis against which the angle is calculated.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+   {
+     name: "Mirror",
+     description:
+       "Boolean value. If true then the angle is mirrored in both directions of the axis.",
+   },
+   {
+     name: "AngleCurve",
+     description:
+       "Curve asset slot. Determines the Density value at any given angle from the axis.",
+   },
+   {
+     name: "DistanceCurve",
+     description:
+       "Curve asset slot. Determines the Density value at any distance from the origin.",
+   },
+  ]}
+/>
+
+---
+
+### CurveMapper
+
+This node maps the input to a Curve.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Curve",
+     description: "The curve.",
+   },
+  ]}
+/>
+
+---
+
+### Mix
+
+Mixes two inputs. How much of each input to use in the mix is gauged by a third input called the gauge:
+
+- Where the Gauge is less or equal to 0.0: only Density A is used.
+- Where the Gauge is more or equal to 1.0: only Density B is used.
+- Where the Gauge is between 0.0 and 1.0: Density A and B are mixed proportional to the Gauge.
+
+Expected Inputs: 3
+
+1. Density A.
+2. Density B.
+3. Gauge.
+
+Parameters: None
+
+---
+
+### MultiMix
+
+Mixes multiple inputs. How much of each input to use in the mix is gauged by the last input called the Gauge.
+
+The inputs are ordered top-down (in the node editor) and each input is assigned an index: starting with 0 for the top one and incrementing downwards.
+
+The keys let you pin the different inputs to Gauge values. Where the Gauge input's value approaches a Key's value, the input referenced by that Key is stronger in the final result.
+
+{/* <figure><img src="../../.gitbook/assets/image (44).png" alt=""><figcaption></figcaption></figure> */}
+
+Expected Inputs: unlimimied, the last one is the Gauge.
+
+Parameters: None
+
+---
+
+### Sum
+
+The output is the sum of all the inputs.
+
+Expected Inputs: [0, infinite)
+
+This node has no parameters.
+
+---
+
+### Multiplier
+
+The output is the multiplication of all the inputs.
+
+The Multiplier node skips the remaining inputs after an input provides a Density value of 0. This can help you optimize your Density performance by ordering the Multiplier inputs with the cheapest mask first.
+
+![Example of Multiplier optimization](/assets/official-documentation/worldgen/technical-hytale-generator/density/multiplier-optimization.png)
+
+The image below is an example where I put the edge's shell first in the Multiplier's input list, and the noise second. I configured the shell to be 0 where I want to mask it out. As a result, the noise (more expensive than the shell) is not calculated for large volumes of space where the shell mask is 0, and I got a performance improvement of ~40%. This is because around that percentage of the volume in that setup was masked out by the shell.
+
+![Example of Multiplier optimization configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/multiplier-optimization-configuration.png)
+
+Expected Inputs: [0, infinite)
+
+This node has no parameters.
+
+---
+
+### Max
+
+The output is the greatest value of all the inputs. If no inputs are provided it is 0.
+
+Expected Inputs: [0, infinite)
+
+This node has no parameters.
+
+---
+
+### Min
+
+The output is the smallest value of all the inputs. If no inputs are provided it is 0.
+
+Expected Inputs: [0, infinite)
+
+This node has no parameters.
+
+---
+
+### SmoothMax
+
+The output is a smoothed maximum between the two inputs. The diagram below compares a smooth maximum and a normal maximum of functions f and g. The normal maximum has sharp angles where f and g cross.
+
+![Example of SmoothMax](/assets/official-documentation/worldgen/technical-hytale-generator/density/smooth-max.png)
+
+Expected Inputs: 2
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "Positive floating point number. Greater values result in more smoothing. A good starter value could be 0.2.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothMin
+
+The output is a smoothed minimum between the two inputs. This node works the same as SmoothMax, please read that node’s description.
+
+Expected Inputs: 2
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "Positive floating point number. Greater values result in more smoothing. A good starter value could be 0.2.",
+   },
+  ]}
+/>
+
+---
+
+### Clamp
+
+This node ensures that the output is within the provided range which is defined by the two wall parameters. Input values that are inside the range don’t change and inputs values outside the range are brought back to the range’s extreme.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WallA",
+     description: "Any floating point number.",
+   },
+   {
+     name: "WallB",
+     description: "Any floating point number.",
+   },
+  ]}
+/>
+
+---
+
+### SmoothClamp
+
+This node ensures that the output is within the provided range which is defined by the two wall parameters. The concept is similar to the Clamp node documented above, but the output is smoothed to the limits by the provided range value.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WallA",
+     description: "Any floating point number.",
+   },
+   {
+     name: "WallB",
+     description: "Any floating point number.",
+   },
+   {
+     name: "Range",
+     description:
+       "Floating point values above 0, larger values result in smoother transition when the input approaches or exceeds the walls.",
+   },
+  ]}
+/>
+
+---
+
+### Abs
+
+The output is the absolute value of the input.
+
+Expected Inputs: 1
+
+This node has no parameters.
+
+---
+
+### XValue
+
+The local X coordinate.
+
+Expected Inputs: 0
+
+Parameters: None
+
+---
+
+### YValue
+
+The local Y coordinate.
+
+Expected Inputs: 0
+
+Parameters: None
+
+---
+
+### ZValue
+
+The local Z coordinate.
+
+Expected Inputs: 0
+
+Parameters: None
+
+---
+
+### XOverride
+
+Overrides the X coordinate the input sees.
+
+Expected Inputs: 1
+
+Parameters: None
+
+---
+
+### YOverride
+
+Overrides the Y coordinate the input sees.
+
+Expected Inputs: 1
+
+Parameters: None
+
+---
+
+### ZOverride
+
+Overrides the Z coordinate the input sees.
+
+Expected Inputs: 1
+
+Parameters: None
+
+---
+
+### Cache
+
+Caches the input for the current coordinates. The capacity determines how many coordinates' can be cached before having to drop the oldest one.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Capacity",
+     description:
+       "Positive Integer. Determines how many coordinates this cache can hold at once. A safe value is 3.",
+   },
+  ]}
+/>
+
+---
+
+### Angle
+
+The angle in degrees between two vectors, one of which is procedurally generated by a VectorProvider.
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Vector",
+     description: "3D vector.",
+   },
+   {
+     name: "VectorProvider",
+     description: "Procedural vector.",
+   },
+  ]}
+/>
+
+---
+
+### Sqrt
+
+The output is the square root value of the input.
+
+For negative inputs, this node uses a modified function to always return values that make sense and are useful. The following graph shows in blue the values for positive inputs, and in red the values for negative inputs.
+
+![Example of Sqrt](/assets/official-documentation/worldgen/technical-hytale-generator/density/sqrt.png)
+
+Expected Inputs: 1
+
+This node has no parameters.
+
+---
+
+### Inverter
+
+The output is the input multiplied by -1.
+
+Expected Inputs: 1
+
+This node has no parameters.
+
+---
+
+### Pow
+
+The output is the input taken to the power of the given exponent.
+
+For negative inputs, this node uses a modified function to always return values that make sense and are useful.;
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Exponent",
+     description: "Any value, A good starting value would be 2.",
+   },
+  ]}
+/>
+
+---
+
+### Scale
+
+Stretches or contracts the input Density field. The input’s Density field is scaled by the factor’s provided for each axis. Values above 1 stretches the field and values below 1 contract it. Values under 0 flip the field.
+
+The image below shows a Density field before and after passing it through a Scale node: The node is configured to only scale up the X direction.
+
+![Example of Scale](/assets/official-documentation/worldgen/technical-hytale-generator/density/scale.png)
+
+You can also scale on a non-orthogonal axis by using Rotator nodes in combination with a Scale node, like this:
+
+![Example of Scale with Rotator](/assets/official-documentation/worldgen/technical-hytale-generator/density/scale-rotator.png)
+
+![Example of Scale with Rotator configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/scale-rotator-configuration.png)
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "X",
+     description: "A floating point number.",
+   },
+   {
+     name: "Y",
+     description: "A floating point number.",
+   },
+   {
+     name: "Z",
+     description: "A floating point number.",
+   },
+  ]}
+/>
+
+---
+
+### DistanceToBiomeEdge
+
+Outputs the distance to the nearest biome edge in blocks.
+
+Expected Inputs: 0
+
+Parameters: None
+
+---
+
+### Terrain
+
+Outputs the world's interpolated terrain Density.;
+
+This should only be used as part of a biome's MaterialProvider nodes. This won't work if used in the Terrain's Density nodes.
+
+Expected Inputs: 0
+
+Parameters: None
+
+---
+
+### Rotator
+
+Aligns the input Density field so that its Y axis is aligned with the provided axis, and spins it around the new axis by the provided angle.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "NewYAxis",
+     description: "3D vector asset.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+   {
+     name: "SpinAngle",
+     description:
+       "Floating point number. The angle in degrees to spin the field around the new axis.",
+   },
+  ]}
+/>
+
+---
+
+### Slider
+
+Slides the input Density field in the direction of the provided vector.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SlideX",
+     description: "A floating point number.",
+   },
+   {
+     name: "SlideY",
+     description: "A floating point number.",
+   },
+   {
+     name: "SlideZ",
+     description: "A floating point number.",
+   },
+  ]}
+/>
+
+---
+
+### PositionsPinch
+
+Pinches or expands the first input’s Density field around the Positions. The intensity and look of the effect is determined by the PinchCurve. The range of the effect around each position is determined by the MaxDistance.
+
+If the NormalizeDistance is true, then the curve’s input and output’s unit is normalized to the MaxDistance. In other words, for half of the MaxDistance, the curve’s input and output will be 0.5, and at the full MaxDistance, it would be 1. Otherwise if false, the curve’s values will represent the absolute distance in terms of blocks for both its input and output.
+
+Below is an example configuration of a pinch, and the resulting terrain.
+
+![Example of PositionsPinch](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-pinch.png)
+
+![Example of PositionsPinch configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-pinch-configuration.png)
+
+Below is an example configuration of a pull and the resulting terrain.
+
+![Example of PositionsPull](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-pull.png)
+
+![Example of PositionsPull configuration](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-pull-configuration.png)
+
+![Graph of PositionsPull's curve](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-pull-curve.png)
+
+The PositionsMinY and PositionsMaxY parameters limit the vertical range queried from the Positions field. The default values are 0.0 and 0.0001 to let in all the Positions at Y:0.
+
+Expected Inputs: 1
+
+<ParameterList
+  parameters={[
+   {
+     name: "Positions",
+     description:
+       "Positions asset slot. The Positions are the anchors that pinch and expand the Density field around them.",
+   },
+   {
+     name: "PinchCurve",
+     description:
+       "Curve asset slot. The curve determines how the Density field is pinched or expanded depending on how close it is to a position.",
+   },
+   {
+     name: "MaxDistance",
+     description:
+       "Positive floating point number. The value represents how big the area of effect is in block units.",
+   },
+   {
+     name: "NormalizeDistance",
+     description:
+       "Boolean value, default is true. If true then the Curve’s input and output unit is normalized to the MaxDistance value, otherwise if false the Curve’s input and output unit is in blocks.",
+   },
+   {
+     name: "HorizontalPinch",
+     description:
+       "Boolean value, default is false. If true, the input is pinched horizontally only.",
+   },
+   {
+     name: "PositionsMaxY",
+     description:
+       "Floating point number. Determines the upper Y level bound of the region queried from the Positions field. Any Positions that are at or above this value are ignored.",
+   },
+   {
+     name: "PositionsMinY",
+     description:
+       "Floating point number. Determines the lower Y level bound of the region queried from the Positions field. Any Positions that are below this value are ignored.",
+   },
+  ]}
+/>
+
+---
+
+### PositionsTwist
+
+Twists the first input’s Density field around the Positions. The intensity and look of the effect is determined by the TwistCurve. The range of the effect around each position is determined by the MaxDistance.
+
+If the NormalizeDistance is true, then the curve’s input unit is normalized to the MaxDistance. In other words, for half of the MaxDistance, the curve’s input will be 0.5, and at the full MaxDistance, it would be 1. Otherwise if false, the curve’s values will represent the absolute distance in terms of blocks.
+
+The output of the curve is always in degrees. This means that to produce a full twist around the axis, the curve must output 360 (degrees).
+
+Below is an example configuration of a simple twist, and the resulting terrain.
+
+![Example of PositionsTwist](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-twist.png)
+
+![Example configuration of a simple twist](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-twist-configuration.png)
+
+Below is an example configuration of a double twist where part of the curve twists in one direction and part in the other direction, and the resulting terrain.
+
+![Example of PositionsTwist double twist](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-twist-double.png)
+
+![Example configuration of a double twist](/assets/official-documentation/worldgen/technical-hytale-generator/density/positions-twist-double-configuration.png)
+
+Expected Inputs: 1
+
+<ParameterList
+  parameters={[
+   {
+     name: "Positions",
+     description:
+       "Positions asset slot. The Positions are the anchors that pinch and expand the Density field around them.",
+   },
+   {
+     name: "TwistCurve",
+     description:
+       "Curve asset slot. The curve determines how the Density field is twisted depending on how close it is to a position.",
+   },
+   {
+     name: "TwistAxis",
+     description:
+       "Vector asset slot. the axis around which the twisting happens.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+   {
+     name: "MaxDistance",
+     description:
+       "Positive floating point number. The value represents how big the area of effect is in block units.",
+   },
+   {
+     name: "NormalizeDistance",
+     description:
+       "Boolean value, default is true. If true then the Curve’s input unit is normalized to the MaxDistance value, otherwise if false the Curve’s input unit is in blocks.",
+   },
+  ]}
+/>
+
+---
+
+### GradientWarp
+
+Warps the first input based on the gradient of the second input Density field. This works similar to the legacy warping functionality, except it also works in 3D and you can plug any Density field into it.
+
+This implementation is relatively expensive because it calculates the gradient of the input Density field. I recommend optimizing the use of this node by isolating and minimizing its use space. A fast version of this node can be implemented which would let you only use Simplex noise to warp. This will depend on the feedback and priorities.
+
+This node incorporates a Cache2D so you don’t need to use a Cache2D node on its output.
+
+Expected Inputs: 2
+
+- Input 1: Density field to be warped.
+- Input 2: Density field that warps the first field.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SampleRange",
+     description:
+       "Floating point number greater than 0. I recommend keeping this value at 1.",
+   },
+   {
+     name: "WarpFactor",
+     description:
+       "A floating point number greater than 0. With greater values you get more warping.",
+   },
+   {
+     name: "2D",
+     description:
+       "Boolean, if true the output of this node is 2D. An internal Cache2D is used.",
+   },
+   {
+     name: "YFor2D",
+     description:
+       "Floating point coordinate, default is 0. the Y coordinate used from the input to calculate the gradient from.",
+   },
+  ]}
+/>
+
+---
+
+### FastGradientWarp
+
+This is a faster implementation of the GradientWarp node. It warps the input Density field using an internal simplex noise generator.
+
+Expected Inputs: 1
+
+- Input 1: Density field to be warped.
+
+<ParameterList
+  parameters={[
+   {
+     name: "WarpScale",
+     description:
+       "Floating point number greater than 0. This determines the scale of the internal warper noise field.",
+   },
+   {
+     name: "WarpLacunarity",
+     description:
+       "Decimal number greater than 0. The lacunarity of the internal simplex field.",
+   },
+   {
+     name: "WarpPersistence",
+     description:
+       "Decimal number greater than 0. The persistence of the internal simplex field.",
+   },
+   {
+     name: "WarpOctaves",
+     description: "Integer greater than 0. The internal field’s octaves.",
+   },
+   {
+     name: "WarpFactor",
+     description:
+       "Decimal number greater than 0. Themaximum distance coordinates can be warped.",
+   },
+  ]}
+/>
+
+---
+
+### VectorWarp
+
+Warps the input along the provided vector. The amount of warping is determined by the intensity of the second input Density field and the WarpFactor.
+
+For example, if your warp field (second input) has a value of 0.5 and the WarpFactor is 15, then the number of blocks the first input will be warped by in the direction of the vector is 7.5 units (blocks),15 x 0.5 = 7.5.
+
+Below is a PositionsCellNoise (Distance2Div) passed through a VectorWarp. The warping field is a normal simplex, the WarpVector is sideways {1, 0, 1} and the WarpFactor is 15.
+
+![Example of VectorWarp](/assets/official-documentation/worldgen/technical-hytale-generator/density/vector-warp.png)
+
+Expected Inputs: 2
+
+- Input 1: Density field to be warped.
+- Input 2: Density field that warps the first field.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WarpFactor",
+     description:
+       "A floating point number greater than 0. With greater values you get more warping.",
+   },
+   {
+     name: "WarpVector",
+     description:
+       "Vector asset slot. Can be any vector. This determines the direction in which the warping happens. Negative values of the factor or the warping density field will result in flipped warping direction.",
+   },
+   {
+     name: "X",
+     description: "Floating point number.",
+   },
+   {
+     name: "Y",
+     description: "Floating point number.",
+   },
+   {
+     name: "Z",
+     description: "Floating point number.",
+   },
+  ]}
+/>
+
+---
+
+### Anchor
+
+Anchors the origin of the child field (input) to the contextual Anchor if it exists. It basically puts the {0, 0, 0} origin of the child Density at the position of the Anchor.;
+
+For a contextual Anchor to exist, a parent of this node must produce an Anchor. The Density ReturnType node, for example, leaves the cell's center as a contextual Anchor in its Density child’s context.;
+
+You can also reverse the effect later down the line to move the origin back to the world’s origin like in the screenshot below. The field is unanchored when it reaches the bottom branch of the Sum, but the top branch is still anchored.
+
+{/* <figure><img src="../../.gitbook/assets/image (45).png" alt=""><figcaption></figcaption></figure> */}
+
+_Example: Say you have a Density field that creates a ball around its origin {0, 0, 0}. You also have a PositionsCellNoise with a Density return type, which leaves an anchor point at its cell's center. If you anchor the ball Density to the cell, the ball will generate around the cell's center._
+
+{/* <figure><img src="../../.gitbook/assets/image (46).png" alt=""><figcaption></figcaption></figure> */}
+
+Expected Inputs: 1
+
+<ParameterList
+  parameters={[
+   {
+     name: "Reverse",
+     description:
+       "Boolean. If true, the node will reverse the origin of the child to the world’s origin, or the origin before the previous Anchor node.",
+   },
+  ]}
+/>
+
+---
+
+### Normalizer
+
+It normalizes the input. The scale is defined by the FromMin, FromMax, ToMin and ToMax parameters. The diagrams below show how those four parameters can be intuitively used to normalize the input.
+
+![Example of Normalizer](/assets/official-documentation/worldgen/technical-hytale-generator/density/normalizer.png)
+
+Note that the FromMin and FromMax can be any values, in this example I decided to place them at the extremes of the input’s range.
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FromMin",
+     description: "Any floating point number.",
+   },
+   {
+     name: "FromMax",
+     description: "Any floating point number.",
+   },
+   {
+     name: "ToMin",
+     description: "Any floating point number.",
+   },
+   {
+     name: "ToMax",
+     description: "Any floating point number.",
+   },
+  ]}
+/>
+
+---
+
+### BaseHeight
+
+This node lets you reference a BaseHeight from the WorldStructure. It can operate in 2 mondes:
+
+- Distance OFF: output the Y value of the BaseHeight at each X/Z position
+- Distance ON: output the distance between the queried position and the BaseHeight.
+
+In Distance mode ON, the output is measured in blocks (coordinate units). The value is positive if the query position is above the BaseHeight, and negative if it is below the BaseHeight. Below is an example of that.
+
+![Example of BaseHeight distance](/assets/official-documentation/worldgen/technical-hytale-generator/density/base-height-distance.png)
+
+Expected Inputs: 0
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "BaseHeightName",
+     description: "String, name of the BaseHeight to reference.",
+   },
+   {
+     name: "Distance",
+     description:
+       "Boolean value, toggles whether to output the raw Y coordinate of the BaseHeight or the distance from the BaseHeight from the query position.",
+   },
+  ]}
+/>
+
+---
+
+### Switch
+
+This node lets you switch between multiple Density branches based on the contextual SwitchState. The SwitchState is a string that can be placed in the context of a Density tree using a SwitchState Density node. The default SwitchState of a Density tree is “Default”.
+
+Below is an example where I use a Default branch, alongside two other branches.
+
+![Example of Switch](/assets/official-documentation/worldgen/technical-hytale-generator/density/switch.png)
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SwitchCases",
+     description: "Switch Case asset slots.",
+   },
+   {
+     name: "CaseState",
+     description:
+       "String. The name of the contextual SwitchCase required for this branch.",
+   },
+   {
+     name: "Density",
+     description: "Density asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### SwitchState
+
+Sets the contextual SwitchState for the downstream Density branch.
+
+See the Switch documentation above for an example use case.
+
+![Example of SwitchState](/assets/official-documentation/worldgen/technical-hytale-generator/density/switch-state.png)
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SwitchState",
+     description:
+       "String, name of the SwitchState to set for the children of this node.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Density asset.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "String. The exported Density.",
+   },
+  ]}
+/>
+
+---
+
+### Exported
+
+Allows exporting a Density field as a single instance. Enabling the SingleInstance on this node ensures all importers share the same logic.;
+
+By default a completely different instance is create for every Imported node. When there are multiple Imported nodes that import the same exported key, a new instance of that exported Density tree will be created for each one of the Imported nodes. SingleInstance ensures all importers share the same underlying instance of the node tree.
+
+This node can be used to optimize caching when an exported Density is imported multiple times in the same context and contains caches. The caches would be shared between the different imported instances.
+
+_Important: This is still an experimental feature and could cause unexpected behaviors if misused._
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SingleInstance",
+     description:
+       "Boolean. Enable to share the exported for all Imported nodes referencing this key.",
+   },
+   {
+     name: "Density",
+     description: "Density slot.",
+   },
+  ]}
+/>
diff --git a/content/docs/bg-BG/official-documentation/worldgen/technical-hytale-generator/directionality.mdx b/content/docs/bg-BG/official-documentation/worldgen/technical-hytale-generator/directionality.mdx
new file mode 100644
index 00000000..bd885958
--- /dev/null
+++ b/content/docs/bg-BG/official-documentation/worldgen/technical-hytale-generator/directionality.mdx
@@ -0,0 +1,95 @@
+---
+title: Directionality
+description: Determines the direction to place a Prop.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Static
+
+Allows you to specify the only direction the Prop will be placed in.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Rotation",
+     description:
+       "integer, optional with default of 0. Can only have on of these four values: 0, 90, 180 or 270.",
+   },
+   {
+     name: "Pattern",
+     description:
+       "Pattern slot. Used to locate a suitable position for the Prop and does not affect the Prefab’s direction.",
+   },
+  ]}
+/>
+
+---
+
+### Random
+
+Gives the Prefab random directions based on a seed.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Seed",
+     description: "string. Affects rotations.",
+   },
+   {
+     name: "Pattern",
+     description:
+       "Pattern slot. Used to locate a suitable position for the Prop and does not affect the Prefab’s direction.",
+   },
+  ]}
+/>
+
+---
+
+### Pattern _(note: name of the Directionality Type)_
+
+Allows the Prop to have the correct direction based on it environment. Allows you to link Prefab directions to Pattern assets for each direction.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "InitialDirection",
+     description:
+       "string with possible values: “N”, “S”, “E”, “W”. The direction the Props are facing in their original state. A balcony facing North in this context would mean that the balcony is looking North.",
+   },
+   {
+     name: "NorthPattern",
+     description:
+       "Pattern slot. Defines environments where this Prop should place facing North.",
+   },
+   {
+     name: "SouthPattern",
+     description:
+       "Pattern slot. Defines environments where this Prop should place facing South.",
+   },
+   {
+     name: "EastPattern",
+     description:
+       "Pattern  slot. Defines environments where this Prop should place facing East.",
+   },
+   {
+     name: "WestPattern",
+     description:
+       "Pattern slot. Defines environments where this Prop should place facing West.",
+   },
+   {
+     name: "Seed",
+     description:
+       "string. Affects direction picking where more than one direction is possible.",
+   },
+  ]}
+/>
diff --git a/content/docs/bg-BG/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx b/content/docs/bg-BG/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx
new file mode 100644
index 00000000..24e628b5
--- /dev/null
+++ b/content/docs/bg-BG/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx
@@ -0,0 +1,506 @@
+---
+title: Material Providers
+description: Determines which Material to use where.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Constant
+
+Provides one constant block type.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "BlockType",
+     description:
+       "string name of the Hytale block type, for example: “Rock_Stone”.",
+   },
+  ]}
+/>
+
+---
+
+### Solidity
+
+Separates into Solid and Empty terrain blocks and provides a Material Provider slot for each of the two selections.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Solid",
+     description: "Material Provider slot.",
+   },
+   {
+     name: "Empty",
+     description: "Material Provider slot.",
+   },
+  ]}
+/>
+
+---
+
+### Queue
+
+Goes through a queue of Material Provider slots from highest to lowest priority. If a Material Provider in the queue doesn’t provide a block type the next one in the queue is queried. If no slot provides a block then the Queue Material Provider will not provide a block. The query stops at the first slot that provides a block.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Queue",
+     description:
+       "list of Material Provider slots. The slots are queried from top to bottom.",
+   },
+  ]}
+/>
+
+---
+
+### SimpleHorizontal
+
+Applies the child Material Provider on a vertical range.;
+
+If a BaseHeight is provided, the TopY and BottomY values are relative to the BaseHeight, otherwise they're relative to the world's Y coordinate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "TopY",
+     description:
+       "integer Y coordinate that defines the vertical top exclusive limit of the region.",
+   },
+   {
+     name: "Top BaseHeight",
+     description: "string. BaseHeight name.",
+   },
+   {
+     name: "BottomY",
+     description:
+       "integer Y coordinate that defines the vertical bottom inclusive limit of the region.",
+   },
+   {
+     name: "Bottom BaseHeight",
+     description: "string. BaseHeight name.",
+   },
+   {
+     name: "Material",
+     description: "Material Provider slot to query for the selected region.",
+   },
+  ]}
+/>
+
+---
+
+### Striped
+
+Applies a Material Provider slot on a set of horizontal stripes of blocks of varying thickness and position. Below is an example image of basalt stripes into a stone cliff.
+
+![Example of basalt stripes](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/basalt-stripes-example.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Stripes",
+     description:
+       "list of stripe assets each containing a TopY and BottomY keys: TopY: any integer representing a world Y value, is inclusive. BottomY: any integer representing a world Y value, is inclusive.",
+   },
+   {
+     name: "Material",
+     description: "Material Provider slot to query for the selected region.",
+   },
+  ]}
+/>
+
+---
+
+### Weighted
+
+Picks the Material Provider slot to query from a list. Each slot has a weight which determines the likelihood for it to be picked.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Seed",
+     description: "string.",
+   },
+   {
+     name: "SkipChance",
+     description:
+       "value from 0.0 to 1.0 determining the percentage of blocks that are skipped. When a block is skipped this Material Provider basically provides no block and it skips picking a slot all together.",
+   },
+   {
+     name: "WeightedMaterials",
+     description:
+       "List of weighted Material Provider slots: Weight: value above 0. Greater value results in higher likelihood of being picked. Material: Material Provider slot.",
+   },
+  ]}
+/>
+
+---
+
+### FieldFunction
+
+Selects a 3D region using a noise function and value delimiters. The delimiters link a Material Provider slot to a specific range of values in the noise function. The noise function shares seeds with the DAOTerrain density function.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FieldFunction",
+     description:
+       "defines the field value for each block. Like in the example above, this is the same type of asset as the one used in DAOTerrain to define density.",
+   },
+   {
+     name: "Delimiters",
+     description:
+       "list of delimiters. Higher in the list results in higher priority.",
+   },
+   {
+     name: "From",
+     description:
+       "any floating point value defining the minimum limit of the delimiter’s range.",
+   },
+   {
+     name: "To",
+     description:
+       "any floating point value defining the maximum limit of the delimiter’s range.",
+   },
+   {
+     name: "Material",
+     description: "Material Provider slot linked to this delimiter.",
+   },
+  ]}
+/>
+
+---
+
+### SpaceAndDepth
+
+Allows placing layers of blocks on a terrain’s floor or ceiling surfaces. Layers of Material are piled on each other inside the surface (floor or ceiling) like a cake. There are multiple Layer types, each type providing a unique way to define its thickness. Below is an example of two layers into the floor of our terrain.
+
+![Example of DepthAndSpace Material Provider](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/depth-and-space-example.png)
+
+Conditions let you skip this Material Provider if they are not met. An example of this could be a condition that only places grass if there is at least 5 blocks of empty above the surface.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "LayerContext",
+     description:
+       "string. The context the layers are applied on. For example if the context is DEPTH\_INTO\_FLOOR then the layers will be applied relative to the depth into the floor. So the first layer will be the topmost block of the floor, and each consecutive layer will build deeper under the previous layer. The graphic above illustrates that.\
+  Possible values: DEPTH\_INTO\_FLOOR and DEPTH\_INTO\_CEILING.",
+   },
+   {
+     name: "MaxExpectedDepth",
+     description:
+       "Positive Integer. This value helps the system optimize this Material Provider by not performing more depth lookups than necessary. Ideally you should set this value at the maximum expected depth all of the layers combined can have.\
+  For example, if I have 3 layers in my provider as such: first layer is 1 block thick, second layer is 2 to 4 blocks thick and the third layer is 0 to 5 blocks thick, then my MaxExpectedDepth value should be the maximum of all these layers, in my case 1 + 4 + 5 = 10. Setting a value that is too small might cut off the extreme ends of a layer, while setting a value that is too large might result in poor performance for super complex configs.",
+   },
+   {
+     name: "Condition",
+     description:
+       "slot for a Condition object, see the Condition’s documentation below. The Material Provider returns no block if the Condition isn’t met for the current block.",
+   },
+   {
+     name: "Layers",
+     description:
+       "List of Layer objects, see the Layer’s documentation below. The Material Provider will pile the layers from the top of the list down as it gets deeper into the context. The diagram above shows that.",
+   },
+  ]}
+/>
+
+---
+
+### Condition
+
+A Condition object checks if the environment is valid to determine whether the Material Provider should be run for the current block. If the Condition fails for a block then the Material Provider will return no block.
+
+An example of Condition could be to check if there is at least 5 blocks of empty space above the floor. This condition could be useful if you want dirt blocks in tight spaces instead of grass. An example of that is shown below.
+
+![Example of Condition checking space above floor](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/condition-space-above-floor.png)
+
+See the [JSON code here](https://miro.com/app/board/o9J_loYgP38=/?moveToWidget=3458764528990928227\&cot=14).
+
+The Condition’s ContextToCheck parameter is the information from the block’s context that you can query in your Condition. In the example above we are checking the SPACE_ABOVE_FLOOR context, which is the number of blocks above the floor. There are currently two possible context values you can use:
+
+- SPACE_ABOVE_FLOOR
+- SPACE_BELOW_CEILING
+
+There are multiple Condition types that allow you to compose more complex Conditions from simpler ones. Below are the different types.
+
+**EqualsCondition**
+
+Validates only if a context value is equal to the Condition’s configured value.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ContextToCheck",
+     description:
+       "string and can have two values, namely SPACE\_ABOVE\_FLOOR and SPACE\_BELOW\_CEILING. These are documented above.",
+   },
+   {
+     name: "Value",
+     description:
+       "any integer. The only valid value of this Condition, if the context value is different then the Condition fails.",
+   },
+  ]}
+/>
+
+**GreaterThanCondition**
+
+Validates only if a context value is greater than the Condition’s configured threshold.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ContextToCheck",
+     description:
+       "string and can have two values, namely SPACE\_ABOVE\_FLOOR and SPACE\_BELOW\_CEILING. These are documented above.",
+   },
+   {
+     name: "Threshold",
+     description:
+       "any integer. For the condition to succeed the context value must be greater than the threshold value.",
+   },
+  ]}
+/>
+
+**SmallerThanCondition**
+
+Validates only if a context value is smaller than the Condition’s configured threshold.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ContextToCheck",
+     description:
+       "string and can have two values, namely SPACE\_ABOVE\_FLOOR and SPACE\_BELOW\_CEILING. These are documented above.",
+   },
+   {
+     name: "Threshold",
+     description:
+       "any integer. For the condition to succeed the context value must be smaller than the threshold value.",
+   },
+  ]}
+/>
+
+**AndCondition**
+
+AND operator logical Condition. Validates only if all of its Condition slots also validate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Conditions",
+     description: "List of Condition slots.",
+   },
+  ]}
+/>
+
+**OrCondition**
+
+OR operator logical Condition. Validates if any of its Condition slots also validate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Conditions",
+     description: "List of Condition slots.",
+   },
+  ]}
+/>
+
+**NotCondition**
+
+NOT operator logical Condition. Validates if its Condition slot does not validate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Condition",
+     description:
+       "Condition slot. Note that this is a single slot and not a list like the AND and the OR variants.",
+   },
+  ]}
+/>
+
+**AlwaysTrueCondition**
+
+This Condition type always validates.
+
+---
+
+### Layer
+
+In the DepthAndSpace Material Provider type, Layers are stacked into the depth of the floor or ceiling. Layers have a thickness and Material Provider.
+
+Below are some examples that illustrate how layers work.
+
+Example 1:
+
+- Layer 1: grass of thickness 1.
+
+![Example of Layer 1 grass thickness 1](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/layer-example-1.png)
+
+Example 2:
+
+- Layer 1: grass of thickness 1.
+- Layer 2: dirt of thickness ranging from 2 to 3.
+
+![Example of Layer 2 grass and dirt](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/layer-example-2.png)
+
+Example 3:
+
+- Layer 1: mud of thickness 1 to 5 defined by a 2D simplex noise function.
+- Layer 2: dirt of thickness ranging from 2 to 3.
+
+![Example of Layer 3 mud and dirt](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/layer-example-3.png)
+
+Example 4: This example shows how this can work not only on floors but also on the ceilings by changing the LayerContext value to DEPTH_INTO_CEILING.
+
+- Layer 1: dirt of thickness in range 2 to 3.
+
+![Example of Layer 4 dirt on ceiling](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/layer-example-4.png)
+
+End of examples.
+
+Below are documented the different types of Layers.
+
+**ConstantThickness**
+
+Has the same thickness everywhere.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Material",
+     description: "slot for Material Provider.",
+   },
+   {
+     name: "Thickness",
+     description: "integer greater or equal to 0, the thickness in blocks.",
+   },
+  ]}
+/>
+
+**RangeThickness**
+
+The thickness varies per XZ coordinate and is defined by a range of possible values.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Material",
+     description: "slot for Material Provider.",
+   },
+   {
+     name: "RangeMin",
+     description:
+       "integer greater or equal to 0, the minimum value in blocks the range can have.",
+   },
+   {
+     name: "RangeMax",
+     description:
+       "integer greater or equal to 0, the maximum inclusive value in blocks the range can have.",
+   },
+   {
+     name: "Seed",
+     description: "string.",
+   },
+  ]}
+/>
+
+**WeightedThickness**
+
+The thickness varies per XZ coordinate and is picked from a list of weighted thickness values.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Material",
+     description: "slot for Material Provider.",
+   },
+   {
+     name: "PossibleThicknesses",
+     description: "a list of weighted thickness values.",
+   },
+   {
+     name: "Seed",
+     description: "the seed used when picking the thickness.",
+   },
+  ]}
+/>
+
+**NoiseThickness**
+
+The thickness varies per XZ coordinate and is determined by a noise function tree. Note that the thickness value is determined by the function output, this is why in the example below I normalized the output to be from 0 to 5 because I wanted the thickest point to be around 5 blocks.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Material",
+     description: "slot for Material Provider.",
+   },
+   {
+     name: "ThicknessFunctionXZ",
+     description:
+       "a noise function tree. This function is only sampled with XZ inputs with a constant Y of 0. In other words, this function is sampled like a 2D function on the XZ plane.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported MaterialProvider..
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported MaterialProvider.",
+   },
+  ]}
+/>
diff --git a/content/docs/bg-BG/official-documentation/worldgen/technical-hytale-generator/patterns.mdx b/content/docs/bg-BG/official-documentation/worldgen/technical-hytale-generator/patterns.mdx
new file mode 100644
index 00000000..58f6f2e1
--- /dev/null
+++ b/content/docs/bg-BG/official-documentation/worldgen/technical-hytale-generator/patterns.mdx
@@ -0,0 +1,412 @@
+---
+title: Patterns
+description: Validates a world location based on its Material composition and other criteria.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### BlockType
+
+Checks against the block's Material.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Material",
+     description: "block Material.",
+   },
+  ]}
+/>
+
+---
+
+### BlockSet
+
+Checks if the block's Material belongs to the BlockSet.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "BlockSet",
+     description: "BlockSet slot.",
+   },
+  ]}
+/>
+
+---
+
+### Offset
+
+Offsets the child Pattern by the given vector.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Pattern",
+     description: "Pattern slot.",
+   },
+   {
+     name: "Offset",
+     description:
+       "3D integer vector. The direction to offset the child Pattern in.",
+   },
+  ]}
+/>
+
+---
+
+### Floor
+
+Checks if there is a floor below the position. The Origin validates the position and the Floor validates right under the position. For a simple Floor configuration use BlockType or BlockSet Patterns in those slots.
+
+![Example of Floor](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/floor.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Floor",
+     description:
+       "Pattern slot. Validates the block under the Origin position.",
+   },
+   {
+     name: "Origin",
+     description: "Pattern slot. Validates the block at the Origin position.",
+   },
+  ]}
+/>
+
+---
+
+### Ceiling
+
+Checks if there is a ceiling above the world position. The Origin validates the position and the Ceiling validates right above the position. For a simple Ceiling configuration use BlockType or BlockSet Patterns in those slots.
+
+![Example of Ceiling](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/ceiling.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Ceiling",
+     description:
+       "Pattern slot. Validates the coordinate above the Origin position.",
+   },
+   {
+     name: "Origin",
+     description:
+       "Pattern slot. Validates the coordinate at the Origin position.",
+   },
+  ]}
+/>
+
+---
+
+### Wall
+
+Checks if there is a wall next to the world position. For a simple Wall configuration use BlockType or BlockSet Patterns in those slots. You can specify which directions are valid for the wall using the N, S, E, W string values.
+
+The size of the wall can be 1x1 blocks or larger.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Wall",
+     description:
+       "Pattern slot. Validates the coordinate next to the Origin position.",
+   },
+   {
+     name: "Origin",
+     description:
+       "Pattern slot. Validates the coordinate at the Origin position.",
+   },
+   {
+     name: "Directions",
+     description: 'list of string directional values: "N", "S", "E" or "W".',
+   },
+   {
+     name: "RequireAllDirections",
+     description:
+       "Boolean. If true then all the directions you put in the list need to validate for the Pattern to validate a position. Otherwise only one of the list directions needs to validate.",
+   },
+  ]}
+/>
+
+---
+
+### Surface
+
+Validates if presented with a surface. A surface is a transition from one set of materials to another. For example, a soil floor to place a large tree on would be a soil surface in an air medium. The surface’s facing, the surface’s area, the medium’s area and the transition gap are configurable.
+
+The surface can face 6 orthogonal directions: up, down, north, south, east and west. A surface’s facing direction is determined by its Facings. Furthermore, you can specify more than one facing and use the RequireAllFacings parameter. When a surface faces up, the medium is at the origin and the surface is below the origin. See the diagram below that shows a side-view of an up-facing surface..
+
+![Example of Surface facing up](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-up.png)
+
+The minimum area required by the surface and medium materials is determined by the SurfaceRadius and the MediumRadius values. A radius of 0.0 would result in an area of 1x1 block, while an area of 2.0 would result in a disc of a 5 block diameter. The diagram below shows that relationship with a top-down view of an up-facing surface.
+
+![Example of Surface and Medium area](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-medium-area.png)
+
+You can make the surface detection less strict by configuring a gap between the medium and the surface. That gap would allow some roughness in between the medium and the surface. The diagrams below show how that works.
+
+![Example of Surface Gap 0](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-gap-0.png)
+
+![Example of Surface Gap 1](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-gap-1.png)
+
+![Example of Surface Gap 2](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-gap-2.png)
+
+![Example of Surface Gap 3](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-gap-3.png)
+
+![Example of Surface Gap 4](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/surface-gap-4.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Surface",
+     description: "Pattern slot. Validates every block of the surface.",
+   },
+   {
+     name: "Medium",
+     description: "Pattern slot. Validates every block of the medium.",
+   },
+   {
+     name: "SurfaceRadius",
+     description:
+       "positive decimal number greater or equal to 0.0. Determines the size of the surface area.",
+   },
+   {
+     name: "MediumRadius",
+     description:
+       "positive decimal number greater or equal to 0.0. Determines the size of the medium area.",
+   },
+   {
+     name: "SurfaceGap",
+     description: "integer greater or equal to 0.",
+   },
+   {
+     name: "MediumGap",
+     description: "integer greater or equal to 0.",
+   },
+   {
+     name: "Facings",
+     description:
+       'list of string facing values: "N", "S", "E", "W", "U", "D".',
+   },
+   {
+     name: "RequireAllFacings",
+     description:
+       "Boolean. If true then the Pattern will only validate if all Facings validate.",
+   },
+  ]}
+/>
+
+---
+
+### Gap
+
+Validates if presented with a gap. In this context a gap is some sort of space between two anchors. You must define the space’s valid material type with the GapPattern parameter and the anchors’ valid material types with the AnchorPattern parameter. The GapSize is measured in blocks and represents the distance between the two anchors. The AnchorSize is also measured in blocks and represents the size of the “wall” that is checked when validating the anchors. You can use the DepthUp and DepthDown parameters to ensure that there is enough space under and/or above the Gap’s origin. The diagram below shows the underlying structure of the Gap Pattern.
+
+![Example of Gap Pattern](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/gap-pattern.png)
+
+Below is a block-build of the diagram above to show the blocks that a typical Gap Pattern would check. The grey blocks would be checked by the GapPattern and the black blocks would be checked by the AnchorPattern..
+
+![Example of Gap Pattern blocks](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/gap-pattern-blocks.png)
+
+Setting an AnchorRoughness higher than 0.0 allows non-flat walls to validate as anchors. You should try increasing this value if you don’t get enough matches. The value of this field is also measured in blocks, and is used to trim the ends of the gap check. The diagram below shows that.
+
+![Example of Anchor Roughness](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/anchor-roughness.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "GapSize",
+     description:
+       "decimal number greater or equal to 0.0. Determines the distance in blocks between the two anchors forming the gap.",
+   },
+   {
+     name: "AnchorSize",
+     description:
+       "decimal number greater or equal to 0.0. Determines the size in blocks of the anchor. See the diagrams above for a visual representation.",
+   },
+   {
+     name: "AnchorRoughness",
+     description:
+       "decimal number greater or equal to 0.0. Determines how strict the anchor checking is, higher values means less strict. A good strating point is 1.",
+   },
+   {
+     name: "DepthDown",
+     description:
+       "integer greater or equal to 0. Determines the depth of the gap downward in blocks starting at the origin.",
+   },
+   {
+     name: "DepthUp",
+     description:
+       "integer greater or equal to 0. Determines the depth of the gap upward in blocks starting at the origin.",
+   },
+   {
+     name: "Angles",
+     description:
+       "list of decimal numbers representing angles in degree. An angle of 0 is the Z axis, and angle of 90 is the X axis.",
+   },
+   {
+     name: "GapPattern",
+     description:
+       "Pattern slot used to validate every block of the gap and depths.",
+   },
+   {
+     name: "AnchorPattern",
+     description: "Pattern slot used to validate every block of the acnhors.",
+   },
+  ]}
+/>
+
+---
+
+### Cuboid
+
+Defines a cuboid region relative to the Pattern’s origin. The region is anchored by Min and Max inclusive points. This is similar to the shape of a creative Selection Tool. The SubPattern is tested against every position inside the cuboid. The Cuboid Pattern validates only if all the inner positions are validated by the SubPattern.
+
+Below is a 2D representation of this 3D Cuboid Pattern.
+
+![Example of Cuboid Pattern](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/cuboid-pattern.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Min",
+     description:
+       "inclusive minimum point of the cuboid relative to the Pattern's origin.",
+   },
+   {
+     name: "Max",
+     description:
+       "inclusive minimum point of the cuboid relative to the Pattern's origin.",
+   },
+   {
+     name: "SubPattern",
+     description:
+       "Pattern slot. The Cuboid uses this Pattern to validate the positions inside itself.",
+   },
+  ]}
+/>
+
+---
+
+### And
+
+Logical operation that validates only if all the Patterns in its list also validate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Patterns",
+     description: "list of Pattern asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Or
+
+Logical operation that validates if at least one of the Patterns in its list validates.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Patterns",
+     description: "list of Pattern asset slots.",
+   },
+  ]}
+/>
+
+---
+
+### Not
+
+Logical operation that validates only where the nested Pattern does not validate.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Pattern",
+     description: "Pattern asset slot.",
+   },
+  ]}
+/>
+
+---
+
+### FieldFunction
+
+This Pattern validates only if the provided Density field at the position is within the specified delimiters. In combination with an And and Or pattern, this Pattern provides more control over the valid positions.
+
+Important: because this Pattern queries a noise field, it can be expensive if placed high in the hierarchy. I recommend setting your Pattern structure such that this Pattern is the last to be tested.The diagram below shows examples of that.
+
+![Example of FieldFunction Pattern usage](/assets/official-documentation/worldgen/technical-hytale-generator/patterns/fieldfunction-usage.png)
+
+In the green box, the FieldFunction Pattern runs only on positions with a floor. In the red box, the FieldFunction Pattern runs on every position. The difference between the two scenarios is significant.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FieldFunction",
+     description: "slot for a noise function RootNode.",
+   },
+   {
+     name: "Delimiters",
+     description: "list of noise value delimiters:",
+   },
+   {
+     name: "Min",
+     description: "decimal number. Lower inclusive bound of the delimiter.",
+   },
+   {
+     name: "Max",
+     description: "decimal number. Higher exclusive bound of the delimiter.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Pattern.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported Pattern.",
+   },
+  ]}
+/>
diff --git a/content/docs/bg-BG/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx b/content/docs/bg-BG/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx
new file mode 100644
index 00000000..a4418473
--- /dev/null
+++ b/content/docs/bg-BG/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx
@@ -0,0 +1,363 @@
+---
+title: Positions Provider
+description: Determines an infinite 3D positions field.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Mesh2D
+
+Generates a mesh of random points on a 2D plane. You can set the points’ Y value.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "PointGenerator",
+     description:
+       "slot for a point generator asset. See the PointGenerator section below.",
+   },
+   {
+     name: "PointsY",
+     description: "the vertical Y position of every point.",
+   },
+  ]}
+/>
+
+#### PointGenerator
+
+Generates a random point distribution in space.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Jitter",
+     description:
+       "decimal number in the range [0, 0.5]. More Jitter results in more random point distribution. A good starting point is 0.2.",
+   },
+   {
+     name: "ScaleX",
+     description: "positive decimal number. Scales the distribution.",
+   },
+   {
+     name: "ScaleY",
+     description: "positive decimal number. Scales the distribution.",
+   },
+   {
+     name: "ScaleZ",
+     description: "positive decimal number. Scales the distribution.",
+   },
+   {
+     name: "Seed",
+     description: "the seed of this point generator.",
+   },
+  ]}
+/>
+
+---
+
+### Mesh3D
+
+Generates a mesh of random points in 3D space.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "PointGenerator",
+     description:
+       "slot for a point generator asset. See the PointGenerator section below.",
+   },
+  ]}
+/>
+
+---
+
+### List
+
+Allows you to manually define a static list of positions in world coordinates.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Positions",
+     description: "list of 3D positions.",
+   },
+   {
+     name: "X",
+     description: "integer.",
+   },
+   {
+     name: "Y",
+     description: "integer.",
+   },
+   {
+     name: "Z",
+     description: "integer.",
+   },
+  ]}
+/>
+
+---
+
+### Anchor
+
+Anchors the origin of the child Positions field to the contextual Anchor, if one exists. For a contextual Anchor to exist, a parent of this node must produce an Anchor.
+
+You can also reverse the effect later down the line to move the origin back to the world’s origin like in the screenshot below.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Reverse",
+     description:
+       "Boolean. If true, the node will reverse the origin of the child to the world's origin, or the origin before the previous Anchor node.",
+   },
+  ]}
+/>
+
+---
+
+### Sphere
+
+Masks out the positions that are farther than the provided range from its origin.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "decimal number. The maximum distance from the origin within which that Positions are kept.",
+   },
+  ]}
+/>
+
+---
+
+### FieldFunction
+
+Enables masking out positions using Density. The delimiters determine the regions of the Density field where positions are kept.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FieldFunction",
+     description: "slot for a Density input.",
+   },
+   {
+     name: "Delimiters",
+     description: "list of Density value delimiters:",
+   },
+   {
+     name: "Min",
+     description: "decimal number. Lower bound of the delimiter.",
+   },
+   {
+     name: "Max",
+     description: "deimal number. Higher bound of the delimiter.",
+   },
+   {
+     name: "Positions",
+     description:
+       "PositionsProvider slot. The positions on which the mask is being applied.",
+   },
+  ]}
+/>
+
+---
+
+### Occurrence
+
+Discards a percentage of input positions based on a Density field. The value of the Density field at each position determines the chance that position has to be kept.;
+
+- Positions where the Density value is below or equal to 0.0 have a 0% chance of being kept.
+- Positions where the Density value is above or equal to 1.0 have a 100% chance of being kept.
+- Positions where the Density value is between 0.0 and 1.0 have a proportional percentage chance of being kept. _Example: 0.4 -> 40%._
+
+Below is a picture that shows a simple noise field used to create regions with rare oak trees and regions with dense oak trees.
+
+![Example of Occurrence PositionsProvider](/assets/official-documentation/worldgen/technical-hytale-generator/positions-provider/occurrence-example-1.png)
+
+![Example of Occurrence PositionsProvider2](/assets/official-documentation/worldgen/technical-hytale-generator/positions-provider/occurrence-example-2.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "FieldFunction",
+     description:
+       "Density slot. Determines the chance of keeping the positions.",
+   },
+   {
+     name: "Seed",
+     description: "string. Determines the outcome.",
+   },
+   {
+     name: "Positions",
+     description: "PositionProvider slot.",
+   },
+  ]}
+/>
+
+---
+
+### Offset
+
+Offsets the positions by the provided vector.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "OffsetX",
+     description: "decimal number. Vector's x.",
+   },
+   {
+     name: "OffsetY",
+     description: "decimal number. Vector's y.",
+   },
+   {
+     name: "OffsetZ",
+     description: "decimal number. Vector's z.",
+   },
+   {
+     name: "Positions",
+     description: "PositionProvider slot. Positions to offset.",
+   },
+  ]}
+/>
+
+---
+
+### BaseHeight
+
+Vertically offsets the Positions inside the configured vertical region by the amount of blocks determined by the BaseHeight . All Positions outside the region are discarded.
+
+A typical application of this would be to grab Positions at Y:0, and offset them up by the BaseHeight to come closer to a terrain feature. Further adjustments can then be made using an Offset PositionsProvider. The diagram below illustrates that.
+
+{/* <figure><img src="../../.gitbook/assets/image (48).png" alt=""><figcaption></figcaption></figure> */}
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "BaseHeightName",
+     description: "string. Name of the BaseHeight to reference.",
+   },
+   {
+     name: "MaxYRead",
+     description:
+       "decimal number. Exclusive limit of the region to grab the Positions from the input.",
+   },
+   {
+     name: "MinYRead",
+     description:
+       "decimal number. Inclusive limit of the region to grab the Positions from the input.",
+   },
+  ]}
+/>
+
+---
+
+### Union
+
+Combines all the positions into a single Positioins field.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Positions",
+     description: "list of PositionProvider slots.",
+   },
+  ]}
+/>
+
+---
+
+### SimpleHorizontal
+
+Keeps only the positions that are within the provided range.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "RangeY",
+     description: "The range to keep the position in.",
+   },
+   {
+     name: "Positions",
+     description: "PositionProvider slot.",
+   },
+  ]}
+/>
+
+---
+
+### Cache
+
+Caches the output provided by the Positions slot to improve performance in certain situations. This asset can be useful to improve performance when a Positions asset is expensive and queried numerous times.
+
+How effective this Cache is depended heavily on the use case, the provided child Positions asset and the order in which it is queried. You can get the best performance out of this Cache asset by trial and error. An example of a good use-case for this asset is at the root of an expensive Positions tree used by a Positions2D/Positions3D Density node.
+
+I recommend that you don’t use this cache everywhere in your Positions trees but rather choose a great place at (or close to) the root of your Positions asset tree. That said, feel free to experiment.
+
+This cache functions by saving 3D sections of space containing the Positions (points) generated by the child slot. The sections are cubes, and their size is determined by the asset’s SectionSize parameter. The number of sections allowed to be saved in the cache is determined by the CacheSize asset parameter. A safe starting value for the SectionSize parameter would be 32, and a safe starting value for the CacheSize would be 50.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SectionsSize",
+     description:
+       "integer greater than 0, safe starting value would be 32. Determines the lateral size of the section's cubic volume in blocks.",
+   },
+   {
+     name: "CacheSize",
+     description:
+       "integer 0 or greater; safe starting value would be 50. Determines the number of Sections that are allowed to be saved in memory. If provided a value of 0, then the cache is ignored, and the Positions are directly sourced from the child Positions slot.",
+   },
+   {
+     name: "Positions",
+     description:
+       "PositionProvider slot. The output of this Positions asset is cached.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported PositionProvider.
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported PositionsProvider.",
+   },
+  ]}
+/>
diff --git a/content/docs/bg-BG/official-documentation/worldgen/technical-hytale-generator/props.mdx b/content/docs/bg-BG/official-documentation/worldgen/technical-hytale-generator/props.mdx
new file mode 100644
index 00000000..d0adb3d5
--- /dev/null
+++ b/content/docs/bg-BG/official-documentation/worldgen/technical-hytale-generator/props.mdx
@@ -0,0 +1,430 @@
+---
+title: Props
+description: Localized content that can read and write to the world.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Box
+
+This is a testing and debugging Prop asset that generates a box. This Prop uses a Pattern and a Scanner to locate a suitable spot relative to its provided position.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "3D positive integer vector. Determines the distance in blocks between the prop's center and each side.",
+   },
+   {
+     name: "X",
+     description: "distance in the x-axis",
+   },
+   {
+     name: "Y",
+     description: "distance in the y-axis",
+   },
+   {
+     name: "Z",
+     description: "distance in the z-axis",
+   },
+   {
+     name: "BoxBlockType",
+     description: "the BlockType the box is made of.",
+   },
+   {
+     name: "Pattern",
+     description: "Pattern asset slot. This defines a suitable slot.",
+   },
+   {
+     name: "Scanner",
+     description:
+       "Scanner asset slot. Scans the surroundings for a suitable spot for this prop.",
+   },
+  ]}
+/>
+
+---
+
+### Density
+
+Generates a Prop from a Density field and MaterialProvider asset.;
+
+Below is an example of terrain with smaller dirt boulders on top of large stone ones.
+
+![Example of Density Prop](/assets/official-documentation/worldgen/technical-hytale-generator/props/density-prop-example.png)
+
+![Example of Density Prop configuration](/assets/official-documentation/worldgen/technical-hytale-generator/props/density-prop-configuration.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "3D positive integer vector. Determines the distance in blocks between the prop's center and each side.",
+   },
+   {
+     name: "X",
+     description: "distance in the x-axis",
+   },
+   {
+     name: "Y",
+     description: "distance in the y-axis",
+   },
+   {
+     name: "Z",
+     description: "distance in the z-axis",
+   },
+   {
+     name: "PlacementMask",
+     description:
+       "BlockMask asset slot. Sets the rules for what blocks can be placed and what blocks can be replaced in the world.",
+   },
+   {
+     name: "Pattern",
+     description: "Pattern asset slot. This defines a suitable slot.",
+   },
+   {
+     name: "Scanner",
+     description:
+       "Scanner asset slot. Scans the surroundings for a suitable spot for this prop.",
+   },
+   {
+     name: "Density",
+     description: "Density asset slot. This gives shape to the Prop.",
+   },
+   {
+     name: "Material",
+     description:
+       "MaterialProvider asset slot. This determines the block types to use.",
+   },
+  ]}
+/>
+
+---
+
+### Prefab
+
+This Prop places a Prefab in a suitable spot. This Prop uses a Directionality asset, a Pattern and a Scanner to locate a suitable spot relative to its provided position. A BlockMask asset can also be used to specify which Materials the Prefab cannot replace in the world, which Materials the Prefab cannot place, and even which world Materials cannot be replaced by specific Prefab Materials. See the BlockMask documentation.
+
+Prefab Prop also support Molding to the terrain. To enable Molding you must specify a MoldingDirection of DOWN or UP, and provide a MoldingScanner and MoldingPattern. If you want your Prefab’s children to also mold, you need to set the MoldingChildren to true. I recommend you use a LinearScanner with the Local parameter set to true for the MoldingScanner, and limit the ResultCap to 1. In a typical ruin Prefab, the MoldingScanner and MoldingPattern can be used to find the floor or ceiling to mold the ruin to.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "WeightedPrefabPaths",
+     description:
+       "list of weighted paths to files or folders containing prefabs. Each path entry contains:",
+   },
+   {
+     name: "Path",
+     description: "path to the folder or file to load from.",
+   },
+   {
+     name: "Weight",
+     description:
+       "the weight for placing a prefab from this path. If the path leads to a folder then every prefab in the folder has the same chance to be picked, once the folder has been picked. In other words, the weight applies to the entire folder.",
+   },
+   {
+     name: "LegacyPath",
+     description:
+       "optional boolean. If true then it will look in HytaleAssets/Server/World/Default/Prefabs/{PrefabPath}, otherwise it will look in HytaleAssets/Server/WorldgenAlt/Prefabs/{PrefabPath}.",
+   },
+   {
+     name: "Directionality",
+     description:
+       "Directionality asset slot. This defines the valid positions and the direction the Prop should place with. See the Directionality asset documentation below.",
+   },
+   {
+     name: "Scanner",
+     description:
+       "Scanner asset slot. Scans the surroundings for a suitable spot for this prop.",
+   },
+   {
+     name: "BlockMask",
+     description:
+       "BlockMask asset slot. Defines masking for this Prefab's block placement.",
+   },
+   {
+     name: "MoldingDirection",
+     description:
+       '(optional, defaults to "NONE") string values "UP", "DOWN" or "NONE".',
+   },
+   {
+     name: "MoldingChildren",
+     description: "(optional) boolean. If the children also mold.",
+   },
+   {
+     name: "MoldingScanner",
+     description:
+       "(optional) Scanner asset slot. Scanner used to match MoldingPattern.",
+   },
+   {
+     name: "MoldingPattern",
+     description:
+       "(optional) Pattern used to find surface to mold Prefab columns to.",
+   },
+   {
+     name: "LoadEntities",
+     description:
+       "(optional) boolean. If true, the entities from the prefabs will be loaded and placed. This configuration applies to the prefab children as well.",
+   },
+  ]}
+/>
+
+---
+
+### Column
+
+Generates a prop that is completely contained within a column.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ColumnBlocks",
+     description:
+       "list of BlockTypes and Y coordinates. The Y coordinates are relative to the Prop's origin (anchor block). Contains BlockType (string BlockType) and Y (the Y integer coordinate relative to the Prop's origin).",
+   },
+   {
+     name: "Directionality",
+     description:
+       "Directionality asset slot. This defines the valid positions and the direction the Prop should place with. See the Directionality asset documentation below.",
+   },
+   {
+     name: "Scanner",
+     description: "Scanner asset slot.",
+   },
+   {
+     name: "BlockMask",
+     description: "BlockMask asset slot. Optional.",
+   },
+  ]}
+/>
+
+---
+
+### Cluster
+
+Places a cluster of Column type Props relative to its origin. The DistanceCurve determines the density depending on the distance from the Cluster’s origin. The Column Props are picked from a weighted list.
+
+The Column Prop assets provided to this Cluster Prop must use Scanner and Pattern assets that only read within the origin column because that is the only space the Cluster Prop will provide to them. If the Column Prop provided reaches outside its column, the Prop will not be used by the Cluster Prop. This is to maintain consistent Context-Dependency.
+
+Below is a diagram showing how the density varies in function of the distance, and how the DistanceCurve affects it.
+
+![Example of Cluster Prop distance curve](/assets/official-documentation/worldgen/technical-hytale-generator/props/cluster-distance-curve.png)
+
+The Pattern and Scanner asset slots are optional. By default, the Cluster Prop will use the Position it is assigned to. If a Pattern and Scanner are provided, it will use those to position the Cluster’s origin.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Range",
+     description:
+       "integer. Determines the distance in blocks from the origin of the cluster to its limit. A good starting range is 10.",
+   },
+   {
+     name: "DistanceCurve",
+     description:
+       "a curve that determines the chance a block will have a Column Prop based on its distance from the Cluster’s origin.",
+   },
+   {
+     name: "Seed",
+     description:
+       "string. Used during density and Prop picking from the weighted list.",
+   },
+   {
+     name: "Pattern",
+     description:
+       "optional Pattern asset slot, used to position the Cluster’s origin.",
+   },
+   {
+     name: "Scanner",
+     description:
+       "optional Scanner asset slot, used to position the Cluster’s origin.",
+   },
+   {
+     name: "WeightedProps",
+     description:
+       "list of weighted Column Props. Each element in the list contains:",
+   },
+   {
+     name: "Weight",
+     description: "floating point value above 0.0.",
+   },
+   {
+     name: "ColumnProp",
+     description:
+       "slot for a Column Prop asset (only Column Prop assets can be used here). This Prop will only have access to a column to both scan and place. This means that you need to ensure your Scanner and Pattern assets operate within that column. If this is violated the Prop might fail to place to keep Context Dependency consistency.",
+   },
+  ]}
+/>
+
+---
+
+### Union
+
+This Prop type places all the props in the provided list at the same position one after the other.;
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Props",
+     description: "list of props to place together.",
+   },
+  ]}
+/>
+
+---
+
+### Offset
+
+Offsets the position of the child Prop.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Offset",
+     description:
+       "3D integer vector. The direction in which to offset the child Prop's position.",
+   },
+   {
+     name: "Prop",
+     description: "Prop slot.",
+   },
+  ]}
+/>
+
+---
+
+### Weighted
+
+Picks which Prop to place based on a seed and weights.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Entries",
+     description:
+       "Entry containing: Weight (greater than 0.0) and Prop (Prop slot).",
+   },
+   {
+     name: "Seed",
+     description:
+       "string. The seed determining which Prop is picked. This seed also mutates the seed passed to the children.",
+   },
+  ]}
+/>
+
+---
+
+### Queue
+
+It places the first Prop in the queue that can be placed. Whether a Prop in the queue can be placed depends on that Prop’s type and configuration. A Box Prop, for example, can only be placed if its Scanner and Pattern configuration finds a valid position.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Queue",
+     description:
+       "ordered list of Prop asset slots. First entry is the highest priority.",
+   },
+  ]}
+/>
+
+---
+
+### PondFiller
+
+It fills up depressions in the terrain with the provided MaterialProvider.
+
+The screenshots below show a few examples of ponds generated with this Prop.\
+
+![Example of PondFiller Prop1](/assets/official-documentation/worldgen/technical-hytale-generator/props/pondfiller-example-1.png)
+
+![Example of PondFiller Prop2](/assets/official-documentation/worldgen/technical-hytale-generator/props/pondfiller-example-2.png)
+
+You can configure the bounding box inside which it will identify and fill-in existing terrain depressions. The bounding box’s size and shape determines how large the resulting ponds can be.
+
+The diagram below shows how the bounding box defines the outcome.
+
+![Example of PondFiller bounding box](/assets/official-documentation/worldgen/technical-hytale-generator/props/pondfiller-bounding-box.png)
+
+The Pattern and Scanner can be used to position the origin of the Filler Prop like any other Prop. The origin anchors the bounding box at runtime. The ponds that fit inside that bounding box are filled with the MaterialProvider.
+
+The BarrierBlockSet defines what the walls of the depressions are made of.
+
+Important: The performance impact of this Prop can be relatively high depending on the size of its bounding box. Because of that, I recommend optimizing the size of its bounding box for each use-case.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "BoundingMin",
+     description:
+       "3D point. Defines the lowest corner of the bounding box relative to the anchor point. Contains X, Y, Z (floating point numbers).",
+   },
+   {
+     name: "BoundingMax",
+     description:
+       "3D point asset slot. Defines the greatest corner of the bounding box relative to the anchor point. Contains X, Y, Z (floating point numbers).",
+   },
+   {
+     name: "BarrierBlockSet",
+     description:
+       "BlockSet asset slot. Defines the types of blocks that can make up the solid terrain, through which the pond material cannot seep.",
+   },
+   {
+     name: "FillMaterial",
+     description:
+       "MaterialProvider asset slot. Determines the types of blocks used when filling up the ponds, water for example.",
+   },
+   {
+     name: "Pattern",
+     description: "Pattern asset slot. This defines a suitable slot.",
+   },
+   {
+     name: "Scanner",
+     description:
+       "Scanner asset slot. Scans the surroundings for a suitable spot for this prop.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Prop.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported Prop.",
+   },
+  ]}
+/>
diff --git a/content/docs/bg-BG/official-documentation/worldgen/technical-hytale-generator/scanners.mdx b/content/docs/bg-BG/official-documentation/worldgen/technical-hytale-generator/scanners.mdx
new file mode 100644
index 00000000..d2f2d9d6
--- /dev/null
+++ b/content/docs/bg-BG/official-documentation/worldgen/technical-hytale-generator/scanners.mdx
@@ -0,0 +1,162 @@
+---
+title: Scanners
+description: Scans a local part of the world for valid positions.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Origin
+
+Only scans the origin position.
+
+No Parameters.
+
+---
+
+### ColumnLinear
+
+Applies the Pattern to a column of blocks bound by the MinY and MaxY values. The scan is performed linearly from one end of the column to the other and returns all the Pattern validated positions. You can specify the direction of the scan and the maximum valid positions it can return. You can also make the MinY/MaxY scan range local to the scan origin Y instead of the world’s Y:0.
+
+![Example of ColumnLinear Scanner](/assets/official-documentation/worldgen/technical-hytale-generator/scanners/columnlinear-example.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "MaxY",
+     description: "integer Y coordinate. Upper exclusive bound of the column.",
+   },
+   {
+     name: "MinY",
+     description: "integer Y coordinate. Lower inclusive bound of the column.",
+   },
+   {
+     name: "RelativeToPosition",
+     description:
+       "Boolean. If true the scan range will be relative to the origin Y of the scan and not the world's Y:0.",
+   },
+   {
+     name: "BaseHeightName",
+     description:
+       "string. Name of the BaseHeight the scan range will be relative to. If this is provided, then the RelativeToPosition is overridden.",
+   },
+   {
+     name: "TopDownOrder",
+     description:
+       "Boolean. If true the scan will start at the top of the column's range and go down.",
+   },
+   {
+     name: "ResultCap",
+     description:
+       "positive integer. The maximum number of valid results this scan will return",
+   },
+  ]}
+/>
+
+---
+
+### ColumnRandom
+
+Applies the Pattern to a column of blocks bound by the MinY and MaxY values. The scan is performed randomly and returns all the valid positions. You can specify the scan strategy and the maximum valid positions it can return.
+
+There are two strategies you can use with this Scanner:
+
+- DART_THROW: tries random blocks in the column and gathers the ones that validate the Pattern. This strategy is better for situations where there are many valid positions such as wall positions on the side of a cliff.
+- PICK_VALID: finds all the valid blocks in the column and randomly picks from the pile. This strategy is better for situations where there are fewer valid positions such as multiple floors stacked on top of each other.
+
+Ultimately, it is up to you to find the right one based on your intent and observation. So try them both!
+
+![Example of ColumnRandom Scanner](/assets/official-documentation/worldgen/technical-hytale-generator/scanners/columnrandom-example.png)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "MaxY",
+     description: "integer Y coordinate. Upper exclusive bound of the column.",
+   },
+   {
+     name: "MinY",
+     description: "integer Y coordinate. Lower inclusive bound of the column.",
+   },
+   {
+     name: "Strategy",
+     description: "string enum value: DART_THROW or PICK_VALID.",
+   },
+   {
+     name: "Seed",
+     description: "string.",
+   },
+   {
+     name: "ResultCap",
+     description:
+       "positive integer. The maximum number of valid results this scan will return.",
+   },
+   {
+     name: "RelativeToPosition",
+     description:
+       "Boolean. If true the scan range will be relative to the origin Y of the scan and not the world's Y:0.",
+   },
+   {
+     name: "BaseHeightName",
+     description:
+       "string. The name of the BaseHeight the scan range will be relative to. If this is provided, then the RelativeToPosition is overridden.",
+   },
+  ]}
+/>
+
+---
+
+### Area
+
+Useful for increasing the density of rarer props that are difficult to place.
+
+Scans an area around the origin. This Scanner uses the ChildScanner asset slot and gradually scans it farther and farther away from the origin if it can’t find enough valid positions. It applies the ChildScanner on every column surrounding the origin up to the ScanRange distance. The ScanShape determines the shape from above of the total area it can scan. The ResultCap is the total number of valid positions this Scanner will try to find, it will start at the origin and scan more and more of the area until it finds enough results or until it runs out of area.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "ScanRange",
+     description:
+       "integer 0 or greater. Range in blocks from the scan origin of the area to scan. If the value is 0 then the ChildScanner is only applied on the origin column. A good starting value would be 0 and then increase it by 1 and see the results. In some situations higher values can have an impact on performance.",
+   },
+   {
+     name: "ScanShape",
+     description:
+       "string, can be CIRCLE or SQUARE. Determines the shape of the scan area.",
+   },
+   {
+     name: "ResultCap",
+     description:
+       "positive integer. The maximum number of valid results this scan will return",
+   },
+   {
+     name: "ChildScanner",
+     description: "Scanner slot used on each column of the area.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported Scanner.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported Scanner.",
+   },
+  ]}
+/>
diff --git a/content/docs/bg-BG/official-documentation/worldgen/technical-hytale-generator/vector-provider.mdx b/content/docs/bg-BG/official-documentation/worldgen/technical-hytale-generator/vector-provider.mdx
new file mode 100644
index 00000000..721a9373
--- /dev/null
+++ b/content/docs/bg-BG/official-documentation/worldgen/technical-hytale-generator/vector-provider.mdx
@@ -0,0 +1,119 @@
+---
+title: Vector Provider
+description: Defines a 3D decimal vector {x, y, z}.
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+### Constant
+
+Generates the provided vector.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Vector",
+     description: "3D decimal vector.",
+   },
+  ]}
+/>
+
+---
+
+### DensityGradient
+
+Generates the gradient of the provided Density field. The resulting gradient vector shows in which direction the Density field is increasing and how fast the field is changing.;
+
+For more information about gradient vectors you can read: [https://en.wikipedia.org/wiki/Gradient](https://en.wikipedia.org/wiki/Gradient)
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SampleDistance",
+     description:
+       "positive decimal value. How far apart the Density field value samples are taken. The optimal value for performance is 1.0. Greater values could be useful for smoothing out results for specific applications.",
+   },
+   {
+     name: "Density",
+     description: "Density slot.",
+   },
+  ]}
+/>
+
+---
+
+### Cache
+
+Caches the input vector for each position.;
+
+This should only be used if the downstream (child) VectorProvider is expensive and the same coordinate is queried more than once.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SampleDistance",
+     description:
+       "positive decimal value. How far apart the Density field value samples are taken. The optimal value for performance is 1.0. Greater values could be useful for smoothing out results for specific applications.",
+   },
+   {
+     name: "Density",
+     description: "Density slot.",
+   },
+  ]}
+/>
+
+---
+
+### Exported
+
+Allows exporting a VectorProvider as a single instance. Enabling the SingleInstance on this node ensures all importers share the same logic.;
+
+By default a completely different instance is create for every Imported node. When there are multiple Imported nodes that import the same exported key, a new instance of that exported VectorProvider tree will be created for each one of the Imported nodes. SingleInstance ensures all importers share the same underlying instance of the node tree.
+
+This node can be used to optimize caching when an exported VectorProvider is imported multiple times in the same context and contains caches. The caches would be shared between the different imported instances.
+
+_Important: This is still an experimental feature and could cause unexpected behaviors if misused._
+
+Expected Inputs: 1
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "SingleInstance",
+     description:
+       "boolean. Enable to share the exported for all Imported nodes referencing this key.",
+   },
+   {
+     name: "VectorProvider",
+     description: "VectorProvider slot.",
+   },
+  ]}
+/>
+
+---
+
+### Imported
+
+Imports an exported VectorProvider.
+
+#### Parameters:
+
+<ParameterList
+  parameters={[
+   {
+     name: "Name",
+     description: "string. The exported VectorProvider.",
+   },
+  ]}
+/>
diff --git a/content/docs/bg-BG/official-documentation/worldgen/worldgen-tutorial/README.mdx b/content/docs/bg-BG/official-documentation/worldgen/worldgen-tutorial/README.mdx
new file mode 100644
index 00000000..5f66d245
--- /dev/null
+++ b/content/docs/bg-BG/official-documentation/worldgen/worldgen-tutorial/README.mdx
@@ -0,0 +1,166 @@
+---
+title: How to edit and create Biomes
+description: Explores where world generation assets can be found and how to edit them.
+---
+
+### Where are the Assets
+
+World generation assets are kept in the HytaleGenerator directory within the assets.
+
+```
+/Server/HytaleGenerator/
+```
+
+<div className="flex flex-row rounded-lg border p-4">
+  <div className="flex-1/2 border-r pr-4">
+    ```
+    /Biomes
+    ```
+
+    Biome assets, with content configurations.
+  </div>
+
+  <div className="flex-1/2 pl-4">
+    ```
+    /WorldStructure
+    ```
+
+    Generator files that define which biomes spawn together.
+  </div>
+</div>
+
+<div className="flex flex-row rounded-lg border p-4">
+  <div className="flex-1/2 border-r pr-4">
+    ```
+    /Density
+    ```
+
+    Density assets that can be referenced by any other assets.
+  </div>
+
+  <div className="flex-1/2 pl-4">
+    ```
+    /Assignments
+    ```
+
+    Prop assets that can be referenced by any Biome assets.
+  </div>
+</div>
+
+***
+
+An example of this structure can be found bellow, packed in an asset pack with the instance configuration.
+
+[https://drive.google.com/file/d/1sIz_CluANIIe3n8vNiOi-4PQdeqCO0qY/view?usp=drive_link](https://drive.google.com/file/d/1sIz_CluANIIe3n8vNiOi-4PQdeqCO0qY/view?usp=drive_link)
+
+<Callout>
+  Ensure you place your asset pack in the correct directory, under Mods.
+</Callout>
+
+### How to visit our worlds
+
+https://drive.google.com/file/d/1BJurxyj-taE-PXWm04bk7Dl6X7ZHTH92/view?usp=sharing
+
+#### Requirements
+
+- You must be an **Operator** in the world.
+  - To do this, run <mark style="color:$danger;">`/op self`</mark>
+- You must be in **Creative mode**.
+  - Press the <mark style="color:$danger;">`O`</mark> key, O for Orange.&#x20;
+
+The generation assets define a set of generators but on their own you cannot visit these. Currently you require an Instance with a generator that will allow you to visit your work.
+
+```
+/Server/Instances/
+```
+
+Instances are separate worlds that players can join using the `/instances` command. Each instance has an `Instance.bson` configuration asset that specifies which generator to use, among other worldly settings.
+
+```json
+{
+  "WorldGen": {
+    "Type": "HytaleGenerator",
+    "WorldStructure": "Basic",
+    "playerSpawn" : {
+      "X" : 123,
+      "Y" : 480,
+      "Z" : 10000,
+      "Pitch" : 0,
+      "Yaw" : 0,
+      "Roll" : 0
+    }
+  }
+}
+```
+
+<Callout>
+  You can create custom instances for different world structures and biomes as you need them.
+</Callout>
+
+### How to edit Biomes
+
+<video>
+  <source src="https://cdn.internal.hytalemodding.dev/guides/official/How-to-edit-Biomes.mp4" type="video/mp4" />
+</video>
+
+We currently use the Hytale Node Editor when editing world generation assets. This can be accessed while in-game from the Content Creation menu when pressing B. The node editor is then found under the asset editor dropdown on the upper left.&#x20;
+
+![Node Editor 1](/assets/official-documentation/worldgen/worldgen-tutorial/biomes/node-editor-1.png)
+
+Once you have the Hytale Node Editor open, through the file menu you can open Biomes by navigating to the Biomes directory and selecting one from your pack.&#x20;
+
+```
+/Server/HytaleGenerator/Biomes/
+```
+
+### Biome Asset Structure
+
+Every Biome has a root Biome node, this node splits into 5 structures. This is covered briefly but more information on each field can be found on the World Generation Concepts page.
+
+![Node Editor 2](/assets/official-documentation/worldgen/worldgen-tutorial/biomes/node-editor-2.png)
+
+<Callout>
+  Each biome is for the most part self contained, meaning it has control over what appears with the biome. The only exception to this are Base Heights.
+</Callout>
+
+<Tabs>
+  <Tab value="Terrain">
+    Mathematical function nodes that calculate the physical shape of the Biome's terrain.
+  </Tab>
+
+  <Tab value="Materials">
+    Logical nodes that determine what materials (blocks) make up a Biome's terrain.
+  </Tab>
+
+  <Tab value="Props">
+    Function nodes that add objects like prefabs and decorations to the terrain.
+  </Tab>
+
+  <Tab value="Environments">
+    Logical nodes that determine the environment asset at a given coordinate within the biome. This asset determines things like weather, NPC spawns, and sounds.
+  </Tab>
+
+  <Tab value="Tints">
+    Logical function nodes that determine a colour code that can be used by certain blocks in the world. Typically this will be grasses and soils.
+  </Tab>
+</Tabs>
+
+### How to preview your work
+
+[https://drive.google.com/file/d/1mNcHn9LhFnWDF0DzWFH6_YllmKAUvUry/view?t=6](https://drive.google.com/file/d/1mNcHn9LhFnWDF0DzWFH6_YllmKAUvUry/view?t=6)
+
+Once you are in an Instance world with the Hytale Generator active you will only be able to see your work by generating new chunks. There are a few ways to do this.
+
+The viewport command selects an area around the Player that will live reload as you make changes to the generator.&#x20;
+
+```
+/viewport --radius 5 
+```
+
+You can also create a new world to show your changes.&#x20;
+
+```
+/instances spawn <instance> 
+```
+
+The last option is to simply fly south, new chunks will generate with the changes made.
diff --git a/content/docs/bg-BG/publishing/builtbybit.mdx b/content/docs/bg-BG/publishing/builtbybit.mdx
new file mode 100644
index 00000000..d3488448
--- /dev/null
+++ b/content/docs/bg-BG/publishing/builtbybit.mdx
@@ -0,0 +1,91 @@
+---
+title: BuiltByBit
+description: Complete guide to publishing and selling your Hytale creations on BuiltByBit.
+---
+
+# Why BuiltByBit?
+
+BuiltByBit is the largest third-party marketplace for Minecraft and Roblox, and now Hytale. Unlike other platforms, BuiltByBit is primarily focused on premium content, allowing creators to monetize their work (though free resources are also welcome)!
+
+Within just days of Hytale's early access launch, creators on BuiltByBit have already earned thousands of dollars selling their Hytale creations.
+
+Key advantages:
+
+- Monetize your work - Set your own prices for premium content with no maximum limit
+- Fast approval times - Industry-leading review times averaging just 4 hours
+- More categories - The widest range of content types of any Hytale platform
+- Established marketplace - Join a proven ecosystem with hundreds of thousands of active buyers
+
+# Available Categories
+
+BuiltByBit supports the following categories:
+Plugins - Server-side plugins and modifications
+Data assets - Custom data packs, loot tables, and data-driven content
+Server setups - Complete server configurations and setups
+Builds - Prefabs, structures, and world builds
+Graphics - UI elements, icons, and visual assets
+Textures - Texture packs and reskins
+Models - Custom 3D models and animations
+Audio - Sound effects and music
+Other - Anything else that doesn't fit the above
+
+# Prerequisites
+
+Before you start, make sure you have:
+
+- A compiled `.jar` file (for plugins) or `.zip` file (for other content)
+- A description of your creation's features
+- A Tebex account for receiving payments (can be created during setup)
+
+We also recommend:
+
+- High-quality screenshots showcasing your creation
+- A clear logo or icon
+- Documentation of any dependencies or requirements
+
+# Step-by-Step Publishing Process
+
+## 1. Create Your Account
+
+Register for a BuiltByBit account at [builtbybit.com/login/register](https://builtbybit.com/login/register).
+
+## 2. Set Up Your Wallet
+
+Link your Tebex Wallet (or create one if you don't have one) at [builtbybit.com/resources/dashboard/wallet](https://builtbybit.com/resources/dashboard/wallet). This is where your earnings will be deposited.
+
+## 3. Add Your Resource
+
+Navigate to [builtbybit.com/resources/add](https://builtbybit.com/resources/add) and select the appropriate category for your content.
+
+## 4. Complete Your Listing
+
+Fill out all required fields:
+
+- Title - A clear, descriptive name for your creation
+- Description - Comprehensive details about features and usage
+- Tags - Relevant keywords to help buyers find your content
+- Pricing - Choose free or set a price (minimum $1.99 to $5.99 for paid content depending on category)
+- File Upload - Upload your .jar or .zip file
+
+## 5. Submit for Approval
+
+Click "Submit for approval" to send your resource to our moderation team.
+
+## 6. You're Done!
+
+Once approved, your resource will be live and accessible to buyers. With our review times averaging just 4 hours, you won't be waiting long.
+
+# Pricing & Fees
+
+- Minimum price: $1.99 to $5.99 for paid content depending on category (no maximum)
+- Platform fee: 9.9% per transaction
+- Gateway fee: Reduced rate charged per transaction
+
+The 9.9% platform fee allows us to continuously introduce new features and improvements. [Learn more about fees](https://builtbybit.com/resources/creators).
+
+# Getting Help
+
+- Creator Knowledge Base - [creators.builtbybit.com](https://creators.builtbybit.com) - Articles covering every feature
+- Discord Community - [discord.gg/builtbybit](https://discord.gg/builtbybit) - Dedicated channels for Hytale creators (sync your account to access)
+- Become a Creator - [builtbybit.com/resources/creators](https://builtbybit.com/resources/creators) - Overview of selling on BuiltByBit
+- Browse Hytale Resources - [builtbybit.com/resources/hytale](https://builtbybit.com/resources/hytale) - See what other creators are selling
diff --git a/content/docs/bg-BG/publishing/curseforge.mdx b/content/docs/bg-BG/publishing/curseforge.mdx
new file mode 100644
index 00000000..d97327d5
--- /dev/null
+++ b/content/docs/bg-BG/publishing/curseforge.mdx
@@ -0,0 +1,71 @@
+---
+title: CurseForge
+description: Learn how to publish your mod to CurseForge
+---
+
+CurseForge is a mod hosting platform, allowing you to share your Hytale mods and creations with players via our website and app.
+
+## 1. Create CurseForge Account
+
+First, [visit our sign-in page](https://curseforge.com/api/v1/auth/login?returnUrl=https://www.curseforge.com/) and either log in to an existing account or click “Create an account”.
+
+This can be done using any Google, Discord, GitHub or Twitch account.
+
+## 2. Create a Project
+
+Now that you're logged in, you can visit our Author Console and navigate to the Projects tab, then click “Create a Project”, either in the sidebar or at the top of the page.
+
+![CurseForge Author Page](/assets/guides/curseforge_author_page.png)
+
+This will then take you to the [project creation](https://authors.curseforge.com/#/projects/create/choose-game) flow. First, select your game (in this case, Hytale) for and the page will be updated with new fields waiting for your inputs. Please see our
+
+[Moderation Policies](https://support.curseforge.com/en/support/solutions/articles/9000197279-moderation-policies#:~:text=General%20CurseForge%20Moderation%20Policies,-Policy\&text=The%20description%20can%20include%20descriptive,the%20game%22%20is%20not%20enough) articles for more information about what is and isn't allowed when creating a new project. Below are the fields along with their descriptions:
+
+- **Name:** This is the title of your project. It should be unique to your project. If the name is already taken, it will be rejected.
+- **Summary:** This is a short blurb about the mod that will show up in the project listings
+- **Description:** This is the longer explanation of what your mod does/adds. Make sure you clearly elaborate on your project. We will reject your project if the description is not grammatically correct or if it does not sufficiently describe the project you are creating. This can be edited later. Note: All titles and descriptions must be in English.
+- **Project License:** This is a drop-down field that contains the most common licenses used in modding games. Research the license type you want to use, including its pros and cons. You can also choose to use a Custom License at the bottom of the dropdown list and enter any text you want.
+- **Class:** This is the root category for your project. Ensure you select the correct one, as it may impact supported file types and app support in CurseForge.
+  - For Hytale, there are four types of Class:
+    - Mods
+      - This is the class that contains both Asset Packs and Plugins, and you should upload either here.
+    - Worlds
+    - Prefabs
+    - Bootstrap
+      - This is the class that contains all Early Plugins.
+- **Main Category:** This is the primary category into which your project will be sorted.
+- **Additional categories:** You can add up to 4 of these. Your project will also show up in lists where people are searching for these types of mods. Be careful, though, if you just add categories that have nothing to do with your mod, we may send it back to you for changes.
+- **Logo Image:** A unique icon to identify your project by.
+
+## 3. Upload a File
+
+Once you've set up your project and filled in the above information, you now need to upload a file to your project for it to enter the moderation queue. To do this, visit the “Files” tab in your Author Console page.
+
+![CurseForge Add Project](/assets/guides/curseforge_add_project.png)
+
+Then, click on “Add File” and upload your mod's file, entering any additional information or meta you wish to include regarding this file.
+
+The file format will depend on the class you select.
+
+### For Plugins
+
+If you're uploading a plugin for Hytale, please make sure you select the "Mods" class and upload your file as a jar file.
+
+### For Packs
+
+If you're uploading a Pack for Hytale, please make sure you select the "Mods" class and upload your file as a ZIP file
+
+### For Worlds
+
+If you're uploading a World for Hytale, make sure you upload it to the "Worlds" class and upload your file as a ZIP file.
+
+**Once you've uploaded your file, it will be sent for our moderation team to review, and once approved, it will be live for all players on CurseForge!**
+
+## 4. Additional Resources & Guides
+
+You can refer to the following resources for guides on how to create a project page, using the upload API, and creating the best project page:
+
+- How to Pass Moderation Review: https://blog.curseforge.com/how-to-pass-moderation-review-on-curseforge-2/
+- Creating and Submitting a Project: https://support.curseforge.com/en/support/solutions/articles/9000197241-creating-and-submitting-a-project
+- How to Create the Best Project Page: https://blog.curseforge.com/how-to-create-the-best-project-page/
+- Our Mod Approval Process: https://blog.curseforge.com/our-mod-approval-process/
diff --git a/content/docs/bg-BG/publishing/index.mdx b/content/docs/bg-BG/publishing/index.mdx
new file mode 100644
index 00000000..fb60fa35
--- /dev/null
+++ b/content/docs/bg-BG/publishing/index.mdx
@@ -0,0 +1,16 @@
+---
+title: Publishing Your Mod
+description: Learn how to publish your mod to the community.
+---
+
+Now that you've created your mod, it's time to share it with the world! There are many marketplaces that allow you to publish your mod, such as Modtale, CurseForge, BuiltByBit, etc.
+
+We have compiled guides to publish for each marketplace, so you can easily get your mod out there and into the hands of players, no matter the marketplace they use.
+
+- [Publishing on Modtale](./publishing/modtale)
+- [Publishing on CurseForge](./publishing/curseforge)
+- [Publishing on BuiltByBit](./publishing/builtbybit)
+
+<Callout>
+  If you run a marketplace, please reach out to us via our email `neil@hytalemodding.dev` to get your marketplace listed in our documentation.
+</Callout>
diff --git a/content/docs/bg-BG/publishing/modtale.mdx b/content/docs/bg-BG/publishing/modtale.mdx
new file mode 100644
index 00000000..3983a5e4
--- /dev/null
+++ b/content/docs/bg-BG/publishing/modtale.mdx
@@ -0,0 +1,137 @@
+---
+title: Modtale
+description: Complete guide to publishing and managing your Hytale mods on Modtale.
+---
+
+# Publishing Your Mod on Modtale
+
+[Modtale](https://modtale.net) is the Hytale Community Repository for discovering mods, asset packs, worlds, and modpacks.
+
+This guide will walk you through the complete process of publishing your mod.
+
+## Prerequisites
+
+Before you start, make sure you have:
+
+- A compiled `.jar` file of your plugin, or `.zip` of your asset pack
+- A description of your mod's features
+
+We also recommended:
+
+- High-quality screenshots or images of your mod in action
+- A clear logo or icon (recommended size: 512x512px)
+- Any dependencies or requirements documented
+
+## Step-by-Step Publishing Process
+
+### 1. Account Setup
+
+Sign in to [Modtale](https://modtale.net) using your preferred method. If you don't have an account, create one first.
+
+### 2. Start Creating
+
+Click on the **"Create"** button in the navigation bar or go directly to the [upload page](https://modtale.net/upload).
+
+### 3. Choose Content Type
+
+Select the appropriate content type for your submission:
+
+- **Server Plugins** - For Hytale server-side plugins and modifications
+- **Data Assets** - For custom data packs, loot tables, and other data-driven content
+- **Art Assets** - For texture packs, models, and other artistic content
+- **Worlds** - For custom Hytale worlds
+- **Modpacks** - For curated collections of mods and assets
+
+![Content Type Selection](/assets/guides/modtale_type.png)
+
+### 4. Basic Information
+
+Fill in the essential details:
+
+- **Name**: Choose a clear, descriptive name for your mod
+- **Summary**: Write a brief description (1-2 sentences, 250 char max) that explains what your mod does
+
+![Project Title and Description](/assets/guides/modtale_title.png)
+
+### 5. Project Configuration
+
+Now you're on your project's management page. Here you can:
+
+#### Upload Files
+
+Navigate to the **"Files"** tab and upload your `.jar` or `.zip` file:
+
+- Drag and drop your file or use the upload button
+- Add version notes describing changes and new features
+- Mark release type (Release, Beta, Alpha)
+
+![File Upload Interface](/assets/guides/modtale_upload.png)
+
+#### Customize Your Project
+
+- **Logo**: Upload a high-quality logo (512x512 recommended)
+- **Banner**: Upload a banner for your page (1920x640 recommended)
+- **Screenshots**: Add multiple screenshots showing your mod in action
+- **Description**: Write a comprehensive description using Markdown formatting
+- **Links**: Add links to your source code, Discord server, or documentation
+- **Tags**: Add relevant tags to help users find your mod
+- **License**: Indicate what license your mod uses from a selection of common licenses, or use a custom license
+
+## Best Practices
+
+### Documentation
+
+<Callout type="info">
+  Always include comprehensive documentation in your mod description. Users should understand what your mod does, how to use it, and any special requirements.
+</Callout>
+
+### Version Notes
+
+When uploading new versions:
+
+- You must adhere to SemVer
+- Clearly document all changes and new features
+- Include bug fixes and known issues
+- Mention any breaking changes or migration steps
+- List new dependencies or requirement changes
+
+### Visual Appeal
+
+- Use high-quality screenshots that showcase your mod's features in the gallery
+- Create an eye-catching logo that represents your mod
+- Consider adding a banner image for your project page
+
+### Community Engagement
+
+- Respond to comments and feedback promptly
+- Consider creating a Discord server for community support
+- Regularly update your mod based on user feedback
+
+## After Publishing
+
+### Automated updates
+
+- You can configure your project to automatically upload new versions using Github Actions, Gradle, Maven, or Go. See examples [here](https://github.com/Modtale/modtale-example)
+
+### Monitoring Your Project
+
+- Check the analytics to see download statistics
+- Monitor comments and reviews
+- Keep track of bug reports and feature requests
+
+### Marketing Your Mod
+
+- Share your mod on relevant Hytale communities
+- Create showcase videos or tutorials
+- Engage with other modders and creators
+
+<Callout type="warning">
+  Remember to keep your mod updated for new Hytale versions and maintain compatibility with Hytale's modding framework to maximize your audience reach.
+</Callout>
+
+## Getting Help
+
+If you encounter any issues during the publishing process:
+
+- Join their Discord community for support
+- Contact the Modtale team directly through their support channels
diff --git a/content/docs/bg-BG/quick-start.mdx b/content/docs/bg-BG/quick-start.mdx
new file mode 100644
index 00000000..249d803a
--- /dev/null
+++ b/content/docs/bg-BG/quick-start.mdx
@@ -0,0 +1,16 @@
+---
+title: Quick Start
+description: Setting up a standard Hytale project.
+---
+
+Welcome to the Hytale modding documentation! Here you'll find everything you need to know about creating your own mods for Hytale.
+
+* [Java Basics](./guides/java-basics/00-introduction)
+* [Setting up your dev environment](./guides/plugin/setting-up-env)
+* [Entity Component System (ECS)](./guides/ecs/entity-component-system)
+* [Publishing your mod](./publishing)
+
+### Useful Links
+
+* [Kaupenjoe's Modding Videos](https://www.youtube.com/@ModdingByKaupenjoe)
+* [TroubleDEV's Modding Videos](https://www.youtube.com/@TroubleDEV)
diff --git a/content/docs/bg-BG/server/argtypes.mdx b/content/docs/bg-BG/server/argtypes.mdx
new file mode 100644
index 00000000..e54a442e
--- /dev/null
+++ b/content/docs/bg-BG/server/argtypes.mdx
@@ -0,0 +1,61 @@
+---
+title: ArgTypes
+description: Available ArgTypes
+icon: List
+full: true
+authors:
+  - name: Valeena
+---
+
+| Name                        | Target Class                           | Description                                                                                                                               |   |
+| :-------------------------- | :------------------------------------- | :---------------------------------------------------------------------------------------------------------------------------------------- | - |
+| Boolean                     | java.lang.Boolean                      | A 'true' or 'false' input                                                                                                                 |   |
+| Integer                     | java.lang.Integer                      | A whole number                                                                                                                            |   |
+| String                      | java.lang.String                       | Words, text, numbers, letters. To input more than one word at a time, you may need to wrap it with double quotes (`"my fancy sentence"`). |   |
+| Float                       | java.lang.Float                        | A floating-pointer number                                                                                                                 |   |
+| Double                      | java.lang.Double                       | A decimal number                                                                                                                          |   |
+| UUID                        | java.util.UUID                         | A UUID (Universally Unique IDentifier)                                                                                                    |   |
+| Player_UUID                 | java.util.UUID                         | A UUID or an online player username                                                                                                       |   |
+| Game_Profile_Lookup_Async   | ProfileServiceClient.PublicGameProfile | A player UUID or username. If not found locally, performs a remote lookup via the Profile Service.                                        |   |
+| Relative_Double_Coord       | Coord                                  | An x, y, or z coordinate as a decimal, optionally relative by specifying a tilde (~) in front of the number                               |   |
+| Relative_Int_Coord          | IntCoord                               | An x, y, or z coordinate as a whole number, optionally relative by specifying a tilde (~) in front of the number                          |   |
+| Relative_Integer            | RelativeInteger                        | A tilde to mark an integer relative to a base                                                                                             |   |
+| Relative_Float              | RelativeFloat                          | A tilde to mark a float relative to a base                                                                                                |   |
+| Player_Ref                  | PlayerRef                              | A UUID or an online player's username                                                                                                     |   |
+| World                       | World                                  | A world folder name                                                                                                                       |   |
+| Model_Asset                 | ModelAsset                             | A reference to an Asset of type Model                                                                                                     |   |
+| Weather_Asset               | Weather                                | A reference to an Asset of type Weather                                                                                                   |   |
+| Interaction_Asset           | Interaction                            | A reference to an Asset of type Interaction                                                                                               |   |
+| Root_Interaction_Asset      | RootInteraction                        | A reference to an Asset of type Root Interaction                                                                                          |   |
+| Effect_Asset                | EntityEffect                           | A refernece to an Asset of type EntityEffect                                                                                              |   |
+| Environment_Asset           | Environment                            | A reference to an Asset of type Environment                                                                                               |   |
+| Item_Asset                  | Item                                   | A reference to an Asset of type Item                                                                                                      |   |
+| Block_Type_Asset            | BlockType                              | A reference to an Asset of type BlockType                                                                                                 |   |
+| Particle_System             | ParticleSystem                         | A reference to an Asset of type ParticleSystem                                                                                            |   |
+| Hitbox_Collision_Config     | HitboxCollisionConfig                  | A reference to an Asset of type HitboxCollisionConfig                                                                                     |   |
+| Repulsion_Config            | RepulsionConfig                        | A reference to an Asset of type RepulsionConfig                                                                                           |   |
+| Sound_Event_Asset           | SoundEvent                             | A reference to an Asset of type SoundEvent                                                                                                |   |
+| Ambiance_Fx_Asset           | AmbianceFX                             | A reference to an Asset of type AmbianceFX                                                                                                |   |
+| Sound_Category              | SoundCategory                          | A sound category (sfx, music, ambient, ui)                                                                                                |   |
+| Entity_ID                   | `ArgWrapper<EntityWrappedArg, UUID>`   | A UUID representing an entity id                                                                                                          |   |
+| Integer_Comparison_Operator | IntegerComparisonOperator              | A mathematical sign for integer comparison                                                                                                |   |
+| Integer_Operation           | IntegerOperation                       | A mathematical sign for performing an operation                                                                                           |   |
+| Int_Range                   | `Pair<Integer, Integer>`               | Two integers representing a minimum and maximum of a range                                                                                |   |
+| Relative_Int_Range          | RelativeIntRange                       | Two integers representing a minimum and maximum of a range                                                                                |   |
+| Vector2I                    | Vector2i                               | Two integers, generally corresponding to x/z axis                                                                                         |   |
+| Vector3I                    | Vector3i                               | Three integers, generally corresponding to x/y/z axis                                                                                     |   |
+| Relative_Vector3I           | RelativeVector3i                       | Three optionally relative integers, generally corresponding to x/y/z axis                                                                 |   |
+| Relative_Block_Position     | RelativeIntPosition                    | A position with three integer coordinates, representing a block's location in world space.                                                |   |
+| Relative_Position           | Relative                               | A position with three decimal coordinates, representing a location in world space.                                                        |   |
+| Relative_Chunk_Position     | RealtiveChunkPosition                  | A position with two integer coordinates (x, z), representing a chunk's location.                                                          |   |
+| Rotation                    | Vector3f                               | A rotation with three coordinates, representing the pitch, yaw, and roll respectively                                                     |   |
+| Block_Type_Key              | String                                 | A block type                                                                                                                              |   |
+| Block_ID                    | Integer                                | A block type, converted to an int id                                                                                                      |   |
+| Color                       | Integer                                | A color value in hex format, hex integer, or decimal integer                                                                              |   |
+| Weighted_Block_Type         | `Pair<Integer, String>`                | A weight corresponding to a blocktype                                                                                                     |   |
+| Weighted_Block_Entry        | String                                 | A block with optional weight prefix                                                                                                       |   |
+| Block_Pattern               | BlockPattern                           | A list of blocks with optional weights                                                                                                    |   |
+| Individual_Block_Mask       | BlockMask                              | Create a block mask using symbols and block names                                                                                         |   |
+| Block_Mask                  | BlockMask                              | A tick rate value (e.g., 30tps, 33ms, or 30)                                                                                              |   |
+| Tick_Rate                   | Integer                                | A list of block masks that combine together                                                                                               |   |
+| Game_Mode                   | GameMode                               | GameMode                                                                                                                                  |   |
diff --git a/content/docs/bg-BG/server/entities.mdx b/content/docs/bg-BG/server/entities.mdx
new file mode 100644
index 00000000..872f3fa4
--- /dev/null
+++ b/content/docs/bg-BG/server/entities.mdx
@@ -0,0 +1,441 @@
+---
+title: Entities
+description: List of all Entities in Hytale
+icon: List
+full: true
+---
+
+This page contains a list of all Entities available to be used as a key in the AssetMap.
+
+- Antelope
+- Archaeopteryx
+- Armadillo
+- Arrow_Crossbow_Signature
+- Arrow_Crude
+- Arrow_Fire
+- Arrow_Frost
+- Arrow_Iron
+- Arrow_Ricochet
+- Arrow_Ricochet_Signature
+- Arrow_Shortbow_Signature
+- Arrow_Vamp
+- Arrow_Vamp_Signature
+- Axe_Bone
+- Axe_Stone_Trork
+- Bat
+- Bat_Ice
+- Bear_Grizzly
+- Bear_Polar
+- Bison
+- Bison_Calf
+- Bluebird
+- Bluegill
+- Boar
+- Boar_Piglet
+- Boat
+- Bomb
+- Bomb_Fire_Goblin
+- Bomb_Fire_Goblin_Dud
+- Bomb_Large_Fire_Goblin
+- Bomb_Popberry
+- Bomb_Potion_Poison
+- Boy_Trail
+- Bramblekin
+- Bramblekin_Shaman
+- Bullet_Blunderbuss
+- Bunny
+- Cactee
+- Cactee_Spike
+- Calf
+- Camel
+- Camel_Calf
+- Cat
+- Catfish
+- Chick
+- Chick_Desert
+- Chicken
+- Chicken_Desert
+- Chicken_Undead
+- Clownfish
+- Corgi
+- Cow
+- Cow_Undead
+- Crab
+- Crawler_Void
+- Crocodile
+- Crossbow_Turret
+- Crossbow_Turret_Item_Projectile
+- Crow
+- Dagger_Adamantite
+- Dagger_Bone
+- Dagger_Bronze
+- Dagger_Bronze_Ancient
+- Dagger_Cobalt
+- Dagger_Copper
+- Dagger_Crude
+- Dagger_Doomed
+- Dagger_Fang_Doomed
+- Dagger_Iron
+- Dagger_Mithril
+- Dagger_Onyxium
+- Dagger_Stone_Trork
+- Dagger_Thorium
+- Debug
+- Deer_Doe
+- Deployable_Fire_Trap
+- Deployable_Fire_Trap_Preview
+- Dog
+- Dragon_Fire
+- Dragon_Frost
+- Dragon_Void
+- Duck
+- Eel_Moray
+- Egg
+- Emberwulf
+- Eye_Void
+- Eye_Void_Blast
+- Fen_Stalker
+- Feran
+- Feran_Burrower
+- Feran_Civilian
+- Feran_Cub
+- Feran_Longtooth
+- Feran_Sharptooth
+- Feran_Windwalker
+- Feran_Windwalker_Wind_Burst
+- Feran_Windwalker_Wind_Vortex
+- Finch_Green
+- Fireball
+- Flamingo
+- Fox
+- Frog_Blue
+- Frog_Green
+- Frog_Orange
+- Frostgill
+- Gecko
+- Ghoul
+- Goat
+- Goat_Kid
+- Goblin
+- Goblin_Boss
+- Goblin_Duke
+- Goblin_Duke_Large
+- Goblin_Hermit
+- Goblin_Lobber
+- Goblin_Miner
+- Goblin_Ogre
+- Goblin_Scrapper
+- Goblin_Thief
+- Golem_Crystal_Earth
+- Golem_Crystal_Flame
+- Golem_Crystal_Frost
+- Golem_Crystal_Sand
+- Golem_Crystal_Thunder
+- Golem_Firesteel
+- Golem_Guardian_Void
+- Grooble
+- Hatworm
+- Hawk
+- Healing_Totem
+- Healing_Totem_Projectile
+- Hedera
+- Horse
+- Horse_Foal
+- Horse_Skeleton
+- Horse_Skeleton_Armored
+- Hound_Bleached
+- Hyena
+- Ice_Ball
+- Ice_Bolt
+- Ingredient_Poop
+- Jellyfish_Blue
+- Jellyfish_Cyan
+- Jellyfish_Green
+- Jellyfish_Man_Of_War
+- Jellyfish_Red
+- Jellyfish_Yellow
+- Klops
+- Klops_Gentleman
+- Klops_Merchant
+- Klops_Miner
+- Kunai
+- Kweebec_Rootling
+- Kweebec_Sapling
+- Kweebec_Sapling_Brown
+- Kweebec_Sapling_Christmas_Blue
+- Kweebec_Sapling_Christmas_Green
+- Kweebec_Sapling_Christmas_Pink
+- Kweebec_Sapling_Green
+- Kweebec_Sapling_HardHat
+- Kweebec_Sapling_Orange
+- Kweebec_Sapling_Pink
+- Kweebec_Sapling_Razorleaf
+- Kweebec_Sapling_Red
+- Kweebec_Sapling_Treesinger
+- Kweebec_Sapling_Yellow
+- Kweebec_Seedling
+- Kweebec_Sproutling
+- Kweebec_Sproutling_Blue
+- Kweebec_Sproutling_Lime
+- Lamb
+- Larva_Silk
+- Larva_Void
+- Leopard_Snow
+- Lizard_Sand
+- Lobster
+- Mannequin
+- Meerkat
+- Minecart
+- Minnow
+- Model_Bee_Swarm
+- Model_Deer_Stag
+- Molerat
+- Moose_Bull
+- Moose_Cow
+- Mosshorn
+- Mosshorn_Plain
+- Mouflon
+- Mouflon_Lamb
+- Mouse
+- Mushee
+- NPC_Elf
+- NPC_Path_Marker
+- NPC_Santa
+- NPC_Sound_Shoe
+- NPC_Spawn_Marker
+- Necromancer_Void
+- Objective_Location_Marker
+- Outlander
+- Outlander_Berserker
+- Outlander_Brute
+- Outlander_Cultist
+- Outlander_Hunter
+- Outlander_Marauder
+- Outlander_Peon
+- Outlander_Priest
+- Outlander_Sorcerer
+- Outlander_Stalker
+- Owl_Brown
+- Owl_Snow
+- Parrot
+- Penguin
+- Pig
+- Pig_Undead
+- Pig_Wild
+- Pigeon
+- Piglet
+- Piglet_Wild
+- Pike
+- Piranha
+- Piranha_Black
+- Player
+- PlayerTestModel_G
+- PlayerTestModel_V
+- Projectile
+- Pterodactyl
+- Pufferfish
+- Rabbit
+- Ram
+- Ram_Lamb
+- Raptor_Cave
+- Rat
+- Raven
+- Reindeer_Christmas
+- Rex_Cave
+- Rubble_Aqua
+- Rubble_Basalt
+- Rubble_Calcite
+- Rubble_Default
+- Rubble_Ice
+- Rubble_Marble
+- Rubble_Quartzite
+- Rubble_Sandstone
+- Rubble_Sandstone_Red
+- Rubble_Sandstone_White
+- Rubble_Shale
+- Rubble_Slate
+- Rubble_Stone
+- Rubble_Stone_Mossy
+- Rubble_Volcanic
+- Salmon
+- Saurian
+- Saurian_Hunter
+- Saurian_Rogue
+- Saurian_Warrior
+- Scarak_Broodmother
+- Scarak_Broodmother_Young
+- Scarak_Defender
+- Scarak_Fighter
+- Scarak_Fighter_Royal_Guard
+- Scarak_Louse
+- Scarak_Seeker
+- Scarak_Seeker_Spitball
+- Scorpion
+- Shadow_Knight
+- Shark_Hammerhead
+- Sheep
+- Shellfish_Lava
+- Showcase_Cobalt_Gear
+- Showcase_Copper_Gear
+- Showcase_Iron_Gear
+- Showcase_Iron_TargetDummy_1
+- Showcase_Mannequin_Heal
+- Showcase_Mannequin_Inv_Portal
+- Showcase_Mannequin_Inv_Sphere
+- Showcase_Mannequin_Lightning
+- Showcase_Mannequin_Sitting
+- Showcase_Onyxium_Gear
+- Showcase_Prisma_Gear
+- Showcase_Skeleton_Assasin
+- Showcase_Skeleton_Dead
+- Showcase_Skeleton_Guard
+- Showcase_Skeleton_Tank
+- Showcase_Wooden_Gear
+- Skeleton
+- Skeleton_Archer
+- Skeleton_Archmage
+- Skeleton_Burnt_Alchemist
+- Skeleton_Burnt_Archer
+- Skeleton_Burnt_Gunner
+- Skeleton_Burnt_Knight
+- Skeleton_Burnt_Lancer
+- Skeleton_Burnt_Praetorian
+- Skeleton_Burnt_Soldier
+- Skeleton_Burnt_Wizard
+- Skeleton_Fighter
+- Skeleton_Frost_Archer
+- Skeleton_Frost_Archmage
+- Skeleton_Frost_Fighter
+- Skeleton_Frost_Knight
+- Skeleton_Frost_Mage
+- Skeleton_Frost_Ranger
+- Skeleton_Frost_Scout
+- Skeleton_Frost_Soldier
+- Skeleton_Incandescent_Fighter
+- Skeleton_Incandescent_Footman
+- Skeleton_Incandescent_Head
+- Skeleton_Incandescent_Mage
+- Skeleton_Knight
+- Skeleton_Mage
+- Skeleton_Mage_Corruption_Orb
+- Skeleton_Pirate_Captain
+- Skeleton_Pirate_Gunner
+- Skeleton_Pirate_Striker
+- Skeleton_Ranger
+- Skeleton_Sand_Archer
+- Skeleton_Sand_Archmage
+- Skeleton_Sand_Assassin
+- Skeleton_Sand_Guard
+- Skeleton_Sand_Mage
+- Skeleton_Sand_Ranger
+- Skeleton_Sand_Scout
+- Skeleton_Sand_Soldier
+- Skeleton_Scout
+- Skeleton_Soldier
+- Skrill
+- Skrill_Chick
+- Slothian
+- Slothian_Elder
+- Slothian_Kid
+- Slothian_Monk
+- Slothian_Scout
+- Slothian_Villager
+- Slothian_Warrior
+- Slowness_Totem
+- Slowness_Totem_Projectile
+- Slug_Magma
+- Snail_Frost
+- Snail_Magma
+- Snake_Cobra
+- Snake_Marsh
+- Snake_Rattle
+- Snapdragon
+- Snapjaw
+- Spark_Living
+- Sparrow
+- Spawn_Void
+- Spear_Adamantite
+- Spear_Adamantite_Saurian
+- Spear_Bone
+- Spear_Bronze
+- Spear_Cobalt
+- Spear_Copper
+- Spear_Crude
+- Spear_Double_Incandescent
+- Spear_Iron
+- Spear_Leaf
+- Spear_Mithril
+- Spear_Onyxium
+- Spear_Scrap
+- Spear_Stone_Trork
+- Spear_Thorium
+- Spear_Tribal
+- Spectre_Void
+- Spider
+- Spider_Cave
+- Spirit_Ember
+- Spirit_Frost
+- Spirit_Root
+- Spirit_Thunder
+- Squirrel
+- Swarm_Bees
+- Sword_Charged_Test
+- Tang_Blue
+- Tang_Chevron
+- Tang_Lemon_Peel
+- Tang_Sailfin
+- Tank
+- Temple_Mithril_Guard
+- Test_Platform
+- Tetrabird
+- Tiger_Sabertooth
+- Toad_Rhino
+- Toad_Rhino_Magma
+- Tornado
+- Tortoise
+- Trash
+- Trillodon
+- Trilobite
+- Trilobite_Black
+- Trork
+- Trork_Brawler
+- Trork_Chieftain
+- Trork_Christmas
+- Trork_Doctor_Witch
+- Trork_Guard
+- Trork_Hunter
+- Trork_Mauler
+- Trork_Sentry
+- Trork_Shaman
+- Trork_Warrior
+- Trout_Rainbow
+- Tuluk
+- Tuluk_Fisherman
+- Turkey
+- Turkey_Chick
+- Vulture
+- Warp
+- Warrior_Quest
+- Warthog
+- Warthog_Piglet
+- Werewolf
+- Whale_Humpback
+- Wolf_Black
+- Wolf_Outlander_Priest
+- Wolf_Outlander_Sorcerer
+- Wolf_Trork_Hunter
+- Wolf_Trork_Shaman
+- Wolf_White
+- Woodpecker
+- Wraith
+- Wraith_Lantern
+- Wurmling_Frost
+- Yeti
+- Zombie
+- Zombie_Aberrant
+- Zombie_Aberrant_Big
+- Zombie_Aberrant_Small
+- Zombie_Burnt
+- Zombie_Frost
+- Zombie_Sand
+- Zombie_Werewolf
diff --git a/content/docs/bg-BG/server/events.mdx b/content/docs/bg-BG/server/events.mdx
new file mode 100644
index 00000000..685d5893
--- /dev/null
+++ b/content/docs/bg-BG/server/events.mdx
@@ -0,0 +1,103 @@
+---
+title: Events
+description: List of all events in Hytale
+icon: List
+full: true
+---
+
+## IEvent
+
+- AddPlayerToWorldEvent
+- AllNPCsLoadedEvent
+- AllWorldsLoadedEvent
+- AssetMonitorEvent
+  - AssetStoreMonitorEvent
+  - CommonAssetMonitorEvent
+- AssetPackRegisterEvent
+- AssetPackUnregisterEvent
+- AssetStoreEvent
+  - RegisterAssetStoreEvent
+  - RemoveAssetStoreEvent
+- AssetsEvent
+  - GenerateAssetsEvent
+  - LoadedAssetsEvent
+  - RemovedAssetsEvent
+- BootEvent
+- ChunkEvent
+  - ChunkPreLoadProcessEvent
+- DrainPlayerFromWorldEvent
+- EditorClientEvent
+  - AssetEditorActivateButtonEvent
+  - AssetEditorAssetCreatedEvent
+  - AssetEditorClientDisconnectEvent
+  - AssetEditorSelectAssetEvent
+  - AssetEditorUpdateWeatherPreviewLockEvent
+- EntityEvent
+  - EntityRemoveEvent
+  - LivingEntityInventoryChangeEvent
+- GenerateDefaultLanguageEvent
+- GenerateSchemaEvent
+- GenerateServerStateEvent
+- ItemContainerChangeEvent
+- ~~LivingEntityUseBlockEvent~~ DEPRECATED
+- LoadAssetEvent
+- LoadedNPCEvent
+- MessagesUpdated
+- PlayerConnectEvent
+- PlayerEvent
+  - ~~PlayerCraftEvent~~ DEPRECATED
+  - ~~PlayerInteractEvent~~ DEPRECATED
+  - PlayerMouseButtonEvent
+  - PlayerMouseMotionEvent
+  - PlayerReadyEvent
+- PlayerRefEvent
+  - PlayerDisconnectEvent
+- PlayerSetupConnectEvent
+- PlayerSetupDisconnectEvent
+- PluginEvent
+  - PluginSetupEvent
+- ~~PrepareUniverseEvent~~ DEPRECATED
+- ShutdownEvent
+- SingleplayerRequestAccessEvent
+- TreasureChestOpeningEvent
+- WindowCloseEvent
+- WorldEvent
+  - AddWorldEvent
+  - RemoveWorldEvent
+  - StartWorldEvent
+- WorldPathChangedEvent
+
+## IAsyncEvent
+
+- AssetEditorFetchAutoCompleteDataEvent
+- AssetEditorRequestDataSetEvent
+- PlayerChatEvent
+- SendCommonAssetsEvent
+
+## EcsEvent
+
+- CancellableEcsEvent
+  - BreakBlockEvent
+  - ChangeGameModeEvent
+  - ChunkSaveEvent
+  - ChunkUnloadEvent
+  - CraftRecipeEvent
+    - Post
+    - Pre
+  - Damage
+  - DamageBlockEvent
+  - DropItemEvent
+    - Drop
+    - PlayerRequest
+  - InteractivelyPickupItemEvent
+  - PlaceBlockEvent
+  - PrefabPasteEvent
+  - SwitchActiveSlotEvent
+- DiscoverInstanceEvent
+  - Display
+- DiscoverZoneEvent
+  - Display
+- MoonPhaseChangeEvent
+- UseBlockEvent
+  - Post
+  - Pre
diff --git a/content/docs/bg-BG/server/interaction-reference.mdx b/content/docs/bg-BG/server/interaction-reference.mdx
new file mode 100644
index 00000000..6c0d01b3
--- /dev/null
+++ b/content/docs/bg-BG/server/interaction-reference.mdx
@@ -0,0 +1,1586 @@
+---
+title: Interactions
+description: A list of most Interaction types provided by Hypixel, along with the meaning of their fields, and how they fit together.
+icon: List
+authors:
+  - name: Stephen Baynham
+    url: https://github.com/cannibalvox
+---
+
+### The Interaction Base Type
+
+All interactions of every type below are inherited from Interaction and have these fields.
+
+**Interaction Fields**
+
+| Field Name                | Type                                                                 | Required? | Notes                                                                                                                                                                                                                       |
+| ------------------------- | -------------------------------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| ViewDistance              | `Double`<br />(Default: 96.0)                                        | **No**    | Distance in blocks at which other players can see the effects from this interaction.                                                                                                                                        |
+| Effects                   | `InteractionEffects`                                                 | **No**    | Sound, animations, and particle effects that should trigger when this interaction begins executing.                                                                                                                         |
+| HorizontalSpeedMultiplier | `Float`<br />(Default: 1.0)                                          | **No**    | Multiplier applied to the User entity's movement speed while this interaction is executing                                                                                                                                  |
+| RunTime                   | `Float`                                                              | **No**    | If provided, this interaction will continue executing for at least this long before the interaction chain moves onto the next interaction.                                                                                  |
+| CancelOnItemChange        | `Boolean`<br />(Default: true)                                       | **No**    | If true, this interaction will be cancelled if the User entity's held item changes during execution. This can happen either due to the selected hotbar slot changing or the contents of the item's inventory slot changing. |
+| Rules                     | `InteractionRules`                                                   | **Yes**   | If provided, adds additional limitations and cancellation conditions to this interaction.                                                                                                                                   |
+| Settings                  | `Map`<br />(Key Type: `GameMode`, Value Type: `InteractionSettings`) | **No**    | If provided, adds additional per-GameMode settings to the interaction.                                                                                                                                                      |
+| Camera                    | `InteractionCameraSettings`                                          | **No**    | Arrays of camera motion keyframes for cutscenes and reveals.                                                                                                                                                                |
+
+**GameMode Values**
+
+- `Creative`: The game is currently in Creative Mode
+- `Adventure`: The game is currently in Adventure Mode
+
+**InteractionEffects Fields**
+
+| Field Name               | Type                                              | Required? | Notes                                                                                                                                                 |
+| ------------------------ | ------------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Particles                | `Array`<br />(Element Type: `ModelParticle`)      | **No**    | Particle systems to activate when this interaction begins if the player is in third-person mode.                                                      |
+| FirstPersonParticles     | `Array`<br />(Element Type: `ModelParticle`)      | **No**    | Particle systems to activate when this interaction begins if the player is in first-person mode.                                                      |
+| WorldSoundEventId        | `Asset`<br />(Asset Type: `SoundEvent`)           | **No**    | A sound to play in the world at the User entity's location when this interaction begins.<br />**The SoundEvent must be single-channel (mono) sound.** |
+| LocalSoundEventId        | `Asset`<br />(Asset Type: `SoundEvent`)           | **No**    | A 2D sound to play for the User entity when this interaction begins. Ignored if the User entity is not a player.                                      |
+| Trails                   | `Array`<br />(Element Type: `ModelTrail`)         | **No**    | Trail effects to activate on the User entity when this interaction begins.                                                                            |
+| WaitForAnimationToFinish | `Boolean`<br />(Default: false)                   | **No**    | If true, this interaction will continue executing for at least the length of any animations in this InteractionEffects object.                        |
+| ItemPlayerAnimationsId   | `Asset`<br />(Asset Type: `ItemPlayerAnimations`) | **No**    | If provided, the User entity will use this ItemPlayerAnimations set while this interaction is executing.                                              |
+| ItemAnimationId          | `String`                                          | **No**    | Id of an animation to trigger when this interaction begins executing.<br />**This animation id is not validated on server start.**                    |
+| ClearAnimationOnFinish   | `Boolean`<br />(Default: false)                   | **No**    | If true, animations triggered by this interaction will be halted when the interaction completes.                                                      |
+| ClearSoundEventOnFinish  | `Boolean`<br />(Default: false)                   | **No**    | If true, sounds triggered by this interaction will be halted when the interaction completes.                                                          |
+| CameraEffect             | `Asset`<br />(Asset Type: `CameraEffect` )        | **No**    | If provided, the CameraEffect will be applied while this interaction is executing.                                                                    |
+| MovementEffects          | `MovementEffects`                                 | **No**    | If provided, apply the movement effects to the User entity while this interaction is executing.                                                       |
+| StartDelay               | `Float`<br />(Default: 0.0f)                      | **No**    | The interaction will wait this many seconds before triggering the effects in this object.                                                             |
+
+**InteractionRules Fields**
+
+| Field Name          | Type                                                                                                | Required? | Notes                                                                                                                                                                                                                                     |
+| ------------------- | --------------------------------------------------------------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| BlockedBy           | `Array`<br />(Element Type: `InteractionType`)<br />(Default: Based on the chain's InteractionType) | **No**    | If provided, this RootInteraction cannot be executed while interaction chains of the provided types are executing.<br />**This field only functions for rules attached to a RootInteraction. It has no effect on an Interaction.**        |
+| Blocking            | `Array`<br />(Element Type: `InteractionType`)                                                      | **No**    | If provided, interaction chains with the specified InteractionTypes cannot be executed while this interaction is executing.                                                                                                               |
+| InterruptedBy       | `Array`<br />(Element Type: `InteractionType`)                                                      | **No**    | If provided, interaction chains with the specified InteractionTypes will cancel this interaction chain when they execute.<br />**This field only functions for rules attached to a RootInteraction. It has no effect on an Interaction.** |
+| Interrupting        | `Array`<br />(Element Type: `InteractionType`)                                                      | **No**    | If provided, interaction chains with the specified InteractionTypes will be canceled when this interaction begins.                                                                                                                        |
+| BlockedByBypass     | `String`                                                                                            | **No**    | If provided, this RootInteraction cannot be blocked by interaction chains whose RootInteraction has this value as an asset tag.                                                                                                           |
+| BlockingBypass      | `String`                                                                                            | **No**    | If provided, this interaction will not block RootInteractions that have the this value as an asset tag.                                                                                                                                   |
+| InterruptedByBypass | `String`                                                                                            | **No**    | If provided, this RootInteraction cannot be canceled by RootInteractions that have this value as an asset tag.                                                                                                                            |
+| InterruptingBypass  | `String`                                                                                            | **No**    | If provided, this interaction will not cancel interaction chains whose RootInteraction has this value as an asset tag.                                                                                                                    |
+
+**InteractionType Values**
+
+- `Primary`
+- `Secondary`
+- `Ability1`
+- `Ability2`
+- `Ability3`
+- `Use`
+- `Pick`
+- `Pickup`
+- `CollisionEnter`
+- `CollisionLeave`
+- `Collision`
+- `EntityStatEffect`
+- `SwapTo`
+- `SwapFrom`
+- `Death`
+- `Wielding`
+- `ProjectileSpawn`
+- `ProjectileHit`
+- `ProjectileMiss`
+- `ProjectileBounce`
+- `Held`
+- `HeldOffhand`
+- `Equipped`
+- `Dodge`
+- `GameModeSwap`
+
+**InteractionSettings Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                        |
+| ---------------- | ------------------------------- | --------- | -------------------------------------------------------------------------------------------- |
+| AllowSkipOnClick | `Boolean`<br />(Default: false) | **No**    | If true, the user will be able to skip this interaction by clicking shortly after it starts. |
+
+**InteractionCameraSettings Fields**
+
+| Field Name  | Type                                             | Required? | Notes                                                                                                                                                           |
+| ----------- | ------------------------------------------------ | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| FirstPerson | `Array`<br />(Element Type: `InteractionCamera`) | **No**    | A list of camera keyframes to be played if the player is in first-person.<br />**The time of each keyframe must be after the keyframe before it in the array.** |
+| ThirdPerson | `Array`<br />(Element Type: `InteractionCamera`) | **No**    | A list of camera keyframes to be played if the player is in third-person.<br />**The time of each keyframe must be after the keyframe before it in the array.** |
+
+**InteractionCamera Fields**
+
+| Field Name | Type                         | Required? | Notes                                                                                                                                       |
+| ---------- | ---------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------- |
+| Time       | `Float`<br />(Default: 0.1f) | **No**    | How long after the interaction begins executing that the camera should arrive at this keyframe.<br />**Cannot be less than or equal to 0.** |
+| Position   | `Vector3`                    | **Yes**   | Where the camera should be located when it arrives at this keyframe.                                                                        |
+| Rotation   | `Direction`                  | **Yes**   | Where the camera should be pointing when it arrives at this keyframe.                                                                       |
+
+### SimpleInteraction
+
+Most interaction types below are inherited from SimpleInteraction and have these
+fields.  If a type does not have these fields, the documentation will mention it.
+
+The purpose of SimpleInteraction is to facilitate Interaction chaining by taking different paths
+based on whether the Interaction succeeded or failed.  The circumstances under which
+a given Interaction fails are generally type-specific (and described in the documentation
+below), but all interactions will be marked failed if they are cancelled via one of the
+many, many mechanisms for doing so.
+
+It is valid to create an interaction asset of type "Simple", which can be valuable when you want to use the
+interaction fields with no additional functionality.
+
+**SimpleInteraction Fields**
+
+| Field Name | Type                                     | Required? | Notes                                                                                          |
+| ---------- | ---------------------------------------- | --------- | ---------------------------------------------------------------------------------------------- |
+| Next       | `Asset`<br />(Asset Type: `Interaction`) | **No**    | After this Interaction has finished, "Next" will be executed if this Interaction did not fail. |
+| Failed     | `Asset`<br />(Asset Type: `Interaction`) | **No**    | After this Interaction has finished, "Failed" will be executed if this Interaction failed.     |
+
+## Flow Control
+
+These are interaction types used to control the flow of an interaction chain and allow interactions
+to be composed into more complex behaviors.  These interaction types generally do not pertain to
+the game and instead pertain to the interaction system itself.
+
+### Condition
+
+This interaction will fail if one of the fields is provided but does not match the current state.
+
+**Condition Fields**
+
+| Field Name       | Type       | Required? | Notes                                                                                                                                                                                    |
+| ---------------- | ---------- | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| RequiredGameMode | `GameMode` | **No**    | If provided, the interaction will fail if the current GameMode does not match the provided value.                                                                                        |
+| Jumping          | `Boolean`  | **No**    | If provided, the interaction will fail if the player's Jumping state does not match the provided value. (i.e. if True, the player must be jumping, if False, the player must not be)     |
+| Swimming         | `Boolean`  | **No**    | If provided, the interaction will fail if the player's Swimming state does not match the provided value. (i.e. if True, the player must be swimming, if False, the player must not be)   |
+| Crouching        | `Boolean`  | **No**    | If provided, the interaction will fail if the player's Crouching state does not match the provided value. (i.e. if True, the player must be crouching, if False, the player must not be) |
+| Running          | `Boolean`  | **No**    | If provided, the interaction will fail if the player's Running state does not match the provided value. (i.e. if True, the player must be running, if False, the player must not be)     |
+| Flying           | `Boolean`  | **No**    | If provided, the interaction will fail if the player's Flying state does not match the provided value. (i.e. if True, the player must be flying, if False, the player must not be)       |
+
+**GameMode Values**
+
+- `Creative`: The game is currently in Creative Mode
+- `Adventure`: The game is currently in Adventure Mode
+
+### FirstClick
+
+This interaction does not inherit from SimpleInteraction and therefore has no Next or Failed fields.
+
+This interaction has two fields that each contain a reference to an Interaction: Click and Hold.  If the root interaction
+of the chain was initiated by a client button/key press (or simulated NPC input) and the input was a tap, then
+the Click interaction is run. if it was a longer press, then the Hold interaction is run.
+
+As a minor implementation detail, this interaction is internally marked as failed when the Hold path is followed.
+This generally shouldn't matter.  If the interaction was not initiated by a key press at all, the Click path will be followed,
+but it seems risky to rely on that behavior.
+
+**FirstClick Fields**
+
+| Field Name | Type                                     | Required? | Notes                                                                                                                                                    |
+| ---------- | ---------------------------------------- | --------- | -------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Click      | `Asset`<br />(Asset Type: `Interaction`) | **No**    | If provided and the root interaction of the chain was initiated by button/key press, this interaction is executed next if the press was a quick tap.     |
+| Hold       | `Asset`<br />(Asset Type: `Interaction`) | **No**    | If provided and the root interaction of the chain was initiated by a button/key press, this interaction is executed next if the press was a longer hold. |
+
+### Interrupt
+
+This interaction can be used to cancel one or more running interaction chains on an entity and **all forked interaction
+chains those chains have spawned that are still currently running**.  All interaction chains canceled in this manner will be marked as
+Failed, which may have additional implications if the canceled chains are themselves forked from
+other chains that are still running.
+
+**Interrupt Fields**
+
+| Field Name     | Type                                           | Required? | Notes                                                                                                                                                                                               |
+| -------------- | ---------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Entity         | `InteractionTarget`<br />(Default: User)       | **Yes**   | The entity that is the owner of the target interaction chains.  This field can indicate the Owner, User, or Target of this interaction chain.                                                       |
+| InterruptTypes | `Array`<br />(Element Type: `InteractionType`) | **No**    | A set of InteractionTypes that are to be interrupted. Only interactions of these types are affected. If null, all types will be interrupted.<br />**(Note: An empty set will interrupt NO TYPES.)** |
+| RequiredTag    | `String`                                       | **No**    | An asset tag that, if provided, the RootInteraction of the interaction chain must have in order to be canceled.                                                                                     |
+| ExcludedTag    | `String`                                       | **No**    | An asset tag that, if provided, the RootInteraction of the interaction chain must not have in order to be canceled.                                                                                 |
+
+**InteractionTarget Values**
+
+- `User` - The user of this interaction chain. The entity whose actions caused this interaction chain to be executed. This is usually the same as the Owner.
+- `Owner` - The owner of this interaction chain. The entity upon whom this interaction chain is executing.
+- `Target` - The entity target of this interaction chain, if any.  This value is mutable (and can therefore come from many places) but most commonly, it is an entity the User was targeting when this interaction chain began executing.
+
+**InteractionType Values**
+
+- `Primary`
+- `Secondary`
+- `Ability1`
+- `Ability2`
+- `Ability3`
+- `Use`
+- `Pick`
+- `Pickup`
+- `CollisionEnter`
+- `CollisionLeave`
+- `Collision`
+- `EntityStatEffect`
+- `SwapTo`
+- `SwapFrom`
+- `Death`
+- `Wielding`
+- `ProjectileSpawn`
+- `ProjectileHit`
+- `ProjectileMiss`
+- `ProjectileBounce`
+- `Held`
+- `HeldOffhand`
+- `Equipped`
+- `Dodge`
+- `GameModeSwap`
+
+### Parallel
+
+This interaction does not inherit from SimpleInteraction and therefore has no Next or Failed fields.
+
+This interaction has a field `Interactions` that is an array of RootInteraction assets. The list must contain at least
+two RootInteractions.  This interaction will fork all of its children except for the first into their
+own interaction chains and immediately complete. After this interaction completes, this interaction chain will
+execute the first RootInteraction in the `Interactions` list.
+
+This interaction does not have any failure conditions and is indifferent to the fate of the forked interaction chains.
+
+**Parallel Fields**
+
+| Field Name   | Type                                                | Required? | Notes                                                         |
+| ------------ | --------------------------------------------------- | --------- | ------------------------------------------------------------- |
+| Interactions | `AssetArray`<br />(Element Type: `RootInteraction`) | **Yes**   | An array of RootInteractions that will be forked or executed. |
+
+### Repeat
+
+This interaction has a field `ForkInteractions` that is an asset of type RootInteraction. This interaction will fork that
+RootInteraction into its own interaction chain and then wait for it to complete. If the RootInteraction fails, this
+interaction will complete immediately and be marked failed. Otherwise, the RootInteraction will be forked and run again,
+up to a specified total number of times.
+
+**Repeat Fields**
+
+| Field Name       | Type                                                                                   | Required? | Notes                                                                                                                                                                                                              |
+| ---------------- | -------------------------------------------------------------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| ForkInteractions | `Asset`<br />(Asset Type: `RootInteraction`)                                           | **Yes**   | A RootInteraction that will be forked.                                                                                                                                                                             |
+| Repeat           | `Integer`<br />(Default: 1)<br />**Must be -1 or a positive integer. 0 is not valid.** | **No**    | The total number of times to fork ForkInteractions. If -1 is provided, ForkInteractions will continue being forked and executed indefinitely, until this interaction is cancelled or until ForkInteractions fails. |
+
+### Replace
+
+This interaction does not inherit from SimpleInteraction and therefore has no Next or Failed fields.
+
+This interaction uses the InteractionVars system that is avaiable for items. InteractionVars are RootInteractions that
+can be attached to an Item asset with a name.
+
+This interaction specifies a var name, and if this interaction chain was executed through
+an item and that item has an InteractionVar of the same name, then this interaction will immediately execute
+the RootInteraction on the var.  Otherwise, it will execute the default RootInteraction specified in this interaction.
+If no default is specified, then this interaction will be marked as failed.
+
+**Replace Fields**
+
+| Field Name   | Type                                         | Required? | Notes                                                                                                                                                                                                           |
+| ------------ | -------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Var          | `String`                                     | **Yes**   | The name of the InteractionVar to execute.                                                                                                                                                                      |
+| DefaultValue | `Asset`<br />(Asset Type: `RootInteraction`) | **No**    | The RootInteraction to execute if the owning item does not have an InteractionVar by the specified name. If not provided, the interaction will be marked as failed instead.                                     |
+| DefaultOk    | `Boolean`<br />(Default: false)              | **No**    | If false, then an angry message will be printed to the server logs if the owning item does not have an InteractionVar by the specified name.  The functioning of this interaction will be otherwise unaffected. |
+
+### RunRootInteraction
+
+This interaction immediately executes the provided RootInteraction as part of this interaction chain. This interaction
+does not have any failure conditions.
+
+**RunRootInteraction Fields**
+
+| Field Name      | Type                                         | Required? | Notes                           |
+| --------------- | -------------------------------------------- | --------- | ------------------------------- |
+| RootInteraction | `Asset`<br />(Asset Type: `RootInteraction`) | **Yes**   | The RootInteraction to execute. |
+
+### Selector
+
+This interaction will execute a Selector to find entities and/or blocks (depending on the Selector) and fork off an
+interaction chain for each located entity or block. This interaction will not wait for those interaction chains
+to complete and is indifferent to their fate. The forked interaction chains will use the located entity/block as
+their target entity/target block. Each entity or block will only fork one interaction chain over the life of this
+interaction.  The Selector is guaranteed to run once for each execution of this interaction, but some Selectors
+are intended to be run over a period of time and sweep across an area to locate targets. In order to use those Selectors
+properly, you will need to extend the execution time of this interaction using `RunTime` or `WaitForAnimationToFinish`.
+The Selector will be executed repeatedly over the lifetime of the interaction.
+
+If the Selector is configured to locate entities, you can add additional sets of entity matching rules. If a located entity
+matches one of the rules, the matching RootInteraction will be forked instead of the standard `HitEntity` RootInteraction.
+
+Entities located by the Selector will be ignored if they do not have a NetworkId, if they are dead, or if they are invulnerable.
+The only exception to this rule is that players in Creative Mode that are marked to receive hits will not be ignored.
+
+This interaction's failure conditions are configurable via the `FailOn` field. You can configure this interaction to never
+fail, to fail if the Selector does not locate any blocks before this interaction finishes executing, to fail if the
+Selector does not locate any entities before this interaction finishes executing, or to fail in either case.
+
+**Selector Fields**
+
+| Field Name     | Type                                         | Required? | Notes                                                                                                                                                                                                                                     |
+| -------------- | -------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Selector       | `Selector`                                   | **Yes**   | The Selector is executed at least once and may be executed repeatedly to locate blocks and/or entities in an area.                                                                                                                        |
+| HitEntity      | `Asset`<br />(Asset Type: `RootInteraction`) | **No**    | If included and the `Selector` locates an entity that does not match any `HitEntityRules`, this RootInteraction will be forked into a new interaction chain with the located entity as the target entity.                                 |
+| HitEntityRules | `Array`<br />(Element Type: `HitEntity`)     | **No**    | If included, these rules will be matched against any entity located by the `Selector`. If an entity matches a set of rules, the RootInteraction associated with the rules will be forked instead of the standard `HitEntity` interaction. |
+| HitBlock       | `Asset`<br />(Asset Type: `RootInteraction`) | **No**    | If included and the `Selector` locates a block, this RootInteraction will be forked into a new interaction chain with the located block as the block target.                                                                              |
+| FailOn         | `FailOnType`<br />(Default: `Neither`)       | **No**    | Defines under what circumstances this interaction will fail.  It can be marked to fail when it completes without locating any blocks, it can be marked to fail when it completes without locating any entities, both, or neither.         |
+| IgnoreOwner    | `Boolean`<br />(Default: true)               | **No**    | If true, the Selector will not locate the User entity of this interaction.                                                                                                                                                                |
+
+**HitEntity Fields**
+
+| Field Name | Type                                         | Required? | Notes                                                                                                 |
+| ---------- | -------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------- |
+| Matchers   | `Array`<br />(Element Type: `EntityMatcher`) | **Yes**   | A set of rules that an entity must match. An entity must successful match all rules to be considered. |
+| Next       | `Asset`<br />(Asset Type: `RootInteraction`) | **Yes**   | The RootInteraction to fork if an entity matches all rules.                                           |
+
+**EntityMatcher Fields**
+
+| Field Name | Type                            | Required? | Notes                                                                                                     |
+| ---------- | ------------------------------- | --------- | --------------------------------------------------------------------------------------------------------- |
+| Type       | `String`                        | **Yes**   | If provided, specifies a type of EntityMatcher to use. Each matcher type may come with additional fields. |
+| Invert     | `Boolean`<br />(Default: false) | **No**    | If true, an entity must fail this rule for it to be marked as succeeded.                                  |
+
+**EntityMatcher Type: Player**
+
+This EntityMatcher will succesfully match the entity only if they are a player.
+
+**EntityMatcher Type: Vulnerable**
+
+This Entitymatcher will successfully match the entity only if they are not marked as invulnerable.
+
+**FailOnType Values**
+
+- `Neither`
+- `Entity`
+- `Block`
+- `Either`
+
+### Serial
+
+This interaction does not inherit from SimpleInteraction and therefore has no Next or Failed fields.
+
+This interaction has a field `Interactions` which is a list of Interaction assets. This interaction immediately
+completes and the interaction chain continues by executing the interactions in the list one at a time. This
+interaction does not have any failure conditions.
+
+**Serial Fields**
+
+| Field Name   | Type                                            | Required? | Notes                                      |
+| ------------ | ----------------------------------------------- | --------- | ------------------------------------------ |
+| Interactions | `AssetArray`<br />(Element Type: `Interaction`) | **Yes**   | An array of Interaction assets to execute. |
+
+## Cooldowns
+
+RootInteractions interface with a complex cooldown system that can be used for a variety of purposes. Aside from simply
+adding an important aspect of resource management to your game design, cooldowns can be used to ensure that click-activated
+interaction chains don't repeatedly spam if the player holds down the input.
+
+By default, every RootInteraction has a cooldown timer that is keyed to the RootInteraction name, and by default, it
+will launch a cooldown of 0.35 seconds when activated by client input.  Otherwise, no cooldown will be activated.  However,
+by configuring your RootInteraction, you can change the key for the cooldown (so that multiple RootInteractions can share
+a single cooldown), set the cooldown timer to whatever you like, and configure multiple charges that can build up over time
+to allow the entity to activate the RootInteraction multiple times before being forced to pause.
+
+One important concept to keep in mind is the difference between **cooldown** and **charge time**.  The cooldown, if any,
+is activated each time a RootInteraction triggers, even if the player has more available charges. If the RootInteraction
+is configured to use charges, then they will gradually build up over time. In order for a RootInteraction to be activated,
+the cooldown (if any) must be expired, and the RootInteraction must have at least one charge (if it has been
+configured to use charges).
+
+Bear in mind that the entire Cooldown configuration is shared between different RootInteractions with the same cooldown id.
+If you activate an ability with 5 charges and a short cooldown and then another ability with a much longer cooldown and no
+charges, the second ability will use the cooldown properties of the first ability until/unless the first ability finishes
+charging and is cleared from the system.  You should generally only have multiple RootInteractions share a cooldown id
+if they have the same configuration.
+
+The interactions below interact with the cooldown system to allow you to manipulate cooldowns via the interaction system. By
+using these interactions, you can have several interaction chains with different cooldown configurations share cooldowns
+that are checked and activated as part of the interaction chain itself, or have some components of an interaction change
+use a second cooldown separate from the main one.
+
+### CooldownCondition
+
+**CooldownCondition Fields**
+
+This interaction will fail if the specified cooldown id is on cooldown for the User entity.  This interaction will only
+function for players- the interaction will always succeed for NPCs.  In order for this interaction to succeed, the
+cooldown, if any, must have expired and at least one charge, if any, must have filled.
+
+| Field Name | Type     | Required? | Notes                     |
+| ---------- | -------- | --------- | ------------------------- |
+| Id         | `String` | **Yes**   | The cooldown id to check. |
+
+### IncrementCooldown
+
+**IncrementCooldown Fields**
+
+This interaction will modify a cooldown that is currently active on the User entity, allowing charges and remaining
+cooldown to be modified.
+Despite its name, this interaction can be used to reduce a cooldown as well as increase it. If the cooldown is not
+currently active, this interaction will have no effect. The interaction has no special failure conditions.
+
+| Field Name        | Type                        | Required? | Notes                                                                                                                                                                                                                                                                                     |
+| ----------------- | --------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Id                | `String`                    | **No**    | If provided, the cooldown id of the cooldown to be manipulated. If not provided, the cooldown id of the current chain's RootInteraction will be used.                                                                                                                                     |
+| Time              | `Float`<br />(Default: 0.0) | **No**    | The amount to increase the remaining cooldown by. Can be negative. The remaining cooldown time will not be reduced below zero or increased above the maximum cooldown time.                                                                                                               |
+| ChargeTime        | `Float`<br />(Default: 0.0) | **No**    | The amount to increase the remaining time until the next charge is filled by. Can be negative. The remaining charge time cannot be reduced below zero or increased above the maximum cooldown time. **This will not work on abilities that have a maximum of 1 charge, for some reason.** |
+| Charge            | `Integer`<br />(Default: 0) | **No**    | The amount to increase the number of charges by. Can be negative. The number of charges cannot be reduced below 0 or increased above the maximum.                                                                                                                                         |
+| InterruptRecharge | `Boolean`(Default: false)   | **No**    | If true and `Charge` is not 0, will reset the remaining time to the next charge to the maximum value after changing the charge count.                                                                                                                                                     |
+
+### ResetCooldown
+
+This interaction will trigger a cooldown on the User entity with a specified configuration. The charges will be refilled
+but the cooldown will be immediately triggered.  The mechanisms for deciding on the configuration are a little bit complicated.
+You may specify a cooldown configuration via the `Cooldown` field. If you do not include an `Id` field, then the
+interaction chain's RootInteraction will be used for any field not specified in the configuration. If there is an active
+cooldown under the specified `Id` (or under the RootInteraction's cooldown id if none is specified) then the fields
+from that active cooldown will overwrite data in the RootInteraction's cooldown, but not data in your `Cooldown` field.
+
+**ResetCooldown Fields**
+
+| Field Name | Type                  | Required? | Notes                                                        |
+| ---------- | --------------------- | --------- | ------------------------------------------------------------ |
+| Cooldown   | `InteractionCooldown` | **No**    | A cooldown configuration to use for the new, reset cooldown. |
+
+**InteractionCooldown Fields**
+
+| Field Name        | Type                                 | Required? | Notes                                                                                                                                                                                                 |
+| ----------------- | ------------------------------------ | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Id                | `String`                             | **No**    | The cooldown id to use for this cooldown. If not provided, the RootInteraction's cooldown id will be used, if any.                                                                                    |
+| Cooldown          | `Float`<br />(Default: 0.0)          | **No**    | The duration of the cooldown, in seconds.                                                                                                                                                             |
+| Charges           | `Array`<br />(Element Type: `Float`) | **No**    | If provided, a list of how many charges this cooldown can build, and how long each charge takes to build, in seconds.                                                                                 |
+| InterruptRecharge | `Boolean`<br />(Default: false)      | **No**    | If true, the charge time will be reset when the number of charges changes.                                                                                                                            |
+| ClickBypass       | `Boolean`<br />(Default: false)      | **No**    | If true, RootInteractions keyed to this cooldown can still be activated when it is on cooldown provided that the RootInteraction was triggered by a distinct key or mouse button press on the client. |
+
+### TriggerCooldown
+
+This interaction is similar to ResetCooldown, except instead of refilling the cooldown's charges, one charge will be deducted
+as normal.
+
+**TriggerCooldown Fields**
+
+| Field Name | Type                  | Required? | Notes                                                        |
+| ---------- | --------------------- | --------- | ------------------------------------------------------------ |
+| Cooldown   | `InteractionCooldown` | **No**    | A cooldown configuration to use for the new, reset cooldown. |
+
+**InteractionCooldown Fields**
+
+| Field Name        | Type                                 | Required? | Notes                                                                                                                                                                                                 |
+| ----------------- | ------------------------------------ | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Id                | `String`                             | **No**    | The cooldown id to use for this cooldown. If not provided, the RootInteraction's cooldown id will be used, if any.                                                                                    |
+| Cooldown          | `Float`<br />(Default: 0.0)          | **No**    | The duration of the cooldown, in seconds.                                                                                                                                                             |
+| Charges           | `Array`<br />(Element Type: `Float`) | **No**    | If provided, a list of how many charges this cooldown can build, and how long each charge takes to build, in seconds.                                                                                 |
+| InterruptRecharge | `Boolean`<br />(Default: false)      | **No**    | If true, the charge time will be reset when the number of charges changes.                                                                                                                            |
+| ClickBypass       | `Boolean`<br />(Default: false)      | **No**    | If true, RootInteractions keyed to this cooldown can still be activated when it is on cooldown provided that the RootInteraction was triggered by a distinct key or mouse button press on the client. |
+
+## Combo Chains
+
+Hytale additionally comes with a rich "combo chaining" system, which allows several inputs in a row to result in different
+attacks and special moves.  Rather than being attached to the RootInteraction like the cooldown system, these are
+primarily driven by the `Chaining` interaction.
+
+### Chaining
+
+This interaction does not inherit from SimpleInteraction and therefore has no Failed field. Its Next field works differently
+from most interaction types.
+
+Chaining is a type of flow control interaction- each time a Chaining interaction with the same `ChainId` is called, a single
+interaction in the `Next` list is chosen and the others are ignored. The first time the `ChainId` is used, the first
+interaction in the list is chosen, the next time the second, etc. Once the end of the list is reached, the first
+interaction will be chosen again.
+
+Bear in mind: the progress through the Next list is based on the **ChainId**, not the interaction!  That means that two
+different Chaining interactions can share a single combo chain. You could have a pair of daggers that attacks with
+the left when the left mouse button is clicked and with the right when the right mouse button is clicked.  You could give
+both interaction chains a Chaining interaction with the same `ChainId` and three `Next` entries that do a light-light-heavy
+combo.  Each specific hit would occur with either the left or the right knife based on which button you clicked, but
+the combo would be otherwise identical regardless of which you chose.
+
+The Chaining interaction also has a concept called "flags".  It is possible to attach named flags to a `ChainId` by using
+the ChainFlag interaction.  Then, you specify the flag name in Chaining's `Flags` field. If a Flag is active when the
+Chaining interaction is run, the Flag's interaction will be run instead of the appropriate interaction in `Next`.
+Bear in mind: the entity's progress through the `Next` list still advances, the resulting `Next` interaction is just not
+run.  Only one flag can be active at a time.
+
+Lastly, it is possible to cancel the entity's progress through the combo chain and reset them to the first interaction in
+the list. This can be done with the CancelChain interaction, but it will also happen automatically if the player does
+not trigger an interaction with the ChainId for the specified ChainingAllowance.  When either of these happen, all flags will be
+canceled as well.
+
+All of these effects are triggered on the User entity only. Non-players can use the chaining system, but Flags do not currently
+work for non-players.  This interaction has no special failure conditions.
+
+**Chaining Fields**
+
+| Field Name        | Type                                                       | Required? | Notes                                                                                                                                                                                                                       |
+| ----------------- | ---------------------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| ChainId           | `String`                                                   | **No**    | If provided, acts as a key that multiple Chaining interactions can use to share combo chain progress and flags. If not provided, a unique ChainId will be generated for this interaction.                                   |
+| ChainingAllowance | `Double`<br />(Default: 0.0)                               | **No**    | If, at the time this interaction is triggered, it has been this long in seconds since the last time a Chaining interaction with the same ChainId was executed, all state for this ChainId will be cleared before execution. |
+| Next              | `AssetArray`<br />(Element Type: `Interaction`)            | **Yes**   | A list of interactions to cycle between each time this interaction is run.                                                                                                                                                  |
+| Flags             | `Map`<br />(Key Type: `String`, Value Type: `Interaction`) | **No**    | A map of flag names to interactions to run if the flag is active when this interaction executes.                                                                                                                            |
+
+### CancelChain
+
+This interaction resets all progress and flag data on the User entity for the provided `ChainId`.  The next time a Chaining
+interaction is called for the provided `ChainId`, it will begin at the first interaction in the `Next` list. This
+interaction has no special failure conditions.
+
+**CancelChain Fields**
+
+| Field Name | Type     | Required? | Notes                                 |
+| ---------- | -------- | --------- | ------------------------------------- |
+| ChainId    | `String` | **Yes**   | A ChainId whose data should be reset. |
+
+### ChainFlag
+
+This interaction activates a flag on the User entity for the provided `ChainId`, which can be used to change behavior the
+next time a Chaining interaction with this `ChainId` is run. This will overwrite any flag that has
+already been raised. This interaction will have no effect for non-players. This interaction has no special failure
+conditions.
+
+| Field Name | Type     | Required? | Notes                                        |
+| ---------- | -------- | --------- | -------------------------------------------- |
+| ChainId    | `String` | **Yes**   | A ChainId on whom the flag should be raised. |
+| Flag       | `String` | **Yes**   | The name of the flag to raise.               |
+
+## Charging
+
+A unique flow-control interaction that is frequently used is the Charging interaction.  It is a flow-control interaction
+that delays while the input button used to trigger the interaction chain is held.  When it is released (or the interaction
+is forced to end), the interaction chain can continue with a different interaction based on how long the input was held
+for.
+
+These interactions are all related by either being the Charging interaction, or other interaction types that inherit the
+Charging interaction's behavior.
+
+### Charging
+
+This interaction does not inherit from SimpleInteraction and therefore its Next field works different from most interactions.
+This interaction adds its own Failed field which works the same way that SimpleInteraction's does.
+
+This interaction only works properly when its interaction chain was triggered by a client key or button press (or
+NPC-simulated equivalent). This interaction will continue executing for as long as the key or button press is held (with
+some exceptions, covered below) by the User entity.  Like other interactions, it has a `Next` field indicating which interaction to execute
+after this one, but the field is a map from `Float` values to `Interaction` assets. When this interaction ends, either
+due to the input being released or the charge duration completing, this interaction will determine the largest `Float` key that is less
+than the amount of time in seconds that the interaction was executing for.  The Interaction mapped to that key will be
+executed next.
+
+The interaction includes some cancellation conditions that are specific to this interaction. For instance, the interaction
+has a `CancelOnOtherClick` field that matches the field on RootInteraction. If it is active on this interaction but not
+the RootInteraction, then clicking while charging will cancel this interaction (and execute the `Failed` interaction rather
+than any of the `Next` interactions) but otherwise continue the interaction chain.
+
+Another valuable feature Charging has is the `Forks` field.  For input-triggered interactions that are triggered while the
+Charging interaction is executing, you can add an entry for the relevant InteractionType to this field and instead of
+triggering the usual interaction chain based on held item, targeted block, etc. the RootInteraction specified in the
+`Forks` field will be triggered.  This can unlock rich attack modes and behaviors. For instance, having a shield bash attack
+triggered off left click while blocking, or a special attack that triggers when both mouse buttons are pressed at the
+same time.
+
+There are two modes of operation for the Charging interaction. One is to have the ability charge for as long
+as the input is held and only end execution when the entity releases the input.  Bows in the main Hytale game work
+that way.  That is accomplished by setting `AllowIndefiniteHold` to true.  Another mode of operation is to have the
+interaction complete execution when the execution time has surpassed the largest key value in the `Next` field and
+immediately begin executing the Interaction mapped to that key.  Food in the main Hytale game work like this.  It
+is accomplished by setting `AllowIndefiniteHold` to false.
+
+One pitfall to be careful of when setting `AllowIndefiniteHold` to false is the way it interacts with cooldowns.\
+Normally, input-initiated interaction chains start a 0.35s cooldown on the triggered RootInteraction that prevents
+holding the mouse button from immediately spamming a new interaction when the first one completes.  However, if the
+duration of a Charging interaction is longer than 0.35s, then the cooldown will have already completed when the
+interaction chain finishes, which will often result in a new execution beginning immediately before the player can
+stop pressing the mouse button.  One solution for this problem is to add a `Simple` interaction to the end of your
+interaction chain with a `RunTime` of 0.35s to simulate the cooldown.  Alternatively, you can add a longer cooldown
+(the maximum duration of your Charging interaction plus 0.35s) to the RootInteraction. However, the longer cooldown is
+not always desirable, as the interaction may have ended prematurely, resulting in an unusually long lockout between
+executions.
+
+**Charging Fields**
+
+| Field Name                         | Type                                                                    | Required? | Notes                                                                                                                                                                                                                                                                                                                                                                                       |
+| ---------------------------------- | ----------------------------------------------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| FailOnDamage                       | `Boolean`<br />(Default: false)                                         | **No**    | If true, this interaction will fail and end immediately if the User entity takes any damage while it is executing.                                                                                                                                                                                                                                                                          |
+| CancelOnOtherClick                 | `Boolean`<br />(Default: true)                                          | **No**    | If true, this interaction will fail and end immediately if the User entity sends another button or key press while it is executing.                                                                                                                                                                                                                                                         |
+| Forks                              | `Map`<br />(Key Type: `InteractionType`, Value Type: `RootInteraction`) | **No**    | A map of InteractionType to RootInteraction. If entity input triggers the InteractionType while this interaction is executing, the mapped RootInteraction will be forked into its own interaction chain. This will happen instead of the usual handling for that InteractionType.  This fork will occur even if `CancelOnOtherClick` is set to true.                                        |
+| Failed                             | `Asset`<br />(Asset Type: `Interaction`)                                | **No**    | After this Interaction has finished, "Failed" will be executed if this Interaction failed.                                                                                                                                                                                                                                                                                                  |
+| AllowIndefiniteHold                | `Boolean`<br />(Default: false)                                         | **No**    | If true, this interaction will continue executing for as long as the User entity continues to hold the input. If false, execution will end as soon as the execution time in seconds reaches the largest key value in the `Next` map.                                                                                                                                                        |
+| DisplayProgress                    | `Boolean`<br />(Default: true)                                          | **No**    | If true, players executing this interaction will see a progress bar will be displayed below their cursor indicating how close to reaching the highest key value in `Next` they are.                                                                                                                                                                                                         |
+| Next                               | `Map`<br />(Key Type: `Float`, Value Type: `Interaction`)               | **No**    | A map from `Float` to `Interaction`.  When this interaction successfully finishes executing (either because the input was released or because the maximum duration was reached), this interaction will find the `Float` value with the largest duration in seconds that is less than the amount of time this interaction executed for. That key's mapped Interaction will then be executed. |
+| MouseSensitivityAdjustmentTarget   | `Float`<br />(Default: 1.0)                                             | **No**    | While charging, this mouse sensitivity multiplier will gradually be applied.                                                                                                                                                                                                                                                                                                                |
+| MouseSensitivityAdjustmentDuration | `Float`<br />(Default: 1.0)                                             | **No**    | Duration in seconds. After this many seconds, `MouseSensitivityAdjustmentTarget` will be fully applied to the mouse sensitivity.                                                                                                                                                                                                                                                            |
+| Delay                              | `ChargingDelay`                                                         | **No**    | Settings that allow charging progress to be pushed back when the User entity takes damage.                                                                                                                                                                                                                                                                                                  |
+
+**ChargingDelay Fields**
+
+| Field Name    | Type                        | Required? | Notes                                                                                                                                                                                                                                                                     |
+| ------------- | --------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| MinHealth     | `Float`<br />(Default: 0.0) | **No**    | Damage taken as a percentage of entity health (0.0-1.0). If a hit deals less than this much damage, no pushback will be applied.  If a hit deals exactly this much damage, `MinDelay` seconds worth of pushback will be applied.                                          |
+| MaxHealth     | `Float`<br />(Default: 0.0) | **No**    | Damage taken as a percentage of entity health (0.0-1.0). If a hit deals at least this much damage, `MaxDelay` seconds worth of pushback will be applied.                                                                                                                  |
+| MinDelay      | `Float`<br />(Default: 0)   | **No**    | The amount of pushback, in seconds, to apply if the entity takes a hit that deals `MinHealth` damage. The amount of pushback applied by a hit is a gradiant between `MinDelay` and `MaxDelay` based on the amount of damage between `MinHealth` and `MaxHealth`.          |
+| MaxDelay      | `Float`<br />(Default: 0)   | **No**    | The amount of pushback, in seconds, to apply if the entity takes a hit that deals at least `MaxHealth` damage. The amount of pushback applied by a hit is a gradiant between `MinDelay` and `MaxDelay` based on the amount of damage between `MinHealth` and `MaxHealth`. |
+| MaxTotalDelay | `Float`<br />(Deault: 0)    | **No**    | The maximum amount of pushback the entity can receive over the course of a single charge, regardless of how many times they are hit.                                                                                                                                      |
+
+**InteractionType Values**
+
+- `Primary`
+- `Secondary`
+- `Ability1`
+- `Ability2`
+- `Ability3`
+- `Use`
+- `Pick`
+- `Pickup`
+- `CollisionEnter`
+- `CollisionLeave`
+- `Collision`
+- `EntityStatEffect`
+- `SwapTo`
+- `SwapFrom`
+- `Death`
+- `Wielding`
+- `ProjectileSpawn`
+- `ProjectileHit`
+- `ProjectileMiss`
+- `ProjectileBounce`
+- `Held`
+- `HeldOffhand`
+- `Equipped`
+- `Dodge`
+- `GameModeSwap`
+
+### Wielding
+
+This interaction is inherited from Charging rather than SimpleInteraction.  However, its `Failed` and `Next` fields function
+identically to SimpleInteraction.  It does not inherit all fields from Charging, so be sure to pay close attention to
+the field list below.
+
+This interaction drives most blocking behavior in the game. While this interaction is executing, attacks made against
+the Owner entity will (conditionally) trigger effects defined in this interaction.  Unlike the Charging interaction,
+this interaction can always execute indefinitely and will only end when it fails or when the input is released.
+
+One option available in Wielding is `AngledWielding`, which allows damage and knockback modifiers to only be applied
+depending on the direction the attack against the Owner entity is coming from.  The AngledWielding type has a
+field `Angle` which determines which direction the protection points relative to the player (0 is the player's
+front), and `AngleDistance` which determines how wide the cone of protection extends around the player.  Block effects
+from this interaction (such as `BlockedEffects`, `BlockedInteractions`, and `StaminaCost`) will only apply if
+the DamageCause matches `DamageModifiers` OR if the DamageCause matches `AngledWielding.DamageModifiers` and
+the source of the damage matches `Angle` and `AngleDistance`.  It is possible for damage and knockback multipliers
+specified on both this interaction's modifier fields and `AngledWielding`'s modifier fields to stack, if both
+have entries for the same DamageCause.
+
+This interaction will only have an effect on damage taken by one of the DamageCause entries in `DamageModifiers` or
+`AngledWielding.DamageModifiers`.  If a DamageCause is in `DamageModifiers`, then the block effect will be triggered
+and the damage modifier applied regardless of what direction the Owner entity is attacked from.  If a DamageCause is in
+`AngledWielding.DamageModifiers`, then the damage modifier is only applied if the
+
+\*\* Wielding Fields\*\*
+
+| Field Name          | Type                                                                    | Required? | Notes                                                                                                                                                                                                                                                                                                                                                                                                      |
+| ------------------- | ----------------------------------------------------------------------- | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| FailOnDamage        | `Boolean`<br />(Default: false)                                         | **No**    | If true, this interaction will fail and end immediately if the User entity takes any damage while it is executing.                                                                                                                                                                                                                                                                                         |
+| CancelOnOtherClick  | `Boolean`<br />(Default: true)                                          | **No**    | If true, this interaction will fail and end immediately if the User entity sends another button or key press while it is executing.                                                                                                                                                                                                                                                                        |
+| Forks               | `Map`<br />(Key Type: `InteractionType`, Value Type: `RootInteraction`) | **No**    | A map of InteractionType to RootInteraction. If entity input triggers the InteractionType while this interaction is executing, the mapped RootInteraction will be forked into its own interaction chain. This will happen instead of the usual handling for that InteractionType.  This fork will occur even if `CancelOnOtherClick` is set to true (after which this interaction chain will be canceled). |
+| Next                | `Asset`<br />(Asset Type: `Interaction`)                                | **No**    | After this interaction has finished, "Next" will be executed if this interaction did not fail.                                                                                                                                                                                                                                                                                                             |
+| Failed              | `Asset`<br />(Asset Type: `Interaction`)                                | **No**    | After this interaction has finished, "Failed" will be executed if this interaction failed.                                                                                                                                                                                                                                                                                                                 |
+| DamageModifiers     | `Map`<br />(Key Type: `DamageCause`, Value Type: `Float`)               | **No**    | A map from DamageCause to Float, where the Float is multiplied against any damage received from the mapped DamageCause while this interaction is executing.                                                                                                                                                                                                                                                |
+| KnockbackModifiers  | `Map`<br />(Key Type: `DamageCause`, Value Type: `Float`)               | **No**    | A map from DamageCause to Float, where the Float is multiplied against any knockback force received from the mapped DamageCause while this interaction is executing.                                                                                                                                                                                                                                       |
+| AngledWielding      | `AngledWielding`                                                        | **No**    | Configuration to only trigger block effects from certain angles.                                                                                                                                                                                                                                                                                                                                           |
+| StaminaCost         | `StaminaCost`                                                           | **No**    | If the Owner entity receives damage that matches `DamageModifiers` or `AngledWielding` while this interaction is executing, then the entity's stamina will be deducted according to this configuration.                                                                                                                                                                                                    |
+| BlockedEffects      | `DamageEffects`                                                         | **No**    | If the Owner entity receives damage that matches `DamageModifiers` or `AngledWielding` while this interaction is executing, then these effects will be applied to the instance of damage.                                                                                                                                                                                                                  |
+| BlockedInteractions | `Asset`<br />(Asset Type: `RootInteraction`)                            | **No**    | If the Owner entity receives damage that matches `DamageModifiers` or `AngledWielding` while this interaction is executing, then this RootInteraction will be launched as a brand new interaction chain with the Owner entity as both Owner and User, and the attacker as the Target entity.  This new interaction chain is, notably, brand new, **not** forked from the current one.                      |
+
+**AngledWielding Fields**
+
+| Field Name         | Type                                                      | Required? | Notes                                                                                                                                                                                                            |
+| ------------------ | --------------------------------------------------------- | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Angle              | `Float`<br />(Default: 0.0)                               | **No**    | Angle in degrees relative to the Owner entity where the angled protection is centered. 0.0 means pointed towards the front of the Owner entity.                                                                  |
+| AngleDistance      | `Float`<br />(Default: 0.0)                               | **No**    | Angle in degrees indicating how wide the cone of protection is.                                                                                                                                                  |
+| DamageModifiers    | `Map`<br />(Key Type: `DamageCause`, Value Type: `Float`) | **No**    | A map from DamageCause to Float, where the Float is multiplied against any damage received from the mapped DamageCause received from within the cone of protection while this interaction is executing.          |
+| KnockbackModifiers | `Map`<br />(Key Type: `DamageCause`, Value Type: `Float`) | **No**    | A map from DamageCause to Float, where the Float is multiplied against any knockback force received from the mapped DamageCause received from within the cone of protection while this interaction is executing. |
+
+**StaminaCost Fields**
+
+| Field Name | Type                                             | Required? | Notes                                                                                                                                                                                                                                                |
+| ---------- | ------------------------------------------------ | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| CostType   | `CostType`<br />(Default: `MaxHealthPercentage`) | **No**    | How to calculate stamina consumed by blocking from the raw pre-block damage. If `Damage`, then the stamina consumed will be `rawDamage / Value`. If `MaxHealthPercentage`, then the stamina consumed will be `rawDamage / (EntityMaxHealth * Value)` |
+| Value      | `Float`<br />(Default: 0.04)                     | **No**    | The value to use in the `CostType` formula.                                                                                                                                                                                                          |
+
+**DamageEffects Fields**
+
+| Field Name             | Type                                         | Required? | Notes                                                                           |
+| ---------------------- | -------------------------------------------- | --------- | ------------------------------------------------------------------------------- |
+| ModelParticles         | `Array`<br />(Element Type: `ModelParticle`) | **No**    | Particle systems to trigger in the first-person view.                           |
+| WorldParticles         | `Array`<br />(Element Type: `WorldParticle`) | **No**    | Particle systems to trigger in the third-person view.                           |
+| LocalSoundEventId      | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | 2D sound to play locally to the attacking entity if they are a player.          |
+| WorldSoundEventId      | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | Sound to play in the world at the Owner entity's location.                      |
+| PlayerSoundEventId     | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | 2D sound to play locally to the Owner entity if they are a player.              |
+| ViewDistance           | `Double`<br />(Default: 75.0)                | **No**    | Distance at which these effects should play for other players.                  |
+| Knockback              | `Knockback`                                  | **No**    | The properties of the knockback that will be applied.                           |
+| CameraEffect           | `Asset`<br />(Asset Type: `CameraEffect`)    | **No**    | CameraEffect to briefly apply locally to the Owner entity if they are a player. |
+| StaminaDrainMultiplier | `Float`<br />(Default: 1.0)                  | **No**    | This multiplier is applied to the `StaminaCost`, if any.                        |
+
+**Knockback Fields**
+
+| Field Name     | Type                                       | Required? | Notes                                                                                                                      |
+| -------------- | ------------------------------------------ | --------- | -------------------------------------------------------------------------------------------------------------------------- |
+| Type           | `String`                                   | **No**    | If provided, specifies a type of knockback to use. Each knockback type may come with additional fields.                    |
+| Force          | `Double`<br />(Default: 0.0)               | **No**    | The amount of force to apply to the Owner entity.                                                                          |
+| Duration       | `Double`<br />(Default: 0.0)               | **No**    | If 0.0, apply the force as a single impulse.  If more, continuously apply the force over a period of time.                 |
+| VelocityType   | `ChangeVelocityType`<br />(Default: `Add`) | **No**    | How to apply the force, either adding it to the entity's current velocity, or setting the velocity to the knockback force. |
+| VelocityConfig | `VelocityConfig`                           | **No**    | Characteristics of friction as the Owner entity is thrown by this knockback.                                               |
+
+**Knockback Type: Force**
+
+Apply the calculated knockback force along the provided direction.
+
+| Field Name | Type                         | Required? | Notes                                                                                |
+| ---------- | ---------------------------- | --------- | ------------------------------------------------------------------------------------ |
+| Direction  | `Vector3`<br />(Default: Up) | **No**    | Which direction the player should be flung, relative to the direction of the attack. |
+
+**Knockback Type: Point**
+
+Apply the calculated knockback force laterally along the XZ plane, plus provided Y velocity.
+
+| Field Name | Type                        | Required? | Notes                                                                                                   |
+| ---------- | --------------------------- | --------- | ------------------------------------------------------------------------------------------------------- |
+| OffsetX    | `Integer`<br />(Default: 0) | **No**    | Offset the source position of the knockback left or right perpendicular to the direction of the attack. |
+| OffsetZ    | `Integer`<br />(Default: 0) | **No**    | Offset the source position of the knockback, forward or backward along the directon of the attack.      |
+| RotateY    | `Integer`<br />(Default: 0) | **No**    | Rotate the knockback direction around the Y axis, where 0 is the default attack direction.              |
+| VelocityY  | `Float`<br />(Default: 0.0) | **No**    | Add vertical velocity to the knockback force after the direction and force has been calculated.         |
+
+**Knockback Type: Directional**
+
+Apply the calculated knockback force along the attack direction, removing any vertical component and replacing it with a provided Y velocity.
+
+| Field Name | Type                      | Required? | Notes                                                                                                                                            |
+| ---------- | ------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------ |
+| RelativeX  | `Float`<br />(Default: 0) | **No**    | Apply additional force left or right perpendicular to the direction of the attack. The additional force is multiplied by the knockback strength. |
+| RelativeZ  | `Float`<br />(Default: 0) | **No**    | Apply additional force forward or backward along the attack direction. The additional force is multiplied by the knockback strength.             |
+| VelocityY  | `Float`<br />(Default: 0) | **No**    | Replace the vertical velocity of the knockback with this value.  This value is not multiplied by knockback strength.                             |
+
+**VelocityConfig Fields**
+
+| Field Name          | Type                                              | Required? | Notes                                                                                                                                                                                           |
+| ------------------- | ------------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| GroundResistance    | `Float`<br />(Default: 0.82)                      | **No**    | The minimum amount of friction applied when the entity is in contact with the ground.  1.0 = no friction, 0.0 = total friction                                                                  |
+| GroundResistanceMax | `Float`<br />(Default: 0.0)                       | **No**    | The maximum amount of friction applied when the entity is in contact with the ground.  1.0 = no friction, 0.0 = total friction                                                                  |
+| AirResistance       | `Float`<br />(Default: 0.96)                      | **No**    | The minimum amount of friction applied when the entity is in the air. 1.0 = no friction, 0.0 = total friction                                                                                   |
+| AirResistanceMax    | `Float`<br />(Default: 0.0)                       | **No**    | The maximum amount of friction applied when the entity is in the air. 1.0 = no friction, 0.0 = total friction                                                                                   |
+| Threshold           | `Float`<br />(Default: 1.0)                       | **No**    | The speed at which the maximum amount of friction will be applied to the entity. The amount of friction applied will increase from minimum to maximum as the entity moves from 0 to this speed. |
+| Style               | `VelocityThresholdStyle`<br />(Default: `Linear`) | **No**    | The curve that friction follows as the entity's speed increases toward the `Threshold`.                                                                                                         |
+
+**CostType Values**
+
+- `MaxHealthPercentage`
+- `Damage`
+
+**ChangeVelocityType Values**
+
+- `Add`
+- `Set`
+
+**VelocityThresholdStyle Values**
+
+- `Linear`
+- `Exp`
+
+## Blocks
+
+These are interaction types meant to reason about and modify blocks in the world.  The most important concept unique
+to these interactions is the Block Target.  Like the Entity Target, it is mutable and can come from many places.
+However, for interaction chains initiated by the client, the block target will initially be the block that the player's cursor was
+over, if any.
+
+Additionally, for interaction chains initiated by the client, the client will send along which face of the block is targeted,
+which is used by a few block-related interactions.
+It is left up to each interaction type that cares about block faces as to how to handle this behavior for simulated input
+(i.e. NPCs initiating chains that are normally initated by the client).  At the time of this writing, all block-related
+interactions choose the top face where relevant in simulated input.
+
+### BlockCondition
+
+This interaction has a field `Matchers` which specifies certain conditions, such as block type, state, etc.  This
+interaction fails if the current target block does not match all of them.
+
+**BlockCondition Fields**
+
+| Field Name       | Type                                        | Required? | Notes                                                                                                                                                                                                                                                                                                                                   |
+| ---------------- | ------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false)             | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction.                                                                                                                                                                                                       |
+| Matchers         | `Array`<br />(Element Type: `BlockMatcher`) | **Yes**   | A list of conditions that the target block must match or this condition will fail.<br />**Note: This field is technically not required but there is a bug that makes it dangerous to not provide at the time of this writing.**<br />**Note: If no conditions are added to this array, the interaction will fail, counterintuitively.** |
+
+**BlockMatcher Fields**
+
+| Field Name | Type                       | Required? | Notes                                                                          |
+| ---------- | -------------------------- | --------- | ------------------------------------------------------------------------------ |
+| Block      | `BlockIdMatcher`           | **No**    | If provided, requires the block itself match some set of conditions.           |
+| Face       | `BlockFace`                | **No**    | If provided and not 'None', requires a specific block face be targeted.        |
+| StaticFace | `Boolean` (Default: false) | **No**    | If false, the face condition will be adjusted by the block's current rotation. |
+
+**BlockFace Values**
+
+- `Up`
+- `Down`
+- `North`
+- `South`
+- `East`
+- `West`
+- `None`
+
+**BlockIdMatcher Fields**
+
+| Field Name | Type                                   | Required? | Notes                                                                      |
+| ---------- | -------------------------------------- | --------- | -------------------------------------------------------------------------- |
+| Id         | `Asset`<br />(Asset Type: `BlockType`) | **No**    | If provided, the block must match the specified `BlockType`.               |
+| State      | `String`                               | **No**    | If provided, the block's current state must match the provided state name. |
+| Tag        | `String`                               | **No**    | If provided, the block type's asset tags must contain the provided tag.    |
+
+### DestroyCondition
+
+This interaction fails if the current User entity cannot destroy the current target blcok.
+
+**DestroyCondition Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+
+### PlacementCountCondition
+
+This interaction accepts the name of a BlockType that has the TrackedPlacement BlockEntity. The interaction will fail if the number of
+blocks of the provided BlockType in the world do not match the provided condition.
+
+**PlacementCountCondition Fields**
+
+| Field Name | Type                           | Required? | Notes                                                                                                                                                                                                                                                           |
+| ---------- | ------------------------------ | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Block      | `String`                       | **Yes**   | The BlockType to examine. The number of instances of the BlockType in the world will be compared to Value.<br />**Note: The specified BlockType must have the TrackedPlacement BlockEntity. Otherwise, the number of blocks in the world will always be zero.** |
+| Value      | `Integer`<br />(Default: 0)    | **No**    | The value to compare the number of blocks in the world with.                                                                                                                                                                                                    |
+| LessThan   | \`Boolean<br />(Default: true) | **No**    | If true, the interaction will fail if the number of blocks in the world is greater than or equal to Value. If false, the interaction will fail if the number of blocks in the world is less than or equal to Value.                                             |
+
+### BreakBlock
+
+This interaction attempts to break the target block while acting as the User entity. The User entity must be a player. It
+is not guaranteed to work, depending on world settings and the User entity's current state, it may not work.  If it
+fails, it will fail the interaction under some circumstances, but not others.
+
+**Note: In particular, if `Harvest`=false and the player is in Survival mode, the player will simply execute a damage operation
+against the block. Even when the Tool field is specified, the player's currently-held item can impact the results in unintuitive
+ways.**
+
+This interaction will fail if there is no block target, if `Harvest`=true and the
+block is not harvestable, or if the world settings prevent the Harvest/Break operation.
+It will generally not fail otherwise, even if the block was not broken or damaged.
+The block will generally break every time if `Harvest`=true or the player is in
+Creative mode.
+
+**BreakBlock Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                                                                                                                                                                                                  |
+| ---------------- | ------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction.                                                                                                                                                                      |
+| Harvest          | `Boolean` (Default: false)      | **No**    | If true, harvest the block and deposit the drops in the player's inventory. This operation will generally always succeed.  If false, this interaction will effectively perform whatever action would have occurred if the player had left-clicked the block.                                           |
+| Tool             | `String`                        | **No**    | If `Harvest`=true, the player is in Survival mode, and this field is provided, then the break operation will be performed as though with this tool type.<br />**This field mostly doesn't work.  Your held item will be used for most block damage calculations regardless of this field's contents.** |
+| MatchTool        | `Boolean` (Default: false)      | **No**    | If true, `Harvest`=true, the player is in Survival mode, and `Tool` is provided, block breaking will be prevented unless `Tool` is a valid gathering tool for the target block. The interaction will not be failed, even if block breaking is prevented in this manner.                                |
+
+### ChangeBlock
+
+This interaction requires a mapping from one or more current BlockTypes to one or more target BlockTypes.  If the
+target block is one of the key BlockTypes, then it will be changed to the mapped target BlockType.  If the current
+BlockType of the target block does not appear as a key in the Changes field, then this interaction fails.
+
+**ChangeBlock Fields**
+
+| Field Name        | Type                                                        | Required? | Notes                                                                                                                             |
+| ----------------- | ----------------------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget  | `Boolean`<br />(Default: false)                             | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+| Changes           | `Map`<br />(Key Type: `BlockType`, Value Type: `BlockType`) | **No**    | A list of potential block type changes, with each entry having a current and new BlockType id.                                    |
+| WorldSoundEventId | `Asset`<br />(Asset Type: `SoundEvent`)                     | **No**    | If provided, this SoundEvent is played in the world at the position of the block if the block successfully changes.               |
+| RequireNotBroken  | `Boolean`<br />(Default: false)                             | **No**    | If true, this interaction will fail if the player's held item is broken (durability 0), and the block change will not take place. |
+
+### ChangeState
+
+This interaction requires a mapping from one or more current block state names to one or more state names. If the
+target block is in one of the key block states, then it will be changed to the mapped target blocks tate. If the
+current block state of the target block does nto appear as a key in the Changes field, then this interaction fails.
+
+All blocks start out with a null state by default.  This null state can be referenced by the key "default" and the block
+can be returned to that state with the value "default".
+
+**ChangeState Fields**
+
+| Field Name       | Type                                                  | Required? | Notes                                                                                                                                          |
+| ---------------- | ----------------------------------------------------- | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false)                       | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction.              |
+| Changes          | `Map`<br />(Key Type: `String`, Value Type: `String`) | **No**    | A list of potential block state changes, with each entry having a current and new state name.                                                  |
+| UpdateBlockState | `Boolean`<br />(Default: false)                       | **No**    | If true, performs a full refresh of the block's BlockEntity component and notifies nearby players as though a full block type change occurred. |
+
+### CycleBlockGroup
+
+This interaction will attempt to change the target block to the next block type in one of the BlockGroups it belongs to.
+If the block type belongs to multiple BlockGroups, which one is used is effectively arbitrary. The User entity must be
+a player. If the block cannot be changed for any reason (entity not a player, no block target, block does not belong
+to a BlockGroup, etc.). If the block is the only entry in the BlockGroup, this interaction will succeed and the block
+will be considered changed despite nothing happening.  Unlike most other block-changing interactions, this one will
+fail if the world settings prevent players from breaking blocks.
+
+**This interaction always reduces the player's held item's durability by a single 'hit' worth of damage if the block
+changes. There is no way to prevent it. The block type will change and the interaction will succeed even if the player's
+held item is broken, however.**
+
+**CycleBlockGroup Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+
+### DestroyBlock
+
+This interaction destroys the target block without dropping anything.  It will successfully destroy the block if the
+target block exists and this interaction has no failure conditions.
+
+**This interaction has no additional fields.**
+
+### PickBlock
+
+This interaction is effectively equivalent to using the middle mouse button in creative mode. In survival mode, the
+block's item will be moved to the user's current active hotbar slot if it is in the player's inventory.  This
+interaction is performed entirely on the client and cannot be performed by non-players.  It is unclear if this
+interaction has failure conditions.
+
+**PickBlock Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+
+### PlaceBlock
+
+This interaction is effectively identical to a right clicking while holding a block in their hand, with some
+additional options. For one, it can be executed with any LivingEntity as the User entity. For another, it has some
+useful fields.  For the most part, though, it follows the same behaviors and rules as any ordinary block placement
+by a player.
+
+It's not clear under what circumstances this interaction can fail. The server will not fail the interaction under any
+special circumstances (including when there is no target block, or when `BlockTypeToPlace` is not provided and the
+LivingEntity is not holding a block). However, the client is very involved with the function of this interaction and
+its behavior is unknown.
+
+**PlaceBlock Fields**
+
+| Field Name         | Type                                   | Required? | Notes                                                                                                                                                                                                                                                                                                                                                           |
+| ------------------ | -------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| BlockTypeToPlace   | `Asset`<br />(Asset Type: `BlockType`) | **No**    | If provided, the block placed by this interaction will be the specified BlockType. If not provided, the User entity's held item will be used, instead, if it is a block.                                                                                                                                                                                        |
+| RemoveItemInHand   | `Boolean`<br />(Default: True)         | **No**    | If true and the User entity is not a player in Creative mode, the item in the player's hand must match the block being placed and one quantity will be removed for each block placed. If the item does not match, the block cannot be placed.  If false, the player's hand item is ignored entirely.\*\*                                                        |
+| AllowDragPlacement | `Boolean`<br />(Default: True)         | **No**    | If true and the interaction was triggered on the client by a player, then the player can hold the input that was used to activate this interaction chain and move the mouse around in order to execute this interaction repeatedly and place several blocks. The interaction chain will not move onto the next interaction until the player releases the input. |
+
+### RunOnBlockTypes
+
+This interaction retrieves all blocks within a provided radius of the User entity. For each block that matches any of
+the provided BlockSets, a new interaction chain will be forked that uses the matching block as the target block.
+This interaction will continue executing until all forked interaction chains have completed.  The interaction will fail if no
+blocks within the radius match the provided BlockSets or if all of the forked interaction chains fail.
+
+**RunOnBlockTypes Fields**
+
+| Field Name   | Type                                         | Required?        | Notes                                                                                                                                                                                                                                                                                      |
+| ------------ | -------------------------------------------- | ---------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| Range        | `Integer`                                    | **Yes**          | The spherical radius around the User entity to search for blocks. Must be at least 1.                                                                                                                                                                                                      |
+| BlockSets    | `AssetArray`<br />(Element Type: `BlockSet`) | **No**           | A list of BlockSets to match nearby blocks again. Only blocks that match any of the BlockSets will have interaction chains forked for them.                                                                                                                                                |
+| MaxCount     | `Integer`                                    | **Yes**          | The maximum number of blocks that will be located with the search. Further blocks will be ignored. If there are more matching blocks within the radius than this number, the specific set of blocks that will be found is completely arbitrary and may change from execution to execution. |
+| Interactions | `Asset`<br />(Asset Type: `RootInteraction`) | **No, but yes.** | The RootInteraction that will be forked for each matching block.  This interaction will not fail to validate if it is missing, but every execution of this interaction will fail.                                                                                                          |
+
+### UseBlock
+
+If the target block has an interaction for this interaction chain's interaction type, execute it immediately as part of
+this interaction chain. The execution will be wrapped in UseBlockEvent.Pre and UseBlockEvent.Post events, and cancellations
+of the UserBlockEvent.Pre event are respected. The User entity is considered the triggering entity for both events.
+
+If the target block does not have an interaction for this interaction chain's interaction type, this interaction fails.
+
+**This interaction has no additional fields.**
+
+## Items
+
+These are interactions intended to interface with an entity's inventory. There is no concept of an "item target",
+unfortunately, so these generally either interact with the entity's held item or the entity's inventory at a high level.
+
+### AddItem
+
+Adds a specified quantity of a specified item to the User entity's inventory, preferring to add it to the
+entity's hotbar where possible. This interaction will have no effect on User entities that are not LivingEntities.
+This interaction has no failure states.
+
+**Note: This interaction has a bug in its field validators that will cause interactions that reference items declared
+in the same mod to fail validation on startup.  Additionally, this interaction has a bug that will cause it to
+fail and have no effect if the User entity has no block target. Use ModifyInventory instead.**
+
+**AddItem Fields**
+
+| Field Name       | Type                              | Required? | Notes                                                                                                                             |
+| ---------------- | --------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false)   | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+| ItemId           | `Asset`<br />(Asset Type: `Item`) | **Yes**   | The item id of the item to add to the player's inventory.                                                                         |
+| Quantity         | `Integer`<br />(Default: 0)       | **No**    | The quantity of the item to add to the player's inventory.                                                                        |
+
+### CheckUniqueItemUsage
+
+This interaction will check whether it has run once for the User entity with their currently-held item before. If it hasn't,
+it will succeed. If it has, it will fail. It will also fail if the User entity is not a player. The interaction will record
+the item id of the User entity's currently-held item on success, ensuring it cannot be successfully run with that player
+and item id combination again.
+
+**This interaction has no additional fields.**
+
+### ChangeActiveSlot
+
+This interaction does not inherit from SimpleInteraction and therefore has no Next or Failed fields.  The `CancelOnItemChange`
+field is ignored for this interaction and is always treated as false. This interaction will set the User entity's currently-
+active hotbar slot to the specified slot index. If none is specified, the interaction chain's target slot will be used,
+if any. Otherwise, slot 0 will be used.  If a slot is specified and it is already active, then this interaction will
+have no effect, but if no slot is specified and the interaction chain's target slot is already active, the logic in
+the next paragraph will still be executed. This interaction will also have no effect if the User entity is not a
+LivingEntity.
+
+Once the slot has changed, a new SwapTo interaction chain will be forked off for the selected slot.
+If a target slot was specified, then the interaction chain's current target slot will be set to the specified slot, as will
+the forked SwapTo interaction chain. If this interaction chain was initiated by a player swapping an item into or out of
+an occupied active hotbar slot, then the swap will be executed after the slot is changed and before the SwapTo
+interaction is forked. Not running this interaction in the resulting SwapFrom interaction chain is a way for the server
+to cancel players performing these sorts of swap interactions. The default behavior for these swap interactions is that
+the SwapFrom interaction chain will be initiated with the currently-active-slot as the target slot. As a result, the
+target slot will usually not change when this interaction runs, it merely exists as a signal for the server to continue the
+item swap.
+
+**ChangeActiveSlot Fields**
+
+| Field Name | Type      | Required? | Notes                                                                                                                                                                                                     |
+| ---------- | --------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| TargetSlot | `Integer` | **No**    | If not provided, indicates the slot the player's active hotbar slot should be changed to.  Otherwise, the interaction chain's target slot will be used (which is usually the already-active hotbar slot). |
+
+### EquipItem
+
+This interaction will equip the User entity's currently-held item into the appropriate armor slot, if it is armor. The
+interaction will fail if the item is armor but it cannot be equipped for some reason. The interaction will succeed but
+take no action if the User entity cannot equip armor or if the item is not armor.
+
+**This interaction has no additional fields.**
+
+### IncreaseBackpackCapacity
+
+This interaction will increase the User entity's backpack size by the provided amount.  **It will additionally remove one
+quantity from the player's currently-held item. There is no way to prevent this.**  This interaction will have no effect
+if the User entity is not a player.  This interaction has no special failure conditions, even if the User entity
+is not a player, or the player is not currently holding an item.
+
+| Field Name | Type                        | Required? | Notes                                                                                   |
+| ---------- | --------------------------- | --------- | --------------------------------------------------------------------------------------- |
+| Capacity   | `Integer`<br />(Default: 1) | **No**    | The additional backpack capacity to add to the player. **Must be between 1 and 32767.** |
+
+### ModifyInventory
+
+This interaction attempts to perform one or more inventory-modifying actions against the User entity. The User entity must
+be a player. If they are not, no actions will be performed, but the interaction will not fail. Any item removals performed
+by this interaction, either as a result of `ItemToRemove` or `AdjustHeldItemQuantity`, are both atomic (meaning the entire
+quantity must be removed, or none) and required (meaning that the interaction will fail and no further actions taken if
+the removal fails for any reason).  Item additions performed by this interaction, either as a result of `ItemToAdd` or
+`AdjustHeldItemQuantity` will drop excess items on the ground near the player if necesary and continue on.
+
+This interaction first executes the item removal in `ItemToRemove`, if any, then adjusts the held item as specified by
+`AdjustHeldItemQuantity`, if provided, then executes the item addition in `ItemToAdd`, if any, and then finally executes
+the damage/healing of the held item in `AdjustHeldItemDurability`, if provided.
+
+**ModifyDurability Fields**
+
+| Field Name               | Type                            | Required? | Notes                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
+| ------------------------ | ------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| RequiredGameMode         | `GameMode`                      | **No**    | If provided, only execute the inventory-modifying actions if the player is in the provided GameMode. The interaction will not fail if the GameMode doesn't match.                                                                                                                                                                                                                                                                                                                                                                               |
+| ItemToRemove             | `ItemStack`                     | **No**    | If provided, a matching item will be removed in the provided quantity. If there is no matching item in the player inventory in the required quantity, then the interaction will fail and further actions will not be executed.                                                                                                                                                                                                                                                                                                                  |
+| AdjustHeldItemQuantity   | `Integer`<br />(Default: 0)     | **No**    | The player's held item, if any, will have its quantity will be modified by the provided amount- subtracted from if this number is negative or added to if this item is positive.  If the player has no held item, then this field will have no effect regardless of its value and the interaction will NOT fail.  If the player's inventory does not have sufficient quantity of items to support the removal, this interaction will fail and further actions will not be executed. Excess items will be dropped on the ground near the player. |
+| ItemToAdd                | `ItemStack`                     | **No**    | If provided, the ItemStack will be added to the player's inventory. Excess items will be dropped on the ground near the player.                                                                                                                                                                                                                                                                                                                                                                                                                 |
+| AdjustHeldItemDurability | `Double`<br />(Default: 0.0)    | **No**    | The player's held item, if any, will have its durability adjusted by the specified amount.  The durability cannot go below 0 or raise above the item's maximum durability. Invalid durability values in this field will not cause the interaction to fail. Neither will it fail if the player has no held item.                                                                                                                                                                                                                                 |
+| BrokenItem               | `String`                        | **No**    | This field should contain an ItemId, but it is not validated by the server on startup, so be careful.  This field can have the value of "Empty" to specify no item, or an empty hand. If specified and the `AdjustHeldItemDurability` operation reduces the player's held item to 0 durability, the player's held item is changed to this ItemId. If the inventory replacement fails, this interaction will fail.                                                                                                                               |
+| NotifyOnBreak            | `Boolean`<br />(Default: false) | **No**    | If true and the `AdjustHeldItemDurability` operation reduces the player's held item to 0 durability, this interaction will perform the usual audiovisual feedback of a broken tool. It will play the usual tool breaking sound and send the player a text message in chat that their item has broken.                                                                                                                                                                                                                                           |
+| NotifyOnBreakMessage     | `String`                        | **No**    | If provided, and `NotifyOnBreak` is true, when the player is notified of a broken tool by this interaction, the message sent to their chat will instead be the translation key specified by this field. The translation key supports the templating parameter `{itemName}`. See the translation key `server.general.repair.itemBroken_Hoe` for an example.                                                                                                                                                                                      |
+
+**GameMode Values**
+
+- `Creative`: The game is currently in Creative Mode
+- `Adventure`: The game is currently in Adventure Mode
+
+**ItemStack Fields**
+
+| Field Name                   | Type                              | Required? | Notes                                                                                |
+| ---------------------------- | --------------------------------- | --------- | ------------------------------------------------------------------------------------ |
+| Id                           | `Asset`<br />(Asset Type: `Item`) | **Yes**   | The id of the Item asset this stack contains.                                        |
+| Quantity                     | `Integer`<br />(Default: 1)       | **No**    | The number of items in this stack.<br />**Must be greater than 0.**                  |
+| Durability                   | `Double`<br />(Default: 0.0)      | **No**    | The durability of the item stack.<br />**Cannot be negative.**                       |
+| MaxDurability                | `Double`<br />(Default: 0.0)      | **No**    | The maximum durability of the item this stack contains.<br />**Cannot be negative.** |
+| Metadata                     | `Bson Document`                   | **No**    | If provided, applies the bson to the item stack metadata.                            |
+| OverrideDroppedItemAnimation | `Boolean`\*(Default: false)       | **No**    | ???                                                                                  |
+
+### PickupItem
+
+This interaction will attempt to pick up the User entity's current target entity and add it to their inventory. It will
+fail if the User entity is not a player, if they do not have a target entity, or if the target entity is not an item
+located in the world.  It will not fail if the player simply cannot pick up the item.
+
+**This interaction has no additional fields.**
+
+### RefillContainer
+
+This interaction will fail if the User entity is not a player. The interaction will draw a ray from the player's head
+down their look direction until the edge of the player's held item's interaction range or until the first solid block.
+The nearest fluid block of a type listed in this interaction's `States` map will result in the one of the player's
+currently-held items being converted to the fluid's related item state.  If the `States` map indicates a durability
+for the new item state, then the converted item will use that durability. If the item is already in the fluid's related
+item state, then this interaction will fail if the player's held item is already at maximum durability (unless the
+`States` map indicates a durability value greater than the item's maximum, in which case the interaction will succeed
+but the item will not change).  Otherwise, the durability listed for the fluid in the `States` map will be added to the
+item's current durability.
+
+If the interaction has not failed by this point, the fluid block in the world may be transformed to a different type if one is listed
+in the `States` map.
+
+If any part of this process does not proceed for any reason (for instance, if the player is not holding an item),
+then this interaction will fail.
+
+**RefillContainer Fields**
+
+| Field Name | Type                                                       | Required? | Notes                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| ---------- | ---------------------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| States     | `Map`<br />(Key Type: `String`, Value Type: `RefillState`) | **Yes**   | A map from item state names to `RefillState` objects, which contain information such as acceptable fluid block types, durability increases, and what fluid type to convert the targeted fluid block to after refill, if any. If the player targets a fluid block that matches one of the fluid types in the `RefillState`, the item will be converted to the keyed item state and the `RefillState` will be used to decide what happens next. |
+
+**RefillState Fields**
+
+| Field Name     | Type                                  | Required? | Notes                                                                                                                                                                                                                                                                                                                           |
+| -------------- | ------------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| AllowedFluids  | `Array`<br />(Element Type: `String`) | **Yes**   | If any of these fluids are targeted by the player, the player's held item will be converted to the keyed item state and `Durability` and `TransformFluid` will be used.                                                                                                                                                         |
+| Durability     | `Double`<br />(Default: -1.0)         | **No**    | If the player's held item changes item states, this value is the new item's durability, unless it is negative, in which case the item will begin at full durability. If the player's held item is already in the item state, and the item is not already at full durability, this value will be added to the item's durability. |
+| TransformFluid | `String`                              | **No**    | If provided, this field is a fluid id that the targeted fluid block should be transformed to if the player's held item is successfully updated.                                                                                                                                                                                 |
+
+## Entities
+
+### DamageEntity
+
+This interaction does not inherit from SimpleInteraction, but adds its own Next and Failed fields that
+work similarly.
+
+This interaction will cause the User entity to damage the Target entity.  It has the capability to apply different
+damage based on the direction of the attack or what body part was targeted by the User entity, with each possibility
+providing different damage calculations, effects, and Next interaction. If multiple entires match the attack, `TargetedDamage`
+(body part damage) takes highest priority, then the first matching `AngledDamage` in the list, then the default
+damage in the base interaction fields.  It is possible for elements of these different damage priorities to be taken peacemeal if higher-priority
+damage fields do not overwrite lower-priority damage fields. For instance,
+damage calculation could be taken from `TargetedDamage`, the damage effects could be taken from the first matching
+`AngledDamage`, and the Next interaction coming from the default damage field.
+
+If all damage dealt by this interaction is cancelled, then this interaction will fail, and the `Failed` interaction
+will be executed next in the chain. If any damage dealt by this interaction is blocked, then this interaction will
+succeed, but the `Blocked` interaction wil lbe executed next in the chain. Otherwise, the highest-precedent matching
+`Next` interaction that you provide will be executed.  For instance, if you provide `Next` interactions for all
+`TargetedDamage` and `AngledDamage` entries, and one in the interaction's `Next` field, then a headshot could result
+in a unique `Next` interaction being executed, even if there is a matching `AngledDamage` entry. However, if you leave
+the `Next` interaction out of your `TargetedDamage` entries, a special `Next` interaction for backstabs could be
+executed.  Otherwise, the `Next` field in the root of the interaction will be executed instead.
+
+DamageEntity has an unusual relationship with `RunTime`. This interaction always ends immediately after its first tick,
+regardless of the status of `RunTime` or `WaitForAnimationToFinish`.  However, if damage dealt by this interaction is
+calculated as `DamageCalculatorType` `Dps`, then the `RunTime` will be used to determine the precise amount of damage to
+deal. If `RunTime` is 0, then no damage will be dealt.
+
+**DamageEntity Fields**
+
+| Field Name       | Type                                                          | Required?                                                                                                                    | Notes                                                                                                                                                                                                                                                                                                                                                                         |
+| ---------------- | ------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| DamageCalculator | `DamageCalculator`                                            | **No**                                                                                                                       | If provided, describes the damage amounts and types to apply to the Target entity.                                                                                                                                                                                                                                                                                            |
+| DamageEffects    | `DamageEffects`                                               | **No**                                                                                                                       | If provided, describes particles, sounds, knockback, etc. to apply to the target entity on damage.                                                                                                                                                                                                                                                                            |
+| Next             | `Asset`<br />(Asset Type: `Interaction`)                      | **No**  After this interaction has finished, "Next" will be executed if damage was dealt to the target and none was blocked. |                                                                                                                                                                                                                                                                                                                                                                               |
+| AngledDamage     | `Array`<br />(Element Type: `AngledDamage`)                   | **No**                                                                                                                       | If provided, allows alternative `DamageCalculator`, `DamageEffects`, and `Next` entries for attacks that approach the target from certain angles.                                                                                                                                                                                                                             |
+| TargetedDamage   | `Map`<br />(Key Type: `String`, Value Type: `TargetedDamage`) | **Yes**                                                                                                                      | This field must be provided, but is not required to have any entries.  This is a map from body part names to `TargetedDamage` values. Hypixel only uses one body part name: `Head`, and it is not clear whether there are others.  If provided, allows alternative `DamageCalculator`, `DamageEffects`, and `Next` entries for attacks that damage specific enemy body parts. |
+| EntityStatsOnHit | `Array`<br />(Element Type: `EntityStatOnHit`)                | **No**                                                                                                                       | If provided, allows this attack to reduce enemy stats other than health.  Each individual damage application dealt by the same ability will apply stat reductions, at diminishing returns. All damage dealt in interaction chains forked by a Selector interaction will share the number of hits across all targets.                                                          |
+| Failed           | `Asset`<br />(Asset Type: `Interaction`)                      | **No**                                                                                                                       | After this interaction has finished, "Failed" will be executed if no damage hits were applied to the player, or if all damage hits were cancelled.                                                                                                                                                                                                                            |
+| Blocked          | `Asset`<br />(Asset Type: `Interaction`)                      | **No**                                                                                                                       | After this interaction has finished, "Blocked" will be executed if any damage hits were blocked by the target.                                                                                                                                                                                                                                                                |
+
+**DamageCalculator Fields**
+
+| Field Name                | Type                                                      | Required? | Notes                                                                                                                                                                                                                                                 |
+| ------------------------- | --------------------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Type                      | `DamageCalculatorType`<br />(Default: Absolute)           | **No**    | Whether the damage being applied is `Absolute` or \`Dps'.                                                                                                                                                                                             |
+| Class                     | `DamageClass`<br />(Default: Unknown)                     | **No**    | The type of attack producing the damage. Some weapon systems apply equipment modifiers based on this value.                                                                                                                                           |
+| BaseDamage                | `Map`<br />(Key Type: `DamageCause`, Value Type: `Float`) | **No**    | A set of DamageCauses and how much base damage is dealt for each.                                                                                                                                                                                     |
+| SequentialModifierStep    | `Float`<br />(Default: 0.0)                               | **No**    | Value between 0.0-1.0. Each additional hit from a single ability will have its damage reduced by this much as a percentage. All damage dealt in interaction chains forked by a Selector interaction will share the number of hits across all targets. |
+| SequentialModifierMinimum | `Float`<br />(Default: 0.0)                               | **No**    | Value between 0.0-1.0. `SequentialModifierStep` cannot reduce damage below this percentage regardless of the number of hits.                                                                                                                          |
+| RandomPercentageModifier  | `Float`<br />(Default: 0.0)                               | **No**    | A random value between +/- this amount multiplied by the base damage will be added to the base damage.                                                                                                                                                |
+
+**DamageEffects Fields**
+
+| Field Name             | Type                                         | Required? | Notes                                                                                   |
+| ---------------------- | -------------------------------------------- | --------- | --------------------------------------------------------------------------------------- |
+| ModelParticles         | `Array`<br />(Element Type: `ModelParticle`) | **No**    | Particle systems to trigger in the first-person view.                                   |
+| WorldParticles         | `Array`<br />(Element Type: `WorldParticle`) | **No**    | Particle systems to trigger in the third-person view.                                   |
+| LocalSoundEventId      | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | 2D sound to play locally to the attacking entity if they are a player.                  |
+| WorldSoundEventId      | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | Sound to play in the world at the Target entity's location.                             |
+| PlayerSoundEventId     | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | 2D sound to play locally to the Target entity if they are a player.                     |
+| ViewDistance           | `Double`<br />(Default: 75.0)                | **No**    | Distance at which these effects should play for other players.                          |
+| Knockback              | `Knockback`                                  | **No**    | The properties of the knockback that will be applied.                                   |
+| CameraEffect           | `Asset`<br />(Asset Type: `CameraEffect`)    | **No**    | CameraEffect to briefly apply locally to the Target entity if they are a player.        |
+| StaminaDrainMultiplier | `Float`<br />(Default: 1.0)                  | **No**    | This multiplier is applied to the stamina cost incurred by the target blocking, if any. |
+
+**AngledDamage Fields**
+
+| Field Name       | Type                                     | Required? | Notes                                                                                                                                                                                                     |
+| ---------------- | ---------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| AngleDistance    | `Float`<br />(Default: 0)                | **No**    | The width in degrees of the matching arc around the Target entity. If the attack against the Target originates from within the arc, then the properties below will be applied to the attack, if provided. |
+| Angle            | `Float`<br />(Default: 0.0)              | **No**    | The angle in degrees around the Target entity at which the matching arc is centered.                                                                                                                      |
+| DamageCalculator | `DamageCalculator`                       | **No**    | If provided and the attack against the Target entity originates from within the provided arc, this DamageCalculator will override the interaction's `DamageCalculator` field.                             |
+| DamageEffects    | `DamageEffects`                          | **No**    | If provided and the attack against the Target entity originates from within the provided arc, this DamageEffects will override the interaction's `DamageEffects` field.                                   |
+| Next             | `Asset`<br />(Asset Type: `Interaction`) | **No**    | If provided and the attack against the Target entity originates from within the provided arc, this Interaction will override the interaction's `Next` field.                                              |
+
+**TargetedDamage Fields**
+
+| Field Name       | Type                                     | Required? | Notes                                                                                                                                                                                            |
+| ---------------- | ---------------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| DamageCalculator | `DamageCalculator`                       | **No**    | If provided and this TargetedDamage was matched, this DamageCalculator will override the interaction's `DamageCalculator` field and the `DamageCalculator` field of any matching `AngledDamage`. |
+| DamageEffects    | `DamageEffects`                          | **No**    | If provided and this TargetedDamage was matched, this DamageEffects will override the interaction's `DamageEffects` field and the `DamageEffects` field of any matching `AngledDamage`.          |
+| Next             | `Asset`<br />(Asset Type: `Interaction`) | **No**    | If provided and this TargetedDamage was matched, this Interaction will override the interaction's `Next` field and the `Next` field of any matching `AngledDamage`.                              |
+
+**EntityStatOnHit Fields**
+
+| Field Name                  | Type                                                                       | Required? | Notes                                                                                                                                                                                                                                                                                        |
+| --------------------------- | -------------------------------------------------------------------------- | --------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| EntityStatId                | `Asset`<br />(AssetType: `EntityStatType`)                                 | **Yes**   | Which entity stat to affect.                                                                                                                                                                                                                                                                 |
+| Amount                      | `Float`<br />(Default: 0.0)                                                | **No**    | How much of the stat to apply for each damage application. Use negative numbers to reduce stats.                                                                                                                                                                                             |
+| MultipliersPerEntitiesHit   | `Array`<br />(Element Type: `Float`, Default: `[1.0, 0.6, 0.4, 0.2, 0.1]`) | **No**    | The diminishing returns curve to be applied for multiple damage applications by the same ability. Each hit's stat impact will be multiplied by the next value in the list.  If there are more hits than array elements, subsequent hits will be multiplied by `MultiplierPerExtraEntityHit`. |
+| MultiplierPerExtraEntityHit | `Float`<br />(Default: 0.05)                                               | **No**    | If an ability carries out more damage applications than there are elements in the `MultipliersPerEntitiesHit` array, then subsequent stat values will be multiplied by this number.                                                                                                          |
+
+**Knockback Fields**
+
+| Field Name     | Type                                       | Required? | Notes                                                                                                                      |
+| -------------- | ------------------------------------------ | --------- | -------------------------------------------------------------------------------------------------------------------------- |
+| Type           | `String`                                   | **No**    | If provided, specifies a type of knockback to use. Each Target type may come with additional fields.                       |
+| Force          | `Double`<br />(Default: 0.0)               | **No**    | The amount of force to apply to the Owner entity.                                                                          |
+| Duration       | `Double`<br />(Default: 0.0)               | **No**    | If 0.0, apply the force as a single impulse.  If more, continuously apply the force over a period of time.                 |
+| VelocityType   | `ChangeVelocityType`<br />(Default: `Add`) | **No**    | How to apply the force, either adding it to the entity's current velocity, or setting the velocity to the knockback force. |
+| VelocityConfig | `VelocityConfig`                           | **No**    | Characteristics of friction as the Owner entity is thrown by this knockback.                                               |
+
+**Knockback Type: Force**
+
+Apply the calculated knockback force along the provided direction.
+
+| Field Name | Type                         | Required? | Notes                                                                                |
+| ---------- | ---------------------------- | --------- | ------------------------------------------------------------------------------------ |
+| Direction  | `Vector3`<br />(Default: Up) | **No**    | Which direction the entity should be flung, relative to the direction of the attack. |
+
+**Knockback Type: Point**
+
+Apply the calculated knockback force laterally along the XZ plane, plus provided Y velocity.
+
+| Field Name | Type                        | Required? | Notes                                                                                                   |
+| ---------- | --------------------------- | --------- | ------------------------------------------------------------------------------------------------------- |
+| OffsetX    | `Integer`<br />(Default: 0) | **No**    | Offset the source position of the knockback left or right perpendicular to the direction of the attack. |
+| OffsetZ    | `Integer`<br />(Default: 0) | **No**    | Offset the source position of the knockback, forward or backward along the directon of the attack.      |
+| RotateY    | `Integer`<br />(Default: 0) | **No**    | Rotate the knockback direction around the Y axis, where 0 is the default attack direction.              |
+| VelocityY  | `Float`<br />(Default: 0.0) | **No**    | Add vertical velocity to the knockback force after the direction and force has been calculated.         |
+
+**Knockback Type: Directional**
+
+Apply the calculated knockback force along the attack direction, removing any vertical component and replacing it with a provided Y velocity.
+
+| Field Name | Type                      | Required? | Notes                                                                                                                                            |
+| ---------- | ------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------ |
+| RelativeX  | `Float`<br />(Default: 0) | **No**    | Apply additional force left or right perpendicular to the direction of the attack. The additional force is multiplied by the knockback strength. |
+| RelativeZ  | `Float`<br />(Default: 0) | **No**    | Apply additional force forward or backward along the attack direction. The additional force is multiplied by the knockback strength.             |
+| VelocityY  | `Float`<br />(Default: 0) | **No**    | Replace the vertical velocity of the knockback with this value.  This value is not multiplied by knockback strength.                             |
+
+**VelocityConfig Fields**
+
+| Field Name          | Type                                              | Required? | Notes                                                                                                                                                                                           |
+| ------------------- | ------------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| GroundResistance    | `Float`<br />(Default: 0.82)                      | **No**    | The minimum amount of friction applied when the entity is in contact with the ground.  1.0 = no friction, 0.0 = total friction                                                                  |
+| GroundResistanceMax | `Float`<br />(Default: 0.0)                       | **No**    | The maximum amount of friction applied when the entity is in contact with the ground.  1.0 = no friction, 0.0 = total friction                                                                  |
+| AirResistance       | `Float`<br />(Default: 0.96)                      | **No**    | The minimum amount of friction applied when the entity is in the air. 1.0 = no friction, 0.0 = total friction                                                                                   |
+| AirResistanceMax    | `Float`<br />(Default: 0.0)                       | **No**    | The maximum amount of friction applied when the entity is in the air. 1.0 = no friction, 0.0 = total friction                                                                                   |
+| Threshold           | `Float`<br />(Default: 1.0)                       | **No**    | The speed at which the maximum amount of friction will be applied to the entity. The amount of friction applied will increase from minimum to maximum as the entity moves from 0 to this speed. |
+| Style               | `VelocityThresholdStyle`<br />(Default: `Linear`) | **No**    | The curve that friction follows as the entity's speed increases toward the `Threshold`.                                                                                                         |
+
+**DamageCalculatorType Values**
+
+- `Absolute`
+- `Dps`
+
+**DamageClass Values**
+
+- `Unknown`
+- `Light`
+- `Charged`
+- `Signature`
+
+**ChangeVelocityType Values**
+
+- `Add`
+- `Set`
+
+**VelocityThresholdStyle Values**
+
+- `Linear`
+- `Exp`
+
+### LaunchProjectile
+
+This is just a worse version of Projectile and is slated to be removed.  Use Projectile.
+
+### Projectile
+
+This interaction will spawn a new projectile at the User entity's eye position that will travel in its look direction.
+
+| Field Name | Type                                          | Required? | Notes                                                  |
+| ---------- | --------------------------------------------- | --------- | ------------------------------------------------------ |
+| Config     | `Asset`<br />(Asset Type: `ProjectileConfig`) | **No**    | Configuration describing the projectile to be spawned. |
+
+### RemoveEntity
+
+Despawns the specified entity from the world. This interaction will have no effect if the specified entity is a player. This
+interaction has no special failure conditions.
+
+| Field Name | Type                                     | Required? | Notes                  |
+| ---------- | ---------------------------------------- | --------- | ---------------------- |
+| Entity     | `InteractionTarget`<br />(Default: User) | **No**    | The entity to despawn. |
+
+**InteractionTarget Values**
+
+- `User` - The user of this interaction chain. The entity whose actions caused this interaction chain to be executed. This is usually the same as the Owner.
+- `Owner` - The owner of this interaction chain. The entity upon whom this interaction chain is executing.
+- `Target` - The entity target of this interaction chain, if any.  This value is mutable (and can therefore come from many places) but most commonly, it is an entity the User was targeting when this interaction chain began executing.
+
+### SendMessage
+
+This interaction sends a message to the Owner entity if that entity can receive messages.  Otherwise, the message
+is written to the server logs.  If the entity is a player, the message will appear in the player's chat window.
+
+\*\*SendMessage
+
+| Field Name | Type     | Required? | Notes                                                                                                                 |
+| ---------- | -------- | --------- | --------------------------------------------------------------------------------------------------------------------- |
+| Message    | `String` | **No**    | A text message to be sent to the Owner entity.  If this field is not provided, `Key` is used instead.                 |
+| Key        | `String` | **No**    | A translation key for a message to be sent to the Owner entity. If `Message` is provided, then this field is ignored. |
+
+### UseEntity
+
+This interaction is not in use by Hypixel and has some unusual qualities that mean it probably won't do what you want it
+to.  Do not use it.
+
+This interaction will retrieve the entity currently targeted by the client (NOT the interaction chain's current Target
+entity) and execute that entity's RootInteraction for this interaction chain's current interaction type. The
+RootInteraction will be executed as part of this current interaction chain. None of the properties of this interaction
+chain will be modified.
+
+This interaction will fail if the client is not currently targeting an entity, or if no interaction for the current
+interaction type exists on the entity.
+
+## Stats
+
+Hytale's resource system has been written about fairly extensively.  You can use these interactions to modify stats in
+response to actions or use stats as a cost for abilities.
+
+### ChangeStat
+
+This interaction applies a set of raw stat changes to the User entity. It has no special failure conditions.
+
+| Field Name    | Type                                                         | Required? | Notes                                                                                                                                                                                                                      |
+| ------------- | ------------------------------------------------------------ | --------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| StatModifiers | `Map`<br />(Key Type: `EntityStatType`, Value Type: `Float`) | **Yes**   | A set of stats to modify and what value to apply to them.                                                                                                                                                                  |
+| ValueType     | `ValueType`<br />(Default: Absolute)                         | **No**    | Whether the values in the `StatModifiers` map represent flat values to apply to the stat total, or percentages (0.0-100.0). Percentage values are percentage of the difference between the maximum and minimum stat value. |
+| Behaviour     | `ChangeStatBehavior`<br />(Default: Add)                     | **No**    | Whether the values in the `StatModifiers` map represent deltas to add into the User entity's current stat values, or fixed values to set the entity's stats to.                                                            |
+
+**ValueType Values**
+
+- `Absolute`
+- `Percent`
+
+**ChangeStatBehaviour Values**
+
+- `Add`
+- `Set`
+
+### ChangeStatWithModifier
+
+This interaction is like ChangeStat, except an armor stat modifier can be chosen which will apply bonuses and penalties
+to a stat from the User entity's equipped armor before it is applied.
+
+| Field Name            | Type                                                         | Required? | Notes                                                                                                                                                                                                                      |
+| --------------------- | ------------------------------------------------------------ | --------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| StatModifiers         | `Map`<br />(Key Type: `EntityStatType`, Value Type: `Float`) | **Yes**   | A set of stats to modify and what value to apply to them.                                                                                                                                                                  |
+| ValueType             | `ValueType`<br />(Default: Absolute)                         | **No**    | Whether the values in the `StatModifiers` map represent flat values to apply to the stat total, or percentages (0.0-100.0). Percentage values are percentage of the difference between the maximum and minimum stat value. |
+| Behaviour             | `ChangeStatBehavior`<br />(Default: Add)                     | **No**    | Whether the values in the `StatModifiers` map represent deltas to add into the User entity's current stat values, or fixed values to set the entity's stats to.                                                            |
+| InteractionModifierId | `InteractionModifierId`                                      | **Yes**   | The armor interaction modifier to apply bonuses and penalties for.                                                                                                                                                         |
+
+**ValueType Values**
+
+- `Absolute`
+- `Percent`
+
+**ChangeStatBehaviour Values**
+
+- `Add`
+- `Set`
+
+**InteractionModifierId Values**
+
+- `Dodge`
+
+### StatsCondition
+
+This interaction will fail if the User entity cannot afford the specified stats costs, or if it does not have the
+requested stats.
+
+| Field Name | Type                                                         | Required? | Notes                                                                                                                                                                                    |
+| ---------- | ------------------------------------------------------------ | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Costs      | `Map`<br />(Key Type:` EntityStatType`, Value Type: `Float`) | **Yes**   | A set of costs that the User entity needs to be able to afford for this interaction to succeed.                                                                                          |
+| ValueType  | `ValueType`<br />(Default: Absolute)                         | **No**    | Whether the values in the `Costs` map represetn flat values or percentages (0.0-100.0).  Percentage values are percentage of the difference between the maximum and minimum value.       |
+| LessThan   | `Boolean`<br />(Default: false)                              | **No**    | If true, this interaction will fail unless the User entity's current stat values are at or **below** the specified levels.  If false, they must be at or **above** the specified levels. |
+| Lenient    | `Boolean`<br />(Default: false)                              | **No**    | If true and `LessThan` is true, and a player's minimum stat value is below zero, then the player can afford a stat cost if the current value of a stat if above 0.                       |
+
+**ValueType Values**
+
+- `Absolute`
+- `Percent`
+
+### StatsConditionWithModifier
+
+This interaction is like StatsCondition, except an armor stat modifier can be chosen which will apply bonuses and penalties
+to a stat's cost from the User entity's equipped armor before it is compared.
+
+| Field Name            | Type                                                         | Required? | Notes                                                                                                                                                                                    |
+| --------------------- | ------------------------------------------------------------ | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Costs                 | `Map`<br />(Key Type:` EntityStatType`, Value Type: `Float`) | **Yes**   | A set of costs that the User entity needs to be able to afford for this interaction to succeed.                                                                                          |
+| ValueType             | `ValueType`<br />(Default: Absolute)                         | **No**    | Whether the values in the `Costs` map represetn flat values or percentages (0.0-100.0).  Percentage values are percentage of the difference between the maximum and minimum value.       |
+| LessThan              | `Boolean`<br />(Default: false)                              | **No**    | If true, this interaction will fail unless the User entity's current stat values are at or **below** the specified levels.  If false, they must be at or **above** the specified levels. |
+| Lenient               | `Boolean`<br />(Default: false)                              | **No**    | If true and `LessThan` is true, and a player's minimum stat value is below zero, then the player can afford a stat cost if the current value of a stat if above 0.                       |
+| InteractionModifierId | `InteractionModifierId`                                      | **Yes**   | The armor interaction modifier to apply bonuses and penalties for.                                                                                                                       |
+
+**ValueType Values**
+
+- `Absolute`
+- `Percent`
+
+**InteractionModifierId Values**
+
+- `Dodge`
+
+## EntityEffects
+
+EntityEffects are buff or debuff effects that can be applied to a LivingEntity.  These can have a variety of effects from
+movement speed changes to periodic damage.
+
+### EffectCondition
+
+This interaction will fail if the specified entity's EntityEffects do not match the provided conditions.
+
+**EffectCondition Fields**
+
+| Field Name      | Type                                             | Required? | Notes                                                                                                                                                                                                             |
+| --------------- | ------------------------------------------------ | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Entity          | `InteractionTarget`<br />(Default: User)         | **Yes**   | The entity to examine for EntityEffects. This field can indicate the Owner, User, or Target of this interaction chain.                                                                                            |
+| Match           | `Match`<br />(Default: All)                      | **No**    | If `All`, then this interaction will fail if any EntityEffect in the `EntityEffectIds` is not on the specified entity. If `None`, then this interaction will fail if any EntityEffect IS on the specified entity. |
+| EntityEffectIds | `AssetArray`<br />(Element Type: `EntityEffect`) | **Yes**   | The set of EntityEffects to check against the specified entity and `Match`.                                                                                                                                       |
+
+**InteractionTarget Values**
+
+- `User` - The user of this interaction chain. The entity whose actions caused this interaction chain to be executed. This is usually the same as the Owner.
+- `Owner` - The owner of this interaction chain. The entity upon whom this interaction chain is executing.
+- `Target` - The entity target of this interaction chain, if any.  This value is mutable (and can therefore come from many places) but most commonly, it is an entity the User was targeting when this interaction chain began executing.
+
+**Match Values**
+
+- `All` - All EntityEffects must be on the specified entity for this interaction to succeed.
+- `None` - None of the EntityEffects must be on the specified entity for this interaction to succeed.
+
+### ApplyEffect
+
+This interaction will apply the specified EntityEffect to the specified Entity.  It has no special failure conditions.
+
+**ApplyEffect Fields**
+
+| Field Name | Type                                      | Required? | Notes                                                                                                                  |
+| ---------- | ----------------------------------------- | --------- | ---------------------------------------------------------------------------------------------------------------------- |
+| Entity     | `InteractionTarget`<br />(Default: User)  | **Yes**   | The entity to apply the EntityEffect to. This field can indicate the Owner, User, or Target of this interaction chain. |
+| EffectId   | `Asset`<br />(Asset Type: `EntityEffect`) | **Yes**   | The effect to apply.                                                                                                   |
+
+**InteractionTarget Values**
+
+- `User` - The user of this interaction chain. The entity whose actions caused this interaction chain to be executed. This is usually the same as the Owner.
+- `Owner` - The owner of this interaction chain. The entity upon whom this interaction chain is executing.
+- `Target` - The entity target of this interaction chain, if any.  This value is mutable (and can therefore come from many places) but most commonly, it is an entity the User was targeting when this interaction chain began executing.
+
+### ClearEntityEffect
+
+This interaction will remove the specified EntityEffect from the specified Entity. It has no special failure conditions.
+It will not fail if the Entity does not have the EntityEffect.
+
+**ClearEntityEffect Fields**
+
+| Field Name | Type                                      | Required? | Notes                                                                                                                     |
+| ---------- | ----------------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------- |
+| Entity     | `InteractionTarget`<br />(Default: User)  | **Yes**   | The entity to remove the EntityEffect from. This field can indicate the Owner, User, or Target of this interaction chain. |
+| EffectId   | `Asset`<br />(Asset Type: `EntityEffect`) | **Yes**   | The effect to remove.                                                                                                     |
+
+**InteractionTarget Values**
+
+- `User` - The user of this interaction chain. The entity whose actions caused this interaction chain to be executed. This is usually the same as the Owner.
+- `Owner` - The owner of this interaction chain. The entity upon whom this interaction chain is executing.
+- `Target` - The entity target of this interaction chain, if any.  This value is mutable (and can therefore come from many places) but most commonly, it is an entity the User was targeting when this interaction chain began executing.
+
+## Farming
+
+These are interaction types built to support the in-game farming system in Hytale. They are mostly block-related interactions
+with a few exceptions.
+
+### ChangeFarmingStage
+
+If the target block is a farming block, this interaction will attempt to modify the current farming stage in one of
+three ways.  The interaction can optionally specify which StageSet to use for the new stage. If it is not specified,
+the current StageSet will be used. If any part of the the process of changing the growth stage fails, this interaction
+will fail, with the one exception that attempting to set the stage to the crop's existing stage will have no effect but
+still succeed.
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                                                                                                                                                                          |
+| ---------------- | ------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction.                                                                                                                                              |
+| StageSet         | `String`                        | **No**    | If provided, set the block's current stage to one in the provided StageSet. Otherwise, use the crop's current StageSet.                                                                                                                                                        |
+| Increase         | `Integer`                       | **No**    | If provided, increase the current stage by the specified amount. If the specified stage does not exist, the block will be set to the closest extant stage.                                                                                                                     |
+| Decrease         | `Integer`                       | **No**    | If provided and `Increase` is not provided, decrease the current stage by the specified amount. If the specified stage does not exist, the block will be set to the closest extant stage.                                                                                      |
+| Stage            | `Integer`<br />(Default: -1)    | **No**    | If provided and `Increase`/`Decrease` are not provided, set the current stage to the specified stage. If this value is less than 0, set the current stage to the final growth stage. If the specified stage does not exist, the block will be set to the closest extant stage. |
+
+### FertilizeSoil
+
+If the target block is unfertilized tilled soil or a farming block on top of unfertilized tilled soil, fertilizes the soil.
+The interaction will fail otherwise.
+
+**FertilizeSoil Fields**
+
+| Field Name       | Type                                  | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false)       | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+| RefreshModifiers | `Array`<br />(Element Type: `String`) | **No**    | Does nothing.                                                                                                                     |
+
+### HarvestCrop
+
+This interaction will attempt to execute the harvest action on the current block target and add the crop's drops to the User entity's
+inventory.  The block will either be destroyed or set to its post-harvest growth stage, depending on the farming
+configuration of the block.  This will happen (and the player will receive the full harvest drops) regardless of the
+block's current growth stage. This interaction has no special failure conditions, even if the block target isn't a
+farming block or gathering isn't permitted in the current world, but nothing will occur in those cases.
+
+**HarvestCrop Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+
+### UseWateringCan
+
+If the target block is tilled soil or a farming block on top of tilled soil, waters the soil for the specified duration.
+The interaction will fail otherwise.
+
+**UseWateringCan Fields**
+
+| Field Name       | Type                                  | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false)       | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+| Duration         | `Integer`<br />(Default: 0)           | **No**    | The duration in seconds to water the soil for.                                                                                    |
+| RefreshModifiers | `Array`<br />(Element Type: `String`) | **No**    | Does nothing.                                                                                                                     |
diff --git a/content/docs/bg-BG/server/sounds.mdx b/content/docs/bg-BG/server/sounds.mdx
new file mode 100644
index 00000000..5b54a035
--- /dev/null
+++ b/content/docs/bg-BG/server/sounds.mdx
@@ -0,0 +1,1162 @@
+---
+title: Sounds
+description: List of all Sounds in Hytale
+icon: List
+full: true
+---
+
+This page contains a list of all Sounds available to be used as a key in the AssetMap.
+
+- SFX_Alchemy_Bench_Close
+- SFX_Alchemy_Bench_Craft
+- SFX_Alchemy_Bench_Open
+- SFX_Antelope_Alerted
+- SFX_Antelope_Death
+- SFX_Antelope_Hurt
+- SFX_Antelope_Run
+- SFX_Antelope_Walk
+- SFX_Arcane_Workbench_Close_Local
+- SFX_Arcane_Workbench_Craft
+- SFX_Arcane_Workbench_Open_Local
+- SFX_Armour_Bench_Close
+- SFX_Armour_Bench_Craft
+- SFX_Armour_Bench_Open
+- SFX_Arrow_Fire_Hit
+- SFX_Arrow_Fire_Miss
+- SFX_Arrow_Frost_Hit
+- SFX_Arrow_Frost_Miss
+- SFX_Arrow_FullCharge_Hit
+- SFX_Arrow_FullCharge_Miss
+- SFX_Arrow_HalfCharge_Hit
+- SFX_Arrow_HalfCharge_Miss
+- SFX_Arrow_NoCharge_Hit
+- SFX_Arrow_NoCharge_Miss
+- SFX_Arrow_Whistle
+- SFX_Attn_Loud
+- SFX_Attn_Moderate
+- SFX_Attn_Quiet
+- SFX_Attn_VeryLoud
+- SFX_Attn_VeryQuiet
+- SFX_Avatar_Powers_Disable
+- SFX_Avatar_Powers_Disable_Local
+- SFX_Avatar_Powers_Enable
+- SFX_Avatar_Powers_Enable_Local
+- SFX_Axe_Crude_Impact
+- SFX_Axe_Crude_Swing
+- SFX_Axe_Iron_Impact
+- SFX_Axe_Iron_Swing
+- SFX_Axe_Special_Impact
+- SFX_Axe_Special_Swing
+- SFX_Axe_Stone_Trork_Hit
+- SFX_Axe_Stone_Trork_Miss
+- SFX_Bat_Alerted
+- SFX_Bat_Death
+- SFX_Bat_Hurt
+- SFX_Battleaxe_T1_Block_Impact
+- SFX_Battleaxe_T1_Impact
+- SFX_Battleaxe_T1_Launch
+- SFX_Battleaxe_T1_Launch_Local
+- SFX_Battleaxe_T1_Raise
+- SFX_Battleaxe_T1_Raise_Local
+- SFX_Battleaxe_T1_Shove
+- SFX_Battleaxe_T1_Shove_Local
+- SFX_Battleaxe_T1_Swing
+- SFX_Battleaxe_T1_Swing_Charged
+- SFX_Battleaxe_T1_Swing_Charged_Local
+- SFX_Battleaxe_T1_Swing_Down_Local
+- SFX_Battleaxe_T1_Swing_LR_Local
+- SFX_Battleaxe_T1_Swing_RL_Local
+- SFX_Battleaxe_T2_Impact
+- SFX_Battleaxe_T2_Raise
+- SFX_Battleaxe_T2_Raise_Local
+- SFX_Battleaxe_T2_Signature_End
+- SFX_Battleaxe_T2_Signature_End_Local
+- SFX_Battleaxe_T2_Signature_Swing
+- SFX_Battleaxe_T2_Signature_Swing_Local
+- SFX_Battleaxe_T2_Swing
+- SFX_Battleaxe_T2_Swing_Charged
+- SFX_Battleaxe_T2_Swing_Charged_Local
+- SFX_Battleaxe_T2_Swing_Down_Local
+- SFX_Battleaxe_T2_Swing_LR_Local
+- SFX_Battleaxe_T2_Swing_RL_Local
+- SFX_Bear_Grizzly_Alerted
+- SFX_Bear_Grizzly_Attack
+- SFX_Bear_Grizzly_Death
+- SFX_Bear_Grizzly_Hurt
+- SFX_Bear_Grizzly_Run
+- SFX_Bear_Grizzly_Sleep
+- SFX_Bear_Walk
+- SFX_Bench_Placeholder
+- SFX_Bison_Alerted
+- SFX_Bison_Death
+- SFX_Bison_Hurt
+- SFX_Bison_Idle
+- SFX_Bison_Run
+- SFX_Bison_Walk
+- SFX_Blunderbuss_Bullet_WhizBy
+- SFX_Blunderbuss_Fire
+- SFX_Blunderbuss_Fire_Local
+- SFX_Blunderbuss_Hit
+- SFX_Blunderbuss_Load
+- SFX_Blunderbuss_Load_Local
+- SFX_Blunderbuss_Miss
+- SFX_Blunderbuss_No_Ammo
+- SFX_Boar_Alerted
+- SFX_Boar_Death
+- SFX_Boar_Hurt
+- SFX_Boar_Run
+- SFX_Boar_Sleep
+- SFX_Boar_Walk
+- SFX_Bomb_Fire_Goblin_Bounce
+- SFX_Bomb_Fire_Goblin_Death
+- SFX_Bomb_Fire_Goblin_Hit
+- SFX_Bomb_Fire_Goblin_Miss
+- SFX_Bomb_Fuse
+- SFX_Bone_Break
+- SFX_Bone_Build
+- SFX_Bone_Hit
+- SFX_Bone_Land
+- SFX_Bone_Walk
+- SFX_Bow_No_Ammo
+- SFX_Bow_T1_Block_Impact
+- SFX_Bow_T1_Draw
+- SFX_Bow_T1_Draw_Local
+- SFX_Bow_T1_Raise
+- SFX_Bow_T1_Raise_Local
+- SFX_Bow_T1_Shoot
+- SFX_Bow_T1_Shoot_Local
+- SFX_Bow_T1_Swing
+- SFX_Bow_T1_Swing_Local
+- SFX_Bow_T2_Draw
+- SFX_Bow_T2_Draw_Local
+- SFX_Bow_T2_Shoot
+- SFX_Bow_T2_Shoot_Local
+- SFX_Bow_T2_Signature_Loop
+- SFX_Bow_T2_Signature_Loop_Local
+- SFX_Bow_T2_Signature_Nock
+- SFX_Bow_T2_Signature_Nock_Local
+- SFX_Bow_T2_Signature_Shoot
+- SFX_Bow_T2_Signature_Shoot_Local
+- SFX_Bramble_MoveIn
+- SFX_Branch_Break
+- SFX_Branch_Build
+- SFX_Branch_Hit
+- SFX_Branch_Land
+- SFX_Branch_Walk
+- SFX_Brazier_Break
+- SFX_Brazier_Build
+- SFX_Bunny_Alerted
+- SFX_Bunny_Death
+- SFX_Bunny_Hurt
+- SFX_Bush_Break
+- SFX_Bush_Hit
+- SFX_Bush_MoveIn
+- SFX_Cactus_Break
+- SFX_Cactus_Hit
+- SFX_Cactus_Large_Hit
+- SFX_Cactus_Small_Break
+- SFX_Cactus_Small_Hit
+- SFX_Calf_Hurt
+- SFX_Calf_Run
+- SFX_Calf_Walk
+- SFX_Camel_Alerted
+- SFX_Camel_Death
+- SFX_Camel_Hurt
+- SFX_Camel_Laydown
+- SFX_Camel_Run
+- SFX_Camel_Sleep
+- SFX_Camel_Wake
+- SFX_Camel_Walk
+- SFX_Campfire_Break
+- SFX_Campfire_Build
+- SFX_Campfire_Close_Local
+- SFX_Campfire_Default_Loop
+- SFX_Campfire_Open_Local
+- SFX_Campfire_Processing
+- SFX_Campfire_Processing_End
+- SFX_Campfire_Processing_Failed
+- SFX_Candle_Default_Loop
+- SFX_Candle_Off
+- SFX_Capture_Crate_Capture_Fail_Local
+- SFX_Capture_Crate_Capture_Succeed
+- SFX_Capture_Crate_Capture_Succeed_Local
+- SFX_Capture_Crate_Spawn_Fail_Local
+- SFX_Capture_Crate_Spawn_Succeed
+- SFX_Cauldron_Bubbling
+- SFX_Cauldron_Bubbling_Small
+- SFX_Chest_Legendary_Close_Player
+- SFX_Chest_Legendary_FirstOpen_Player
+- SFX_Chest_Legendary_Loop
+- SFX_Chest_Legendary_Open
+- SFX_Chest_Wooden_Close
+- SFX_Chest_Wooden_Open
+- SFX_Chest_Wooden_Open_Player
+- SFX_Chick_Alerted
+- SFX_Chick_Death
+- SFX_Chick_Hurt
+- SFX_Chicken_Alerted
+- SFX_Chicken_Death
+- SFX_Chicken_Flee
+- SFX_Chicken_Hurt
+- SFX_Chicken_Run
+- SFX_Chicken_Walk
+- SFX_Clay_Pot_Large_Break
+- SFX_Clay_Pot_Large_Build
+- SFX_Clay_Pot_Large_Hit
+- SFX_Clay_Pot_Large_Walk
+- SFX_Clay_Pot_Small_Break
+- SFX_Clay_Pot_Small_Build
+- SFX_Clay_Pot_Small_Hit
+- SFX_Clay_Pot_Small_Walk
+- SFX_Cloth_Break
+- SFX_Cloth_Build
+- SFX_Cloth_Hit
+- SFX_Cloth_Land
+- SFX_Cloth_Walk
+- SFX_Club_Meat_Impact
+- SFX_Club_Meat_Swing
+- SFX_Club_Special_Impact
+- SFX_Club_Special_Swing
+- SFX_Club_Steel_Impact
+- SFX_Club_Steel_Swing
+- SFX_Club_Wood_Impact
+- SFX_Club_Wood_Swing
+- SFX_Cocoon_Active
+- SFX_Cocoon_Break
+- SFX_Cocoon_Build
+- SFX_Cocoon_Hit
+- SFX_Cocoon_Walk
+- SFX_Coins_Land
+- SFX_Coins_Walk
+- SFX_Consume_Bread
+- SFX_Consume_Bread_Local
+- SFX_Cow_Alerted
+- SFX_Cow_Death
+- SFX_Cow_Hurt
+- SFX_Cow_Idle
+- SFX_Cow_Run
+- SFX_Cow_Sleep
+- SFX_Cow_Walk
+- SFX_Crawler_Void_Alerted
+- SFX_Crawler_Void_Alerted_02
+- SFX_Crawler_Void_Death
+- SFX_Crawler_Void_Despawn
+- SFX_Crawler_Void_Hurt
+- SFX_Crawler_Void_Run
+- SFX_Crawler_Void_Sleep
+- SFX_Crawler_Void_Spawn
+- SFX_Crawler_Void_Spawn_02
+- SFX_Crawler_Void_Walk
+- SFX_Creative_Play_Add_Mask
+- SFX_Creative_Play_Brush_Erase
+- SFX_Creative_Play_Brush_Mode
+- SFX_Creative_Play_Brush_Paint_Base
+- SFX_Creative_Play_Brush_Paint_Idle_Layer
+- SFX_Creative_Play_Brush_Paint_Move_Layer
+- SFX_Creative_Play_Brush_Shape
+- SFX_Creative_Play_Brush_Stamp
+- SFX_Creative_Play_Error
+- SFX_Creative_Play_Eyedropper_Select
+- SFX_Creative_Play_Paste
+- SFX_Creative_Play_Selection_Drag
+- SFX_Creative_Play_Selection_Place
+- SFX_Creative_Play_Selection_Scale
+- SFX_Creative_Play_Selection_Widget
+- SFX_Creative_Play_Set_Mask
+- SFX_Crocodile_Alerted
+- SFX_Crocodile_Death
+- SFX_Crocodile_Hurt
+- SFX_Crops_Grow
+- SFX_Crops_Grow_Stage_Complete
+- SFX_Crow_Death
+- SFX_Crow_Hurt
+- SFX_Crystal_Break
+- SFX_Crystal_Build
+- SFX_Crystal_Hit
+- SFX_Crystal_Walk
+- SFX_Daggers_T1_Guard
+- SFX_Daggers_T1_Guard_Local
+- SFX_Daggers_T1_Pounce
+- SFX_Daggers_T1_Pounce_Local
+- SFX_Daggers_T1_Slash_Impact
+- SFX_Daggers_T1_Stab_Double_Impact
+- SFX_Daggers_T1_Stab_Impact
+- SFX_Daggers_T1_Stab_Left_Local
+- SFX_Daggers_T1_Stab_Retreat
+- SFX_Daggers_T1_Stab_Retreat_Local
+- SFX_Daggers_T1_Stab_Right_Local
+- SFX_Daggers_T1_Swing
+- SFX_Daggers_T1_Swing_Double
+- SFX_Daggers_T1_Swing_Double_Local
+- SFX_Daggers_T1_Swing_LR_Local
+- SFX_Daggers_T1_Swing_RL_Local
+- SFX_Daggers_T2_Guard
+- SFX_Daggers_T2_Guard_Local
+- SFX_Daggers_T2_Signature_P1
+- SFX_Daggers_T2_Signature_P1_Local
+- SFX_Daggers_T2_Signature_P2
+- SFX_Daggers_T2_Signature_P2_Local
+- SFX_Daggers_T2_Signature_P3
+- SFX_Daggers_T2_Signature_P3_Local
+- SFX_Daggers_T2_Slash_Impact
+- SFX_Daggers_T2_Stab_Double_Impact
+- SFX_Daggers_T2_Stab_Impact
+- SFX_Daggers_T2_Stab_Left_Local
+- SFX_Daggers_T2_Stab_Retreat
+- SFX_Daggers_T2_Stab_Retreat_Local
+- SFX_Daggers_T2_Stab_Right_Local
+- SFX_Daggers_T2_Swing
+- SFX_Daggers_T2_Swing_Double
+- SFX_Daggers_T2_Swing_Double_Local
+- SFX_Daggers_T2_Swing_LR_Local
+- SFX_Daggers_T2_Swing_RL_Local
+- SFX_Deer_Doe_Alerted
+- SFX_Deer_Doe_Death
+- SFX_Deer_Doe_Hurt
+- SFX_Deer_Doe_Run
+- SFX_Deer_Doe_Sleep
+- SFX_Deer_Stag_Alerted
+- SFX_Deer_Stag_Death
+- SFX_Deer_Stag_Hurt
+- SFX_Deer_Stag_Roar
+- SFX_Deer_Stag_Run
+- SFX_Deer_Stag_Sleep
+- SFX_Deer_Walk
+- SFX_Default_Break
+- SFX_Default_Build
+- SFX_Default_Clone
+- SFX_Default_Harvest
+- SFX_Default_Walk
+- SFX_Deployable_Totem_Heal_Despawn
+- SFX_Deployable_Totem_Heal_Effect_Local
+- SFX_Deployable_Totem_Heal_Spawn
+- SFX_Deployable_Totem_Slowing_Despawn
+- SFX_Deployable_Totem_Slowing_Effect_Local
+- SFX_Deployable_Totem_Slowing_Spawn
+- SFX_Dirt_Break
+- SFX_Dirt_Build
+- SFX_Dirt_Clone
+- SFX_Dirt_Hit
+- SFX_Dirt_Land
+- SFX_Dirt_Walk
+- SFX_Discovery_Z1_Medium
+- SFX_Discovery_Z1_Short
+- SFX_Discovery_Z2_Medium
+- SFX_Discovery_Z2_Short
+- SFX_Discovery_Z3_Medium
+- SFX_Discovery_Z3_Short
+- SFX_Discovery_Z4_Medium
+- SFX_Discovery_Z4_Short
+- SFX_Divine_Respawn
+- SFX_Door_Ancient_Close
+- SFX_Door_Ancient_Open
+- SFX_Door_Crude_Close
+- SFX_Door_Crude_Open
+- SFX_Door_Desert_Close
+- SFX_Door_Desert_Open
+- SFX_Door_Jungle_Close
+- SFX_Door_Jungle_Open
+- SFX_Door_Lumberjack_Close
+- SFX_Door_Lumberjack_Open
+- SFX_Door_Temple_Dark_Close
+- SFX_Door_Temple_Dark_Open
+- SFX_Door_Temple_Light_Close
+- SFX_Door_Temple_Light_Open
+- SFX_Door_Wooden_Close
+- SFX_Door_Wooden_Open
+- SFX_Drag_Armor_Cloth
+- SFX_Drag_Armor_Heavy
+- SFX_Drag_Armor_Leather
+- SFX_Drag_Blocks_Gravel
+- SFX_Drag_Blocks_Soft
+- SFX_Drag_Blocks_Splatty
+- SFX_Drag_Blocks_Stone
+- SFX_Drag_Blocks_Wood
+- SFX_Drag_Item_Default
+- SFX_Drag_Items_Bones
+- SFX_Drag_Items_Chest
+- SFX_Drag_Items_Clay
+- SFX_Drag_Items_Cloth
+- SFX_Drag_Items_Foliage
+- SFX_Drag_Items_Gadget
+- SFX_Drag_Items_Gems
+- SFX_Drag_Items_Ingots
+- SFX_Drag_Items_Leather
+- SFX_Drag_Items_Metal
+- SFX_Drag_Items_Paper
+- SFX_Drag_Items_Potion
+- SFX_Drag_Items_Seeds
+- SFX_Drag_Items_Shells
+- SFX_Drag_Items_Splatty
+- SFX_Drag_Weapon_Blade_Small
+- SFX_Drag_Weapon_Blunt_Large
+- SFX_Drag_Weapons_Arrows
+- SFX_Drag_Weapons_Blade_Large
+- SFX_Drag_Weapons_Blunt_Small
+- SFX_Drag_Weapons_Books
+- SFX_Drag_Weapons_Shield_Metal
+- SFX_Drag_Weapons_Shield_Wood
+- SFX_Drag_Weapons_Stone_Large
+- SFX_Drag_Weapons_Stone_Small
+- SFX_Drag_Weapons_Wand
+- SFX_Drag_Weapons_Wood
+- SFX_Dragon_Sleep
+- SFX_Drop_Armor_Cloth
+- SFX_Drop_Armor_Heavy
+- SFX_Drop_Armor_Leather
+- SFX_Drop_Blocks_Gravel
+- SFX_Drop_Blocks_Soft
+- SFX_Drop_Blocks_Splatty
+- SFX_Drop_Blocks_Stone
+- SFX_Drop_Blocks_Wood
+- SFX_Drop_Item_Default
+- SFX_Drop_Items_Bones
+- SFX_Drop_Items_Chest
+- SFX_Drop_Items_Clay
+- SFX_Drop_Items_Cloth
+- SFX_Drop_Items_Foliage
+- SFX_Drop_Items_Gadget
+- SFX_Drop_Items_Gems
+- SFX_Drop_Items_Ingots
+- SFX_Drop_Items_Leather
+- SFX_Drop_Items_Metal
+- SFX_Drop_Items_Paper
+- SFX_Drop_Items_Potion
+- SFX_Drop_Items_Seeds
+- SFX_Drop_Items_Shells
+- SFX_Drop_Items_Splatty
+- SFX_Drop_Weapon_Blade_Small
+- SFX_Drop_Weapon_Blunt_Large
+- SFX_Drop_Weapons_Arrows
+- SFX_Drop_Weapons_Blade_Large
+- SFX_Drop_Weapons_Blunt_Small
+- SFX_Drop_Weapons_Books
+- SFX_Drop_Weapons_Shield_Metal
+- SFX_Drop_Weapons_Shield_Wood
+- SFX_Drop_Weapons_Stone_Large
+- SFX_Drop_Weapons_Stone_Small
+- SFX_Drop_Weapons_Wand
+- SFX_Drop_Weapons_Wood
+- SFX_Duck_Alerted
+- SFX_Duck_Death
+- SFX_Duck_Hurt
+- SFX_Duck_Run
+- SFX_Effect_Burn_Local
+- SFX_Effect_Burn_World
+- SFX_Effect_Poison_Local
+- SFX_Effect_Poison_World
+- SFX_Egg_Hit
+- SFX_Egg_Miss
+- SFX_Eggsac_Active
+- SFX_Emberwulf_Alerted
+- SFX_Emberwulf_Attack_Bite
+- SFX_Emberwulf_Death
+- SFX_Emberwulf_Hurt
+- SFX_Emberwulf_Run
+- SFX_Emberwulf_Sleep
+- SFX_Emberwulf_Walk
+- SFX_Emit_Forgotten_Whispers
+- SFX_Emit_Lake_Water
+- SFX_Emit_Temple_Wisps
+- SFX_Emit_Tree_Creak
+- SFX_Emit_Wind_Grass
+- SFX_Emit_Wind_Gusts
+- SFX_Env_Emit_Fluid_Lava
+- SFX_Env_Emit_Fluid_Water
+- SFX_Env_Emit_Fluid_Water_Far
+- SFX_Env_Emit_Geyzer
+- SFX_Eye_Void_Alerted
+- SFX_Eye_Void_Attack_Blast
+- SFX_Eye_Void_Attack_Summon
+- SFX_Eye_Void_Death
+- SFX_Eye_Void_Fly_Movement
+- SFX_Eye_Void_Hurt
+- SFX_Eye_Void_Idle
+- SFX_Fen_Stalker_Alerted
+- SFX_Fen_Stalker_Attack_Swing
+- SFX_Fen_Stalker_Attack_Swipe
+- SFX_Fen_Stalker_Death
+- SFX_Fen_Stalker_Eat
+- SFX_Fen_Stalker_Eat_Finish
+- SFX_Fen_Stalker_Greet
+- SFX_Fen_Stalker_Hurt
+- SFX_Fen_Stalker_Run
+- SFX_Fen_Stalker_Scared
+- SFX_Fen_Stalker_Seek
+- SFX_Fen_Stalker_Sniff
+- SFX_Feran_Death
+- SFX_Fern_Break
+- SFX_Fern_MoveIn
+- SFX_Fireball_Bounce
+- SFX_Fireball_Death
+- SFX_Fireball_Miss
+- SFX_Fish_Death
+- SFX_Fish_Flee
+- SFX_Fish_Hurt
+- SFX_Flail_Charge
+- SFX_Flail_Charge_Local
+- SFX_Flail_Swing
+- SFX_Flail_Swing_Left_Local
+- SFX_Flail_Swing_Right_Local
+- SFX_Flame_Break
+- SFX_Flame_Build
+- SFX_Flame_Default_Loop
+- SFX_Flamingo_Alerted
+- SFX_Flamingo_Death
+- SFX_Flamingo_Fly
+- SFX_Flamingo_Hurt
+- SFX_Forgotten_Temple_Emit_Birds
+- SFX_Forgotten_Temple_Emit_Birds_Interior
+- SFX_Fox_Alerted
+- SFX_Fox_Death
+- SFX_Fox_Hurt
+- SFX_Fox_Run
+- SFX_Fox_Sleep
+- SFX_Frog_Alerted
+- SFX_Frog_Croak
+- SFX_Frog_Death
+- SFX_Frog_Hurt
+- SFX_Frog_Idle
+- SFX_Frog_Run
+- SFX_Furnace_Bench_Close
+- SFX_Furnace_Bench_Open
+- SFX_Furnace_Bench_Processing
+- SFX_Furnace_Bench_Processing_Complete
+- SFX_Furnace_Bench_Processing_End
+- SFX_Furnace_Bench_Processing_Failed
+- SFX_Gecko_Alerted
+- SFX_Gecko_Death
+- SFX_Gecko_Hurt
+- SFX_Gem_Break
+- SFX_Gem_Emit_Loop
+- SFX_Generic_Crafting_Failed
+- SFX_Glass_Break
+- SFX_Global_Weather_Thunder
+- SFX_Goat_Run
+- SFX_Goat_Walk
+- SFX_Goblin_Alerted
+- SFX_Goblin_Death
+- SFX_Goblin_Hurt
+- SFX_Goblin_Lobber_Bomb_Bounce
+- SFX_Goblin_Lobber_Bomb_Death
+- SFX_Goblin_Lobber_Bomb_Hit
+- SFX_Goblin_Lobber_Bomb_Miss
+- SFX_Goblin_Run
+- SFX_Goblin_Search
+- SFX_Golem_Earth_Alerted
+- SFX_Golem_Earth_Death
+- SFX_Golem_Earth_Hurt
+- SFX_Golem_Earth_Laydown
+- SFX_Golem_Earth_Slam
+- SFX_Golem_Earth_Slam_Impact
+- SFX_Golem_Earth_Spin
+- SFX_Golem_Earth_Stomp
+- SFX_Golem_Earth_Stomp_Impact
+- SFX_Golem_Earth_Swing
+- SFX_Golem_Earth_Swing_Impact
+- SFX_Golem_Earth_Wake
+- SFX_Golem_Firesteel_Alerted_01
+- SFX_Golem_Firesteel_Alerted_02
+- SFX_Golem_Firesteel_Death
+- SFX_Golem_Firesteel_Laydown
+- SFX_Golem_Firesteel_Wake
+- SFX_Golem_Frost_Alerted
+- SFX_Golem_Frost_Death
+- SFX_Golem_Frost_Hurt
+- SFX_Golem_Frost_Laydown
+- SFX_Golem_Frost_Slam
+- SFX_Golem_Frost_Slam_Impact
+- SFX_Golem_Frost_Spin
+- SFX_Golem_Frost_Stomp
+- SFX_Golem_Frost_Swing
+- SFX_Golem_Frost_Swing_Impact
+- SFX_Golem_Frost_Wake
+- SFX_Golem_Sand_Alerted
+- SFX_Golem_Sand_Death
+- SFX_Golem_Sand_Hurt
+- SFX_Golem_Sand_Laydown
+- SFX_Golem_Sand_Slam
+- SFX_Golem_Sand_Slam_Impact
+- SFX_Golem_Sand_Spin
+- SFX_Golem_Sand_Stomp
+- SFX_Golem_Sand_Stomp_Impact
+- SFX_Golem_Sand_Swing
+- SFX_Golem_Sand_Swing_Impact
+- SFX_Golem_Sand_Wake
+- SFX_Grass_Break
+- SFX_Grass_Build
+- SFX_Grass_Hit
+- SFX_Grass_Land
+- SFX_Grass_Walk
+- SFX_Gravel_Break
+- SFX_Gravel_Build
+- SFX_Gravel_Hit
+- SFX_Gravel_Land
+- SFX_Gravel_Walk
+- SFX_GunPvP_Assault_Rifle_Bullet_Death
+- SFX_GunPvP_Grenade_Frag_Bounce
+- SFX_GunPvP_Grenade_Frag_Death
+- SFX_GunPvP_Grenade_Frag_Hit
+- SFX_GunPvP_Grenade_Frag_Miss
+- SFX_GunPvP_Handgun_Bullet_Death
+- SFX_Gun_Fire
+- SFX_Hand_Crossbow_T1_Block_Impact
+- SFX_Hand_Crossbow_T1_Raise
+- SFX_Hand_Crossbow_T1_Raise_Local
+- SFX_Hand_Crossbow_T1_Shove
+- SFX_Hand_Crossbow_T1_Shove_Local
+- SFX_Hand_Crossbow_T2_Load
+- SFX_Hand_Crossbow_T2_Load_Local
+- SFX_Hand_Crossbow_T2_Reload_Start
+- SFX_Hand_Crossbow_T2_Reload_Start_Local
+- SFX_Handgun_Fire
+- SFX_Handgun_Fire_Local
+- SFX_Hatchet_T1_Swing_RL_Local
+- SFX_Hatchet_T2_Impact_Nice
+- SFX_Health_Potion_High_Drink
+- SFX_Health_Potion_High_Drink_Local
+- SFX_Health_Potion_Low_Drink
+- SFX_Health_Potion_Low_Drink_Local
+- SFX_Hedera_Scream
+- SFX_Hoe_T1_Swing_Down_Local
+- SFX_Hoe_T1_Till
+- SFX_Horse_Alerted
+- SFX_Horse_Death
+- SFX_Horse_Hurt
+- SFX_Horse_Idle
+- SFX_Horse_Sleep
+- SFX_Horse_Wake
+- SFX_Hyena_Alerted
+- SFX_Hyena_Death
+- SFX_Hyena_Hurt
+- SFX_Hyena_Idle
+- SFX_Ice_Ball_Death
+- SFX_Ice_Bolt_Death
+- SFX_Ice_Break
+- SFX_Ice_Build
+- SFX_Ice_Hit
+- SFX_Ice_Item_Impact
+- SFX_Ice_Item_Swing
+- SFX_Ice_Land
+- SFX_Ice_Walk
+- SFX_Incorrect_Tool
+- SFX_Item_Break
+- SFX_Item_Repair
+- SFX_Klops_Alerted
+- SFX_Klops_Death
+- SFX_Klops_Hurt
+- SFX_Klops_Idle
+- SFX_Klops_Run
+- SFX_Kweebec_Plushie_Impact
+- SFX_Lamb_Alerted
+- SFX_Lamb_Death
+- SFX_Lamb_Hurt
+- SFX_Larva_Alerted
+- SFX_Larva_Death
+- SFX_Larva_Despawn
+- SFX_Larva_Hurt
+- SFX_Larva_Spawn
+- SFX_LeavesGround_Break
+- SFX_LeavesGround_Hit
+- SFX_LeavesGround_Land
+- SFX_LeavesGround_Walk
+- SFX_Leaves_Break
+- SFX_Leaves_Hit
+- SFX_Leaves_Walk
+- SFX_Leopard_Snow_Alerted
+- SFX_Leopard_Snow_Death
+- SFX_Leopard_Snow_Hurt
+- SFX_Leopard_Snow_Run
+- SFX_Light_Melee_T1_Block
+- SFX_Light_Melee_T1_Guard_Hit
+- SFX_Light_Melee_T1_Impact
+- SFX_Light_Melee_T1_Lunge
+- SFX_Light_Melee_T1_Lunge_Charge
+- SFX_Light_Melee_T1_Shove
+- SFX_Light_Melee_T1_Swing
+- SFX_Light_Melee_T2_Block
+- SFX_Light_Melee_T2_Guard_Break
+- SFX_Light_Melee_T2_Guard_Hit
+- SFX_Light_Melee_T2_Lunge
+- SFX_Light_Melee_T2_Lunge_Charge
+- SFX_Light_Melee_T2_Swing
+- SFX_Longsword_Special_Impact
+- SFX_Longsword_Special_Swing
+- SFX_Longsword_Steel_Charged_Swing
+- SFX_Longsword_Steel_Impact
+- SFX_Longsword_Steel_Swing
+- SFX_Lumbermill_Bench_Close
+- SFX_Lumbermill_Bench_Open
+- SFX_Lumbermill_Bench_Processing
+- SFX_Mace_T1_Block_Impact
+- SFX_Mace_T1_Impact
+- SFX_Mace_T1_Raise
+- SFX_Mace_T1_Raise_Local
+- SFX_Mace_T1_Shove
+- SFX_Mace_T1_Shove_Local
+- SFX_Mace_T1_Swing
+- SFX_Mace_T1_Swing_Charged
+- SFX_Mace_T1_Swing_Charged_LR_Local
+- SFX_Mace_T1_Swing_Charged_RL_Local
+- SFX_Mace_T1_Swing_Charged_Up_Local
+- SFX_Mace_T1_Swing_LR_Local
+- SFX_Mace_T1_Swing_RL_Local
+- SFX_Mace_T1_Swing_Up_Local
+- SFX_Mace_T2_Impact
+- SFX_Mace_T2_Raise
+- SFX_Mace_T2_Raise_Local
+- SFX_Mace_T2_Signature_Impact
+- SFX_Mace_T2_Signature_Impact_Local
+- SFX_Mace_T2_Signature_Launch
+- SFX_Mace_T2_Signature_Launch_Local
+- SFX_Mace_T2_Swing
+- SFX_Mace_T2_Swing_Charged
+- SFX_Mace_T2_Swing_Charged_LR_Local
+- SFX_Mace_T2_Swing_Charged_RL_Local
+- SFX_Mace_T2_Swing_Charged_Up_Local
+- SFX_Mace_T2_Swing_LR_Local
+- SFX_Mace_T2_Swing_RL_Local
+- SFX_Mace_T2_Swing_Up_Local
+- SFX_Meerkat_Alerted
+- SFX_Meerkat_Death
+- SFX_Meerkat_Hurt
+- SFX_Meerkat_Idle
+- SFX_Memories_Unlock_Local
+- SFX_Metal_Break
+- SFX_Metal_Build
+- SFX_Metal_Hit
+- SFX_Metal_Land
+- SFX_Metal_Walk
+- SFX_Moose_Bull_Alerted
+- SFX_Mouse_Alerted
+- SFX_Mouse_Death
+- SFX_Mouse_Flee
+- SFX_Mouse_Hurt
+- SFX_Mouse_Run
+- SFX_Mouse_Sleep
+- SFX_Mud_Break
+- SFX_Mud_Build
+- SFX_Mud_Hit
+- SFX_Mud_Land
+- SFX_Mud_Walk
+- SFX_Mug_Fill
+- SFX_Mug_Fill_Local
+- SFX_Mushroom_Break
+- SFX_Mushroom_Harvest
+- SFX_Music_Ducking_2db
+- SFX_NPC_Unarmed_Impact
+- SFX_NPC_Unarmed_Swing
+- SFX_Ore_Break
+- SFX_Ore_Hit
+- SFX_Outlander_Hunter_Arrow_Hit
+- SFX_Outlander_Hunter_Arrow_Miss
+- SFX_Outlander_Hurt
+- SFX_Owl_Alerted
+- SFX_Owl_Death
+- SFX_Owl_Hurt
+- SFX_Pickaxe_T1_Swing_Down_Local
+- SFX_Pickaxe_T2_Impact_Nice
+- SFX_Pig_Alerted
+- SFX_Pig_Death
+- SFX_Pig_Hurt
+- SFX_Pig_Run
+- SFX_Pig_Walk
+- SFX_Pigeon_Death
+- SFX_Pigeon_Hurt
+- SFX_Piglet_Alerted
+- SFX_Piglet_Death
+- SFX_Piglet_Hurt
+- SFX_Piglet_Run
+- SFX_Pistol_Fire
+- SFX_Plant_Break
+- SFX_Plant_Hit
+- SFX_Plant_MoveIn
+- SFX_Player_Climb_Down
+- SFX_Player_Climb_Side
+- SFX_Player_Climb_Up
+- SFX_Player_Craft_Item_Inventory
+- SFX_Player_Death
+- SFX_Player_Death_Drown
+- SFX_Player_Death_Fall
+- SFX_Player_Drop_Item
+- SFX_Player_Fall
+- SFX_Player_Glide_Motion
+- SFX_Player_Glide_Stationary
+- SFX_Player_Grab_Item
+- SFX_Player_Hurt
+- SFX_Player_Hurt_Burn
+- SFX_Player_Hurt_Drowning
+- SFX_Player_Hurt_Fall
+- SFX_Player_Jump
+- SFX_Player_Mantle
+- SFX_Player_Pickup_Item
+- SFX_Player_Roll
+- SFX_Player_Slide
+- SFX_Player_Swim
+- SFX_Player_Swim_Fast
+- SFX_Player_Swim_Jump
+- SFX_Player_Unarmed_Swing_Left
+- SFX_Player_Unarmed_Swing_Right
+- SFX_Plushie_Break
+- SFX_Plushie_Build
+- SFX_Poop_Bounce
+- SFX_Poop_Break
+- SFX_Poop_Hit
+- SFX_Poop_Walk
+- SFX_Portal_Neutral
+- SFX_Portal_Neutral_Open
+- SFX_Portal_Neutral_Teleport_Local
+- SFX_Portal_Void
+- SFX_Potion_Drink_Success
+- SFX_Processing_Placeholder
+- SFX_Projectile_Poop_Hit
+- SFX_Rabbit_Alerted
+- SFX_Rabbit_Death
+- SFX_Rabbit_Hurt
+- SFX_Rabbit_Run
+- SFX_Rabbit_Sleep
+- SFX_Ram_Alerted
+- SFX_Ram_Death
+- SFX_Ram_Hurt
+- SFX_Ram_Run
+- SFX_Ram_Sleep
+- SFX_Raptor_Cave_Alerted
+- SFX_Raptor_Cave_Idle
+- SFX_Rat_Death
+- SFX_Rat_Hurt
+- SFX_Raven_Alerted
+- SFX_Raven_Death
+- SFX_Raven_Flee
+- SFX_Raven_Hurt
+- SFX_Reeds_MoveIn
+- SFX_Rifle_Fire
+- SFX_Rifle_Fire_Local
+- SFX_Rope_Break
+- SFX_Rope_Build
+- SFX_Rope_Land
+- SFX_Rope_Walk
+- SFX_Rotate_Pitch_Default
+- SFX_Rotate_Roll_Default
+- SFX_Rotate_Yaw_Default
+- SFX_Rubble_Bounce
+- SFX_Rubble_Hit
+- SFX_Sand_Break
+- SFX_Sand_Build
+- SFX_Sand_Hit
+- SFX_Sand_Land
+- SFX_Sand_Walk
+- SFX_Scarak_Fighter_Alerted
+- SFX_Scarak_Fighter_Death
+- SFX_Scarak_Fighter_Hurt
+- SFX_Scarak_Seeker_Alerted
+- SFX_Scarak_Seeker_Death
+- SFX_Scarak_Seeker_Hurt
+- SFX_Scarak_Seeker_Spitball_Death
+- SFX_Scarak_Spitball_Fire
+- SFX_Scorpion_Alerted
+- SFX_Scorpion_Death
+- SFX_Scorpion_Run
+- SFX_Scorpion_Threaten
+- SFX_Seeds_Place
+- SFX_Shark_Death
+- SFX_Shark_Dive
+- SFX_Shark_Hurt
+- SFX_Shark_Swim
+- SFX_Shears_Activate
+- SFX_Sheep_Alerted
+- SFX_Sheep_Death
+- SFX_Sheep_Hurt
+- SFX_Sheep_Run
+- SFX_Sheep_Sheared
+- SFX_Sheep_Walk
+- SFX_Shield_T1_Break
+- SFX_Shield_T1_Impact
+- SFX_Shield_T1_Raise
+- SFX_Shield_T1_Raise_Local
+- SFX_Shield_T1_Swing
+- SFX_Shield_T1_Swing_Local
+- SFX_Shield_T2_Impact
+- SFX_Shield_T2_Raise
+- SFX_Shield_T2_Raise_Local
+- SFX_Shield_T2_Swing
+- SFX_Shield_T2_Swing_Local
+- SFX_Shovel_T1_Swing_RL_Local
+- SFX_Shovel_T2_Impact_Nice
+- SFX_Skeleton_Alerted
+- SFX_Skeleton_Death_1
+- SFX_Skeleton_Death_2
+- SFX_Skeleton_Death_3
+- SFX_Skeleton_Death_4
+- SFX_Skeleton_Despawn_1
+- SFX_Skeleton_Despawn_2
+- SFX_Skeleton_Hurt
+- SFX_Skeleton_Mage_Spellbook_Charge
+- SFX_Skeleton_Mage_Spellbook_Impact
+- SFX_Skeleton_Praetorian_Alerted
+- SFX_Skeleton_Praetorian_Death_1
+- SFX_Skeleton_Praetorian_Death_2
+- SFX_Skeleton_Praetorian_Death_3
+- SFX_Skeleton_Praetorian_Death_4
+- SFX_Skeleton_Praetorian_Despawn_1
+- SFX_Skeleton_Praetorian_Despawn_2
+- SFX_Skeleton_Praetorian_Hurt
+- SFX_Skeleton_Praetorian_Run
+- SFX_Skeleton_Praetorian_Search_2
+- SFX_Skeleton_Praetorian_Spawn_1
+- SFX_Skeleton_Praetorian_Walk
+- SFX_Skeleton_Run
+- SFX_Skeleton_Search_2
+- SFX_Skeleton_Spawn_1
+- SFX_Skeleton_Spawn_2
+- SFX_Skeleton_Walk
+- SFX_Snake_Alerted
+- SFX_Snake_Death
+- SFX_Snake_Hurt
+- SFX_Snake_Idle
+- SFX_Snow_Break
+- SFX_Snow_Build
+- SFX_Snow_Hit
+- SFX_Snow_Land
+- SFX_Snow_Walk
+- SFX_Soft_Break
+- SFX_Soft_Build
+- SFX_Soft_Hit
+- SFX_Soft_Land
+- SFX_Soft_Walk
+- SFX_Spark_Living_Alerted
+- SFX_Spark_Living_Death
+- SFX_Sparrow_Alerted
+- SFX_Sparrow_Death
+- SFX_Sparrow_Hurt
+- SFX_Sparrow_Idle
+- SFX_Spawn_Void_Alerted
+- SFX_Spawn_Void_Attack
+- SFX_Spawn_Void_Death
+- SFX_Spawn_Void_Hurt
+- SFX_Spawn_Void_Run
+- SFX_Spear_Impact
+- SFX_Spear_Lunge
+- SFX_Spear_Lunge_Local
+- SFX_Spear_Miss
+- SFX_Spear_Projectile_Impact
+- SFX_Spear_Throw
+- SFX_Spear_Throw_Charge
+- SFX_Spear_Throw_Charge_Local
+- SFX_Spear_Throw_Local
+- SFX_Spider_Alerted
+- SFX_Spider_Death
+- SFX_Spider_Run
+- SFX_Spirit_Root_Alerted
+- SFX_Spirit_Root_Death_01
+- SFX_Spirit_Root_Death_02
+- SFX_Spirit_Root_Hurt
+- SFX_Spirit_Root_Spawn
+- SFX_Squirrel_Alerted
+- SFX_Squirrel_Death
+- SFX_Squirrel_Hurt
+- SFX_Squirrel_Run
+- SFX_Staff_Charged_Loop
+- SFX_Staff_Fire_Shoot
+- SFX_Staff_Flame_Consume_Charge_1
+- SFX_Staff_Flame_Consume_Charge_1_Local
+- SFX_Staff_Flame_Consume_Charge_2
+- SFX_Staff_Flame_Consume_Charge_2_Local
+- SFX_Staff_Flame_Consume_Charge_3
+- SFX_Staff_Flame_Consume_Charge_3_Local
+- SFX_Staff_Flame_Consume_Charge_4
+- SFX_Staff_Flame_Consume_Charge_4_Local
+- SFX_Staff_Flame_Fireball_Impact
+- SFX_Staff_Flame_Fireball_Launch
+- SFX_Staff_Flame_Fireball_Launch_Local
+- SFX_Staff_Flame_Flamethrower
+- SFX_Staff_Flame_Flamethrower_End
+- SFX_Staff_Flame_Flamethrower_End_Local
+- SFX_Staff_Flame_Flamethrower_Impact
+- SFX_Staff_Flame_Flamethrower_Local
+- SFX_Staff_Flame_Trap_Deploy
+- SFX_Staff_Flame_Trap_Despawn
+- SFX_Staff_Flame_Trap_Loop
+- SFX_Staff_Ice_Shoot
+- SFX_Stamina_Potion_Success
+- SFX_Sticks_Break
+- SFX_Stone_Break
+- SFX_Stone_Build
+- SFX_Stone_Coffin_Open_Close
+- SFX_Stone_Harvest
+- SFX_Stone_Hit
+- SFX_Stone_Land
+- SFX_Stone_Walk
+- SFX_Sword_T1_Block_Local
+- SFX_Sword_T1_Lunge_Charge_Local
+- SFX_Sword_T1_Lunge_Local
+- SFX_Sword_T1_Shove_Local
+- SFX_Sword_T1_Swing_Down_Local
+- SFX_Sword_T1_Swing_LR_Local
+- SFX_Sword_T1_Swing_RL_Local
+- SFX_Sword_T2_Block_Local
+- SFX_Sword_T2_Impact
+- SFX_Sword_T2_Lunge_Charge_Local
+- SFX_Sword_T2_Lunge_Local
+- SFX_Sword_T2_Signature_Part_1
+- SFX_Sword_T2_Signature_Part_1_Local
+- SFX_Sword_T2_Signature_Part_2
+- SFX_Sword_T2_Signature_Part_2_Local
+- SFX_Sword_T2_Swing_Down_Local
+- SFX_Sword_T2_Swing_LR_Local
+- SFX_Sword_T2_Swing_RL_Local
+- SFX_T1_Impact_Blunt
+- SFX_Tall_Grass_MoveIn
+- SFX_Test_Blip_A
+- SFX_Test_Blip_B
+- SFX_Test_Blip_C
+- SFX_Tetrabird_Alerted
+- SFX_Tetrabird_Death
+- SFX_Tetrabird_Flee
+- SFX_Tetrabird_Hurt
+- SFX_Tetrabird_Run
+- SFX_Tiger_Sabertooth_Alerted
+- SFX_Tiger_Sabertooth_Death
+- SFX_Tiger_Sabertooth_Hurt
+- SFX_Tiger_Sabertooth_Run
+- SFX_Toad_Rhino_Alerted
+- SFX_Toad_Rhino_Death
+- SFX_Toad_Rhino_Hurt
+- SFX_Toad_Rhino_Magma_Alerted
+- SFX_Toad_Rhino_Magma_Death
+- SFX_Toad_Rhino_Magma_Hurt
+- SFX_Toad_Rhino_Magma_Run
+- SFX_Toad_Rhino_Magma_Tongue_Impact
+- SFX_Toad_Rhino_Magma_Tongue_Whoosh
+- SFX_Toad_Rhino_Run
+- SFX_Toad_Rhino_Tongue_Impact
+- SFX_Toad_Rhino_Tongue_Whoosh
+- SFX_Tombstone_Break
+- SFX_Tool_T1_Swing
+- SFX_Tool_Watering_Can_Water
+- SFX_Torch_Break
+- SFX_Torch_Build
+- SFX_Torch_Default_Loop
+- SFX_Torch_Impact
+- SFX_Torch_Off
+- SFX_Torch_On_Loop
+- SFX_Torch_Swing
+- SFX_Torch_Swing_Left_Local
+- SFX_Torch_Swing_Right_Local
+- SFX_Tornado
+- SFX_Trashpile_Land
+- SFX_Trashpile_Walk
+- SFX_Trork_Alerted
+- SFX_Trork_Chieftain_Alerted
+- SFX_Trork_Chieftain_Death
+- SFX_Trork_Chieftain_Hurt
+- SFX_Trork_Chieftain_Run
+- SFX_Trork_Chieftain_Search
+- SFX_Trork_Death
+- SFX_Trork_Exertion
+- SFX_Trork_Hurt_01
+- SFX_Trork_Hurt_02
+- SFX_Trork_Run
+- SFX_Trork_Search
+- SFX_Trork_Sleep
+- SFX_Trork_Throwing_Axe
+- SFX_Unarmed_Impact
+- SFX_Unarmed_Swing
+- SFX_Unbreakable_Block
+- SFX_Vulture_Alerted
+- SFX_Vulture_Death
+- SFX_Vulture_Flee
+- SFX_Vulture_Hurt
+- SFX_Wand_Fire_Shoot
+- SFX_Wand_Ice_Shoot
+- SFX_Warthog_Alerted
+- SFX_Warthog_Death
+- SFX_Warthog_Hurt
+- SFX_Warthog_Piglet_Alerted
+- SFX_Warthog_Piglet_Death
+- SFX_Warthog_Piglet_Hurt
+- SFX_Warthog_Piglet_Run
+- SFX_Warthog_Run
+- SFX_Warthog_Sleep
+- SFX_Warthog_Walk
+- SFX_Water_MoveIn
+- SFX_Water_MoveOut
+- SFX_Weapon_Bench_Close
+- SFX_Weapon_Bench_Craft
+- SFX_Weapon_Bench_Open
+- SFX_Weapon_Charge_Swing
+- SFX_Web_MoveIn
+- SFX_Window_Break
+- SFX_Window_Stone_Break
+- SFX_Wisp_Lamp_Loop
+- SFX_Wolf_Alerted
+- SFX_Wolf_Death
+- SFX_Wolf_Hurt
+- SFX_Wolf_Run
+- SFX_Wolf_Sleep
+- SFX_Wood_Break
+- SFX_Wood_Build
+- SFX_Wood_Hit
+- SFX_Wood_Land
+- SFX_Wood_Walk
+- SFX_Woodpecker_Death
+- SFX_Woodpecker_Hurt
+- SFX_Workbench_Close
+- SFX_Workbench_Craft
+- SFX_Workbench_Open
+- SFX_Workbench_Upgrade_Complete_Default
+- SFX_Workbench_Upgrade_Start_Default
+- SFX_Yeti_Alerted
+- SFX_Z1_Emit_Forest_Autumn_Day_Birds
+- SFX_Z1_Emit_Forest_Autumn_Day_Insects
+- SFX_Z1_Emit_Forest_Autumn_Day_Wind
+- SFX_Z1_Emit_Forest_Azure_Day_Insects
+- SFX_Z1_Emit_Forest_Azure_Day_Wind
+- SFX_Z1_Emit_Forest_Gen_Day_Birds
+- SFX_Z1_Emit_Forest_Gen_Day_Insects
+- SFX_Z1_Emit_Forest_Gen_Day_Winds
+- SFX_Z1_Emit_Forest_Moss_Day_Birds
+- SFX_Z1_Emit_Forest_Moss_Day_Insects
+- SFX_Z1_Emit_Forest_Moss_Day_Wind
+- SFX_Z1_Emit_Forest_Night_Birds
+- SFX_Z1_Emit_Forest_Night_Insects
+- SFX_Z1_Emit_Forest_Night_Wind
+- SFX_Z1_Emit_Kweebec_Village_Wind
+- SFX_Z1_Emit_Mountain_Day_Birds
+- SFX_Z1_Emit_Plains_Gen_Day_Birds
+- SFX_Z1_Emit_Plains_Gen_Day_Insects
+- SFX_Z1_Emit_Plains_Gen_Day_Wind
+- SFX_Z1_Emit_Plains_Gen_Night_Birds
+- SFX_Z1_Emit_Plains_Gen_Night_Insects
+- SFX_Z1_Emit_Plains_Gen_Night_Wind
+- SFX_Z1_Emit_Shore_Day_Birds
+- SFX_Z1_Emit_Shore_Waves
+- SFX_Z1_Emit_Shore_Wind
+- SFX_Z1_Emit_Swamp_Day_Birds
+- SFX_Z1_Emit_Swamp_Day_Frogs
+- SFX_Z1_Emit_Swamp_Day_Insects
+- SFX_Z1_Emit_Swamp_Day_Wind
+- SFX_Z1_Emit_Swamp_Night_Frogs
+- SFX_Z1_Emit_Trork_Camp
+- SFX_Z1_Shore_Day_Birds
+- SFX_Z3_Emit_Cave_Ice_Crackle
+- SFX_Z3_Emit_Cave_Ice_Rumble
+- SFX_Z3_Emit_Cave_Ice_Stress
+- SFX_Z3_Emit_Cave_Snow_Crackle
+- SFX_Z3_Emit_Cave_Snow_Melt
+- SFX_Z3_Emit_Hedera_FX
+- SFX_Z3_Emit_Hedera_PlantRustle
+- SFX_Z3_Emit_Tree_Creak
+- SFX_Z3_Emit_Wind_Leaves
+- SFX_Z3_Emit_Wind_Leaves_Stereo
+- SFX_Z3_Forest_Day_Birds
+- SFX_Z3_Forest_Day_General
+- SFX_Z3_Forest_Night_Birds
+- SFX_Zombie_Alerted
+- SFX_Zombie_Attack_Bite
+- SFX_Zombie_Attack_Swing
+- SFX_Zombie_Death
+- SFX_Zombie_Despawn
+- SFX_Zombie_Hurt
+- SFX_Zombie_Pursuit
+- SFX_Zombie_ScratchBack
+- SFX_Zombie_Spawn
diff --git a/content/docs/cs-CZ/contributing/pr-guidelines.mdx b/content/docs/cs-CZ/contributing/pr-guidelines.mdx
index 7a251032..c226da04 100644
--- a/content/docs/cs-CZ/contributing/pr-guidelines.mdx
+++ b/content/docs/cs-CZ/contributing/pr-guidelines.mdx
@@ -19,6 +19,8 @@ To ensure a smooth and efficient review process, both contributors and reviewers
 4. **Code Quality**
    - Ensure your code follows the project's coding standards and best practices.
    - Include comments where necessary to explain complex logic.
+   - Always test your changes locally before submitting the PR to catch any issues early.
+   - Format your code using `bun format` to maintain consistency across the codebase.
 5. **Testing**
    - Test your changes thoroughly before submitting the PR.
    - If applicable, include unit tests or integration tests to verify your changes.
diff --git a/content/docs/cs-CZ/contributing/translate.mdx b/content/docs/cs-CZ/contributing/translate.mdx
new file mode 100644
index 00000000..c62ffdde
--- /dev/null
+++ b/content/docs/cs-CZ/contributing/translate.mdx
@@ -0,0 +1,74 @@
+---
+title: Translate
+description: How to translate HytaleModding to your language
+---
+
+# Translating HytaleModding
+
+HytaleModding is translated with the help of the community using **Crowdin**. If you want to help translate or improve existing translations, this is the right place.
+
+## Steps to Translate
+
+All translations are managed **via Crowdin**.
+
+1. Visit [our Crowdin project](https://crowdin.com/project/hytalemodding) and log in if required.
+2. Click on your language.
+3. Click on the file/article you wish to translate. We recommend starting with Official Documentation, and then Server Plugin Documentation.
+4. Start translating!
+5. Approved translations will appear on the website.
+
+### Video Guide
+
+<iframe src="https://www.youtube.com/embed/NHiG1rDRgks" allowFullScreen />
+
+## How to discuss
+
+You can always report issues or discuss specific topics directly on Crowdin, but we recommend using Discord instead of the Crowdin comment system to keep everything organized in one place.
+
+1. Join [our Discord](https://discord.gg/hytalemodding)
+2. Open `#translations` channel. Here you can discuss or ask questions that are not related to a specific language.
+3. If you want to join a thread, you are required to run `/translator <your-language>` command here. The bot will add you to the thread for your language.
+
+## Translation Guidelines
+
+- You need to be confident in what you are translating. You should be able to read the text you just translated and understand the meaning of it very easily.
+- It should use the simplest form of language possible. Use English words if the translation is unknown to the majority in your country.
+- Use your imagination, trust yourself. Feel free to change any context as you wish as long as it can still get the same point across and is understandable.
+- These guidelines are more important than language-specific guidelines, but less important than Hytale terminology and rules.
+
+## What not to translate
+
+We request you all to not translate these specific sections of the website:
+
+### Callout types
+
+Callouts are the boxes that contain important information. We request you to not translate the types as they only work in English.
+
+**Example:**
+
+```mdx
+<Callout type="warning" title="Translate this title!">
+Translate the text inside the callout!
+</Callout>
+```
+
+In this example, please don't translate the word warning, the rest you can translate.
+
+### Icons
+
+Icon names must not be translated.
+They are technical identifiers mapped directly to existing icons. Translating them will break the icon rendering.
+
+```mdx
+icon: Globe
+```
+
+---
+
+{/* 
+For translators who will edit this page:
+
+- You are required to translate the Guidelines as they change.
+- General guidelines should be translated but not edited.
+- Learn how to use Markdown from writing_guides.mdx
+*/}
diff --git a/content/docs/cs-CZ/established-information/server/content-categories/art-assets.mdx b/content/docs/cs-CZ/established-information/server/content-categories/art-assets.mdx
index 39c2ed37..1e926874 100644
--- a/content/docs/cs-CZ/established-information/server/content-categories/art-assets.mdx
+++ b/content/docs/cs-CZ/established-information/server/content-categories/art-assets.mdx
@@ -14,7 +14,7 @@ Hytale provides comprehensive support for 3D modeling and texture art creation,
 Hytale uses **Blockbench** as the primary tool for 3D modeling and animation:
 
 * **Official support**: Used for "creating Hytale models, textures, and animations"
-* **Special plugin**: Hytale will have a dedicated Blockbench plugin, to be released ASAP
+* **Special plugin**: Hytale has a dedicated [Blockbench Plugin](https://www.blockbench.net/plugins/hytale_plugin).
 * **Direct compatibility**: The plugin allows creators to "create Hytale-compatible models, textures, and animations directly in Blockbench"
 * **Replaces legacy tools**: Fully replaces the old Hytale Model Maker to better support established creative workflows in the community
 * **Safety features**: Only allows you to add things compatible with the engine, so no need to worry about breaking anything
diff --git a/content/docs/cs-CZ/guides/ecs/block-components.mdx b/content/docs/cs-CZ/guides/ecs/block-components.mdx
new file mode 100644
index 00000000..ca68b38a
--- /dev/null
+++ b/content/docs/cs-CZ/guides/ecs/block-components.mdx
@@ -0,0 +1,247 @@
+---
+title: Block Components
+description: Learn how to use the block components.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+  - name: oskarscot
+    link: https://oskar.scot
+---
+
+# Overview
+
+In this guide, you'll learn how to use block components to create a ticking block.
+
+<Callout>
+  For a more complete reference, you may also want to review FarmingSystems.Ticking, as much of the underlying logic is based on its implementation.
+</Callout>
+
+## Steps
+
+### 1. ExampleBlock - holds block behavior
+
+```java
+public class ExampleBlock implements Component<ChunkStore> {
+
+    public static final BuilderCodec CODEC = BuilderCodec.builder(ExampleBlock.class, ExampleBlock::new).build();
+
+    // Components usually require a copy constructor as well but since we don't actually hold any data in this component this is not neccessary
+    public ExampleBlock() { }
+
+    public static ComponentType getComponentType() {
+        return ExamplePlugin.get().getExampleBlockComponentType();
+    }
+
+    @Nullable
+    public Component<ChunkStore> clone() {
+        return new ExampleBlock();
+    }
+}
+```
+
+ExampleBlock is a custom component that stores the behavior and data for your ticking block. Here, it simply places an Ice Block at x + 1 relative to its current position when it ticks.
+
+---
+
+### 2. ExampleInitializer - marks blocks as ticking when placed
+
+```java
+public class ExampleInitializer extends RefSystem {
+
+    @Override
+    public void onEntityAdded(@Nonnull Ref ref, @Nonnull AddReason reason, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+        BlockModule.BlockStateInfo info = (BlockModule.BlockStateInfo) commandBuffer.getComponent(ref, BlockModule.BlockStateInfo.getComponentType());
+        if (info == null) return;
+
+        ExampleBlock generator = (ExampleBlock) commandBuffer.getComponent(ref, ExamplePlugin.get().getExampleBlockComponentType());
+        if (generator != null) {
+            int x = ChunkUtil.xFromBlockInColumn(info.getIndex());
+            int y = ChunkUtil.yFromBlockInColumn(info.getIndex());
+            int z = ChunkUtil.zFromBlockInColumn(info.getIndex());
+
+            WorldChunk worldChunk = (WorldChunk) commandBuffer.getComponent(info.getChunkRef(), WorldChunk.getComponentType());
+            if (worldChunk != null) {
+				worldChunk.setTicking(x, y, z, true);
+            }
+        }
+    }
+
+    @Override
+    public void onEntityRemove(@Nonnull Ref ref, @Nonnull RemoveReason reason, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+    }
+
+    @Override
+    public Query getQuery() {
+        return Query.and(BlockModule.BlockStateInfo.getComponentType(), ExamplePlugin.get().getExampleBlockComponentType());
+    }
+}
+```
+
+ExampleInitializer is a RefSystem that reacts when block entities with the ExampleBlock component are added or removed. This is crucial for marking blocks as ticking when they're first placed.
+
+**Key Points:**
+
+- Tells the game that this block should tick, allowing `ExampleSystem` to process it.
+
+```java
+worldChunk.setTicking(x, y, z, true);
+```
+
+---
+
+### 3. ExampleSystem - handles ticking
+
+```java
+public class ExampleSystem extends EntityTickingSystem {
+
+    public void tick(float dt, int index, @Nonnull ArchetypeChunk archetypeChunk, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+        BlockSection blocks = (BlockSection) archetypeChunk.getComponent(index, BlockSection.getComponentType());
+
+        assert blocks != null;
+
+        if (blocks.getTickingBlocksCountCopy() != 0) {
+            ChunkSection section = (ChunkSection) archetypeChunk.getComponent(index, ChunkSection.getComponentType());
+
+            assert section != null;
+
+            BlockComponentChunk blockComponentChunk = (BlockComponentChunk) commandBuffer.getComponent(section.getChunkColumnReference(), BlockComponentChunk.getComponentType());
+
+            assert blockComponentChunk != null;
+
+            blocks.forEachTicking(blockComponentChunk, commandBuffer, section.getY(), (blockComponentChunk1, commandBuffer1, localX, localY, localZ, blockId) -> {
+                Ref<ChunkStore> blockRef = blockComponentChunk.getEntityReference(ChunkUtil.indexBlockInColumn(localX, localY, localZ));
+                if (blockRef == null) {
+                    return BlockTickStrategy.IGNORED;
+                } else {
+                    ExampleBlock exampleBlock = (ExampleBlock) commandBuffer1.getComponent(blockRef, ExampleBlock.getComponentType());
+                    if (exampleBlock != null) {
+                        WorldChunk worldChunk = (WorldChunk) commandBuffer.getComponent(section.getChunkColumnReference(), WorldChunk.getComponentType());
+                        World world = worldChunk.getWorld();
+
+                        int globalX = localX + (worldChunk.getX() * 32);
+                        int globalZ = localZ + (worldChunk.getZ() * 32);
+
+                        // We need to execute setBlock on the world thread as you cannot call store functions from a system
+                        // This is because of the architecture of the server, depending on your needs you can also use the CommandBuffer
+                        world.execute(() -> {
+                            world.setBlock(globalX + 1, localY, globalZ, "Rock_Ice");
+                        });
+
+                        return BlockTickStrategy.CONTINUE;
+
+                    } else {
+                        return BlockTickStrategy.IGNORED;
+                    }
+                }
+            });
+        }
+    }
+
+    @Nullable
+    public Query getQuery() {
+        return Query.and(BlockSection.getComponentType(), ChunkSection.getComponentType());;
+    }
+}
+```
+
+ExampleSystem is an EntityTickingSystem that runs every tick to execute the logic for all ticking blocks with the ExampleBlock component.
+
+**Key Points:**
+
+- **Get the block component**
+
+```java
+ExampleBlock exampleBlock = (ExampleBlock) commandBuffer.getComponent(blockRef, ExampleBlock.getComponentType());
+```
+
+- **Convert local chunk coordinates to world coordinates**
+
+```java
+int globalX = localX + (worldChunk.getX() * 32);
+int globalZ = localZ + (worldChunk.getZ() * 32);
+```
+
+- **Run the block logic**
+
+```java
+exampleBlock.runBlockAction(globalX, localY, globalZ, worldChunk.getWorld());
+```
+
+- **Keep the block ticking in the next tick**
+
+```java
+return BlockTickStrategy.CONTINUE;
+```
+
+---
+
+### 4. ExamplePlugin - registers components and systems
+
+```java
+public class ExamplePlugin extends JavaPlugin {
+    protected static ExamplePlugin instance;
+    private static final HytaleLogger LOGGER = HytaleLogger.forEnclosingClass();
+    private ComponentType exampleBlockComponentType;
+
+    public static ExamplePlugin get() {
+        return instance;
+    }
+
+    public ExamplePlugin(@Nonnull JavaPluginInit init) {
+        super(init);
+        LOGGER.atInfo().log("Hello from " + this.getName() + " version " + this.getManifest().getVersion().toString());
+    }
+
+    @Override
+    protected void setup() {
+        instance = this;
+        LOGGER.atInfo().log("Setting up plugin " + this.getName());
+        this.exampleBlockComponentType = this.getChunkStoreRegistry().registerComponent(ExampleBlock.class, "ExampleBlock", ExampleBlock.CODEC);
+    }
+	
+	@Override
+	protected void start() {
+		this.getChunkStoreRegistry().registerSystem(new ExampleSystem());
+		this.getChunkStoreRegistry().registerSystem(new ExampleInitializer());
+	}
+
+    public ComponentType getExampleBlockComponentType() {
+        return this.exampleBlockComponentType;
+    }
+}
+```
+
+---
+
+### 5. Configure In-Game
+
+![block-component-1](/assets/guides/block-component-1.png)
+
+![block-component-2](/assets/guides/block-component-2.png)
+
+With this logic, the block will now continuously place an Ice Block at the coordinates x + 1 relative to its current position every time it ticks.
+
+---
+
+## Common Issues
+
+### NullPointerException on Startup
+
+**Error message:**
+
+```java
+java.lang.NullPointerException: Cannot invoke "com.hypixel.hytale.component.query.Query.validateRegistry(com.hypixel.hytale.component.ComponentRegistry)" because "query" is null
+```
+
+**Cause:**
+This error occurs when your module is loaded **before** the required Hytale modules.
+
+**Fix:**
+Add `EntityModule` and `BlockModule` as dependencies in your `manifest.json` to ensure proper load order.
+
+```json
+"Dependencies": {
+  "Hytale:EntityModule": "*",
+  "Hytale:BlockModule": "*"
+}
+```
diff --git a/content/docs/cs-CZ/guides/ecs/hytale-ecs-theory.mdx b/content/docs/cs-CZ/guides/ecs/hytale-ecs-theory.mdx
index 20c3a94d..52d8b1f5 100644
--- a/content/docs/cs-CZ/guides/ecs/hytale-ecs-theory.mdx
+++ b/content/docs/cs-CZ/guides/ecs/hytale-ecs-theory.mdx
@@ -29,7 +29,7 @@ for now this is the basic understanding for the `ChunkStore`. You can use it to
 
 ## Holder
 
-A Holder is essentially a blueprint for an entity. Before an entity exists in the Store (and thus in the world), is exists as a `Holder`. It collects and holds all the necessary components (data). You can compare it analogous to shopping cart. You grab all components you need and once you have everything, check out at the store which will take your cart and create a valid entity ID and hand you back a receipt (a Ref).
+A Holder is essentially a blueprint for an entity. Before an entity exists in the Store (and thus in the world), it exists as a `Holder`. It collects and holds all the necessary components (data). You can compare it analogous to shopping cart. You grab all components you need and once you have everything, check out at the store which will take your cart and create a valid entity ID and hand you back a receipt (a Ref).
 
 Let's take a look at an example: initializing players. In `Universe`, the `addPlayer` method demonstrates it perfectly.
 When a player connects, we don't immediately throw them into the ECS. We first construct their data in a Holder.
@@ -167,7 +167,7 @@ MyComponent comp = commandBuffer.getComponent(ref, componentType);
 
 Codecs handle serialization and deserialization of components. Hytale uses them to save and load entity data to and from disk as well as sending component data over the network. When creating a custom component, you must also create a corresponding Codec.
 
-There are mutliple Codec types already implemented in the default Codec Interface:
+There are multiple Codec types already implemented in the default Codec Interface:
 
 - Codec.STRING
 - Codec.BOOLEAN
@@ -215,7 +215,7 @@ This might seem tedious at first but it ensures that your component can be corre
   KeyedCodec<Integer> exampleInt = new KeyedCodec<Integer>("ExampleIntIdForCodec", Codec.INTEGER);
   ```
 
-- **Setter Function**: This is a lambda function that takes an instance of your component and returns the value of the field you want to serialize. For example, if you have a field called `myCustomField` in your custom component, your getter function would look like this:
+- **Setter Function**: This is a lambda function that takes an instance of your component + the value to set and sets the field value on the component. For example, if you have a field called `myCustomField` in your custom component, your setter function would look like this:
   ```java
   (data, value) -> data.myCustomField = value
   ```
@@ -276,7 +276,7 @@ public class PoisonComponent implements Component<EntityStore> {
 
 You can also add validators to your Codec fields to ensure that the data being serialized/deserialized meets certain criteria. For example, if you want to ensure that the `damagePerTick` field is always non-negative or the poison name is never null, you can add a validator like this:
 
-````java
+```java
 .append(
     new KeyedCodec<Float>("DamagePerTick", Codec.FLOAT),
     (data, value) -> data.damagePerTick = value,
@@ -292,14 +292,15 @@ You can also add validators to your Codec fields to ensure that the data being s
 )
 .addValidator(Validators.nonNull())
 .add()
+```
 
 ### Complex Codec Examples
 
-If you want to have a map inside your component, you can use the MapCodec class to build a KeyedCoded for it. Here's an example of how to create a Codec for a Map field:
+If you want to have a map inside your component, you can use the MapCodec class to build a KeyedCodec for it. Here's an example of how to create a Codec for a Map field:
 
 ```java
 var damagePerTick = new KeyedCodec<>("DamagePerTick", new MapCodec<>(Codec.FLOAT, HashMap<String, Float>::new));
-````
+```
 
 <Callout type="info">
   This also works with custom Objects as long as you have a Codec defined for the Object type.
diff --git a/content/docs/cs-CZ/guides/java-basics/00-introduction.mdx b/content/docs/cs-CZ/guides/java-basics/00-introduction.mdx
index a03ad638..b0130d74 100644
--- a/content/docs/cs-CZ/guides/java-basics/00-introduction.mdx
+++ b/content/docs/cs-CZ/guides/java-basics/00-introduction.mdx
@@ -7,7 +7,7 @@ Welcome to your journey into Java Programming! This guide is designed to introdu
 
 ## What is Java?
 
-Java is a powerful, object-oriented programming language created in 1995. It's one of the most popular programming languages in the world and is used for everything from mobile apps to enterprise software. Most importantly for us, it's the language Hytale uses for it's servers & modding API.
+Java is a powerful, object-oriented programming language created in 1995. It's one of the most popular programming languages in the world and is used for everything from mobile apps to enterprise software. Most importantly for us, it's the language Hytale uses for its servers & modding API.
 
 ## What You'll Learn
 
diff --git a/content/docs/cs-CZ/guides/java-basics/02-operators.mdx b/content/docs/cs-CZ/guides/java-basics/02-operators.mdx
index a132b1c0..18634665 100644
--- a/content/docs/cs-CZ/guides/java-basics/02-operators.mdx
+++ b/content/docs/cs-CZ/guides/java-basics/02-operators.mdx
@@ -119,7 +119,7 @@ String greetingWithName = "Hello, " + name + "!"; // "Hello, Alice!"
 
 ## Operator Precedence
 
-Operator Precendence means which operator gets evaluated first in an line of code. Think of it like BODMAS/PEMDAS in math!
+Operator Precedence means which operator gets evaluated first in an line of code. Think of it like BODMAS/PEMDAS in math!
 
 ```java
 int result = 10 + 5 * 2; // result is 20, not 30
diff --git a/content/docs/cs-CZ/guides/java-basics/03-control-flow-if.mdx b/content/docs/cs-CZ/guides/java-basics/03-control-flow-if.mdx
index b9d6c479..af2d1c22 100644
--- a/content/docs/cs-CZ/guides/java-basics/03-control-flow-if.mdx
+++ b/content/docs/cs-CZ/guides/java-basics/03-control-flow-if.mdx
@@ -7,7 +7,7 @@ Programs need to make decisions. If statements let your code choose different pa
 
 ## Basic If Statement
 
-The simplest form checks one condition;
+The simplest form checks one condition:
 
 ```java
 int health = 20;
diff --git a/content/docs/cs-CZ/guides/java-basics/08-access-modifiers.mdx b/content/docs/cs-CZ/guides/java-basics/08-access-modifiers.mdx
index af560932..da2bf33b 100644
--- a/content/docs/cs-CZ/guides/java-basics/08-access-modifiers.mdx
+++ b/content/docs/cs-CZ/guides/java-basics/08-access-modifiers.mdx
@@ -484,7 +484,7 @@ class Data {
     // Static member:
     // cannot access to non-static variables
     public static void bar() {
-        x = 100; // Error: non-static variable x cannot be renference from a static context
+        x = 100; // Error: non-static variable x cannot be referenced from a static context
         y = 100; // OK
     }
 }
@@ -504,7 +504,7 @@ Data.x = 1000; // Error: cannot access instanced variables in a static context
 
 ### Static Fields
 
-A static field represents a data member owned by the class type rather then the object. Static fields are also stored in a specific memory location that's been shared between all the object instances that are created.
+A static field represents a data member owned by the class type rather than the object. Static fields are also stored in a specific memory location that's been shared between all the object instances that are created.
 
 It is declared as following:
 
diff --git a/content/docs/cs-CZ/guides/plugin/animated-block-textures.mdx b/content/docs/cs-CZ/guides/plugin/animated-block-textures.mdx
new file mode 100644
index 00000000..42bfa51f
--- /dev/null
+++ b/content/docs/cs-CZ/guides/plugin/animated-block-textures.mdx
@@ -0,0 +1,101 @@
+---
+title: Animated Block Textures
+description: Learn how to attach a .blockyanim to a block
+authors:
+  - name: Burkino
+---
+
+import { File, Folder, Files } from 'fumadocs-ui/components/files';
+
+So, you want to make your blocks feel more alive through animations, do you?\
+Now for the most part this is the exact same as [Creating custom blocks](./creating-block).
+![blue fire gif](/assets/guides/blue_fire.gif)
+
+## Prerequisites
+
+This is NOT a guide on animating or texturing or even using BlockBench, why? Because I don't know how to do that.\
+The only thing we will be doing is taking the fire texture, changing the color, and applying it to our new fire block.
+
+## Setup
+
+To start, you're obviously going to want to grab the `Common/VFX/Fire/Fire.png` file. How you do it is up to you, in the Asset Editor you'll need to switch to the Common tab.\
+I'll assume you know how colorize or change the hue of an image, so go ahead and do that now and save it as `Blue_Fire.png`.
+
+The other assets used in this guide are `Common/VFX/Fire/Fire.blockymodel` and `Common/Blocks/Animations/Fire/Fire_Burn.blockyanim` (both renamed to `Blue_Fire`) but since we won't be changing them it's probably fine to leave them. I will reference the `Blue_Fire` versions as a way to point out what should be custom assets.\
+I will also duplicate `Server/Item/Item/Deco/Deco_Fire.json` and call it `Deco_Blue_Fire.json`.
+
+## Applying the changes
+
+The `Deco_Blue_Fire` block is actually just a particle emitter, however we will not be using particles, so lets start by removing them in `Block > Particles`.\
+Next we want to set the Block Model (called `CustomModel` in JSON) to `VFX/Blue_Fire/Blue_Fire.blockymodel` and Block Model Textures (`CustomModelTexture` in JSON) to
+
+```json
+[
+    {
+        "Texture": "VFX/Blue_Fire/Blue_Fire.png",
+        "Weight": 1
+    }
+]
+```
+
+Finally, we will apply the .blockyanim to our model, this is done through the Block Model Animation property (`CustomModelAnimation` in JSON) and the value should be `Blocks/Animations/Blue_Fire/Blue_Fire_Burn.blockyanim`.
+
+## Final Code
+
+With that your new blue fire should be done. Here is the minimal JSON for our blue fire.\
+There is an additional `Looping` and `RequiresAlphaBlending` property that I have not gone over, however I hope it is self-explanatory.
+
+```json
+{
+  "BlockType": {
+    "DrawType": "Model",
+    "CustomModel": "VFX/Blue_Fire/Blue_Fire.blockymodel",
+    "CustomModelAnimation": "Blocks/Animations/Blue_Fire/Blue_Fire_Burn.blockyanim",
+    "CustomModelTexture": [
+      {
+        "Texture": "VFX/Blue_Fire/Blue_Fire.png",
+        "Weight": 1
+      }
+    ],
+    "Looping": true,
+    "RequiresAlphaBlending": false
+  },
+  "PlayerAnimationsId": "Block"
+}
+```
+
+<Files>
+  <Folder name="resources" defaultOpen>
+    <Folder name="Server" defaultOpen>
+      <Folder name="Item" defaultOpen>
+        <Folder name="Items" defaultOpen>
+          <Folder name="Deco" defaultOpen>
+            <File name="Deco_Blue_Fire.json" />
+          </Folder>
+        </Folder>
+      </Folder>
+    </Folder>
+
+    <Folder name="Common" defaultOpen>
+      <Folder name="Blocks" defaultOpen>
+        <Folder name="Animations" defaultOpen>
+          <Folder name="Blue_Fire" defaultOpen>
+            <File name="Blue_Fire_Burn.blockyanim" />
+          </Folder>
+        </Folder>
+      </Folder>
+
+      <Folder name="VFX" defaultOpen>
+        <Folder name="Blue_Fire" defaultOpen>
+          <File name="Blue_Fire.blockymodel" />
+
+          <File name="Blue_Fire.png" />
+        </Folder>
+      </Folder>
+    </Folder>
+  </Folder>
+</Files>
+
+## Next steps
+
+Now that you know how to attach an animation to a block, try adding it to a block state.
diff --git a/content/docs/cs-CZ/guides/plugin/build-and-test.mdx b/content/docs/cs-CZ/guides/plugin/build-and-test.mdx
index 0e7fe7eb..f37534c3 100644
--- a/content/docs/cs-CZ/guides/plugin/build-and-test.mdx
+++ b/content/docs/cs-CZ/guides/plugin/build-and-test.mdx
@@ -9,18 +9,18 @@ If you followed along with the [Setting Up Your Development Environment](./setti
 
 ## Building Your Mod
 
-In our case, we've **Maven** as the build system. Maven is a powerful build automation tool that manages dependencies, compiles your code, and packages everything into a distributable JAR file.
+In our case, we've **Gradle** as the build system. Gradle is a powerful build automation tool that manages dependencies, compiles your code, and packages everything into a distributable JAR file.
 
-### Understanding Maven
+### Understanding Gradle
 
-Maven uses a `pom.xml` file (Project Object Model) to define your project's configuration, dependencies, and build settings. You can learn more about Maven at the [official Apache Maven website](https://maven.apache.org/).
+Gradle can use a `build.gradle.kts` file (Kotlin DSL) to define your project's configuration, dependencies, and build settings. You can learn more about Gradle at the [official Gradle website](https://gradle.org/).
 
-### Building with Maven
+### Building with Gradle
 
 To build your mod, open a terminal in your project directory and run:
 
 ```bash
-mvn package
+./gradlew build
 ```
 
 This command will:
@@ -29,16 +29,35 @@ This command will:
 2. Run any tests (if present)
 3. Package everything into a JAR file
 
+<Callout type="info">
+  If you are using the plugin template from the [Setting Up Your Development Environment](./setting-up-env) guide, then the build script is already set up for you. It includes paths to your Hytale game library and handles the packaging of your mod, managing hytale dependencies and manifest changes.
+
+  If you have a different path to your Hytale installation, you may receive the following error:
+
+  ```bash
+  FAILURE: Build failed with an exception.
+
+  * What went wrong:
+  Failed to find Hytale at the expected location. Please make sure you have installed the game. The expected location can be changed using the hytale.home_path property. Currently looking in 'C:\Path\To\Hytale'
+  ```
+
+  You can change the path by adding a property to your `gradle.properties` file (if it doesn't exist, create it in the root of your project):
+
+  ```properties
+  hytale.home_path=C:\Correct\Path\To\Hytale
+  ```
+</Callout>
+
 ### Build Output
 
-Once the build completes successfully, your mod will be located in the `target` directory and named:
+Once the build completes successfully, your mod will be located in the `build/libs` directory and named:
 
 ```
-ExamplePlugin-1.0-SNAPSHOT.jar
+ExamplePlugin-1.0.jar
 ```
 
 <Callout type="info">
-  The exact name may vary depending on what you configured in your `pom.xml` file. Check the `artifactId` and `version` fields to see what your JAR will be named.
+  The exact name may vary depending on what you configured in your `build.gradle.kts` and `settings.gradle.kts` file. Check the `rootProject.name` and `version` fields to see what your JAR will be named.
 </Callout>
 
 ## Testing Your Mod
@@ -49,11 +68,11 @@ Now that you've built your mod, it's time to test it in Hytale!
 
 First, you need to find Hytale's mods directory:
 
-1. Press **Win + R** on your keyboard
-2. Type `%appdata%` and press Enter
-3. Navigate to: `Hytale\UserData\Mods`
+1. Go to your Hytale installation directory (The default location is usually in your AppData folder)
+   > On Windows, you can access it by clicking `windows + R` and typing `%appdata%`.
+2. Navigate to: `/UserData/Mods`
 
-The full path should look like:
+The default path would look like:
 
 ```
 C:\Users\YourUsername\AppData\Roaming\Hytale\UserData\Mods
@@ -65,7 +84,7 @@ C:\Users\YourUsername\AppData\Roaming\Hytale\UserData\Mods
 
 ### 2. Copy Your Mod
 
-Copy the `ExamplePlugin-1.0-SNAPSHOT.jar` file from your project's `target` directory into the `Mods` folder you just located.
+Copy the `ExamplePlugin-1.0.jar` file from your project's `build/libs` directory into the `Mods` folder you just located.
 
 ### 3. Launch Hytale and Verify
 
@@ -84,7 +103,7 @@ If your mod doesn't appear in the mods list:
 - Make sure the JAR file is in the correct `Mods` folder
 - Check that your `manifest.json` file is properly configured
 - Look for any error messages in the Hytale logs
-- Verify that you're using the correct version of Java and Maven
+- Verify that you're using the correct version of Java and Gradle
 
 ## Next Steps
 
diff --git a/content/docs/cs-CZ/guides/plugin/creating-commands.mdx b/content/docs/cs-CZ/guides/plugin/creating-commands.mdx
index d33597f3..08572f16 100644
--- a/content/docs/cs-CZ/guides/plugin/creating-commands.mdx
+++ b/content/docs/cs-CZ/guides/plugin/creating-commands.mdx
@@ -8,6 +8,8 @@ authors:
     url: https://oskar.scot
   - name: jacobwojoski
     url: https://github.com/jacobwojoski
+  - name: Marcel-TO
+    url: https://marcel-to.net
 ---
 
 In this guide, you will learn how to create custom commands for your Hytale mod.
@@ -36,7 +38,7 @@ The most basic command is an `AbstractAsyncCommand`. It has very minimal data av
   `AbstractAsyncCommand` runs on its own background thread. This means its execute is not tied to any world instance and because of this it can not edit any **Stores** or **Refs** without getting the desired world first. To access this data any of the other command types would be preferred and are likely what you will want to use instead.
 </Callout>
 
-The main purpose for a command like this would be for something that can happen everywhere and is not tied to a specific world. For example a `serverRules` command to tell the user thats running the command in chat what the servers rules are nomatter what world they are in.
+The main purpose for a command like this would be for something that can happen everywhere and is not tied to a specific world. For example a `serverRules` command to tell the user that's running the command in chat what the server's rules are no matter what world they are in.
 
 ```java
 // Command that can be run that lists the server rules in chat to the player
@@ -49,7 +51,7 @@ public class ServerRulesCommand extends AbstractAsyncCommand {
     }
 
     // Run the command
-    // conetext - info about who ran the command. Server console?, Some player?
+    // context - info about who ran the command. Server console?, Some player?
     @Override
     protected CompletableFuture<Void> executeAsync(@Nonnull CommandContext context) {
         context.sendMessage(Message.raw("The only rule is there are no rules."));
@@ -134,7 +136,7 @@ Uses a Ray to see what the player is looking at and tries to run the command on
 
 ## Adding Arguments
 
-Arguments are additional fields that the user can input when running a command. The different types of arguments along with small snipits and a large example can be seen below.
+Arguments are additional fields that the user can input when running a command. The different types of arguments along with small snippets and a large example can be seen below.
 
 ### Command Argument Types
 
@@ -163,14 +165,14 @@ this.messageArg = this.withOptionalArg("message", "Message to print while healin
 
 ### Default Arguments
 
-Adding a default argument has two additional arguemnt for the default value and default value description. You need to use `withDefaultArg` method.
+Adding a default argument has two additional argument for the default value and default value description. You need to use `withDefaultArg` method.
 
 ```java
 // args <Command String> <Description> <Default Value> <Desc of default value>
 this.healthArg = this.withDefaultArg("health", "Amount to heal player", ArgTypes.FLOAT, (float)100, "Desc of Default: 100");
 ```
 
-### Flag Arguemnts
+### Flag Arguments
 
 Similar as above but the flags return is either true if it exists or false if it does not. You need to use `withFlagArg` method.
 
@@ -181,20 +183,13 @@ this.debugArg = this.withFlagArg("debug", "Add debug logs");
 
 ### ArgTypes
 
-The following ArgTypes are available (only lists common types):
-
-- `ArgTypes.STRING`
-- `ArgTypes.INTEGER`
-- `ArgTypes.BOOLEAN`
-- `ArgTypes.FLOAT`
-- `ArgTypes.DOUBLE`
-- `ArgTypes.UUID`
+You can find all the available argument types on the [ArgTypes](../../argtypes) page.
 
 ### Example Command Arg Types
 
-Shows all Command arguemnt types with different various input types.
+Shows all Command argument types with different various input types.
 
-**NOTE:** When getting the value of an argument during execute you need to pass the context with `someArg.get(commandContext)`. Where `commandContext` is the first variable in the execute funtion.
+**NOTE:** When getting the value of an argument during execute you need to pass the context with `someArg.get(commandContext)`. Where `commandContext` is the first variable in the execute function.
 
 ```java
 // Example usage: /healplayer --health 50 --message "Feels Good" --debug
@@ -204,7 +199,7 @@ public class HealPlayerCommand extends AbstractTargetPlayerCommand {
     private final FlagArg debugArg;
 
     public HealPlayerCommand() {
-        super("healplayer", "Healing a player for an <input> ammount of HP (default: 100)");
+        super("healplayer", "Healing a player for an <input> amount of HP (default: 100)");
 
         // Abstract TargetPlayerCommand passes the player that ran the command by default and implements
         // the use of `--player <value>` to specify someone else
@@ -213,10 +208,10 @@ public class HealPlayerCommand extends AbstractTargetPlayerCommand {
         this.healthArg = this.withDefaultArg("health", "Amount to heal player", ArgTypes.FLOAT, (float)100, "Desc of Default: 100");
 
         // Or you could do the following making the health value required instead of with a default.
-        //    You would need to change the decleration to RequiredArg<Float>
+        //    You would need to change the declaration to RequiredArg<Float>
         // this.healthArg = this.withRequiredArg("health", "Amount to heal player", ArgTypes.FLOAT);
 
-        // Optional args reguare the user the input `--<key> <value>` so the following would require `--message "Good Luck"`
+// Optional args require the user the input `--<key> <value>` so the following would require `--message "Good Luck"`
         this.messageArg = this.withOptionalArg("message", "Message to print while healing", ArgTypes.STRING);
 
         // No type needed due to being a bool
@@ -230,7 +225,7 @@ public class HealPlayerCommand extends AbstractTargetPlayerCommand {
             commandContext.sendMessage(Message.raw("We are debugging"));
         }
 
-        // Health is stored in a generic stat map to allowing mods/future contect to easily add more stats if desired.
+        // Health is stored in a generic stat map to allowing mods/future content to easily add more stats if desired.
         EntityStatMap stats = store.getComponent(ref, EntityStatMap.getComponentType());
         int healthIdx = DefaultEntityStatTypes.getHealth();
         EntityStatValue health = stats.get(healthIdx);
@@ -252,7 +247,7 @@ public class HealPlayerCommand extends AbstractTargetPlayerCommand {
 
 ## Argument Validators
 
-Argument validators are a way to check the command before the command gets executed. They are added with the `addValidator` method on an argument when calling `withXxxArg`. They provide a nice output to the user when an input value is invalid.
+Argument validators are a way to check the command before the command gets executed. They are added with the `addValidator` method on an argument when calling `withXxxArg`. They provide a nice output to the user when an input value is invalid. There are some common validators provided in the `Validators` class such as `greaterThan`, `lessThan`, and `or`, `max`, `range`, etc.
 
 ```java
 ...
@@ -260,18 +255,59 @@ Argument validators are a way to check the command before the command gets execu
     OptionalArg<Integer> healAmount = withOptionalArg("amount", "Heal Amount", ArgTypes.INTEGER)
         .addValidator(Validators.greaterThan(0))
         .addValidator(Validators.lessThan(1000));
-
-    // Custom check example
-    OptionalArg<Integer> healAmount = withOptionalArg("amount", "Heal Amount", ArgTypes.INTEGER)
-            .addValidator( value -> {
-                if (value != null && value <= 0) {
-                    return ValidationResult.error("ammount argument must be a positive number");
-                }
-                return ValidationResult.success();
-            });
 ...
 ```
 
+### Custom Validators
+
+You can also create custom validators by implementing the `com.hypixel.hytale.codec.validation.Validator` interface. The interfaces forces you to implement the `accept` and `updateSchema` method. The `accept` method takes in the argument value and validates it. If the validation fails, you can use the `fail` method of the `com.hypixel.hytale.codec.validation.ValidationResults` class to return an error message.
+The `updateSchema` method is used to update the schema of the command argument. This is used for commands that have dynamic schemas based on the input value. For example, if you have a command that takes in a player name as an argument, you can use the `updateSchema` method to update the schema to include a list of online players for validation.
+
+Here is an example of a custom validator that checks if a string value is equal to a banned word. In this example, the banned word is "badword". If the input value is "badword", the validator will fail and return an error message.
+
+```java
+import com.hypixel.hytale.codec.schema.SchemaContext;
+import com.hypixel.hytale.codec.schema.config.Schema;
+import com.hypixel.hytale.codec.validation.ValidationResults;
+import com.hypixel.hytale.codec.validation.Validator;
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+
+public class MyCustomValidator implements Validator<String> {
+    @Nonnull
+    private final String value;
+
+    public MyCustomValidator(@Nonnull String value) {
+        this.value = value;
+    }
+
+    @Override
+    public void accept(@Nullable String input, @Nonnull ValidationResults results) {
+        if (this.value.equalsIgnoreCase(input)) {
+            results.fail("The given role has been banned.");
+        }
+    }
+
+    @Override
+    public void updateSchema(SchemaContext context, @Nonnull Schema target) {
+        // This method can be used to update the schema of the command argument. This is useful for commands that have dynamic schemas based on the input value. For example, if you have a command that takes in a player name as an argument, you can use the `updateSchema` method to update the schema to include a list of online players for validation.
+        throw new UnsupportedOperationException("Not implemented yet.");
+    }
+}
+```
+
+After the custom validator is created, you can add it to an argument like the following example. In this example, we add the `MyCustomValidator` to a string argument called "role". If the user inputs "badword" as the role, the command will fail and return the error message defined in the `MyCustomValidator`.
+
+```java
+    ...
+    // Custom validator example
+    String bannedRole = "badword";
+
+    OptionalArg<String> roleArg = withOptionalArg("role", "Role to assign", ArgTypes.STRING)
+        .addValidator(new MyCustomValidator(bannedRole));
+    ...
+```
+
 ---
 
 ## Permissions
@@ -312,7 +348,7 @@ This allows the server to control who has access to specific commands. You add t
 
 If you want variants of the same command without doing argument parsing you can instead use `addUsageVariant(new OtherCommandClass())` in the original commands constructor.
 
-The only difference is in the `OtherCommandClass()` constrcutor you don't pass the command name to the super class.
+The only difference is in the `OtherCommandClass()` constructor you don't pass the command name to the super class.
 
 <Callout type="info">
   You can also use `addAliases("some_alias", "some_other_alias")` as a way to add shorthand or other ways to write the same command.
@@ -387,7 +423,7 @@ public class AdminCommand extends AbstractCommandCollection {
     public AdminCommand () {
         super("admin", "Admin commands");
         addSubCommand(new UserCommandCollection());
-        addSybCommand(new ServerCommandCollection);
+        addSubCommand(new ServerCommandCollection);
     }
 }
 ```
@@ -417,5 +453,5 @@ public class MyPlugin extends JavaPlugin {
 
 ## Video Link
 
-_Special Thanks to [TroubleDev](https://www.youtube.com/@TroubleDEV) for his excelent video guide on all of these features._
+_Special Thanks to [TroubleDev](https://www.youtube.com/@TroubleDEV) for his excellent video guide on all of these features._
 _Video Link: [TroubleDev - Hytale's Command API Explained](https://www.youtube.com/watch?v=KnmhG9MDMgo)_
diff --git a/content/docs/cs-CZ/guides/plugin/creating-events.mdx b/content/docs/cs-CZ/guides/plugin/creating-events.mdx
index 95863990..d3f0925d 100644
--- a/content/docs/cs-CZ/guides/plugin/creating-events.mdx
+++ b/content/docs/cs-CZ/guides/plugin/creating-events.mdx
@@ -1,6 +1,6 @@
 ---
-title: Creating Events
-description: Learn how to create custom events for your Hytale mod.
+title: Creating Events Listeners
+description: Learn how to create event listeners for your Hytale mod.
 authors:
   - name: Neil Revin
     url: https://itsneil.dev
@@ -10,7 +10,7 @@ authors:
 
 ## Event Class
 
-You can import a Event class and create a function with the Event as a argument. [Click here](../../server/events) to look at all available events.
+You can import an Event class and create a function with the Event as an argument. [Click here](../../server/events) to look at all available events.
 
 Example plugin when a player is ready (joins a server):
 
diff --git a/content/docs/cs-CZ/guides/plugin/item-registry.mdx b/content/docs/cs-CZ/guides/plugin/item-registry.mdx
new file mode 100644
index 00000000..9a0fd53a
--- /dev/null
+++ b/content/docs/cs-CZ/guides/plugin/item-registry.mdx
@@ -0,0 +1,95 @@
+---
+title: Working with the Item Registry
+description: Learn how to access and query the game's item registry to list all items, check if items exist, and retrieve item properties.
+authors:
+  - name: Denis
+---
+
+In this guide, you'll learn how to work with Hytale's Item Registry system. This is useful when you need to programmatically list all available items, validate item IDs, or retrieve item properties at runtime.
+
+## Prerequisites
+
+Before diving in, you should be familiar with:
+
+- [Setting up your development environment](./setting-up-env)
+- [Creating commands](./creating-commands) (optional, for testing)
+
+## Required Imports
+
+To work with the Item Registry, you'll need the following imports:
+
+```java
+import com.hypixel.hytale.assetstore.map.DefaultAssetMap;
+import com.hypixel.hytale.server.core.asset.type.item.config.Item;
+```
+
+## Getting the Item Registry
+
+The Item Registry is accessed through the `Item.getAssetMap()` method, which returns a `DefaultAssetMap<String, Item>` containing all registered items in the game:
+
+```java
+DefaultAssetMap<String, Item> itemMap = Item.getAssetMap();
+```
+
+## Listing All Items
+
+To iterate through all items in the registry, you can get the underlying map and loop through its entries:
+
+```java
+DefaultAssetMap<String, Item> itemMap = Item.getAssetMap();
+var map = itemMap.getAssetMap();
+
+for (var entry : map.entrySet()) {
+    String itemId = String.valueOf(entry.getKey());
+    Item item = entry.getValue();
+    
+    // Do something with the item
+    LOGGER.atInfo().log("Item ID: " + itemId);
+}
+```
+
+You can also get the total count of registered items:
+
+```java
+int totalItems = map.size();
+```
+
+## Checking if an Item Exists
+
+To check if a specific item exists in the registry, use `getAsset()` and verify the result:
+
+```java
+public boolean itemExists(String itemId) {
+    var assetMap = Item.getAssetMap();
+    if (assetMap != null) {
+        Item item = assetMap.getAsset(itemId);
+        return item != null && item != Item.UNKNOWN;
+    }
+    return false;
+}
+```
+
+<Callout type="info">
+  The `Item.UNKNOWN` constant represents an invalid or unrecognized item. Always check for both `null` and `Item.UNKNOWN` when validating items.
+</Callout>
+
+## Accessing Item Properties
+
+Once you have an `Item` instance, you can access various properties:
+
+```java
+var assetMap = Item.getAssetMap();
+Item item = assetMap.getAsset("Soil_Grass");
+
+if (item != null && item != Item.UNKNOWN) {
+    String id = item.getId(); // Soil_Grass
+    int maxStack = item.getMaxStack(); // 100
+    boolean isBlock = item.hasBlockType(); // true
+    boolean isConsumable = item.isConsumable(); // false
+}
+```
+
+## Related Guides
+
+- [Inventory Management](./inventory-management) - Learn how to add and remove items from player inventories
+- [Create Custom Item and Interaction](./item-interaction) - Learn how to create your own custom items
diff --git a/content/docs/cs-CZ/guides/plugin/permission-management.mdx b/content/docs/cs-CZ/guides/plugin/permission-management.mdx
index 6b7cfd46..55f06101 100644
--- a/content/docs/cs-CZ/guides/plugin/permission-management.mdx
+++ b/content/docs/cs-CZ/guides/plugin/permission-management.mdx
@@ -10,132 +10,569 @@ authors:
     link: https://discord.com/users/292656109939064833
   - name: Ivan
     link: https://discord.com/users/505770451218333717
+  - name: ZenithDevHQ
+    link: https://github.com/ZenithDevHQ
 ---
 
-In this guide, you'll learn how to manage permission nodes and groups in your Hytale plugin.
+In this guide, you'll learn how to manage permission nodes and groups in your Hytale plugin. Permissions control what actions players can perform on your server, from basic commands to advanced administrative functions.
 
-## The `PermissionsModule` class
+## What Are Permissions?
 
-The `PermissionsModule` class is responsible for managing permission nodes and groups in your plugin. It provides methods to check, grant and revoke permissions and groups for players. It allows the following operations
+Permissions are string identifiers that control access to features and commands. When a player tries to perform an action (like using a command), the server checks if they have the required permission.
 
-- Add permissions to user
-- Remove permissions from user
-- Add permissions to group (this also creates the group if it doesn't exist)
-- Remove permissions from group
-- Add user to group
-- Remove user from group
-- List all groups for a user
-- Check if a user has a permission (it checks both user and group permissions for the given player UUID)
+**Example permission nodes:**
 
-With this class you cannot:
+- `hytale.command.gamemode` - Permission to use the gamemode command
+- `hytale.editor.brush.use` - Permission to use brush tools
+- `myplugin.teleport.home` - A custom permission for your plugin
 
-- List all defined groups
-- Remove a group
+Permissions follow a hierarchical naming pattern: `namespace.category.action`
 
-### Adding Permission Nodes
+## Key Concepts
 
-You need a `Set<String>` containing all the permission nodes you want to add, these are added on top of the already existing permission nodes the user may have, it is not a replacement.
+Before diving into code, let's understand the core concepts:
+
+| Concept             | Description                                                                |
+| ------------------- | -------------------------------------------------------------------------- |
+| **Permission Node** | A string like `myplugin.feature.use` that represents a specific permission |
+| **Group**           | A named collection of permissions (e.g., "Admin", "VIP", "Default")        |
+| **Provider**        | The backend that stores and retrieves permissions                          |
+| **Wildcard**        | A pattern like `*` or `myplugin.*` that matches multiple permissions       |
+
+### How Permissions Are Checked
+
+When checking if a player has a permission, Hytale follows this order:
+
+1. **User's direct permissions** - Permissions granted directly to the player
+2. **Group permissions** - Permissions from groups the player belongs to
+3. **Virtual groups** - Game-mode-based permissions (e.g., Creative mode grants builder tools)
+4. **Default value** - Falls back to `false` if no match found
+
+<Callout type="info">
+  The first definitive match wins. If a player has a permission granted at the user level, group permissions won't override it.
+</Callout>
+
+---
+
+## The `PermissionsModule` Class
+
+The `PermissionsModule` class is the central hub for managing permissions. Access it using the singleton pattern:
 
 ```java
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.addUserPermission(playerUUID, permissions);
 ```
 
-### Removing Permission Nodes
+### Available Operations
+
+The module supports these operations:
+
+| Operation                     | Method                                          |
+| ----------------------------- | ----------------------------------------------- |
+| Add permissions to user       | `addUserPermission(uuid, permissions)`          |
+| Remove permissions from user  | `removeUserPermission(uuid, permissions)`       |
+| Add permissions to group      | `addGroupPermission(groupName, permissions)`    |
+| Remove permissions from group | `removeGroupPermission(groupName, permissions)` |
+| Add user to group             | `addUserToGroup(uuid, groupName)`               |
+| Remove user from group        | `removeUserFromGroup(uuid, groupName)`          |
+| Get user's groups             | `getGroupsForUser(uuid)`                        |
+| Check permission              | `hasPermission(uuid, permissionNode)`           |
+
+<Callout type="warning">
+  The module does **not** support:
+
+  - Listing all defined groups
+  - Deleting a group entirely
+
+  Groups are implicitly created when you first add permissions to them.
+</Callout>
+
+---
 
-Same as above, we just use the `removeUserPermission` method instead to remove permission nodes.
+## Checking Permissions
+
+The most common operation is checking if a player has a permission.
+
+### Basic Permission Check
+
+```java
+// Returns true if player has the permission, false otherwise
+boolean canUse = PermissionsModule.get().hasPermission(playerUUID, "myplugin.feature.use");
+
+if (canUse) {
+    // Player has permission, allow the action
+} else {
+    // Player lacks permission, deny or show error
+}
+```
+
+### Permission Check with Default Value
+
+You can specify what to return when no permission is explicitly set:
+
+```java
+// Returns true by default if no explicit permission is found
+boolean canUse = PermissionsModule.get().hasPermission(playerUUID, "myplugin.feature.use", true);
+```
+
+This is useful for features that should be enabled by default but can be revoked.
+
+### Using PermissionHolder Interface
+
+Players and command senders implement `PermissionHolder`, allowing direct checks:
+
+```java
+// In a command or event handler where you have access to the player
+if (player.hasPermission("myplugin.admin.manage")) {
+    // Player has admin permission
+}
+```
+
+---
+
+## Managing User Permissions
+
+### Adding Permissions to a User
+
+Permissions are additive - new permissions are added on top of existing ones, not replaced.
+
+```java
+PermissionsModule perms = PermissionsModule.get();
+
+// Add a single permission
+perms.addUserPermission(playerUUID, Set.of("myplugin.vip.chat"));
+
+// Add multiple permissions at once
+Set<String> newPerms = Set.of(
+    "myplugin.vip.chat",
+    "myplugin.vip.fly",
+    "myplugin.vip.kit"
+);
+perms.addUserPermission(playerUUID, newPerms);
+```
+
+### Removing Permissions from a User
 
 ```java
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.removeUserPermission(playerUUID, permissions);
+
+// Remove specific permissions
+Set<String> toRemove = Set.of("myplugin.vip.fly");
+perms.removeUserPermission(playerUUID, toRemove);
 ```
 
-### Add permissions to group
+---
+
+## Managing Groups
+
+Groups let you assign a collection of permissions to multiple players. This is more manageable than assigning permissions individually.
+
+### Adding Permissions to a Group
+
+If the group doesn't exist, it will be created automatically.
 
 ```java
-String groupName = "testGroup";
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.addGroupPermission(groupName, permissions);
+
+// Create/update the "VIP" group with permissions
+Set<String> vipPerms = Set.of(
+    "myplugin.vip.chat",
+    "myplugin.vip.fly",
+    "myplugin.vip.kit"
+);
+perms.addGroupPermission("VIP", vipPerms);
 ```
 
-### Remove permissions from group
+### Removing Permissions from a Group
 
 ```java
-String groupName = "testGroup";
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.removeGroupPermission(groupName, permissions);
+
+// Remove specific permissions from the group
+Set<String> toRemove = Set.of("myplugin.vip.fly");
+perms.removeGroupPermission("VIP", toRemove);
 ```
 
-### Add user to group
+### Adding a User to a Group
 
 ```java
-String groupName = "testGroup";
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.addUserToGroup(playerUUID, groupName);
+
+// Add player to the VIP group - they now have all VIP permissions
+perms.addUserToGroup(playerUUID, "VIP");
 ```
 
-### Remove user from group
+### Removing a User from a Group
 
 ```java
-String groupName = "testGroup";
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.removeUserFromGroup(playerUUID, groupName);
+
+// Remove player from VIP group
+perms.removeUserFromGroup(playerUUID, "VIP");
 ```
 
-### List all groups for a user
+### Getting a User's Groups
 
 ```java
 PermissionsModule perms = PermissionsModule.get();
-perms.getGroupsForUser(playerUUID);
+
+// Get all groups the player belongs to
+Set<String> groups = perms.getGroupsForUser(playerUUID);
+
+for (String group : groups) {
+    System.out.println("Player is in group: " + group);
+}
 ```
 
-### Check Permission Nodes
+---
+
+## Built-in Groups
+
+Hytale includes two default groups:
+
+| Group     | Default Permissions   | Purpose                           |
+| --------- | --------------------- | --------------------------------- |
+| `OP`      | `*` (all permissions) | Server operators with full access |
+| `Default` | None                  | Base group for all players        |
+
+Players without any explicit group assignment are automatically part of the `Default` group.
 
-To check if a player has a specific permission node, you can use the `hasPermission` method.
+---
+
+## Wildcards
+
+Wildcards let you grant or deny multiple permissions with a single pattern.
+
+### Wildcard Patterns
+
+| Pattern             | Meaning                                          |
+| ------------------- | ------------------------------------------------ |
+| `*`                 | Grants **all** permissions                       |
+| `myplugin.*`        | Grants all permissions starting with `myplugin.` |
+| `-*`                | Denies **all** permissions                       |
+| `-myplugin.admin.*` | Denies all admin permissions in your plugin      |
+
+### Example: Admin Group with Wildcards
 
 ```java
-boolean hasPermission = PermissionsModule.hasPermission(playerUUID, "permission.node");
+// Grant all permissions to admins
+perms.addGroupPermission("Admin", Set.of("*"));
+
+// Grant all plugin permissions to moderators
+perms.addGroupPermission("Moderator", Set.of("myplugin.*"));
+
+// Grant all permissions except admin commands
+perms.addGroupPermission("Helper", Set.of(
+    "*",
+    "-myplugin.admin.*"  // Deny admin permissions
+));
 ```
 
-## Additional: Defining your own provider for permissions and groups
+<Callout type="warning">
+  Negation permissions (starting with `-`) take precedence at each level. Use them carefully to avoid accidentally blocking permissions.
+</Callout>
+
+---
+
+## Built-in Permission Nodes
+
+Hytale provides constants for common permissions in the `HytalePermissions` class:
+
+### Command Permissions
+
+```java
+// Generate permission for a command
+String perm = HytalePermissions.fromCommand("gamemode");
+// Result: "hytale.command.gamemode"
+
+// Generate permission for a subcommand
+String perm = HytalePermissions.fromCommand("gamemode", "creative");
+// Result: "hytale.command.gamemode.creative"
+```
+
+### Common Permission Nodes
+
+| Permission                    | Description                  |
+| ----------------------------- | ---------------------------- |
+| `hytale.command.op.add`       | Add players to OP group      |
+| `hytale.command.op.remove`    | Remove players from OP group |
+| `hytale.editor.brush.use`     | Use brush tools              |
+| `hytale.editor.prefab.use`    | Use prefabs                  |
+| `hytale.editor.selection.use` | Use selection tools          |
+| `hytale.editor.history`       | Undo/redo operations         |
+| `hytale.camera.flycam`        | Use fly camera mode          |
+
+---
+
+## Listening to Permission Events
+
+You can react to permission changes using Hytale's event system.
+
+### Available Events
+
+| Event                                            | Triggered When                   |
+| ------------------------------------------------ | -------------------------------- |
+| `PlayerPermissionChangeEvent.PermissionsAdded`   | Permissions added to a user      |
+| `PlayerPermissionChangeEvent.PermissionsRemoved` | Permissions removed from a user  |
+| `PlayerGroupEvent.Added`                         | User added to a group            |
+| `PlayerGroupEvent.Removed`                       | User removed from a group        |
+| `GroupPermissionChangeEvent.Added`               | Permissions added to a group     |
+| `GroupPermissionChangeEvent.Removed`             | Permissions removed from a group |
 
-The PermissionsModule also enables us to define our own PermissionProvider's, this can be useful for:
+### Example: Reacting to Permission Changes
 
-- Cross server permission systems
-- Implementing features missing in the `HytalePermissionsProvider` like permission expiry
+```java
+public class PermissionListener {
+
+    public static void onPermissionsAdded(PlayerPermissionChangeEvent.PermissionsAdded event) {
+        UUID playerUUID = event.getPlayerUuid();
+        Set<String> added = event.getAddedPermissions();
+
+        System.out.println("Permissions added to " + playerUUID + ": " + added);
 
-To implement our PermissionProvider, first we need to define a provider class that implements PermissionProvider:
+        // Maybe notify the player or update cached data
+    }
+
+    public static void onGroupAdded(PlayerGroupEvent.Added event) {
+        UUID playerUUID = event.getPlayerUuid();
+        String groupName = event.getGroupName();
+
+        System.out.println("Player " + playerUUID + " joined group: " + groupName);
+    }
+}
+```
+
+### Registering the Events
 
 ```java
-public class DatabasePermissionProvider implements PermissionProvider
+public class MyPlugin extends JavaPlugin {
+
+    @Override
+    public void setup() {
+        EventRegistry events = this.getEventRegistry();
+
+        events.registerGlobal(
+            PlayerPermissionChangeEvent.PermissionsAdded.class,
+            PermissionListener::onPermissionsAdded
+        );
+
+        events.registerGlobal(
+            PlayerGroupEvent.Added.class,
+            PermissionListener::onGroupAdded
+        );
+    }
+}
 ```
 
-Then we just implement the required methods using a database implementation.
+---
+
+## Creating a Custom Permission Provider
+
+For advanced use cases, you can create your own permission provider. This is useful for:
+
+- Database-backed permissions (MySQL, MongoDB, etc.)
+- Cross-server permission synchronization
+- Custom features like permission expiry or contexts
+
+### Implementing PermissionProvider
+
+```java
+public class DatabasePermissionProvider implements PermissionProvider {
+
+    @Nonnull
+    @Override
+    public String getName() {
+        return "DatabasePermissionProvider";
+    }
+
+    // User permission methods
+    @Override
+    public void addUserPermissions(@Nonnull UUID uuid, @Nonnull Set<String> permissions) {
+        // Save to your database
+    }
+
+    @Override
+    public void removeUserPermissions(@Nonnull UUID uuid, @Nonnull Set<String> permissions) {
+        // Remove from your database
+    }
+
+    @Override
+    public Set<String> getUserPermissions(@Nonnull UUID uuid) {
+        // Query your database
+        return Set.of();
+    }
+
+    // Group permission methods
+    @Override
+    public void addGroupPermissions(@Nonnull String group, @Nonnull Set<String> permissions) {
+        // Save to your database
+    }
+
+    @Override
+    public void removeGroupPermissions(@Nonnull String group, @Nonnull Set<String> permissions) {
+        // Remove from your database
+    }
+
+    @Override
+    public Set<String> getGroupPermissions(@Nonnull String group) {
+        // Query your database
+        return Set.of();
+    }
+
+    // User-group membership methods
+    @Override
+    public void addUserToGroup(@Nonnull UUID uuid, @Nonnull String group) {
+        // Save to your database
+    }
+
+    @Override
+    public void removeUserFromGroup(@Nonnull UUID uuid, @Nonnull String group) {
+        // Remove from your database
+    }
+
+    @Override
+    public Set<String> getGroupsForUser(@Nonnull UUID uuid) {
+        // Query your database
+        return Set.of("Default");
+    }
+}
+```
 
 <Callout type="warning">
-  Hytale will try to use the first available permissions provider to add/remove gamemode groups (i.e. `Creative`, `Adventure`).
+  Hytale automatically assigns players to game-mode groups (like `Creative` or `Adventure`) using the first available provider.
+
+  If your provider throws an error when the group doesn't exist, the player will be disconnected! Always handle missing groups gracefully.
+</Callout>
+
+### Registering Your Provider
 
-  If your provider throws an error (for instance, if the group does not exist) when the server is preparing the player, the player will be disconnected.
+```java
+public class MyPlugin extends JavaPlugin {
+
+    @Override
+    public void setup() {
+        // Add your provider alongside the default one
+        PermissionsModule.get().addProvider(new DatabasePermissionProvider());
+    }
+}
+```
+
+The `PermissionsModule` aggregates permissions from all registered providers. This means:
+
+- Permission checks query all providers
+- Write operations (add/remove) use the **first** provider
+
+### Replacing the Default Provider
+
+If you want full control, you can remove the default provider:
+
+```java
+public class MyPlugin extends JavaPlugin {
+
+    @Override
+    public void setup() {
+        PermissionsModule perms = PermissionsModule.get();
+
+        // Remove the default provider FIRST
+        perms.removeProvider(perms.getFirstPermissionProvider());
+
+        // Then add your provider
+        perms.addProvider(new DatabasePermissionProvider());
+    }
+}
+```
+
+<Callout type="info">
+  When you remove the default provider, the `/op self` command will stop working since it checks for provider tampering.
 </Callout>
 
-We can then register the provider using the built-in permission module:
+---
+
+## Best Practices
+
+### Permission Naming Conventions
+
+Follow the pattern: `namespace.category.action`
 
 ```java
-PermissionsModule.get().addProvider(new DatabasePermissionProvider());
+// Good - clear hierarchy
+"myplugin.admin.ban"
+"myplugin.user.teleport.home"
+"myplugin.vip.chat.color"
+
+// Bad - unclear structure
+"myplugin_ban"
+"teleport"
+"vipChatColor"
 ```
 
-Please note that the `HytalePermissionsProvider` will still be enabled alongside your provider.
-The `PermissionsModule` will aggregate groups and permissions from all available providers.
+### Use Constants for Permissions
 
-If you want to disable the default `HytalePermissionsProvider`, you can use:
+Define your permissions as constants to avoid typos:
 
 ```java
-// put this **before** you add your provider
-PermissionsModule.get().removeProvider(PermissionsModule.get().getFirstPermissionProvider());
+public final class MyPermissions {
+    public static final String ADMIN_BAN = "myplugin.admin.ban";
+    public static final String ADMIN_KICK = "myplugin.admin.kick";
+    public static final String USER_HOME = "myplugin.user.home";
+    public static final String VIP_FLY = "myplugin.vip.fly";
+}
+
+// Usage
+if (player.hasPermission(MyPermissions.ADMIN_BAN)) {
+    // ...
+}
 ```
+
+### Don't Over-Permission
+
+Only create permissions for actions that genuinely need access control. Not everything needs a permission check.
+
+### Thread Safety
+
+If you create a custom provider, ensure it's thread-safe. Permission checks can occur from multiple threads simultaneously. Use `ReadWriteLock` or `ConcurrentHashMap` for your data structures.
+
+---
+
+## In-Game Commands
+
+Hytale provides built-in commands for managing permissions:
+
+### `/op` Command
+
+| Command               | Description                                                        |
+| --------------------- | ------------------------------------------------------------------ |
+| `/op self`            | Toggle your own OP status (singleplayer or with `--allow-op` flag) |
+| `/op add <player>`    | Add a player to the OP group                                       |
+| `/op remove <player>` | Remove a player from the OP group                                  |
+
+### `/perm` Command
+
+Use `/perm --help` in-game for full usage. Common operations:
+
+| Command                                  | Description                   |
+| ---------------------------------------- | ----------------------------- |
+| `/perm user list <uuid>`                 | List user's permissions       |
+| `/perm user add <uuid> <perm>`           | Add permission to user        |
+| `/perm user remove <uuid> <perm>`        | Remove permission from user   |
+| `/perm user group list <uuid>`           | List user's groups            |
+| `/perm user group add <uuid> <group>`    | Add user to group             |
+| `/perm user group remove <uuid> <group>` | Remove user from group        |
+| `/perm group list <group>`               | List group's permissions      |
+| `/perm group add <group> <perm>`         | Add permission to group       |
+| `/perm group remove <group> <perm>`      | Remove permission from group  |
+| `/perm test <perm>`                      | Test if you have a permission |
+
+---
+
+## Summary
+
+You've learned how to:
+
+- **Check permissions** using `PermissionsModule.hasPermission()`
+- **Manage user permissions** with `addUserPermission()` and `removeUserPermission()`
+- **Work with groups** using `addGroupPermission()`, `addUserToGroup()`, etc.
+- **Use wildcards** like `*` and `myplugin.*` for bulk permissions
+- **Listen to events** for permission changes
+- **Create custom providers** for database-backed permissions
+
+For more advanced permission systems with features like inheritance, expiry, and contexts, we're looking into expanding this guide with advanced permission management techniques in the future.
diff --git a/content/docs/cs-CZ/guides/plugin/setting-up-env.mdx b/content/docs/cs-CZ/guides/plugin/setting-up-env.mdx
index d2718098..5be5e9e0 100644
--- a/content/docs/cs-CZ/guides/plugin/setting-up-env.mdx
+++ b/content/docs/cs-CZ/guides/plugin/setting-up-env.mdx
@@ -4,6 +4,10 @@ description: Learn how to set up your development environment for modding Hytale
 authors:
   - name: Neil Revin
     link: https://itsneil.dev
+  - name: Marcel-TO
+    url: https://marcel-to.net
+  - name: Ádám Liszkai
+    link: https://adaliszk.dev
 ---
 
 This guide will walk you through setting up a complete development environment for Hytale modding, including all necessary tools and dependencies.
@@ -19,24 +23,73 @@ Before we begin, make sure you have:
 
 ## Required Software
 
-### 1. Java Development Kit (JDK)
+### Integrated Development Environment (IDE)
 
+We recommend IntelliJ IDEA Community Edition for Hytale modding. If you use IntelliJ IDEA, **almost everything is built-in**. You can clone a template, open a new project, and start working right away!
+
+1. Download from [JetBrains website](https://www.jetbrains.com/idea/download/)
+2. Install with default settings
+3. Launch and complete the initial setup wizard
+
+When opening a project, wait for indexing to finish, then start coding.
+Now, IDEA may say "No JDK configured" at the top of the source file you have.
+In that case, you can click Download JDK and choose JetBrains JDK 25.
+
+<Callout type="success">
+  If IDEA opened the project without errors, your environment is ready.
+</Callout>
+
+More details by [JetBrains](https://www.jetbrains.com/help/idea/2026.1/run-for-the-first-time.html)
+help page, where we recommend that you also check the
+[SDK configuration](https://www.jetbrains.com/help/idea/2026.1/sdk.html) guide.
+
+<Callout type="info">
+  We recommened following
+  [TheNullicorn's](https://gist.github.com/TheNullicorn/90a619796c40f20ae1fcf13094c1a57d) guide to ensure
+  you are using the correct `Nonnull` in your projects.
+</Callout>
+
+#### What the IDE Does for You
+
+When opened in IntelliJ IDEA, the project automatically:
+
+- Detects and configures Gradle or Maven
+- Downloads all dependencies
+- Sets up project structure and classpaths
+- Configures run/build tasks
+
+You do **not** need to manually install or configure Maven or Gradle if you stay inside the IDE.
+
+Skip to the [Setting Up Your Workspace](#setting-up-your-workspace).
+
+### Manual Setup: Java Development Kit (JDK)
+
+For any other setup, you will need to install and configure your system to have and load Java.
 Hytale modding requires Java 25 or later. We recommend using OpenJDK.
 
-#### Windows
+#### Windows via Installer
 
 1. Download OpenJDK 25 from [Adoptium](https://adoptium.net/)
 2. Run the installer with default settings
+   - Optionally enable feature `Set or Override JAVA_HOME variable` to resolve version related build issues with your project.
 3. Verify installation by opening Command Prompt and running:
 
+#### Windows via Scoop
+
+1. Install Scoop via PowerShell using [scoop.sh](https://scoop.sh/)
+2. Install OpenJDK 25:
+
 ```bash
-java -version
+scoop bucket add java
+scoop install java/openjdk25
 ```
 
 #### macOS
 
+1. Install Brew via Terminal using [brew.sh](https://brew.sh)
+2. Install JDK via Homebrew:
+
 ```bash
-# Using Homebrew
 brew install openjdk@25
 ```
 
@@ -51,22 +104,41 @@ brew install openjdk@25
 
 #### Linux (Ubuntu/Debian)
 
+1. Install JDK via the built-in package repository:
+
 ```bash
 sudo apt update
 sudo apt install openjdk-25-jdk
 ```
 
-### 2. Integrated Development Environment (IDE)
+### Verify installation:
 
-We recommend IntelliJ IDEA Community Edition for Hytale modding.
+Run the following command to see what version of Java you have:
 
-1. Download from [JetBrains website](https://www.jetbrains.com/idea/download/)
-2. Install with default settings
-3. Launch and complete the initial setup wizard
+```bash
+java -version
+```
+
+### Java Build Tool (Optional)
+
+We recommend using a Gradle Wrapper for managing dependencies and building your Hytale plugins. It provides benefits by eliminating the need for a system-wide Gradle installation and ensuring consistent Gradle versions across different environments. (Alternatively you can use Maven, but this guide focuses on Gradle since it is the default for our plugin template.)
+
+The plugin template in the following sections includes a Gradle Wrapper, so you can skip this step if you plan to use the template.
+
+#### Choosing Gradle (if not using the template)
+
+If you prefer to install Gradle manually, follow these steps:
 
-### 3) Java Build Tool
+1. Visit the official website: https://gradle.org/releases/
+2. Download the newest gradle binary: `gradle-9.3.1-bin.zip` (Binary zip archive)
+3. Unzip it
+4. Add the `gradle-9.3.1/bin/` folder to your PATH
+
+You can now try the command `gradle -version` to verify Gradle is installed correctly. Make sure to do this in a fresh new terminal instead of one you had opened from before!
+
+#### Choosing Maven (if not using the template)
 
-We recommend using Apache Maven for managing dependencies and building your Hytale plugins. (Alternatively you can use Gradle, but this guide focuses on Maven.)
+If you prefer to use Maven instead of Gradle, follow these steps to install Maven:
 
 1. Visit the official website: https://maven.apache.org/download.cgi
 2. Download this file: `apache-maven-3.9.12-bin.zip` (Binary zip archive)
@@ -89,22 +161,61 @@ cd MyFirstMod
 
 If you don't have Git installed, you can download the ZIP file from the repository page and extract it to a folder named `MyFirstMod`.
 
-### 2. Open Plugin in your IDEA
+### 2. Open Plugin in your IDE
 
-1. Open IntelliJ IDEA
+1. Open Your IDE (e.g., IntelliJ IDEA)
 2. Click "Open" and navigate to your `MyFirstMod` directory
-3. IntelliJ will automatically detect it as a Maven project
+3. Most IDEs like IntelliJ will automatically detect it as a Gradle project
 4. Wait for the project to index and dependencies to download
 
-<Callout type="info">
-  We recommened following [this](https://gist.github.com/TheNullicorn/90a619796c40f20ae1fcf13094c1a57d) guide to ensure you are using the correct `Nonnull` in your projects.
-</Callout>
+## Alternate Approach: Hytale Dependency
+
+If you prefer to set up your project from scratch without using the template and importing the hytale dependencies manually, ensure your build configuration includes the Hytale repositories and dependencies:
+
+For Gradle, add the following to your `build.gradle.kts`:
+
+```kotlin
+repositories {
+    mavenCentral()
+    maven {
+        name = "hytale"
+        url = uri("https://maven.hytale.com/release") // Or "hytale-pre-release" for pre-release versions
+    }
+}
+dependencies {
+    // + here means the latest version, but you can hard-wire any known version!
+    implementation("com.hypixel.hytale:Server:+")
+}
+```
+
+For Maven, add the following to your `pom.xml`:
+
+```xml
+<project>
+    <repositories>
+        <repository>
+            <id>hytale-release</id> <!-- Or "hytale-pre-release" for pre-release versions -->
+            <url>https://maven.hytale.com/release</url> <!-- Or "https://maven.hytale.com/pre-release" -->
+        </repository>
+    </repositories>
+
+    <dependencies>
+        <dependency>
+            <groupId>com.hypixel.hytale</groupId>
+            <artifactId>Server</artifactId>
+            <!-- Replace with latest version, Hytale provides jars for the last five releases -->
+            <version>LATEST_VERSION_HERE</version>
+            <scope>provided</scope>
+        </dependency>
+    </dependencies>
+</project>
+```
 
 ## Next Steps
 
 Now that you have your development environment set up with the plugin template:
 
-1. **Customize the template** - Edit the `pom.xml` and `manifest.json` file to change your mod's name and details
+1. **Customize the template** - Edit the `settings.gradle.kts`, `build.gradle.kts` and `manifest.json` file to change your mod's name and details
 2. **Explore the code structure** - Familiarize yourself with the template's organization
 3. **Start modding** - Begin writing your first Hytale plugin!
 
diff --git a/content/docs/cs-CZ/guides/plugin/spawning-entities.mdx b/content/docs/cs-CZ/guides/plugin/spawning-entities.mdx
index e12c0aea..15be2fb3 100644
--- a/content/docs/cs-CZ/guides/plugin/spawning-entities.mdx
+++ b/content/docs/cs-CZ/guides/plugin/spawning-entities.mdx
@@ -36,7 +36,7 @@ Store<EntityStore> store = world.getEntityStore().getStore();
 
 ## Creating Entities
 
-Once you have the `EntityStore` instance, you can start to create a entity and give it components. Entities are just instances of `Holder<EntityStore>` with several components attached to them.
+Once you have the `EntityStore` instance, you can start to create an entity and give it components. Entities are just instances of `Holder<EntityStore>` with several components attached to them.
 
 <Callout type="warning">
   To interact with the `World` instance, some methods require you to run the code inside the world's execution context.
@@ -118,3 +118,48 @@ Finally, we can add the entity to the world by calling the `addEntity` method on
 ```java
 store.addEntity(holder, AddReason.SPAWN);
 ```
+
+## Making the entity persist
+
+Hytale automatically saves all entities, but the `NetworkId` component (required for players to be able to see the entity) needs to be manually added every time the entity is loaded.
+
+### Using a system
+
+If you have a component that is unique to your entities, this can be done by creating and registering a custom system as follows:
+
+```java
+public class AddNetworkIdToMyEntitySystem extends HolderSystem<EntityStore> {
+    private final ComponentType<EntityStore, MyEntityComponent> myEntityComponentType = MyEntityComponent.getComponentType();
+    private final ComponentType<EntityStore, NetworkId> networkIdComponentType = NetworkId.getComponentType();
+    private final Query<EntityStore> query = Query.and(this.myEntityComponentType, Query.not(this.networkIdComponentType));
+
+    @Override
+    public void onEntityAdd(@NotNull Holder<EntityStore> holder, @NotNull AddReason reason, @NotNull Store<EntityStore> store) {
+        if (!holder.getArchetype().contains(NetworkId.getComponentType())) {
+            holder.addComponent(NetworkId.getComponentType(), new NetworkId(store.getExternalData().takeNextNetworkId()));
+        }
+    }
+
+    @Override
+    public void onEntityRemoved(@NotNull Holder<EntityStore> holder, @NotNull RemoveReason reason, @NotNull Store<EntityStore> store) {}
+
+    @Override
+    public @Nullable Query<EntityStore> getQuery() {
+        return query;
+    }
+}
+```
+
+In your plugin's `setup()` function
+
+```java
+this.getEntityStoreRegistry().registerSystem(new AddNetworkIdToMyEntitySystem())
+```
+
+### Using PropComponent
+
+Alternatively you can add `PropComponent` to your entity. Hytale adds `PropComponent` to entities spawned with the Entity Tool, and such entities automatically get `NetworkId` and `PrefabCopyableComponent` (which makes the entity work with prefabs).
+
+<Callout type="warning">
+  There is no guarantee, that Hytale will not add some other behavior to this component in the future, which may break your entity, so be careful if you decide to rely on it.
+</Callout>
diff --git a/content/docs/cs-CZ/guides/plugin/store-persistent-data.mdx b/content/docs/cs-CZ/guides/plugin/store-persistent-data.mdx
new file mode 100644
index 00000000..1071dff3
--- /dev/null
+++ b/content/docs/cs-CZ/guides/plugin/store-persistent-data.mdx
@@ -0,0 +1,171 @@
+---
+title: Storing Persistent Data on the Player
+description: Learn how to save and load persistent data using Components
+authors:
+  - name: Neil Revin
+    url: https://itsneil.dev/
+  - name: ArcticDev
+    url: https://github.com/ArcticRaven
+  - name: oskarscot
+    url: https://oskar.scot
+  - name: JammingEng
+    url: https://github.com/JammingEnd
+---
+
+Here is how to store persistent data using a custom component on a Player.
+
+## Build your Component Class
+
+Creating a custom component class leverages the Component system made with the ECS architecture in mind. For more information on Components, check out the [ECS Guide](../ecs/hytale-ecs-theory#components).
+
+Start by creating your custom component class. This will be extremely similar to how regular components are created, however we'll setup a custom Codec so the server can translate this data to BSON, or the server's internal json encoder.
+
+<Callout type="info">
+  Each variable you want to store in your component must have its own Codec field defined in the BuilderCodec.
+  For more information on how to create custom Codecs, check out the [ECS Codec Guide](../ecs/hytale-ecs-theory#codec).
+</Callout>
+
+```java
+public class YourPlayerData implements Component<EntityStore> {
+
+    // define some vars!
+    private int someInteger;
+    private String someString;
+    private Map<String, String> someMap;
+
+    public static final BuilderCodec<YourPlayerData> CODEC =
+            BuilderCodec.builder(YourPlayerData.class, YourPlayerData::new)
+            .append(new KeyedCodec<>("SomeInteger", Codec.INTEGER),
+                    (data, value) -> data.someInteger = value, // setter
+                    data -> data.someInteger) // getter
+            .addValidator(Validators.nonNull())
+            .add()
+            .append(new KeyedCodec<>("SomeString", Codec.STRING),
+                    (data, value) -> data.someString = value, // setter
+                    data -> data.someString) // getter
+            .add()
+            .append(new KeyedCodec<>("SomeMap",
+                            new MapCodec<>(Codec.STRING, HashMap::new, false)),
+                    (data, value) -> data.someMap = value, // setter
+                    data -> data.someMap) // getter
+            .add()
+            .build();
+
+
+
+    // Getters and Setters are for the purpose of this example omitted.
+
+    // constructor
+    public YourPlayerData() {
+        this.someInteger = 0;
+        this.someString = "";
+        this.someMap = new HashMap<>();
+    }
+
+    // copy constructor for cloning
+    public YourPlayerData(YourPlayerData clone) {
+        this.someInteger = clone.someInteger;
+        this.someString = clone.someString;
+        this.someMap = clone.someMap;
+    }
+
+    @Nonnull
+    @Override
+    public Component<EntityStore> clone() {
+        return new YourPlayerData(this);
+    }
+}
+```
+
+## Register your Component
+
+Inside your main class's `setup()` method, register your new Component.
+
+```java
+public class YourPlugin extends JavaPlugin {
+
+    private ComponentType<EntityStore, YourPlayerData> yourPlayerDataComponent;
+
+    public YourPlugin(@Nonnull JavaPluginInit init) {
+        super(init);
+    }
+
+    @Override
+    protected void setup(){
+        this.yourPlayerDataComponent = this.getEntityStoreRegistry().registerComponent(
+            YourPlayerData.class,
+            "YourPlayerDataComponent",
+            YourPlayerData.CODEC
+        );
+    }
+
+    public ComponentType<EntityStore, YourPlayerData> getYourPlayerDataComponent() {
+        return this.yourPlayerDataComponent;
+    }
+}
+```
+
+## Using your Component
+
+To use your newly created component, you can add the Component to a player using the `addComponent` method, although this only adds it temporarily, meaning when the player/entity leaves the world, the component is removed. You can use `putComponent` to ensure the component persists between sessions.
+
+```java
+// You will need the Ref and Store to apply components
+private void someEntryMethod(@Nonnull Ref<EntityStore> ref, @Nonnull Store<EntityStore> store)
+{
+       // Any entity will work, for now we will use the player
+      Player player = (Player) store.getComponent(ref, Player.getComponentType());
+
+      // since we're using putComponent, it could be useful to check if it already exists on the player in case we want to update it
+     if(store.getComponent(ref, YourPlugin.instance().getYourPlayerDataComponent()) != null)
+     {
+          // here we implement logic that updates the component
+         var comp = store.getComponent(ref, YourPlugin.instance().getYourPlayerDataComponent())
+         // declare public fields or methods in the component class
+         comp.SomeString = "An Updated Field";
+     } else {
+          // Here we put the component
+          var myCustomComp = new CustomComponent();
+          // declare public fields or methods in the component class
+          myCustomComp.SomeString = "Edited String";
+
+          // putComponent allows you to insert declared objects
+          store.putComponent(ref, YourPlugin.instance().getYourPlayerDataComponent(), myCustomComp);
+     }
+}
+```
+
+## Using your Data
+
+Your component will be stored within the `Store<EntityStore>` when added to the player. In the provided example,
+we'll fetch this data off the player using the `ensureAndGetComponent()` method, which will add the component to
+the player if it does not exist with the default values.
+
+```java
+public class IncompleteCustomCommand extends AbstractPlayerCommand {
+
+    public IncompleteCustomCommand() {
+        super("nope", "don't use this command");
+    }
+
+    @Override
+    protected void execute(
+        @NonNullDecl CommandContext commandContext,
+        @NonNullDecl Store<EntityStore> store,
+        @NonNullDecl Ref<EntityStore> ref,
+        @NonNullDecl PlayerRef playerRef,
+        @NonNullDecl World world
+    ) {
+        YourPlayerData customData = store.ensureAndGetComponent(ref, YourPlugin.instance().getYourPlayerDataComponent());
+        // ensureAndGetComponent adds the component to the ref, with the default values defined inside your component.
+ 		// use your data
+    }
+}
+```
+
+And that's it! Your data will now be saved and loaded automatically with the player.
+
+Using custom components to store persistent data on players is a powerful way to maintain state across sessions.
+By following the steps outlined above, you can easily create, register, and utilize your own data structures within the Hytale ECS framework.
+This approach ensures that your data is seamlessly integrated with the game's existing systems.
+For more information about Hytale's Entity Component System visit the [Hytale ECS Theory](https://hytalemodding.dev/en/docs/guides/ecs/hytale-ecs-theory) guide.
diff --git a/content/docs/cs-CZ/guides/plugin/teleporting-players.mdx b/content/docs/cs-CZ/guides/plugin/teleporting-players.mdx
index 57cee77f..32ce0435 100644
--- a/content/docs/cs-CZ/guides/plugin/teleporting-players.mdx
+++ b/content/docs/cs-CZ/guides/plugin/teleporting-players.mdx
@@ -1,26 +1,32 @@
 ---
 title: Teleporting the player
 description: Learn how to teleport the player.
+authors:
+  - name: oskarscot
+    url: https://oskar.scot
 ---
 
-To teleport players in Hytale, you will need to get a `World` object so we can safely run the teleport on the world thread. The world thread manages all entity updates, so modifying entities off-thread can crash the server or cause inconsistent state.
-Next, we get the entity store and make a `Teleport` object.
-We add a `Teleport` component to the player’s entity reference in the entity store. This triggers the teleportation logic for that player.
+Teleporting players in Hytale works by simply attaching a `Teleport` component to a player with the desired world and transform.
+You can only trigger teleports from a world where the player is currently present.
+Teleport itself is a component but it also provides factory methods to configure the Teleport. Just as with any entity component, an EntityStore and a Ref to the EntityStore is required
+
+We can create a simple teleport utility like this:
 
 ```java
-public static void teleportPlayer(Player player, int x, int y, int z) {
-        World world = player.getWorld();
-        if (world == null) return;
-        world.execute(() -> {
-            if (player.getReference() == null) return;
-            Store<EntityStore> store = player.getReference().getStore();
-            Teleport teleport = Teleport.createForPlayer(world,
-                new Vector3d(x ,y, z), // Target position
-                new Vector3f(0, 0, 0)  // Target rotation (pitch, yaw, roll)
-            );
+public static void teleportPlayer(Ref<EntityStore> ref, Store<EntityStore> store, World targetWorld, double x, double y, double z) {                                                                                       
+    Transform transform = new Transform(x, y, z);                                                                                                                           
+    Teleport teleport = Teleport.createForPlayer(targetWorld, transform);                                                                                                   
+    store.addComponent(ref, Teleport.getComponentType(), teleport);                                                                                                         
+}  
+```
 
-            store.addComponent(player.getReference(), Teleport.getComponentType(), teleport);
-        });
+A `Transform` is a representation of a position Vector3d and rotation Vector3f which works in the following way:
 
-}
+```java
+Transform transform = new Transform(
+    new Vector3d(x, y, z),      // Position
+    new Rotation(yaw, pitch, 0) // Rotation, last value seems to always be 0
+);
+Teleport teleport = Teleport.createForPlayer(targetWorld, transform);
+store.addComponent(ref, Teleport.getComponentType(), teleport);
 ```
diff --git a/content/docs/cs-CZ/guides/plugin/tracking-mod-analytics-with-hstats.mdx b/content/docs/cs-CZ/guides/plugin/tracking-mod-analytics-with-hstats.mdx
new file mode 100644
index 00000000..45c022e0
--- /dev/null
+++ b/content/docs/cs-CZ/guides/plugin/tracking-mod-analytics-with-hstats.mdx
@@ -0,0 +1,65 @@
+---
+title: Tracking Mod Analytics with HStats
+description: Learn how you can track Analytics for your Hytale Mod for Free using hstats.dev
+authors:
+  - name: Al3x
+    url: https://hstats.dev
+---
+
+In this guide, you will learn how to integrate HStats into your Plugin/Mod which will allow you to track how many Servers are using it along with other stats.
+
+<Callout type="info">
+  HStats is a third-party tool and is not affiliated with HytaleModding or Hypixel Studios
+</Callout>
+
+# Step 1: Register your Mod to HStats
+
+Before you touch any code, you will need to add your mod to the HStats website which will give you a UUID for your mod.
+
+- Create or Login to an Account on https://hstats.dev
+- Navigate to the dashboard page (https://hstats.dev/dashboard)
+- On the left, type in your mod's name and click "Add Mod"
+- Keep note of the UUID generated for later.
+
+# Step 2: Add the HStats Class to Your Project
+
+To keep things simple, HStats uses a single Java class file that handles everything for you.
+
+- Download / Copy the File from the GitHub page (https://github.com/hstats-dev/HStatsExamplePlugin/blob/main/src/main/java/com/al3x/HStats.java)
+- Paste into your Project. You should now have a HStats.java file somewhere in your projects directory.
+- Update the package name from com.al3x to whatever fits your project.
+
+# Step 3: Initialize HStats in your code
+
+You only need to add one line of code to your mod's setup method in your main class to start tracking.
+
+`new HStats("YOUR-MOD-UUID", "1.0.0");`
+
+Replace `YOUR-MOD-UUID` with the Mod UUID we made note of earlier and change the `1.0.0` version to whatever version your mod is currently on.
+
+Your setup method should now look something like this:
+
+```java
+@Override
+protected void setup() {
+  super.setup();
+  new HStats("c34a2b2a-afd8-4d6a-821e-7a63e12c5ea6", "1.0.0");
+}
+```
+
+# Extras
+
+Your done! Your mod should now be listed under the Mods page (https://hstats.dev/mods) as well as under your dashboard.
+
+Servers using your mod should now post updates about every minute to HStats which you can view in the Dashboard.
+
+### Embeds
+
+HStats allows you to generate an Embed Card that you can place on your CurseForge or GitHub page. This is useful for server owners to be able to see how many other servers are using your mod.
+
+- In your dashboard, scroll down to the Embed Card section.
+- Customize the appearance (Light/Dark mode, layout, etc).
+- Copy the generated URL to display your "Active Servers" and "Players Online" live on your mod's description page
+
+Heres an example of what they look like:
+![HStats Example](https://api.hstats.dev/api/embed/d52fa672-6966-47b2-b501-1a11bddebac3/card.svg?theme=light\&layout=compact\&size=md\&show_id=true\&dark=false)
diff --git a/content/docs/cs-CZ/guides/plugin/world-gen.mdx b/content/docs/cs-CZ/guides/plugin/world-gen.mdx
index 4c23b0c9..7b193ffd 100644
--- a/content/docs/cs-CZ/guides/plugin/world-gen.mdx
+++ b/content/docs/cs-CZ/guides/plugin/world-gen.mdx
@@ -100,7 +100,7 @@ Biome biome = biomeGen.generateBiomeAt(zoneResult, seed, x, z);
 
 ### Zone & Cave Integration
 
-Each zone defines it's own cave patterns:
+Each zone defines its own cave patterns:
 
 ```java
 Zone zone = /* ... */;
diff --git a/content/docs/cs-CZ/guides/prefabs.mdx b/content/docs/cs-CZ/guides/prefabs.mdx
index 08404b30..b1a55109 100644
--- a/content/docs/cs-CZ/guides/prefabs.mdx
+++ b/content/docs/cs-CZ/guides/prefabs.mdx
@@ -14,7 +14,7 @@ Prefabs are Hytale's way of creating reusable structures.
 There are a few fundamental concepts to understand about prefabs:
 
 - Users interact with prefabs via a prefab editing world.
-- Prefabs the physical structures in the game world, and are saved as JSON files.
+- Prefabs are the physical structures in the game world, and are saved as JSON files.
 
 ## How to Create a Prefab
 
diff --git a/content/docs/cs-CZ/official-documentation/custom-ui/common-styling.mdx b/content/docs/cs-CZ/official-documentation/custom-ui/common-styling.mdx
new file mode 100644
index 00000000..c36e3e3a
--- /dev/null
+++ b/content/docs/cs-CZ/official-documentation/custom-ui/common-styling.mdx
@@ -0,0 +1,50 @@
+---
+title: Common Styling
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# Common Styling
+
+## Common UI Styling Library
+
+This document describes the shared UI components and styles defined in `Common.ui`.
+
+---
+
+### Styles
+
+We are providing some styles that can be re-used in any custom UI that, provide a cohesive UI experience with the core game UI. These styles are available in the `Common.ui` file.
+
+You can find a list of all the styles defined with live examples by running the `/ui-gallery` command ingame.
+
+<Callout type="warning">
+  This command is not available yet, but will be in a future patch.
+</Callout>
+
+![Gallery](/assets/official-documentation/ui/gallery.png)
+
+### Importing
+
+To use these styles in your UI file:
+
+```
+$Common = "Common.ui";
+
+// Then reference styles and components:
+$Common.@TextButton { @Text = "My Button"; }
+$Common.@Container { ... }
+```
+
+<Callout type="info">
+  The `Common.ui` file is at `Common/UI/Custom/Common.ui` within the Hytale pack. If your custom ui document is in a subfolder of `Common/UI/Custom/`, reference it via relative path traversal:
+
+  ```
+  $Common = "../Common.ui";
+  ```
+
+  You can find more info about paths [here](markup#path).
+</Callout>
diff --git a/content/docs/cs-CZ/official-documentation/custom-ui/index.mdx b/content/docs/cs-CZ/official-documentation/custom-ui/index.mdx
new file mode 100644
index 00000000..f94c4e88
--- /dev/null
+++ b/content/docs/cs-CZ/official-documentation/custom-ui/index.mdx
@@ -0,0 +1,125 @@
+---
+title: Custom UI
+icon: LayoutDashboard
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# Custom UI
+
+## What is Custom UI?
+
+Custom UI is Hytale's framework for creating **custom user interfaces** controlled by the game server. Unlike the built-in Client UI (which is part of the game client and cannot be modified), Server UI allows you to create interactive screens and HUD overlays through Java plugins and asset packs.
+
+As a modder, Custom UI gives you the power to:
+
+- **Create custom interactive pages** - Shop interfaces, quest dialogs, server settings menus, admin panels
+- **Add custom HUD overlays** - Quest trackers, status displays, custom health bars, server information
+- **Design with markup** - Use `.ui` files to define reusable UI templates
+- **Handle user interactions** - Respond to button clicks, form submissions, and other events
+- **Localize your UI** - Support multiple languages using the game's translation system
+
+## How Custom UI Fits Into Hytale's UI
+
+Hytale's user interface is divided into two main categories:
+
+### Client UI (Not Moddable)
+
+Built-in interfaces controlled by the C# game client:
+
+- Main menu and settings
+- Character creation
+- Built-in HUD (health, hotbar, chat)
+- Inventory and crafting screens
+- Development tools
+
+**You cannot modify these** - they are part of the core game client.
+
+### In-Game UI (Moddable via Server)
+
+Server-controlled interfaces that you can create and customize:
+
+#### Custom Pages
+
+Full-screen interactive overlays that appear during gameplay:
+
+- Can be dismissed by the player (ESC key)
+- Capture all input (keyboard and mouse)
+- Support loading states while waiting for server responses
+- Perfect for: shops, dialogs, menus, configuration screens
+
+#### Custom HUDs
+
+Persistent overlay elements drawn on top of the game world:
+
+- Display-only (no user interaction)
+- Always visible during gameplay
+- Lightweight and non-intrusive
+- Perfect for: quest objectives, status indicators, server info panels
+
+## Architecture Overview
+
+Server UI uses a **command-based architecture**:
+
+```
+┌─────────────────────┐         ┌──────────────────────┐
+│   Java Server       │         │    C# Client         │
+│   (Your Plugin)     │         │    (Game)            │
+├─────────────────────┤         ├──────────────────────┤
+│                     │         │                      │
+│ InteractiveCustomUI │         │   CustomPage or      │
+│ Page                │         │   CustomHud          │
+│   ↓ build()         ├────────→│     ↓ Apply          │
+│ UICommandBuilder    │         │   Element Tree       │
+│   - append()        │         │     ↓ Layout         │
+│   - set()           │         │   Rendered UI        │
+│   - clear()         │         │                      │
+│                     │         │                      │
+│ ↓ handleDataEvent() │← Events │   User Interaction   │
+│   Process input     │         │   (click, type, etc) │
+│   sendUpdate()      │         │                      │
+└─────────────────────┘         └──────────────────────┘
+```
+
+**The flow:**
+
+1. Your Java code builds UI using `UICommandBuilder`
+2. Commands are sent to the client as data
+3. Client parses `.ui` markup files and creates visual elements
+4. User interacts with the UI
+5. Events are sent back to your Java code
+6. You process events and send updates back
+
+## Key Principles
+
+### Declarative, Not Imperative
+
+You don't create UI objects directly. Instead, you send **commands** that describe what you want:
+
+- "Append this button template to that container"
+- "Set this label's text to 'Hello World'"
+- "Clear all children from this list"
+
+### Asset-Driven
+
+UI structure is defined in `.ui` markup files (assets), not hardcoded in Java. This enables:
+
+- Designers to modify layouts without touching code
+- Reusable UI components
+- Consistent visual language
+
+### Event-Driven
+
+User interactions trigger events that flow back to your server code. You register event bindings and handle them in `handleDataEvent()`.
+
+### Selector-Based
+
+You target specific UI elements using **selectors:**
+
+- `#MyButton` - Element with ID "MyButton"
+- `#List[0]` - First child of element "List"
+- `#List[0] #Title` - Element with ID "Title" in the first child of element "List"
+- `#Label.TextColor` - The TextColor property of element "Label"
diff --git a/content/docs/cs-CZ/official-documentation/custom-ui/layout.mdx b/content/docs/cs-CZ/official-documentation/custom-ui/layout.mdx
new file mode 100644
index 00000000..0a24ca09
--- /dev/null
+++ b/content/docs/cs-CZ/official-documentation/custom-ui/layout.mdx
@@ -0,0 +1,492 @@
+---
+title: Layout
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# Layout
+
+The layout system determines how UI elements are positioned and sized on screen. Understanding layout is crucial for creating well-structured, responsive interfaces.
+
+## Layout Fundamentals
+
+Every UI element has:
+
+- **Container Rectangle** - The space allocated by the parent
+- **Anchor** - How the element positions/sizes itself within the container
+- **Padding** - Inner spacing that affects child layout
+- **LayoutMode** - How the element arranges its children (if it's a container)
+
+```
+┌─────────────────────────────────────┐
+│  Container Rectangle (from parent)  │
+│  ┌───────────────────────────────┐  │
+│  │  Anchored Rectangle           │  │
+│  │  ┌─────────────────────────┐  │  │
+│  │  │ Padding                 │  │  │
+│  │  │  ┌───────────────────┐  │  │  │
+│  │  │  │  Content Area     │  │  │  │
+│  │  │  └───────────────────┘  │  │  │
+│  │  └─────────────────────────┘  │  │
+│  └───────────────────────────────┘  │
+└─────────────────────────────────────┘
+```
+
+## Anchor
+
+`Anchor` controls how an element positions and sizes itself within its container rectangle.
+
+### Fixed Size
+
+```
+Button {
+    Anchor: (Width: 200, Height: 40);
+}
+```
+
+Creates a 200×40 pixel button.
+
+### Positioning
+
+```
+Label {
+    Anchor: (Top: 10, Left: 20, Width: 100, Height: 30);
+}
+```
+
+- **Top**: 10 pixels from container's top edge
+- **Left**: 20 pixels from container's left edge
+- **Width**: 100 pixels wide
+- **Height**: 30 pixels tall
+
+### Anchoring to Edges
+
+```
+Button {
+    Anchor: (Bottom: 10, Right: 10, Width: 100, Height: 30);
+}
+```
+
+Anchors the button to the bottom-right corner, 10 pixels from each edge.
+
+### Stretching
+
+```
+Group {
+    Anchor: (Top: 0, Bottom: 0, Left: 0, Right: 0);
+}
+```
+
+Stretches to fill the entire container (all edges at 0 pixels).
+
+**Shorthand:**
+
+```
+Group {
+    Anchor: (Full: 0);
+}
+```
+
+### Mixed Anchoring
+
+```
+Panel {
+    Anchor: (Top: 10, Bottom: 10, Left: 20, Width: 300);
+}
+```
+
+- Fixed width of 300 pixels
+- Stretches vertically between top and bottom edges
+- 10 pixels from top and bottom
+- 20 pixels from left
+
+## Padding
+
+`Padding` creates inner spacing, affecting where children are positioned.
+
+### Uniform Padding
+
+```
+Group {
+    Padding: (Full: 20);
+}
+```
+
+20 pixels of padding on all sides.
+
+### Directional Padding
+
+```
+Group {
+    Padding: (Top: 10, Bottom: 20, Left: 15, Right: 15);
+}
+```
+
+Different padding per edge.
+
+### Shorthand
+
+```
+// Horizontal and vertical
+Group {
+    Padding: (Horizontal: 20, Vertical: 10);
+}
+
+// Equivalent to:
+// Top: 10, Bottom: 10, Left: 20, Right: 20
+```
+
+### Effect on Children
+
+```
+Group {
+    Anchor: (Width: 200, Height: 100);
+    Padding: (Full: 10);
+
+    Label {
+        Anchor: (Full: 0);
+    }
+}
+```
+
+The label fills the group, but there's a 10-pixel gap on all sides due to padding.
+
+```
+┌──────────────────────┐
+│ Group (200×100)      │
+│  ┌────────────────┐  │
+│  │ Label          │  │ ← 10px padding all around
+│  │                │  │
+│  └────────────────┘  │
+└──────────────────────┘
+```
+
+## LayoutMode
+
+`LayoutMode` determines how a container arranges its children.
+
+### Top (Vertical Stack)
+
+```
+Group {
+    LayoutMode: Top;
+
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+}
+```
+
+Children stack vertically from top to bottom:
+
+```
+┌──────────┐
+│ Button 1 │
+├──────────┤
+│ Button 2 │
+├──────────┤
+│ Button 3 │
+└──────────┘
+
+
+```
+
+Each child's `Anchor.Bottom` adds spacing between elements:
+
+```
+Button { Anchor: (Height: 30, Bottom: 10); }  // 10px gap after this button
+```
+
+### Bottom (Vertical Stack)
+
+```
+Group {
+    LayoutMode: Bottom;
+
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+}
+```
+
+Children stack vertically from top to bottom but aligned to the bottom edge of the parent:
+
+```
+
+
+
+┌──────────┐
+│ Button 1 │
+├──────────┤
+│ Button 2 │
+├──────────┤
+│ Button 3 │
+└──────────┘
+```
+
+### Left (Horizontal Stack)
+
+```
+Group {
+    LayoutMode: Left;
+
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+}
+```
+
+Children arrange horizontally from left to right:
+
+```
+┌────────┬────────┬────────┐
+│ Button │ Button │ Button │
+│   1    │   2    │   3    │
+└────────┴────────┴────────┘
+```
+
+Use `Anchor.Right` for spacing between elements.
+
+### Right (Horizontal Stack)
+
+```
+Group {
+    LayoutMode: Right;
+
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+}
+```
+
+Children arrange horizontally from left to right but aligned to the right side of the parent:
+
+```
+                                                                 ┌────────┬────────┬────────┐
+                                                                 │ Button │ Button │ Button │
+                                                                 │   1    │   2    │   3    │
+                                                                 └────────┴────────┴────────┘
+```
+
+### Center
+
+```
+Group {
+    LayoutMode: Center;
+
+    Group #Dialog {
+        Anchor: (Width: 400, Height: 300);
+    }
+}
+```
+
+Centers the children horizontally.
+
+### Middle
+
+```
+Group {
+    LayoutMode: Middle;
+
+    Group #Dialog {
+        Anchor: (Width: 400, Height: 300);
+    }
+}
+```
+
+Centers the children vertically.
+
+### CenterMiddle (Horizontal Stack, Fully Centered)
+
+```
+Group {
+    LayoutMode: CenterMiddle;
+
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+}
+```
+
+Children stack horizontally from left to right, centered both horizontally and vertically within the parent:
+
+```
+┌────────────────────────────────────────────┐
+│                                            │
+│                                            │
+│         ┌──────┐ ┌──────┐ ┌──────┐         │
+│         │  B1  │ │  B2  │ │  B3  │         │
+│         └──────┘ └──────┘ └──────┘         │
+│                                            │
+│                                            │
+└────────────────────────────────────────────┘
+```
+
+---
+
+### MiddleCenter (Vertical Stack, Fully Centered)
+
+```
+Group {
+    LayoutMode: MiddleCenter;
+
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+}
+```
+
+Children stack vertically from top to bottom, centered both horizontally and vertically within the parent:
+
+```
+┌────────────────────────────────────────────┐
+│                                            │
+│              ┌──────────┐                  │
+│              │ Button 1 │                  │
+│              ├──────────┤                  │
+│              │ Button 2 │                  │
+│              ├──────────┤                  │
+│              │ Button 3 │                  │
+│              └──────────┘                  │
+│                                            │
+└────────────────────────────────────────────┘
+```
+
+---
+
+### Full
+
+```
+Group {
+    LayoutMode: Full;
+
+    Label {
+        Anchor: (Top: 20, Left: 20, Width: 100, Height: 30);
+    }
+}
+```
+
+Children use absolute positioning via their `Anchor` properties.
+
+### TopScrolling
+
+```
+Group {
+    LayoutMode: TopScrolling;
+    ScrollbarStyle: $Common.@DefaultScrollbar;
+
+    // ... many children
+}
+```
+
+Like `Top`, but adds a scrollbar if content exceeds container height.
+
+Or use `BottomScrolling` for bottom-aligned content.
+
+### LeftScrolling
+
+```
+Group {
+    LayoutMode: LeftScrolling;
+    ScrollbarStyle: $Common.@DefaultScrollbar;
+
+    // ... many children
+}
+```
+
+Like `Left`, but adds a scrollbar for horizontal scrolling.
+
+Or use `RightScrolling` for right-aligned content.
+
+### LeftCenterWrap (Wrapping Horizontal Stack, Horizontally Centered)
+
+```
+Group {
+    LayoutMode: LeftCenterWrap;
+
+    Button { Anchor: (Width: 80, Height: 30); }
+    Button { Anchor: (Width: 80, Height: 30); }
+    Button { Anchor: (Width: 80, Height: 30); }
+    Button { Anchor: (Width: 80, Height: 30); }
+    Button { Anchor: (Width: 80, Height: 30); }
+}
+```
+
+Children flow left to right. When there's no more horizontal space, they wrap to the next row. Each row is horizontally centered within the parent:
+
+```
+┌────────────────────────────────────────────┐
+│                                            │
+│       ┌──────┐ ┌──────┐ ┌──────┐           │
+│       │  B1  │ │  B2  │ │  B3  │           │
+│       └──────┘ └──────┘ └──────┘           │
+│            ┌──────┐ ┌──────┐               │
+│            │  B4  │ │  B5  │               │
+│            └──────┘ └──────┘               │
+│                                            │
+└────────────────────────────────────────────┘
+```
+
+## FlexWeight
+
+`FlexWeight` distributes remaining space among children.
+
+```
+Group {
+    LayoutMode: Left;
+    Anchor: (Width: 400);
+
+    Button {
+        Anchor: (Width: 100);
+    }
+
+    Group {
+        FlexWeight: 1;  // Takes all remaining space
+    }
+
+    Button {
+        Anchor: (Width: 100);
+    }
+}
+```
+
+Result:
+
+- First button: 100px
+- Middle group: 200px (400 - 100 - 100 = 200)
+- Last button: 100px
+
+### Multiple FlexWeights
+
+```
+Group {
+    LayoutMode: Left;
+    Anchor: (Width: 600);
+
+    Group { FlexWeight: 1; }
+    Group { FlexWeight: 2; }
+    Group { FlexWeight: 1; }
+}
+```
+
+Remaining space (600px) is split:
+
+- First group: 600 × (1/4) = 150px
+- Second group: 600 × (2/4) = 300px
+- Third group: 600 × (1/4) = 150px
+
+## Visibility
+
+```
+Button #HiddenButton {
+    Visible: false;
+}
+```
+
+**Effect:**
+
+- Element and its children are not displayed
+- Element is **not included in layout** (doesn't take up space)
diff --git a/content/docs/cs-CZ/official-documentation/custom-ui/markup.mdx b/content/docs/cs-CZ/official-documentation/custom-ui/markup.mdx
new file mode 100644
index 00000000..564110ed
--- /dev/null
+++ b/content/docs/cs-CZ/official-documentation/custom-ui/markup.mdx
@@ -0,0 +1,226 @@
+---
+title: Markup
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# Markup
+
+## Markup
+
+An element is the basic building block of a user interface. There are various types of elements with different properties, which are documented below.
+
+Here's what the syntax looks like:
+
+```
+// Basic declaration of an element
+// with its Anchor property set to attach on all sides of its parent
+// with 10 pixels of margin
+Group { Anchor: (Left: 10, Top: 10, Right: 10, Bottom: 10); }
+
+Group { Anchor: (Full: 10); } // More concise version
+
+// Declaration of a Label with a name
+// (can be used to access the element from game code)
+Label #MyLabel {
+  Style: LabelStyle(FontSize: 16); // or just Style: (FontSize: 16), type can be inferred.
+  Text: "Hi! I am text.";
+}
+
+// Declaration of a Group containing 2 children
+// You can use FlexWeight to distribute any left-over space after explicit widths/heights have been subtracted
+Group {
+  LayoutMode: Left;
+  Label { Text: "Child 1"; FlexWeight: 2; }
+  Label { Text: "Child 2"; FlexWeight: 1; }
+}
+```
+
+### Documents
+
+A UI document (_.ui_ file) contains trees of elements. There can be multiple root elements.
+
+### Named Expressions
+
+Named expressions can be declared at any level of a document (including at the root) and will be scoped to that subtree, though they need to be declared at the top of the block.
+
+```
+// Example of named expressions, declared and used with @ prefix
+@Title = "Hytale";
+@ExtraSpacing = 5;
+
+Label {
+  Text: @Title;
+  Style: (LetterSpacing: 2 + @ExtraSpacing);
+}
+```
+
+You can use the spread operator `...` to reuse a named expression while overriding some of its fields:
+
+```
+@MyBaseStyle = LabelStyle(FontSize: 24, LetterSpacing: 2);
+
+Label {
+  Style: (...@MyBaseStyle, FontSize: 36);
+}
+```
+
+You can even layer multiple named expressions like so:
+
+```
+@TitleStyle = LabelStyle(FontSize: 24, HorizontalAlignment: Center);
+@SpacedTextStyle = LabelStyle(LetterSpacing: 2);
+
+Label {
+  Style: (...@BigTextStyle, ...@SpacedTextStyle);
+}
+```
+
+#### Document references
+
+A document can reference another document and access its named expressions.
+
+```
+// Document references are defined with $ prefix
+$Common = "../Common.ui";
+
+TextButton {
+  Style: $Common.@DefaultButtonStyle;
+}
+```
+
+### Templates
+
+You can declare a reusable bit of interface as a named expression and then instantiate it as many times as you want in the tree while customizing it.
+
+You can override local named expressions as well as insert additional children at any point in the template tree. However, local named expressions must be defined at the very top of the block, before properties and child elements.
+
+```
+// This is the template
+@Row = Group {
+  Anchor: (Height: 50);
+  Label #Label { Anchor: (Left: 0, Width: 100); Text: @LabelText; }
+  Group #Content { Anchor: (Left: 100); }
+};
+
+// Here we'll be using it twice in the document tree
+Group #Rows {
+  LayoutMode: TopScrolling;
+
+  @Row #MyFirstRow {
+    @LabelText = "First row";
+    #Content { TextInput {} }
+  }
+
+  @Row #MySecondRow {
+    @LabelText = "Second row";
+  }
+}
+```
+
+### Property Types
+
+#### Basic Types
+
+- **Boolean**
+  - `Visible: false;`
+  - `Visible: true;`
+- **Int**
+  - `Height: 20;`
+- **Float, Double, Decimal**
+  - `Min: 0.2;`
+- **String**
+  - `Text: "Hi!";`
+- **Char**
+  - `PasswordChar: "*";`
+  - _Note: The syntax is the same as a string, however a value of this type cannot contain more than one character!_
+- **Color**
+  - `Background: #ffffff;`&#x20;
+- **Objects**
+  - `Style: (Background: #ffffff)`
+- **Array**&#x20;
+  - `TextSpans: [(Text: "Hi", IsBold: true)]`
+
+#### Translations
+
+Translation keys can be referenced anywhere in markup where you can provide a string, and they are then converted to a string when an element gets instantiated.
+
+**Example:**
+
+```
+Label {
+  Text: %ui.general.cancel;
+}
+```
+
+#### Colors
+
+A color literal can be written as follows:
+
+- `#rrggbb`: 6-digit hexadecimal representation for red, green, blue (fully opaque)
+- `#rrggbb(a.a)`: 6-digit hexadecimal representation for red, green, blue with alpha between 0 and 1
+- `#rrggbbaa`: 8-digit hexadecimal representation for red, green, blue and alpha
+
+```
+Group {
+  Background: #000000(0.3);
+}
+```
+
+<Callout>
+  The `#rrggbb(a.a)` format is prefered over the `#rrggbbaa` format for
+  readability reasons.
+</Callout>
+
+#### Font Name
+
+Font names can be referenced directly by their string ID. Internally this is using a custom type called `UIFontName`, however strings will be converted automatically to this type in markup.
+
+```
+Label {
+  Text: "Hi";
+  Style: (FontName: "Secondary");
+}
+```
+
+**Available Font Names**
+
+- _Default_ - This is the default font that is used for most text and is always used unless a different option has been specified
+- _Secondary_ - This font is mostly used for headlines or elements that are supposed to stick out
+- _Mono_ - This is only used for development; For things such as profiling or error overlays.
+
+#### Path
+
+We can reference other UI assets with the `UIPath` type. Similar to `UIFontName`_,_ Strings are automatically converted to a `UIPath`. Paths are always relative to the file where they have been declared in. Looking up _MyButton.png_ in _Menu/MyAwesomeMenu.ui_ will result in _Menu/MyButton.png_. If you want to reference a file that is in a parent folder you can go back one directory by writing two dots (_../MyButton.png_).
+
+The markup syntax of a `UIPath` is the same as a String. (e.g. `Path: "Test.png"`)
+
+Here are some more examples:
+
+| UIPath             | .ui File                              | Resulting Path    |
+| ------------------ | ------------------------------------- | ----------------- |
+| MyButton.png       | Menu/MyAwesomeMenu.ui                 | Menu/MyButton.png |
+| ../MyButton.png    | Menu/MyAwesomeMenu.ui                 | MyButton.png      |
+| ../../MyButton.png | Menu/Popup/Templates/MyAwesomeMenu.ui | Menu/MyButton.png |
+
+#### Objects
+
+Objects contain a set of properties. In this example we are assigning an Anchor object to the _Anchor_ property:
+
+```
+Group {
+  Anchor: (
+   Height: 10,
+   Width: 20
+ );
+}
+```
+
+You can find all objects that can be used in markup [here](type-documentation#elements).
+
+## Visual Studio Code Extension
+
+There is an official extension for Visual Studio Code which adds syntax highlighting for .ui files. You can find it [here](https://marketplace.visualstudio.com/items?itemName=HypixelStudiosCanadaInc.vscode-hytaleui).
diff --git a/content/docs/cs-CZ/official-documentation/custom-ui/type-documentation/index.mdx b/content/docs/cs-CZ/official-documentation/custom-ui/type-documentation/index.mdx
new file mode 100644
index 00000000..69cea406
--- /dev/null
+++ b/content/docs/cs-CZ/official-documentation/custom-ui/type-documentation/index.mdx
@@ -0,0 +1,127 @@
+---
+title: Type Documentation
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# Type Documentation
+
+This is a generated list of UI elements accessible by markup. More information about the User Interface framework can be found in the main documentation.
+
+## Elements
+
+- [ActionButton](type-documentation/elements/actionbutton)
+- [AssetImage](type-documentation/elements/assetimage)
+- [BackButton](type-documentation/elements/backbutton)
+- [BlockSelector](type-documentation/elements/blockselector)
+- [Button](type-documentation/elements/button)
+- [CharacterPreviewComponent](type-documentation/elements/characterpreviewcomponent)
+- [CheckBox](type-documentation/elements/checkbox)
+- [CheckBoxContainer](type-documentation/elements/checkboxcontainer)
+- [CircularProgressBar](type-documentation/elements/circularprogressbar)
+- [CodeEditor](type-documentation/elements/codeeditor)
+- [ColorOptionGrid](type-documentation/elements/coloroptiongrid)
+- [ColorPicker](type-documentation/lements/colorpicker)
+- [ColorPickerDropdownBox](type-documentation/elements/colorpickerdropdownbox)
+- [CompactTextField](type-documentation/elements/compacttextfield)
+- [DropdownBox](type-documentation/elements/dropdownbox)
+- [DropdownEntry](type-documentation/elements/dropdownentry)
+- [DynamicPane](type-documentation/elements/dynamicpane)
+- [DynamicPaneContainer](type-documentation/elements/dynamicpanecontainer)
+- [FloatSlider](type-documentation/elements/floatslider)
+- [FloatSliderNumberField](type-documentation/elements/floatslidernumberfield)
+- [Group](type-documentation/elements/group)
+- [HotkeyLabel](type-documentation/elements/hotkeylabel)
+- [ItemGrid](type-documentation/elements/itemgrid)
+- [ItemIcon](type-documentation/elements/itemicon)
+- [ItemPreviewComponent](type-documentation/elements/itempreviewcomponent)
+- [ItemSlot](type-documentation/elements/itemslot)
+- [ItemSlotButton](type-documentation/elements/itemslotbutton)
+- [Label](type-documentation/elements/label)
+- [LabeledCheckBox](type-documentation/elements/labeledcheckbox)
+- [MenuItem](type-documentation/elements/menuitem)
+- [MultilineTextField](type-documentation/elements/multilinetextfield)
+- [NumberField](type-documentation/elements/numberfield)
+- [Panel](type-documentation/elements/panel)
+- [ProgressBar](type-documentation/elements/progressbar)
+- [ReorderableList](type-documentation/elements/reorderablelist)
+- [ReorderableListGrip](type-documentation/elements/reorderablelistgrip)
+- [SceneBlur](type-documentation/elements/sceneblur)
+- [Slider](type-documentation/elements/slider)
+- [SliderNumberField](type-documentation/elements/slidernumberfield)
+- [Sprite](type-documentation/elements/sprite)
+- [TabButton](type-documentation/elements/tabbutton)
+- [TabNavigation](type-documentation/elements/tabnavigation)
+- [TextButton](type-documentation/elements/textbutton)
+- [TextField](type-documentation/elements/textfield)
+- [TimerLabel](type-documentation/elements/timerlabel)
+- [ToggleButton](type-documentation/elements/togglebutton)
+
+## Property Types
+
+- [Anchor](type-documentation/property-types/anchor)
+- [BlockSelectorStyle](type-documentation/property-types/blockselectorstyle)
+- [ButtonSounds](type-documentation/property-types/buttonsounds)
+- [ButtonStyle](type-documentation/property-types/buttonstyle)
+- [ButtonStyleState](type-documentation/property-types/buttonstylestate)
+- [CheckBoxStyle](type-documentation/property-types/checkboxstyle)
+- [CheckBoxStyleState](type-documentation/property-types/checkboxstylestate)
+- [ClientItemStack](type-documentation/property-types/clientitemstack)
+- [ColorOptionGridStyle](type-documentation/property-types/coloroptiongridstyle)
+- [ColorPickerDropdownBoxStateBackground](type-documentation/property-types/colorpickerdropdownboxstatebackground)
+- [ColorPickerDropdownBoxStyle](type-documentation/property-types/colorpickerdropdownboxstyle)
+- [ColorPickerStyle](type-documentation/property-types/colorpickerstyle)
+- [DropdownBoxSearchInputStyle](type-documentation/property-types/dropdownboxsearchinputstyle)
+- [DropdownBoxSounds](type-documentation/property-types/dropdownboxsounds)
+- [DropdownBoxStyle](type-documentation/property-types/dropdownboxstyle)
+- [InputFieldButtonStyle](type-documentation/property-types/inputfieldbuttonstyle)
+- [InputFieldDecorationStyle](type-documentation/property-types/inputfielddecorationstyle)
+- [InputFieldDecorationStyleState](type-documentation/property-types/inputfielddecorationstylestate)
+- [InputFieldIcon](type-documentation/property-types/inputfieldicon)
+- [InputFieldStyle](type-documentation/property-types/inputfieldstyle)
+- [ItemGridSlot](type-documentation/property-types/itemgridslot)
+- [ItemGridStyle](type-documentation/property-types/itemgridstyle)
+- [LabeledCheckBoxStyle](type-documentation/property-types/labeledcheckboxstyle)
+- [LabeledCheckBoxStyleState](type-documentation/property-types/labeledcheckboxstylestate)
+- [LabelSpan](type-documentation/property-types/labelspan)
+- [LabelStyle](type-documentation/property-types/labelstyle)
+- [NumberFieldFormat](type-documentation/property-types/numberfieldformat)
+- [Padding](type-documentation/property-types/padding)
+- [PatchStyle](type-documentation/property-types/patchstyle)
+- [PopupStyle](type-documentation/property-types/popupstyle)
+- [ScrollbarStyle](type-documentation/property-types/scrollbarstyle)
+- [SliderStyle](type-documentation/property-types/sliderstyle)
+- [SoundStyle](type-documentation/property-types/soundstyle)
+- [SpriteFrame](type-documentation/property-types/spriteframe)
+- [SubMenuItemStyle](type-documentation/property-types/submenuitemstyle)
+- [SubMenuItemStyleState](type-documentation/property-types/submenuitemstylestate)
+- [Tab](type-documentation/property-types/tab)
+- [TabNavigationStyle](type-documentation/property-types/tabnavigationstyle)
+- [TabStyle](type-documentation/property-types/tabstyle)
+- [TabStyleState](type-documentation/property-types/tabstylestate)
+- [TextButtonStyle](type-documentation/property-types/textbuttonstyle)
+- [TextButtonStyleState](type-documentation/property-types/textbuttonstylestate)
+- [TextTooltipStyle](type-documentation/property-types/texttooltipstyle)
+- [ToggleButtonStyle](type-documentation/property-types/togglebuttonstyle)
+- [ToggleButtonStyleState](type-documentation/property-types/togglebuttonstylestate)
+
+## Enums
+
+- [ActionButtonAlignment](type-documentation/enums/actionbuttonalignment)
+- [CodeEditorLanguage](type-documentation/enums/codeeditorlanguage)
+- [ColorFormat](type-documentation/enums/colorformat)
+- [DropdownBoxAlign](type-documentation/enums/dropdownboxalign)
+- [InputFieldButtonSide](type-documentation/enums/inputfieldbuttonside)
+- [InputFieldIconSide](type-documentation/enums/inputfieldiconside)
+- [ItemGridInfoDisplayMode](type-documentation/enums/itemgridinfodisplaymode)
+- [LabelAlignment](type-documentation/enums/labelalignment)
+- [LayoutMode](type-documentation/enums/layoutmode)
+- [MouseWheelScrollBehaviourType](type-documentation/enums/mousewheelscrollbehaviourtype)
+- [ProgressBarAlignment](type-documentation/enums/progressbaralignment)
+- [ProgressBarDirection](type-documentation/enums/progressbardirection)
+- [ResizeType](type-documentation/enums/resizetype)
+- [TimerDirection](type-documentation/enums/timerdirection)
+- [TooltipAlignment](type-documentation/enums/tooltipalignment)
diff --git a/content/docs/cs-CZ/official-documentation/npc/2-getting-started-with-templates.mdx b/content/docs/cs-CZ/official-documentation/npc/2-getting-started-with-templates.mdx
index 91081ca1..99d078e0 100644
--- a/content/docs/cs-CZ/official-documentation/npc/2-getting-started-with-templates.mdx
+++ b/content/docs/cs-CZ/official-documentation/npc/2-getting-started-with-templates.mdx
@@ -9,7 +9,7 @@ authors:
 
 There are no hard and fast rules for making a start on a template. I like to duplicate **BlankTemplate** and start from there because it already provides the basic structure of the file.
 
-This leaves me with the following template (`Template_Goblin_Ogre.json`): (note: the file could be looking different in the current version of the game)
+This leaves me with the following template (`Template_Goblin_Ogre.json`): (**note: the file could be looking different in the current version of the game**)
 
 ```json
 {
@@ -33,7 +33,7 @@ This leaves me with the following template (`Template_Goblin_Ogre.json`): (note:
     }
   },
   "Appearance": { "Compute": "Appearance" },
-  "DropList": { "Compute": "Droplist" },
+  "DropList": { "Compute": "DropList" },
   "MaxHealth": { "Compute": "MaxHealth" },
   "MotionControllerList": [
     {
@@ -65,10 +65,10 @@ And the following variant (`Goblin_Ogre.json`) next to the template. There's a t
   "Type": "Variant",
   "Reference": "Template_Goblin_Ogre",
   "Modify": {
-    "Appearance": "Goblin_Ogre",
+    "Appearance": "Goblin",
     "MaxHealth": 124
   }
 }
 ```
 
-Our artists have defined the `Goblin_Ogre` appearance already so I'm going to use that.
+Our artists have not yet finished animations for the `Goblin_Ogre`, for that sake of the tutorial I am going to use appearance `Goblin`, because it offers a more complete set of animations that we will need.
diff --git a/content/docs/cs-CZ/official-documentation/worldgen/pack-tutorial/asset-packs.mdx b/content/docs/cs-CZ/official-documentation/worldgen/pack-tutorial/asset-packs.mdx
index 38809fad..dcf1f3b9 100644
--- a/content/docs/cs-CZ/official-documentation/worldgen/pack-tutorial/asset-packs.mdx
+++ b/content/docs/cs-CZ/official-documentation/worldgen/pack-tutorial/asset-packs.mdx
@@ -9,13 +9,13 @@ authors:
 
 <OfficialDocumentationNotice />
 
-# How to modify Hytale
+# How to modify Hytale?
 
-## What's an Asset Pack
+## What's an Asset Pack?
 
-Hytales gameplay is driven by assets in the game that can be modified by creators. Asset Packs are our solution to let you override or add features to the base game with your own work. These can in the form of zip files of folders, which contain a custom set of assets. This is not the only way for a creator to change Hytale but this is the most accessible form.;
+Hytales gameplay is driven by assets in the game that can be modified by creators. Asset Packs are our solution to let you override or add features to the base game with your own work. These can be the form of zip files of folders, which contain a custom set of assets. This is not the only way for a creator to change Hytale but this is the most accessible form.;
 
-### How do I make an Asset Pack
+### How do I make an Asset Pack?
 
 <video controls className="my-6 aspect-video w-full rounded-lg border">
   <source src="https://cdn.internal.hytalemodding.dev/guides/official/how-to-asset-pack.mp4" type="video/mp4" />
@@ -48,7 +48,7 @@ An asset pack is typically a zip or folder, with a `manifest.json` inside. This
 }
 ```
 
-### Where are they stored
+### Where are they stored?
 
 Asset Packs are stored with other mods in the Mods folder.
 
@@ -76,7 +76,7 @@ C:\Users\<user>\AppData\Roaming\Hytale\UserData\Saves\New World 5\mods
 
 When you have Asset Packs or Mods installed, these will appear in the New World menu under the Options menu.;
 
-### How do I change an existing asset
+### How do I change an existing asset?
 
 <video controls className="my-6 aspect-video w-full rounded-lg border">
   <source src="https://cdn.internal.hytalemodding.dev/guides/official/how-to-asset.mp4" type="video/mp4" />
diff --git a/content/docs/cs-CZ/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx b/content/docs/cs-CZ/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx
index 44528376..24e628b5 100644
--- a/content/docs/cs-CZ/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx
+++ b/content/docs/cs-CZ/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx
@@ -106,7 +106,7 @@ If a BaseHeight is provided, the TopY and BottomY values are relative to the Bas
 
 Applies a Material Provider slot on a set of horizontal stripes of blocks of varying thickness and position. Below is an example image of basalt stripes into a stone cliff.
 
-{/* ![](https://540086904-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F7KAmBkOg6d13nZCkf9ku%2Fuploads%2FbcxO9LpArn8gPCaBwFg5%2Funknown.png?alt=media&token=1c72b67a-8253-4d03-8c64-1ad5f6830050) */}
+![Example of basalt stripes](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/basalt-stripes-example.png)
 
 #### Parameters:
 
diff --git a/content/docs/cs-CZ/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx b/content/docs/cs-CZ/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx
index 5e34acd4..a4418473 100644
--- a/content/docs/cs-CZ/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx
+++ b/content/docs/cs-CZ/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx
@@ -294,7 +294,7 @@ Combines all the positions into a single Positioins field.
 
 ---
 
-### SimpleHoritontal
+### SimpleHorizontal
 
 Keeps only the positions that are within the provided range.
 
diff --git a/content/docs/cs-CZ/official-documentation/worldgen/worldgen-tutorial/README.mdx b/content/docs/cs-CZ/official-documentation/worldgen/worldgen-tutorial/README.mdx
new file mode 100644
index 00000000..5f66d245
--- /dev/null
+++ b/content/docs/cs-CZ/official-documentation/worldgen/worldgen-tutorial/README.mdx
@@ -0,0 +1,166 @@
+---
+title: How to edit and create Biomes
+description: Explores where world generation assets can be found and how to edit them.
+---
+
+### Where are the Assets
+
+World generation assets are kept in the HytaleGenerator directory within the assets.
+
+```
+/Server/HytaleGenerator/
+```
+
+<div className="flex flex-row rounded-lg border p-4">
+  <div className="flex-1/2 border-r pr-4">
+    ```
+    /Biomes
+    ```
+
+    Biome assets, with content configurations.
+  </div>
+
+  <div className="flex-1/2 pl-4">
+    ```
+    /WorldStructure
+    ```
+
+    Generator files that define which biomes spawn together.
+  </div>
+</div>
+
+<div className="flex flex-row rounded-lg border p-4">
+  <div className="flex-1/2 border-r pr-4">
+    ```
+    /Density
+    ```
+
+    Density assets that can be referenced by any other assets.
+  </div>
+
+  <div className="flex-1/2 pl-4">
+    ```
+    /Assignments
+    ```
+
+    Prop assets that can be referenced by any Biome assets.
+  </div>
+</div>
+
+***
+
+An example of this structure can be found bellow, packed in an asset pack with the instance configuration.
+
+[https://drive.google.com/file/d/1sIz_CluANIIe3n8vNiOi-4PQdeqCO0qY/view?usp=drive_link](https://drive.google.com/file/d/1sIz_CluANIIe3n8vNiOi-4PQdeqCO0qY/view?usp=drive_link)
+
+<Callout>
+  Ensure you place your asset pack in the correct directory, under Mods.
+</Callout>
+
+### How to visit our worlds
+
+https://drive.google.com/file/d/1BJurxyj-taE-PXWm04bk7Dl6X7ZHTH92/view?usp=sharing
+
+#### Requirements
+
+- You must be an **Operator** in the world.
+  - To do this, run <mark style="color:$danger;">`/op self`</mark>
+- You must be in **Creative mode**.
+  - Press the <mark style="color:$danger;">`O`</mark> key, O for Orange.&#x20;
+
+The generation assets define a set of generators but on their own you cannot visit these. Currently you require an Instance with a generator that will allow you to visit your work.
+
+```
+/Server/Instances/
+```
+
+Instances are separate worlds that players can join using the `/instances` command. Each instance has an `Instance.bson` configuration asset that specifies which generator to use, among other worldly settings.
+
+```json
+{
+  "WorldGen": {
+    "Type": "HytaleGenerator",
+    "WorldStructure": "Basic",
+    "playerSpawn" : {
+      "X" : 123,
+      "Y" : 480,
+      "Z" : 10000,
+      "Pitch" : 0,
+      "Yaw" : 0,
+      "Roll" : 0
+    }
+  }
+}
+```
+
+<Callout>
+  You can create custom instances for different world structures and biomes as you need them.
+</Callout>
+
+### How to edit Biomes
+
+<video>
+  <source src="https://cdn.internal.hytalemodding.dev/guides/official/How-to-edit-Biomes.mp4" type="video/mp4" />
+</video>
+
+We currently use the Hytale Node Editor when editing world generation assets. This can be accessed while in-game from the Content Creation menu when pressing B. The node editor is then found under the asset editor dropdown on the upper left.&#x20;
+
+![Node Editor 1](/assets/official-documentation/worldgen/worldgen-tutorial/biomes/node-editor-1.png)
+
+Once you have the Hytale Node Editor open, through the file menu you can open Biomes by navigating to the Biomes directory and selecting one from your pack.&#x20;
+
+```
+/Server/HytaleGenerator/Biomes/
+```
+
+### Biome Asset Structure
+
+Every Biome has a root Biome node, this node splits into 5 structures. This is covered briefly but more information on each field can be found on the World Generation Concepts page.
+
+![Node Editor 2](/assets/official-documentation/worldgen/worldgen-tutorial/biomes/node-editor-2.png)
+
+<Callout>
+  Each biome is for the most part self contained, meaning it has control over what appears with the biome. The only exception to this are Base Heights.
+</Callout>
+
+<Tabs>
+  <Tab value="Terrain">
+    Mathematical function nodes that calculate the physical shape of the Biome's terrain.
+  </Tab>
+
+  <Tab value="Materials">
+    Logical nodes that determine what materials (blocks) make up a Biome's terrain.
+  </Tab>
+
+  <Tab value="Props">
+    Function nodes that add objects like prefabs and decorations to the terrain.
+  </Tab>
+
+  <Tab value="Environments">
+    Logical nodes that determine the environment asset at a given coordinate within the biome. This asset determines things like weather, NPC spawns, and sounds.
+  </Tab>
+
+  <Tab value="Tints">
+    Logical function nodes that determine a colour code that can be used by certain blocks in the world. Typically this will be grasses and soils.
+  </Tab>
+</Tabs>
+
+### How to preview your work
+
+[https://drive.google.com/file/d/1mNcHn9LhFnWDF0DzWFH6_YllmKAUvUry/view?t=6](https://drive.google.com/file/d/1mNcHn9LhFnWDF0DzWFH6_YllmKAUvUry/view?t=6)
+
+Once you are in an Instance world with the Hytale Generator active you will only be able to see your work by generating new chunks. There are a few ways to do this.
+
+The viewport command selects an area around the Player that will live reload as you make changes to the generator.&#x20;
+
+```
+/viewport --radius 5 
+```
+
+You can also create a new world to show your changes.&#x20;
+
+```
+/instances spawn <instance> 
+```
+
+The last option is to simply fly south, new chunks will generate with the changes made.
diff --git a/content/docs/cs-CZ/quick-start.mdx b/content/docs/cs-CZ/quick-start.mdx
index 653644f4..249d803a 100644
--- a/content/docs/cs-CZ/quick-start.mdx
+++ b/content/docs/cs-CZ/quick-start.mdx
@@ -9,3 +9,8 @@ Welcome to the Hytale modding documentation! Here you'll find everything you nee
 * [Setting up your dev environment](./guides/plugin/setting-up-env)
 * [Entity Component System (ECS)](./guides/ecs/entity-component-system)
 * [Publishing your mod](./publishing)
+
+### Useful Links
+
+* [Kaupenjoe's Modding Videos](https://www.youtube.com/@ModdingByKaupenjoe)
+* [TroubleDEV's Modding Videos](https://www.youtube.com/@TroubleDEV)
diff --git a/content/docs/cs-CZ/server/argtypes.mdx b/content/docs/cs-CZ/server/argtypes.mdx
new file mode 100644
index 00000000..e54a442e
--- /dev/null
+++ b/content/docs/cs-CZ/server/argtypes.mdx
@@ -0,0 +1,61 @@
+---
+title: ArgTypes
+description: Available ArgTypes
+icon: List
+full: true
+authors:
+  - name: Valeena
+---
+
+| Name                        | Target Class                           | Description                                                                                                                               |   |
+| :-------------------------- | :------------------------------------- | :---------------------------------------------------------------------------------------------------------------------------------------- | - |
+| Boolean                     | java.lang.Boolean                      | A 'true' or 'false' input                                                                                                                 |   |
+| Integer                     | java.lang.Integer                      | A whole number                                                                                                                            |   |
+| String                      | java.lang.String                       | Words, text, numbers, letters. To input more than one word at a time, you may need to wrap it with double quotes (`"my fancy sentence"`). |   |
+| Float                       | java.lang.Float                        | A floating-pointer number                                                                                                                 |   |
+| Double                      | java.lang.Double                       | A decimal number                                                                                                                          |   |
+| UUID                        | java.util.UUID                         | A UUID (Universally Unique IDentifier)                                                                                                    |   |
+| Player_UUID                 | java.util.UUID                         | A UUID or an online player username                                                                                                       |   |
+| Game_Profile_Lookup_Async   | ProfileServiceClient.PublicGameProfile | A player UUID or username. If not found locally, performs a remote lookup via the Profile Service.                                        |   |
+| Relative_Double_Coord       | Coord                                  | An x, y, or z coordinate as a decimal, optionally relative by specifying a tilde (~) in front of the number                               |   |
+| Relative_Int_Coord          | IntCoord                               | An x, y, or z coordinate as a whole number, optionally relative by specifying a tilde (~) in front of the number                          |   |
+| Relative_Integer            | RelativeInteger                        | A tilde to mark an integer relative to a base                                                                                             |   |
+| Relative_Float              | RelativeFloat                          | A tilde to mark a float relative to a base                                                                                                |   |
+| Player_Ref                  | PlayerRef                              | A UUID or an online player's username                                                                                                     |   |
+| World                       | World                                  | A world folder name                                                                                                                       |   |
+| Model_Asset                 | ModelAsset                             | A reference to an Asset of type Model                                                                                                     |   |
+| Weather_Asset               | Weather                                | A reference to an Asset of type Weather                                                                                                   |   |
+| Interaction_Asset           | Interaction                            | A reference to an Asset of type Interaction                                                                                               |   |
+| Root_Interaction_Asset      | RootInteraction                        | A reference to an Asset of type Root Interaction                                                                                          |   |
+| Effect_Asset                | EntityEffect                           | A refernece to an Asset of type EntityEffect                                                                                              |   |
+| Environment_Asset           | Environment                            | A reference to an Asset of type Environment                                                                                               |   |
+| Item_Asset                  | Item                                   | A reference to an Asset of type Item                                                                                                      |   |
+| Block_Type_Asset            | BlockType                              | A reference to an Asset of type BlockType                                                                                                 |   |
+| Particle_System             | ParticleSystem                         | A reference to an Asset of type ParticleSystem                                                                                            |   |
+| Hitbox_Collision_Config     | HitboxCollisionConfig                  | A reference to an Asset of type HitboxCollisionConfig                                                                                     |   |
+| Repulsion_Config            | RepulsionConfig                        | A reference to an Asset of type RepulsionConfig                                                                                           |   |
+| Sound_Event_Asset           | SoundEvent                             | A reference to an Asset of type SoundEvent                                                                                                |   |
+| Ambiance_Fx_Asset           | AmbianceFX                             | A reference to an Asset of type AmbianceFX                                                                                                |   |
+| Sound_Category              | SoundCategory                          | A sound category (sfx, music, ambient, ui)                                                                                                |   |
+| Entity_ID                   | `ArgWrapper<EntityWrappedArg, UUID>`   | A UUID representing an entity id                                                                                                          |   |
+| Integer_Comparison_Operator | IntegerComparisonOperator              | A mathematical sign for integer comparison                                                                                                |   |
+| Integer_Operation           | IntegerOperation                       | A mathematical sign for performing an operation                                                                                           |   |
+| Int_Range                   | `Pair<Integer, Integer>`               | Two integers representing a minimum and maximum of a range                                                                                |   |
+| Relative_Int_Range          | RelativeIntRange                       | Two integers representing a minimum and maximum of a range                                                                                |   |
+| Vector2I                    | Vector2i                               | Two integers, generally corresponding to x/z axis                                                                                         |   |
+| Vector3I                    | Vector3i                               | Three integers, generally corresponding to x/y/z axis                                                                                     |   |
+| Relative_Vector3I           | RelativeVector3i                       | Three optionally relative integers, generally corresponding to x/y/z axis                                                                 |   |
+| Relative_Block_Position     | RelativeIntPosition                    | A position with three integer coordinates, representing a block's location in world space.                                                |   |
+| Relative_Position           | Relative                               | A position with three decimal coordinates, representing a location in world space.                                                        |   |
+| Relative_Chunk_Position     | RealtiveChunkPosition                  | A position with two integer coordinates (x, z), representing a chunk's location.                                                          |   |
+| Rotation                    | Vector3f                               | A rotation with three coordinates, representing the pitch, yaw, and roll respectively                                                     |   |
+| Block_Type_Key              | String                                 | A block type                                                                                                                              |   |
+| Block_ID                    | Integer                                | A block type, converted to an int id                                                                                                      |   |
+| Color                       | Integer                                | A color value in hex format, hex integer, or decimal integer                                                                              |   |
+| Weighted_Block_Type         | `Pair<Integer, String>`                | A weight corresponding to a blocktype                                                                                                     |   |
+| Weighted_Block_Entry        | String                                 | A block with optional weight prefix                                                                                                       |   |
+| Block_Pattern               | BlockPattern                           | A list of blocks with optional weights                                                                                                    |   |
+| Individual_Block_Mask       | BlockMask                              | Create a block mask using symbols and block names                                                                                         |   |
+| Block_Mask                  | BlockMask                              | A tick rate value (e.g., 30tps, 33ms, or 30)                                                                                              |   |
+| Tick_Rate                   | Integer                                | A list of block masks that combine together                                                                                               |   |
+| Game_Mode                   | GameMode                               | GameMode                                                                                                                                  |   |
diff --git a/content/docs/cs-CZ/server/interaction-reference.mdx b/content/docs/cs-CZ/server/interaction-reference.mdx
new file mode 100644
index 00000000..6c0d01b3
--- /dev/null
+++ b/content/docs/cs-CZ/server/interaction-reference.mdx
@@ -0,0 +1,1586 @@
+---
+title: Interactions
+description: A list of most Interaction types provided by Hypixel, along with the meaning of their fields, and how they fit together.
+icon: List
+authors:
+  - name: Stephen Baynham
+    url: https://github.com/cannibalvox
+---
+
+### The Interaction Base Type
+
+All interactions of every type below are inherited from Interaction and have these fields.
+
+**Interaction Fields**
+
+| Field Name                | Type                                                                 | Required? | Notes                                                                                                                                                                                                                       |
+| ------------------------- | -------------------------------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| ViewDistance              | `Double`<br />(Default: 96.0)                                        | **No**    | Distance in blocks at which other players can see the effects from this interaction.                                                                                                                                        |
+| Effects                   | `InteractionEffects`                                                 | **No**    | Sound, animations, and particle effects that should trigger when this interaction begins executing.                                                                                                                         |
+| HorizontalSpeedMultiplier | `Float`<br />(Default: 1.0)                                          | **No**    | Multiplier applied to the User entity's movement speed while this interaction is executing                                                                                                                                  |
+| RunTime                   | `Float`                                                              | **No**    | If provided, this interaction will continue executing for at least this long before the interaction chain moves onto the next interaction.                                                                                  |
+| CancelOnItemChange        | `Boolean`<br />(Default: true)                                       | **No**    | If true, this interaction will be cancelled if the User entity's held item changes during execution. This can happen either due to the selected hotbar slot changing or the contents of the item's inventory slot changing. |
+| Rules                     | `InteractionRules`                                                   | **Yes**   | If provided, adds additional limitations and cancellation conditions to this interaction.                                                                                                                                   |
+| Settings                  | `Map`<br />(Key Type: `GameMode`, Value Type: `InteractionSettings`) | **No**    | If provided, adds additional per-GameMode settings to the interaction.                                                                                                                                                      |
+| Camera                    | `InteractionCameraSettings`                                          | **No**    | Arrays of camera motion keyframes for cutscenes and reveals.                                                                                                                                                                |
+
+**GameMode Values**
+
+- `Creative`: The game is currently in Creative Mode
+- `Adventure`: The game is currently in Adventure Mode
+
+**InteractionEffects Fields**
+
+| Field Name               | Type                                              | Required? | Notes                                                                                                                                                 |
+| ------------------------ | ------------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Particles                | `Array`<br />(Element Type: `ModelParticle`)      | **No**    | Particle systems to activate when this interaction begins if the player is in third-person mode.                                                      |
+| FirstPersonParticles     | `Array`<br />(Element Type: `ModelParticle`)      | **No**    | Particle systems to activate when this interaction begins if the player is in first-person mode.                                                      |
+| WorldSoundEventId        | `Asset`<br />(Asset Type: `SoundEvent`)           | **No**    | A sound to play in the world at the User entity's location when this interaction begins.<br />**The SoundEvent must be single-channel (mono) sound.** |
+| LocalSoundEventId        | `Asset`<br />(Asset Type: `SoundEvent`)           | **No**    | A 2D sound to play for the User entity when this interaction begins. Ignored if the User entity is not a player.                                      |
+| Trails                   | `Array`<br />(Element Type: `ModelTrail`)         | **No**    | Trail effects to activate on the User entity when this interaction begins.                                                                            |
+| WaitForAnimationToFinish | `Boolean`<br />(Default: false)                   | **No**    | If true, this interaction will continue executing for at least the length of any animations in this InteractionEffects object.                        |
+| ItemPlayerAnimationsId   | `Asset`<br />(Asset Type: `ItemPlayerAnimations`) | **No**    | If provided, the User entity will use this ItemPlayerAnimations set while this interaction is executing.                                              |
+| ItemAnimationId          | `String`                                          | **No**    | Id of an animation to trigger when this interaction begins executing.<br />**This animation id is not validated on server start.**                    |
+| ClearAnimationOnFinish   | `Boolean`<br />(Default: false)                   | **No**    | If true, animations triggered by this interaction will be halted when the interaction completes.                                                      |
+| ClearSoundEventOnFinish  | `Boolean`<br />(Default: false)                   | **No**    | If true, sounds triggered by this interaction will be halted when the interaction completes.                                                          |
+| CameraEffect             | `Asset`<br />(Asset Type: `CameraEffect` )        | **No**    | If provided, the CameraEffect will be applied while this interaction is executing.                                                                    |
+| MovementEffects          | `MovementEffects`                                 | **No**    | If provided, apply the movement effects to the User entity while this interaction is executing.                                                       |
+| StartDelay               | `Float`<br />(Default: 0.0f)                      | **No**    | The interaction will wait this many seconds before triggering the effects in this object.                                                             |
+
+**InteractionRules Fields**
+
+| Field Name          | Type                                                                                                | Required? | Notes                                                                                                                                                                                                                                     |
+| ------------------- | --------------------------------------------------------------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| BlockedBy           | `Array`<br />(Element Type: `InteractionType`)<br />(Default: Based on the chain's InteractionType) | **No**    | If provided, this RootInteraction cannot be executed while interaction chains of the provided types are executing.<br />**This field only functions for rules attached to a RootInteraction. It has no effect on an Interaction.**        |
+| Blocking            | `Array`<br />(Element Type: `InteractionType`)                                                      | **No**    | If provided, interaction chains with the specified InteractionTypes cannot be executed while this interaction is executing.                                                                                                               |
+| InterruptedBy       | `Array`<br />(Element Type: `InteractionType`)                                                      | **No**    | If provided, interaction chains with the specified InteractionTypes will cancel this interaction chain when they execute.<br />**This field only functions for rules attached to a RootInteraction. It has no effect on an Interaction.** |
+| Interrupting        | `Array`<br />(Element Type: `InteractionType`)                                                      | **No**    | If provided, interaction chains with the specified InteractionTypes will be canceled when this interaction begins.                                                                                                                        |
+| BlockedByBypass     | `String`                                                                                            | **No**    | If provided, this RootInteraction cannot be blocked by interaction chains whose RootInteraction has this value as an asset tag.                                                                                                           |
+| BlockingBypass      | `String`                                                                                            | **No**    | If provided, this interaction will not block RootInteractions that have the this value as an asset tag.                                                                                                                                   |
+| InterruptedByBypass | `String`                                                                                            | **No**    | If provided, this RootInteraction cannot be canceled by RootInteractions that have this value as an asset tag.                                                                                                                            |
+| InterruptingBypass  | `String`                                                                                            | **No**    | If provided, this interaction will not cancel interaction chains whose RootInteraction has this value as an asset tag.                                                                                                                    |
+
+**InteractionType Values**
+
+- `Primary`
+- `Secondary`
+- `Ability1`
+- `Ability2`
+- `Ability3`
+- `Use`
+- `Pick`
+- `Pickup`
+- `CollisionEnter`
+- `CollisionLeave`
+- `Collision`
+- `EntityStatEffect`
+- `SwapTo`
+- `SwapFrom`
+- `Death`
+- `Wielding`
+- `ProjectileSpawn`
+- `ProjectileHit`
+- `ProjectileMiss`
+- `ProjectileBounce`
+- `Held`
+- `HeldOffhand`
+- `Equipped`
+- `Dodge`
+- `GameModeSwap`
+
+**InteractionSettings Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                        |
+| ---------------- | ------------------------------- | --------- | -------------------------------------------------------------------------------------------- |
+| AllowSkipOnClick | `Boolean`<br />(Default: false) | **No**    | If true, the user will be able to skip this interaction by clicking shortly after it starts. |
+
+**InteractionCameraSettings Fields**
+
+| Field Name  | Type                                             | Required? | Notes                                                                                                                                                           |
+| ----------- | ------------------------------------------------ | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| FirstPerson | `Array`<br />(Element Type: `InteractionCamera`) | **No**    | A list of camera keyframes to be played if the player is in first-person.<br />**The time of each keyframe must be after the keyframe before it in the array.** |
+| ThirdPerson | `Array`<br />(Element Type: `InteractionCamera`) | **No**    | A list of camera keyframes to be played if the player is in third-person.<br />**The time of each keyframe must be after the keyframe before it in the array.** |
+
+**InteractionCamera Fields**
+
+| Field Name | Type                         | Required? | Notes                                                                                                                                       |
+| ---------- | ---------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------- |
+| Time       | `Float`<br />(Default: 0.1f) | **No**    | How long after the interaction begins executing that the camera should arrive at this keyframe.<br />**Cannot be less than or equal to 0.** |
+| Position   | `Vector3`                    | **Yes**   | Where the camera should be located when it arrives at this keyframe.                                                                        |
+| Rotation   | `Direction`                  | **Yes**   | Where the camera should be pointing when it arrives at this keyframe.                                                                       |
+
+### SimpleInteraction
+
+Most interaction types below are inherited from SimpleInteraction and have these
+fields.  If a type does not have these fields, the documentation will mention it.
+
+The purpose of SimpleInteraction is to facilitate Interaction chaining by taking different paths
+based on whether the Interaction succeeded or failed.  The circumstances under which
+a given Interaction fails are generally type-specific (and described in the documentation
+below), but all interactions will be marked failed if they are cancelled via one of the
+many, many mechanisms for doing so.
+
+It is valid to create an interaction asset of type "Simple", which can be valuable when you want to use the
+interaction fields with no additional functionality.
+
+**SimpleInteraction Fields**
+
+| Field Name | Type                                     | Required? | Notes                                                                                          |
+| ---------- | ---------------------------------------- | --------- | ---------------------------------------------------------------------------------------------- |
+| Next       | `Asset`<br />(Asset Type: `Interaction`) | **No**    | After this Interaction has finished, "Next" will be executed if this Interaction did not fail. |
+| Failed     | `Asset`<br />(Asset Type: `Interaction`) | **No**    | After this Interaction has finished, "Failed" will be executed if this Interaction failed.     |
+
+## Flow Control
+
+These are interaction types used to control the flow of an interaction chain and allow interactions
+to be composed into more complex behaviors.  These interaction types generally do not pertain to
+the game and instead pertain to the interaction system itself.
+
+### Condition
+
+This interaction will fail if one of the fields is provided but does not match the current state.
+
+**Condition Fields**
+
+| Field Name       | Type       | Required? | Notes                                                                                                                                                                                    |
+| ---------------- | ---------- | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| RequiredGameMode | `GameMode` | **No**    | If provided, the interaction will fail if the current GameMode does not match the provided value.                                                                                        |
+| Jumping          | `Boolean`  | **No**    | If provided, the interaction will fail if the player's Jumping state does not match the provided value. (i.e. if True, the player must be jumping, if False, the player must not be)     |
+| Swimming         | `Boolean`  | **No**    | If provided, the interaction will fail if the player's Swimming state does not match the provided value. (i.e. if True, the player must be swimming, if False, the player must not be)   |
+| Crouching        | `Boolean`  | **No**    | If provided, the interaction will fail if the player's Crouching state does not match the provided value. (i.e. if True, the player must be crouching, if False, the player must not be) |
+| Running          | `Boolean`  | **No**    | If provided, the interaction will fail if the player's Running state does not match the provided value. (i.e. if True, the player must be running, if False, the player must not be)     |
+| Flying           | `Boolean`  | **No**    | If provided, the interaction will fail if the player's Flying state does not match the provided value. (i.e. if True, the player must be flying, if False, the player must not be)       |
+
+**GameMode Values**
+
+- `Creative`: The game is currently in Creative Mode
+- `Adventure`: The game is currently in Adventure Mode
+
+### FirstClick
+
+This interaction does not inherit from SimpleInteraction and therefore has no Next or Failed fields.
+
+This interaction has two fields that each contain a reference to an Interaction: Click and Hold.  If the root interaction
+of the chain was initiated by a client button/key press (or simulated NPC input) and the input was a tap, then
+the Click interaction is run. if it was a longer press, then the Hold interaction is run.
+
+As a minor implementation detail, this interaction is internally marked as failed when the Hold path is followed.
+This generally shouldn't matter.  If the interaction was not initiated by a key press at all, the Click path will be followed,
+but it seems risky to rely on that behavior.
+
+**FirstClick Fields**
+
+| Field Name | Type                                     | Required? | Notes                                                                                                                                                    |
+| ---------- | ---------------------------------------- | --------- | -------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Click      | `Asset`<br />(Asset Type: `Interaction`) | **No**    | If provided and the root interaction of the chain was initiated by button/key press, this interaction is executed next if the press was a quick tap.     |
+| Hold       | `Asset`<br />(Asset Type: `Interaction`) | **No**    | If provided and the root interaction of the chain was initiated by a button/key press, this interaction is executed next if the press was a longer hold. |
+
+### Interrupt
+
+This interaction can be used to cancel one or more running interaction chains on an entity and **all forked interaction
+chains those chains have spawned that are still currently running**.  All interaction chains canceled in this manner will be marked as
+Failed, which may have additional implications if the canceled chains are themselves forked from
+other chains that are still running.
+
+**Interrupt Fields**
+
+| Field Name     | Type                                           | Required? | Notes                                                                                                                                                                                               |
+| -------------- | ---------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Entity         | `InteractionTarget`<br />(Default: User)       | **Yes**   | The entity that is the owner of the target interaction chains.  This field can indicate the Owner, User, or Target of this interaction chain.                                                       |
+| InterruptTypes | `Array`<br />(Element Type: `InteractionType`) | **No**    | A set of InteractionTypes that are to be interrupted. Only interactions of these types are affected. If null, all types will be interrupted.<br />**(Note: An empty set will interrupt NO TYPES.)** |
+| RequiredTag    | `String`                                       | **No**    | An asset tag that, if provided, the RootInteraction of the interaction chain must have in order to be canceled.                                                                                     |
+| ExcludedTag    | `String`                                       | **No**    | An asset tag that, if provided, the RootInteraction of the interaction chain must not have in order to be canceled.                                                                                 |
+
+**InteractionTarget Values**
+
+- `User` - The user of this interaction chain. The entity whose actions caused this interaction chain to be executed. This is usually the same as the Owner.
+- `Owner` - The owner of this interaction chain. The entity upon whom this interaction chain is executing.
+- `Target` - The entity target of this interaction chain, if any.  This value is mutable (and can therefore come from many places) but most commonly, it is an entity the User was targeting when this interaction chain began executing.
+
+**InteractionType Values**
+
+- `Primary`
+- `Secondary`
+- `Ability1`
+- `Ability2`
+- `Ability3`
+- `Use`
+- `Pick`
+- `Pickup`
+- `CollisionEnter`
+- `CollisionLeave`
+- `Collision`
+- `EntityStatEffect`
+- `SwapTo`
+- `SwapFrom`
+- `Death`
+- `Wielding`
+- `ProjectileSpawn`
+- `ProjectileHit`
+- `ProjectileMiss`
+- `ProjectileBounce`
+- `Held`
+- `HeldOffhand`
+- `Equipped`
+- `Dodge`
+- `GameModeSwap`
+
+### Parallel
+
+This interaction does not inherit from SimpleInteraction and therefore has no Next or Failed fields.
+
+This interaction has a field `Interactions` that is an array of RootInteraction assets. The list must contain at least
+two RootInteractions.  This interaction will fork all of its children except for the first into their
+own interaction chains and immediately complete. After this interaction completes, this interaction chain will
+execute the first RootInteraction in the `Interactions` list.
+
+This interaction does not have any failure conditions and is indifferent to the fate of the forked interaction chains.
+
+**Parallel Fields**
+
+| Field Name   | Type                                                | Required? | Notes                                                         |
+| ------------ | --------------------------------------------------- | --------- | ------------------------------------------------------------- |
+| Interactions | `AssetArray`<br />(Element Type: `RootInteraction`) | **Yes**   | An array of RootInteractions that will be forked or executed. |
+
+### Repeat
+
+This interaction has a field `ForkInteractions` that is an asset of type RootInteraction. This interaction will fork that
+RootInteraction into its own interaction chain and then wait for it to complete. If the RootInteraction fails, this
+interaction will complete immediately and be marked failed. Otherwise, the RootInteraction will be forked and run again,
+up to a specified total number of times.
+
+**Repeat Fields**
+
+| Field Name       | Type                                                                                   | Required? | Notes                                                                                                                                                                                                              |
+| ---------------- | -------------------------------------------------------------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| ForkInteractions | `Asset`<br />(Asset Type: `RootInteraction`)                                           | **Yes**   | A RootInteraction that will be forked.                                                                                                                                                                             |
+| Repeat           | `Integer`<br />(Default: 1)<br />**Must be -1 or a positive integer. 0 is not valid.** | **No**    | The total number of times to fork ForkInteractions. If -1 is provided, ForkInteractions will continue being forked and executed indefinitely, until this interaction is cancelled or until ForkInteractions fails. |
+
+### Replace
+
+This interaction does not inherit from SimpleInteraction and therefore has no Next or Failed fields.
+
+This interaction uses the InteractionVars system that is avaiable for items. InteractionVars are RootInteractions that
+can be attached to an Item asset with a name.
+
+This interaction specifies a var name, and if this interaction chain was executed through
+an item and that item has an InteractionVar of the same name, then this interaction will immediately execute
+the RootInteraction on the var.  Otherwise, it will execute the default RootInteraction specified in this interaction.
+If no default is specified, then this interaction will be marked as failed.
+
+**Replace Fields**
+
+| Field Name   | Type                                         | Required? | Notes                                                                                                                                                                                                           |
+| ------------ | -------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Var          | `String`                                     | **Yes**   | The name of the InteractionVar to execute.                                                                                                                                                                      |
+| DefaultValue | `Asset`<br />(Asset Type: `RootInteraction`) | **No**    | The RootInteraction to execute if the owning item does not have an InteractionVar by the specified name. If not provided, the interaction will be marked as failed instead.                                     |
+| DefaultOk    | `Boolean`<br />(Default: false)              | **No**    | If false, then an angry message will be printed to the server logs if the owning item does not have an InteractionVar by the specified name.  The functioning of this interaction will be otherwise unaffected. |
+
+### RunRootInteraction
+
+This interaction immediately executes the provided RootInteraction as part of this interaction chain. This interaction
+does not have any failure conditions.
+
+**RunRootInteraction Fields**
+
+| Field Name      | Type                                         | Required? | Notes                           |
+| --------------- | -------------------------------------------- | --------- | ------------------------------- |
+| RootInteraction | `Asset`<br />(Asset Type: `RootInteraction`) | **Yes**   | The RootInteraction to execute. |
+
+### Selector
+
+This interaction will execute a Selector to find entities and/or blocks (depending on the Selector) and fork off an
+interaction chain for each located entity or block. This interaction will not wait for those interaction chains
+to complete and is indifferent to their fate. The forked interaction chains will use the located entity/block as
+their target entity/target block. Each entity or block will only fork one interaction chain over the life of this
+interaction.  The Selector is guaranteed to run once for each execution of this interaction, but some Selectors
+are intended to be run over a period of time and sweep across an area to locate targets. In order to use those Selectors
+properly, you will need to extend the execution time of this interaction using `RunTime` or `WaitForAnimationToFinish`.
+The Selector will be executed repeatedly over the lifetime of the interaction.
+
+If the Selector is configured to locate entities, you can add additional sets of entity matching rules. If a located entity
+matches one of the rules, the matching RootInteraction will be forked instead of the standard `HitEntity` RootInteraction.
+
+Entities located by the Selector will be ignored if they do not have a NetworkId, if they are dead, or if they are invulnerable.
+The only exception to this rule is that players in Creative Mode that are marked to receive hits will not be ignored.
+
+This interaction's failure conditions are configurable via the `FailOn` field. You can configure this interaction to never
+fail, to fail if the Selector does not locate any blocks before this interaction finishes executing, to fail if the
+Selector does not locate any entities before this interaction finishes executing, or to fail in either case.
+
+**Selector Fields**
+
+| Field Name     | Type                                         | Required? | Notes                                                                                                                                                                                                                                     |
+| -------------- | -------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Selector       | `Selector`                                   | **Yes**   | The Selector is executed at least once and may be executed repeatedly to locate blocks and/or entities in an area.                                                                                                                        |
+| HitEntity      | `Asset`<br />(Asset Type: `RootInteraction`) | **No**    | If included and the `Selector` locates an entity that does not match any `HitEntityRules`, this RootInteraction will be forked into a new interaction chain with the located entity as the target entity.                                 |
+| HitEntityRules | `Array`<br />(Element Type: `HitEntity`)     | **No**    | If included, these rules will be matched against any entity located by the `Selector`. If an entity matches a set of rules, the RootInteraction associated with the rules will be forked instead of the standard `HitEntity` interaction. |
+| HitBlock       | `Asset`<br />(Asset Type: `RootInteraction`) | **No**    | If included and the `Selector` locates a block, this RootInteraction will be forked into a new interaction chain with the located block as the block target.                                                                              |
+| FailOn         | `FailOnType`<br />(Default: `Neither`)       | **No**    | Defines under what circumstances this interaction will fail.  It can be marked to fail when it completes without locating any blocks, it can be marked to fail when it completes without locating any entities, both, or neither.         |
+| IgnoreOwner    | `Boolean`<br />(Default: true)               | **No**    | If true, the Selector will not locate the User entity of this interaction.                                                                                                                                                                |
+
+**HitEntity Fields**
+
+| Field Name | Type                                         | Required? | Notes                                                                                                 |
+| ---------- | -------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------- |
+| Matchers   | `Array`<br />(Element Type: `EntityMatcher`) | **Yes**   | A set of rules that an entity must match. An entity must successful match all rules to be considered. |
+| Next       | `Asset`<br />(Asset Type: `RootInteraction`) | **Yes**   | The RootInteraction to fork if an entity matches all rules.                                           |
+
+**EntityMatcher Fields**
+
+| Field Name | Type                            | Required? | Notes                                                                                                     |
+| ---------- | ------------------------------- | --------- | --------------------------------------------------------------------------------------------------------- |
+| Type       | `String`                        | **Yes**   | If provided, specifies a type of EntityMatcher to use. Each matcher type may come with additional fields. |
+| Invert     | `Boolean`<br />(Default: false) | **No**    | If true, an entity must fail this rule for it to be marked as succeeded.                                  |
+
+**EntityMatcher Type: Player**
+
+This EntityMatcher will succesfully match the entity only if they are a player.
+
+**EntityMatcher Type: Vulnerable**
+
+This Entitymatcher will successfully match the entity only if they are not marked as invulnerable.
+
+**FailOnType Values**
+
+- `Neither`
+- `Entity`
+- `Block`
+- `Either`
+
+### Serial
+
+This interaction does not inherit from SimpleInteraction and therefore has no Next or Failed fields.
+
+This interaction has a field `Interactions` which is a list of Interaction assets. This interaction immediately
+completes and the interaction chain continues by executing the interactions in the list one at a time. This
+interaction does not have any failure conditions.
+
+**Serial Fields**
+
+| Field Name   | Type                                            | Required? | Notes                                      |
+| ------------ | ----------------------------------------------- | --------- | ------------------------------------------ |
+| Interactions | `AssetArray`<br />(Element Type: `Interaction`) | **Yes**   | An array of Interaction assets to execute. |
+
+## Cooldowns
+
+RootInteractions interface with a complex cooldown system that can be used for a variety of purposes. Aside from simply
+adding an important aspect of resource management to your game design, cooldowns can be used to ensure that click-activated
+interaction chains don't repeatedly spam if the player holds down the input.
+
+By default, every RootInteraction has a cooldown timer that is keyed to the RootInteraction name, and by default, it
+will launch a cooldown of 0.35 seconds when activated by client input.  Otherwise, no cooldown will be activated.  However,
+by configuring your RootInteraction, you can change the key for the cooldown (so that multiple RootInteractions can share
+a single cooldown), set the cooldown timer to whatever you like, and configure multiple charges that can build up over time
+to allow the entity to activate the RootInteraction multiple times before being forced to pause.
+
+One important concept to keep in mind is the difference between **cooldown** and **charge time**.  The cooldown, if any,
+is activated each time a RootInteraction triggers, even if the player has more available charges. If the RootInteraction
+is configured to use charges, then they will gradually build up over time. In order for a RootInteraction to be activated,
+the cooldown (if any) must be expired, and the RootInteraction must have at least one charge (if it has been
+configured to use charges).
+
+Bear in mind that the entire Cooldown configuration is shared between different RootInteractions with the same cooldown id.
+If you activate an ability with 5 charges and a short cooldown and then another ability with a much longer cooldown and no
+charges, the second ability will use the cooldown properties of the first ability until/unless the first ability finishes
+charging and is cleared from the system.  You should generally only have multiple RootInteractions share a cooldown id
+if they have the same configuration.
+
+The interactions below interact with the cooldown system to allow you to manipulate cooldowns via the interaction system. By
+using these interactions, you can have several interaction chains with different cooldown configurations share cooldowns
+that are checked and activated as part of the interaction chain itself, or have some components of an interaction change
+use a second cooldown separate from the main one.
+
+### CooldownCondition
+
+**CooldownCondition Fields**
+
+This interaction will fail if the specified cooldown id is on cooldown for the User entity.  This interaction will only
+function for players- the interaction will always succeed for NPCs.  In order for this interaction to succeed, the
+cooldown, if any, must have expired and at least one charge, if any, must have filled.
+
+| Field Name | Type     | Required? | Notes                     |
+| ---------- | -------- | --------- | ------------------------- |
+| Id         | `String` | **Yes**   | The cooldown id to check. |
+
+### IncrementCooldown
+
+**IncrementCooldown Fields**
+
+This interaction will modify a cooldown that is currently active on the User entity, allowing charges and remaining
+cooldown to be modified.
+Despite its name, this interaction can be used to reduce a cooldown as well as increase it. If the cooldown is not
+currently active, this interaction will have no effect. The interaction has no special failure conditions.
+
+| Field Name        | Type                        | Required? | Notes                                                                                                                                                                                                                                                                                     |
+| ----------------- | --------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Id                | `String`                    | **No**    | If provided, the cooldown id of the cooldown to be manipulated. If not provided, the cooldown id of the current chain's RootInteraction will be used.                                                                                                                                     |
+| Time              | `Float`<br />(Default: 0.0) | **No**    | The amount to increase the remaining cooldown by. Can be negative. The remaining cooldown time will not be reduced below zero or increased above the maximum cooldown time.                                                                                                               |
+| ChargeTime        | `Float`<br />(Default: 0.0) | **No**    | The amount to increase the remaining time until the next charge is filled by. Can be negative. The remaining charge time cannot be reduced below zero or increased above the maximum cooldown time. **This will not work on abilities that have a maximum of 1 charge, for some reason.** |
+| Charge            | `Integer`<br />(Default: 0) | **No**    | The amount to increase the number of charges by. Can be negative. The number of charges cannot be reduced below 0 or increased above the maximum.                                                                                                                                         |
+| InterruptRecharge | `Boolean`(Default: false)   | **No**    | If true and `Charge` is not 0, will reset the remaining time to the next charge to the maximum value after changing the charge count.                                                                                                                                                     |
+
+### ResetCooldown
+
+This interaction will trigger a cooldown on the User entity with a specified configuration. The charges will be refilled
+but the cooldown will be immediately triggered.  The mechanisms for deciding on the configuration are a little bit complicated.
+You may specify a cooldown configuration via the `Cooldown` field. If you do not include an `Id` field, then the
+interaction chain's RootInteraction will be used for any field not specified in the configuration. If there is an active
+cooldown under the specified `Id` (or under the RootInteraction's cooldown id if none is specified) then the fields
+from that active cooldown will overwrite data in the RootInteraction's cooldown, but not data in your `Cooldown` field.
+
+**ResetCooldown Fields**
+
+| Field Name | Type                  | Required? | Notes                                                        |
+| ---------- | --------------------- | --------- | ------------------------------------------------------------ |
+| Cooldown   | `InteractionCooldown` | **No**    | A cooldown configuration to use for the new, reset cooldown. |
+
+**InteractionCooldown Fields**
+
+| Field Name        | Type                                 | Required? | Notes                                                                                                                                                                                                 |
+| ----------------- | ------------------------------------ | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Id                | `String`                             | **No**    | The cooldown id to use for this cooldown. If not provided, the RootInteraction's cooldown id will be used, if any.                                                                                    |
+| Cooldown          | `Float`<br />(Default: 0.0)          | **No**    | The duration of the cooldown, in seconds.                                                                                                                                                             |
+| Charges           | `Array`<br />(Element Type: `Float`) | **No**    | If provided, a list of how many charges this cooldown can build, and how long each charge takes to build, in seconds.                                                                                 |
+| InterruptRecharge | `Boolean`<br />(Default: false)      | **No**    | If true, the charge time will be reset when the number of charges changes.                                                                                                                            |
+| ClickBypass       | `Boolean`<br />(Default: false)      | **No**    | If true, RootInteractions keyed to this cooldown can still be activated when it is on cooldown provided that the RootInteraction was triggered by a distinct key or mouse button press on the client. |
+
+### TriggerCooldown
+
+This interaction is similar to ResetCooldown, except instead of refilling the cooldown's charges, one charge will be deducted
+as normal.
+
+**TriggerCooldown Fields**
+
+| Field Name | Type                  | Required? | Notes                                                        |
+| ---------- | --------------------- | --------- | ------------------------------------------------------------ |
+| Cooldown   | `InteractionCooldown` | **No**    | A cooldown configuration to use for the new, reset cooldown. |
+
+**InteractionCooldown Fields**
+
+| Field Name        | Type                                 | Required? | Notes                                                                                                                                                                                                 |
+| ----------------- | ------------------------------------ | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Id                | `String`                             | **No**    | The cooldown id to use for this cooldown. If not provided, the RootInteraction's cooldown id will be used, if any.                                                                                    |
+| Cooldown          | `Float`<br />(Default: 0.0)          | **No**    | The duration of the cooldown, in seconds.                                                                                                                                                             |
+| Charges           | `Array`<br />(Element Type: `Float`) | **No**    | If provided, a list of how many charges this cooldown can build, and how long each charge takes to build, in seconds.                                                                                 |
+| InterruptRecharge | `Boolean`<br />(Default: false)      | **No**    | If true, the charge time will be reset when the number of charges changes.                                                                                                                            |
+| ClickBypass       | `Boolean`<br />(Default: false)      | **No**    | If true, RootInteractions keyed to this cooldown can still be activated when it is on cooldown provided that the RootInteraction was triggered by a distinct key or mouse button press on the client. |
+
+## Combo Chains
+
+Hytale additionally comes with a rich "combo chaining" system, which allows several inputs in a row to result in different
+attacks and special moves.  Rather than being attached to the RootInteraction like the cooldown system, these are
+primarily driven by the `Chaining` interaction.
+
+### Chaining
+
+This interaction does not inherit from SimpleInteraction and therefore has no Failed field. Its Next field works differently
+from most interaction types.
+
+Chaining is a type of flow control interaction- each time a Chaining interaction with the same `ChainId` is called, a single
+interaction in the `Next` list is chosen and the others are ignored. The first time the `ChainId` is used, the first
+interaction in the list is chosen, the next time the second, etc. Once the end of the list is reached, the first
+interaction will be chosen again.
+
+Bear in mind: the progress through the Next list is based on the **ChainId**, not the interaction!  That means that two
+different Chaining interactions can share a single combo chain. You could have a pair of daggers that attacks with
+the left when the left mouse button is clicked and with the right when the right mouse button is clicked.  You could give
+both interaction chains a Chaining interaction with the same `ChainId` and three `Next` entries that do a light-light-heavy
+combo.  Each specific hit would occur with either the left or the right knife based on which button you clicked, but
+the combo would be otherwise identical regardless of which you chose.
+
+The Chaining interaction also has a concept called "flags".  It is possible to attach named flags to a `ChainId` by using
+the ChainFlag interaction.  Then, you specify the flag name in Chaining's `Flags` field. If a Flag is active when the
+Chaining interaction is run, the Flag's interaction will be run instead of the appropriate interaction in `Next`.
+Bear in mind: the entity's progress through the `Next` list still advances, the resulting `Next` interaction is just not
+run.  Only one flag can be active at a time.
+
+Lastly, it is possible to cancel the entity's progress through the combo chain and reset them to the first interaction in
+the list. This can be done with the CancelChain interaction, but it will also happen automatically if the player does
+not trigger an interaction with the ChainId for the specified ChainingAllowance.  When either of these happen, all flags will be
+canceled as well.
+
+All of these effects are triggered on the User entity only. Non-players can use the chaining system, but Flags do not currently
+work for non-players.  This interaction has no special failure conditions.
+
+**Chaining Fields**
+
+| Field Name        | Type                                                       | Required? | Notes                                                                                                                                                                                                                       |
+| ----------------- | ---------------------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| ChainId           | `String`                                                   | **No**    | If provided, acts as a key that multiple Chaining interactions can use to share combo chain progress and flags. If not provided, a unique ChainId will be generated for this interaction.                                   |
+| ChainingAllowance | `Double`<br />(Default: 0.0)                               | **No**    | If, at the time this interaction is triggered, it has been this long in seconds since the last time a Chaining interaction with the same ChainId was executed, all state for this ChainId will be cleared before execution. |
+| Next              | `AssetArray`<br />(Element Type: `Interaction`)            | **Yes**   | A list of interactions to cycle between each time this interaction is run.                                                                                                                                                  |
+| Flags             | `Map`<br />(Key Type: `String`, Value Type: `Interaction`) | **No**    | A map of flag names to interactions to run if the flag is active when this interaction executes.                                                                                                                            |
+
+### CancelChain
+
+This interaction resets all progress and flag data on the User entity for the provided `ChainId`.  The next time a Chaining
+interaction is called for the provided `ChainId`, it will begin at the first interaction in the `Next` list. This
+interaction has no special failure conditions.
+
+**CancelChain Fields**
+
+| Field Name | Type     | Required? | Notes                                 |
+| ---------- | -------- | --------- | ------------------------------------- |
+| ChainId    | `String` | **Yes**   | A ChainId whose data should be reset. |
+
+### ChainFlag
+
+This interaction activates a flag on the User entity for the provided `ChainId`, which can be used to change behavior the
+next time a Chaining interaction with this `ChainId` is run. This will overwrite any flag that has
+already been raised. This interaction will have no effect for non-players. This interaction has no special failure
+conditions.
+
+| Field Name | Type     | Required? | Notes                                        |
+| ---------- | -------- | --------- | -------------------------------------------- |
+| ChainId    | `String` | **Yes**   | A ChainId on whom the flag should be raised. |
+| Flag       | `String` | **Yes**   | The name of the flag to raise.               |
+
+## Charging
+
+A unique flow-control interaction that is frequently used is the Charging interaction.  It is a flow-control interaction
+that delays while the input button used to trigger the interaction chain is held.  When it is released (or the interaction
+is forced to end), the interaction chain can continue with a different interaction based on how long the input was held
+for.
+
+These interactions are all related by either being the Charging interaction, or other interaction types that inherit the
+Charging interaction's behavior.
+
+### Charging
+
+This interaction does not inherit from SimpleInteraction and therefore its Next field works different from most interactions.
+This interaction adds its own Failed field which works the same way that SimpleInteraction's does.
+
+This interaction only works properly when its interaction chain was triggered by a client key or button press (or
+NPC-simulated equivalent). This interaction will continue executing for as long as the key or button press is held (with
+some exceptions, covered below) by the User entity.  Like other interactions, it has a `Next` field indicating which interaction to execute
+after this one, but the field is a map from `Float` values to `Interaction` assets. When this interaction ends, either
+due to the input being released or the charge duration completing, this interaction will determine the largest `Float` key that is less
+than the amount of time in seconds that the interaction was executing for.  The Interaction mapped to that key will be
+executed next.
+
+The interaction includes some cancellation conditions that are specific to this interaction. For instance, the interaction
+has a `CancelOnOtherClick` field that matches the field on RootInteraction. If it is active on this interaction but not
+the RootInteraction, then clicking while charging will cancel this interaction (and execute the `Failed` interaction rather
+than any of the `Next` interactions) but otherwise continue the interaction chain.
+
+Another valuable feature Charging has is the `Forks` field.  For input-triggered interactions that are triggered while the
+Charging interaction is executing, you can add an entry for the relevant InteractionType to this field and instead of
+triggering the usual interaction chain based on held item, targeted block, etc. the RootInteraction specified in the
+`Forks` field will be triggered.  This can unlock rich attack modes and behaviors. For instance, having a shield bash attack
+triggered off left click while blocking, or a special attack that triggers when both mouse buttons are pressed at the
+same time.
+
+There are two modes of operation for the Charging interaction. One is to have the ability charge for as long
+as the input is held and only end execution when the entity releases the input.  Bows in the main Hytale game work
+that way.  That is accomplished by setting `AllowIndefiniteHold` to true.  Another mode of operation is to have the
+interaction complete execution when the execution time has surpassed the largest key value in the `Next` field and
+immediately begin executing the Interaction mapped to that key.  Food in the main Hytale game work like this.  It
+is accomplished by setting `AllowIndefiniteHold` to false.
+
+One pitfall to be careful of when setting `AllowIndefiniteHold` to false is the way it interacts with cooldowns.\
+Normally, input-initiated interaction chains start a 0.35s cooldown on the triggered RootInteraction that prevents
+holding the mouse button from immediately spamming a new interaction when the first one completes.  However, if the
+duration of a Charging interaction is longer than 0.35s, then the cooldown will have already completed when the
+interaction chain finishes, which will often result in a new execution beginning immediately before the player can
+stop pressing the mouse button.  One solution for this problem is to add a `Simple` interaction to the end of your
+interaction chain with a `RunTime` of 0.35s to simulate the cooldown.  Alternatively, you can add a longer cooldown
+(the maximum duration of your Charging interaction plus 0.35s) to the RootInteraction. However, the longer cooldown is
+not always desirable, as the interaction may have ended prematurely, resulting in an unusually long lockout between
+executions.
+
+**Charging Fields**
+
+| Field Name                         | Type                                                                    | Required? | Notes                                                                                                                                                                                                                                                                                                                                                                                       |
+| ---------------------------------- | ----------------------------------------------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| FailOnDamage                       | `Boolean`<br />(Default: false)                                         | **No**    | If true, this interaction will fail and end immediately if the User entity takes any damage while it is executing.                                                                                                                                                                                                                                                                          |
+| CancelOnOtherClick                 | `Boolean`<br />(Default: true)                                          | **No**    | If true, this interaction will fail and end immediately if the User entity sends another button or key press while it is executing.                                                                                                                                                                                                                                                         |
+| Forks                              | `Map`<br />(Key Type: `InteractionType`, Value Type: `RootInteraction`) | **No**    | A map of InteractionType to RootInteraction. If entity input triggers the InteractionType while this interaction is executing, the mapped RootInteraction will be forked into its own interaction chain. This will happen instead of the usual handling for that InteractionType.  This fork will occur even if `CancelOnOtherClick` is set to true.                                        |
+| Failed                             | `Asset`<br />(Asset Type: `Interaction`)                                | **No**    | After this Interaction has finished, "Failed" will be executed if this Interaction failed.                                                                                                                                                                                                                                                                                                  |
+| AllowIndefiniteHold                | `Boolean`<br />(Default: false)                                         | **No**    | If true, this interaction will continue executing for as long as the User entity continues to hold the input. If false, execution will end as soon as the execution time in seconds reaches the largest key value in the `Next` map.                                                                                                                                                        |
+| DisplayProgress                    | `Boolean`<br />(Default: true)                                          | **No**    | If true, players executing this interaction will see a progress bar will be displayed below their cursor indicating how close to reaching the highest key value in `Next` they are.                                                                                                                                                                                                         |
+| Next                               | `Map`<br />(Key Type: `Float`, Value Type: `Interaction`)               | **No**    | A map from `Float` to `Interaction`.  When this interaction successfully finishes executing (either because the input was released or because the maximum duration was reached), this interaction will find the `Float` value with the largest duration in seconds that is less than the amount of time this interaction executed for. That key's mapped Interaction will then be executed. |
+| MouseSensitivityAdjustmentTarget   | `Float`<br />(Default: 1.0)                                             | **No**    | While charging, this mouse sensitivity multiplier will gradually be applied.                                                                                                                                                                                                                                                                                                                |
+| MouseSensitivityAdjustmentDuration | `Float`<br />(Default: 1.0)                                             | **No**    | Duration in seconds. After this many seconds, `MouseSensitivityAdjustmentTarget` will be fully applied to the mouse sensitivity.                                                                                                                                                                                                                                                            |
+| Delay                              | `ChargingDelay`                                                         | **No**    | Settings that allow charging progress to be pushed back when the User entity takes damage.                                                                                                                                                                                                                                                                                                  |
+
+**ChargingDelay Fields**
+
+| Field Name    | Type                        | Required? | Notes                                                                                                                                                                                                                                                                     |
+| ------------- | --------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| MinHealth     | `Float`<br />(Default: 0.0) | **No**    | Damage taken as a percentage of entity health (0.0-1.0). If a hit deals less than this much damage, no pushback will be applied.  If a hit deals exactly this much damage, `MinDelay` seconds worth of pushback will be applied.                                          |
+| MaxHealth     | `Float`<br />(Default: 0.0) | **No**    | Damage taken as a percentage of entity health (0.0-1.0). If a hit deals at least this much damage, `MaxDelay` seconds worth of pushback will be applied.                                                                                                                  |
+| MinDelay      | `Float`<br />(Default: 0)   | **No**    | The amount of pushback, in seconds, to apply if the entity takes a hit that deals `MinHealth` damage. The amount of pushback applied by a hit is a gradiant between `MinDelay` and `MaxDelay` based on the amount of damage between `MinHealth` and `MaxHealth`.          |
+| MaxDelay      | `Float`<br />(Default: 0)   | **No**    | The amount of pushback, in seconds, to apply if the entity takes a hit that deals at least `MaxHealth` damage. The amount of pushback applied by a hit is a gradiant between `MinDelay` and `MaxDelay` based on the amount of damage between `MinHealth` and `MaxHealth`. |
+| MaxTotalDelay | `Float`<br />(Deault: 0)    | **No**    | The maximum amount of pushback the entity can receive over the course of a single charge, regardless of how many times they are hit.                                                                                                                                      |
+
+**InteractionType Values**
+
+- `Primary`
+- `Secondary`
+- `Ability1`
+- `Ability2`
+- `Ability3`
+- `Use`
+- `Pick`
+- `Pickup`
+- `CollisionEnter`
+- `CollisionLeave`
+- `Collision`
+- `EntityStatEffect`
+- `SwapTo`
+- `SwapFrom`
+- `Death`
+- `Wielding`
+- `ProjectileSpawn`
+- `ProjectileHit`
+- `ProjectileMiss`
+- `ProjectileBounce`
+- `Held`
+- `HeldOffhand`
+- `Equipped`
+- `Dodge`
+- `GameModeSwap`
+
+### Wielding
+
+This interaction is inherited from Charging rather than SimpleInteraction.  However, its `Failed` and `Next` fields function
+identically to SimpleInteraction.  It does not inherit all fields from Charging, so be sure to pay close attention to
+the field list below.
+
+This interaction drives most blocking behavior in the game. While this interaction is executing, attacks made against
+the Owner entity will (conditionally) trigger effects defined in this interaction.  Unlike the Charging interaction,
+this interaction can always execute indefinitely and will only end when it fails or when the input is released.
+
+One option available in Wielding is `AngledWielding`, which allows damage and knockback modifiers to only be applied
+depending on the direction the attack against the Owner entity is coming from.  The AngledWielding type has a
+field `Angle` which determines which direction the protection points relative to the player (0 is the player's
+front), and `AngleDistance` which determines how wide the cone of protection extends around the player.  Block effects
+from this interaction (such as `BlockedEffects`, `BlockedInteractions`, and `StaminaCost`) will only apply if
+the DamageCause matches `DamageModifiers` OR if the DamageCause matches `AngledWielding.DamageModifiers` and
+the source of the damage matches `Angle` and `AngleDistance`.  It is possible for damage and knockback multipliers
+specified on both this interaction's modifier fields and `AngledWielding`'s modifier fields to stack, if both
+have entries for the same DamageCause.
+
+This interaction will only have an effect on damage taken by one of the DamageCause entries in `DamageModifiers` or
+`AngledWielding.DamageModifiers`.  If a DamageCause is in `DamageModifiers`, then the block effect will be triggered
+and the damage modifier applied regardless of what direction the Owner entity is attacked from.  If a DamageCause is in
+`AngledWielding.DamageModifiers`, then the damage modifier is only applied if the
+
+\*\* Wielding Fields\*\*
+
+| Field Name          | Type                                                                    | Required? | Notes                                                                                                                                                                                                                                                                                                                                                                                                      |
+| ------------------- | ----------------------------------------------------------------------- | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| FailOnDamage        | `Boolean`<br />(Default: false)                                         | **No**    | If true, this interaction will fail and end immediately if the User entity takes any damage while it is executing.                                                                                                                                                                                                                                                                                         |
+| CancelOnOtherClick  | `Boolean`<br />(Default: true)                                          | **No**    | If true, this interaction will fail and end immediately if the User entity sends another button or key press while it is executing.                                                                                                                                                                                                                                                                        |
+| Forks               | `Map`<br />(Key Type: `InteractionType`, Value Type: `RootInteraction`) | **No**    | A map of InteractionType to RootInteraction. If entity input triggers the InteractionType while this interaction is executing, the mapped RootInteraction will be forked into its own interaction chain. This will happen instead of the usual handling for that InteractionType.  This fork will occur even if `CancelOnOtherClick` is set to true (after which this interaction chain will be canceled). |
+| Next                | `Asset`<br />(Asset Type: `Interaction`)                                | **No**    | After this interaction has finished, "Next" will be executed if this interaction did not fail.                                                                                                                                                                                                                                                                                                             |
+| Failed              | `Asset`<br />(Asset Type: `Interaction`)                                | **No**    | After this interaction has finished, "Failed" will be executed if this interaction failed.                                                                                                                                                                                                                                                                                                                 |
+| DamageModifiers     | `Map`<br />(Key Type: `DamageCause`, Value Type: `Float`)               | **No**    | A map from DamageCause to Float, where the Float is multiplied against any damage received from the mapped DamageCause while this interaction is executing.                                                                                                                                                                                                                                                |
+| KnockbackModifiers  | `Map`<br />(Key Type: `DamageCause`, Value Type: `Float`)               | **No**    | A map from DamageCause to Float, where the Float is multiplied against any knockback force received from the mapped DamageCause while this interaction is executing.                                                                                                                                                                                                                                       |
+| AngledWielding      | `AngledWielding`                                                        | **No**    | Configuration to only trigger block effects from certain angles.                                                                                                                                                                                                                                                                                                                                           |
+| StaminaCost         | `StaminaCost`                                                           | **No**    | If the Owner entity receives damage that matches `DamageModifiers` or `AngledWielding` while this interaction is executing, then the entity's stamina will be deducted according to this configuration.                                                                                                                                                                                                    |
+| BlockedEffects      | `DamageEffects`                                                         | **No**    | If the Owner entity receives damage that matches `DamageModifiers` or `AngledWielding` while this interaction is executing, then these effects will be applied to the instance of damage.                                                                                                                                                                                                                  |
+| BlockedInteractions | `Asset`<br />(Asset Type: `RootInteraction`)                            | **No**    | If the Owner entity receives damage that matches `DamageModifiers` or `AngledWielding` while this interaction is executing, then this RootInteraction will be launched as a brand new interaction chain with the Owner entity as both Owner and User, and the attacker as the Target entity.  This new interaction chain is, notably, brand new, **not** forked from the current one.                      |
+
+**AngledWielding Fields**
+
+| Field Name         | Type                                                      | Required? | Notes                                                                                                                                                                                                            |
+| ------------------ | --------------------------------------------------------- | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Angle              | `Float`<br />(Default: 0.0)                               | **No**    | Angle in degrees relative to the Owner entity where the angled protection is centered. 0.0 means pointed towards the front of the Owner entity.                                                                  |
+| AngleDistance      | `Float`<br />(Default: 0.0)                               | **No**    | Angle in degrees indicating how wide the cone of protection is.                                                                                                                                                  |
+| DamageModifiers    | `Map`<br />(Key Type: `DamageCause`, Value Type: `Float`) | **No**    | A map from DamageCause to Float, where the Float is multiplied against any damage received from the mapped DamageCause received from within the cone of protection while this interaction is executing.          |
+| KnockbackModifiers | `Map`<br />(Key Type: `DamageCause`, Value Type: `Float`) | **No**    | A map from DamageCause to Float, where the Float is multiplied against any knockback force received from the mapped DamageCause received from within the cone of protection while this interaction is executing. |
+
+**StaminaCost Fields**
+
+| Field Name | Type                                             | Required? | Notes                                                                                                                                                                                                                                                |
+| ---------- | ------------------------------------------------ | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| CostType   | `CostType`<br />(Default: `MaxHealthPercentage`) | **No**    | How to calculate stamina consumed by blocking from the raw pre-block damage. If `Damage`, then the stamina consumed will be `rawDamage / Value`. If `MaxHealthPercentage`, then the stamina consumed will be `rawDamage / (EntityMaxHealth * Value)` |
+| Value      | `Float`<br />(Default: 0.04)                     | **No**    | The value to use in the `CostType` formula.                                                                                                                                                                                                          |
+
+**DamageEffects Fields**
+
+| Field Name             | Type                                         | Required? | Notes                                                                           |
+| ---------------------- | -------------------------------------------- | --------- | ------------------------------------------------------------------------------- |
+| ModelParticles         | `Array`<br />(Element Type: `ModelParticle`) | **No**    | Particle systems to trigger in the first-person view.                           |
+| WorldParticles         | `Array`<br />(Element Type: `WorldParticle`) | **No**    | Particle systems to trigger in the third-person view.                           |
+| LocalSoundEventId      | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | 2D sound to play locally to the attacking entity if they are a player.          |
+| WorldSoundEventId      | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | Sound to play in the world at the Owner entity's location.                      |
+| PlayerSoundEventId     | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | 2D sound to play locally to the Owner entity if they are a player.              |
+| ViewDistance           | `Double`<br />(Default: 75.0)                | **No**    | Distance at which these effects should play for other players.                  |
+| Knockback              | `Knockback`                                  | **No**    | The properties of the knockback that will be applied.                           |
+| CameraEffect           | `Asset`<br />(Asset Type: `CameraEffect`)    | **No**    | CameraEffect to briefly apply locally to the Owner entity if they are a player. |
+| StaminaDrainMultiplier | `Float`<br />(Default: 1.0)                  | **No**    | This multiplier is applied to the `StaminaCost`, if any.                        |
+
+**Knockback Fields**
+
+| Field Name     | Type                                       | Required? | Notes                                                                                                                      |
+| -------------- | ------------------------------------------ | --------- | -------------------------------------------------------------------------------------------------------------------------- |
+| Type           | `String`                                   | **No**    | If provided, specifies a type of knockback to use. Each knockback type may come with additional fields.                    |
+| Force          | `Double`<br />(Default: 0.0)               | **No**    | The amount of force to apply to the Owner entity.                                                                          |
+| Duration       | `Double`<br />(Default: 0.0)               | **No**    | If 0.0, apply the force as a single impulse.  If more, continuously apply the force over a period of time.                 |
+| VelocityType   | `ChangeVelocityType`<br />(Default: `Add`) | **No**    | How to apply the force, either adding it to the entity's current velocity, or setting the velocity to the knockback force. |
+| VelocityConfig | `VelocityConfig`                           | **No**    | Characteristics of friction as the Owner entity is thrown by this knockback.                                               |
+
+**Knockback Type: Force**
+
+Apply the calculated knockback force along the provided direction.
+
+| Field Name | Type                         | Required? | Notes                                                                                |
+| ---------- | ---------------------------- | --------- | ------------------------------------------------------------------------------------ |
+| Direction  | `Vector3`<br />(Default: Up) | **No**    | Which direction the player should be flung, relative to the direction of the attack. |
+
+**Knockback Type: Point**
+
+Apply the calculated knockback force laterally along the XZ plane, plus provided Y velocity.
+
+| Field Name | Type                        | Required? | Notes                                                                                                   |
+| ---------- | --------------------------- | --------- | ------------------------------------------------------------------------------------------------------- |
+| OffsetX    | `Integer`<br />(Default: 0) | **No**    | Offset the source position of the knockback left or right perpendicular to the direction of the attack. |
+| OffsetZ    | `Integer`<br />(Default: 0) | **No**    | Offset the source position of the knockback, forward or backward along the directon of the attack.      |
+| RotateY    | `Integer`<br />(Default: 0) | **No**    | Rotate the knockback direction around the Y axis, where 0 is the default attack direction.              |
+| VelocityY  | `Float`<br />(Default: 0.0) | **No**    | Add vertical velocity to the knockback force after the direction and force has been calculated.         |
+
+**Knockback Type: Directional**
+
+Apply the calculated knockback force along the attack direction, removing any vertical component and replacing it with a provided Y velocity.
+
+| Field Name | Type                      | Required? | Notes                                                                                                                                            |
+| ---------- | ------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------ |
+| RelativeX  | `Float`<br />(Default: 0) | **No**    | Apply additional force left or right perpendicular to the direction of the attack. The additional force is multiplied by the knockback strength. |
+| RelativeZ  | `Float`<br />(Default: 0) | **No**    | Apply additional force forward or backward along the attack direction. The additional force is multiplied by the knockback strength.             |
+| VelocityY  | `Float`<br />(Default: 0) | **No**    | Replace the vertical velocity of the knockback with this value.  This value is not multiplied by knockback strength.                             |
+
+**VelocityConfig Fields**
+
+| Field Name          | Type                                              | Required? | Notes                                                                                                                                                                                           |
+| ------------------- | ------------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| GroundResistance    | `Float`<br />(Default: 0.82)                      | **No**    | The minimum amount of friction applied when the entity is in contact with the ground.  1.0 = no friction, 0.0 = total friction                                                                  |
+| GroundResistanceMax | `Float`<br />(Default: 0.0)                       | **No**    | The maximum amount of friction applied when the entity is in contact with the ground.  1.0 = no friction, 0.0 = total friction                                                                  |
+| AirResistance       | `Float`<br />(Default: 0.96)                      | **No**    | The minimum amount of friction applied when the entity is in the air. 1.0 = no friction, 0.0 = total friction                                                                                   |
+| AirResistanceMax    | `Float`<br />(Default: 0.0)                       | **No**    | The maximum amount of friction applied when the entity is in the air. 1.0 = no friction, 0.0 = total friction                                                                                   |
+| Threshold           | `Float`<br />(Default: 1.0)                       | **No**    | The speed at which the maximum amount of friction will be applied to the entity. The amount of friction applied will increase from minimum to maximum as the entity moves from 0 to this speed. |
+| Style               | `VelocityThresholdStyle`<br />(Default: `Linear`) | **No**    | The curve that friction follows as the entity's speed increases toward the `Threshold`.                                                                                                         |
+
+**CostType Values**
+
+- `MaxHealthPercentage`
+- `Damage`
+
+**ChangeVelocityType Values**
+
+- `Add`
+- `Set`
+
+**VelocityThresholdStyle Values**
+
+- `Linear`
+- `Exp`
+
+## Blocks
+
+These are interaction types meant to reason about and modify blocks in the world.  The most important concept unique
+to these interactions is the Block Target.  Like the Entity Target, it is mutable and can come from many places.
+However, for interaction chains initiated by the client, the block target will initially be the block that the player's cursor was
+over, if any.
+
+Additionally, for interaction chains initiated by the client, the client will send along which face of the block is targeted,
+which is used by a few block-related interactions.
+It is left up to each interaction type that cares about block faces as to how to handle this behavior for simulated input
+(i.e. NPCs initiating chains that are normally initated by the client).  At the time of this writing, all block-related
+interactions choose the top face where relevant in simulated input.
+
+### BlockCondition
+
+This interaction has a field `Matchers` which specifies certain conditions, such as block type, state, etc.  This
+interaction fails if the current target block does not match all of them.
+
+**BlockCondition Fields**
+
+| Field Name       | Type                                        | Required? | Notes                                                                                                                                                                                                                                                                                                                                   |
+| ---------------- | ------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false)             | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction.                                                                                                                                                                                                       |
+| Matchers         | `Array`<br />(Element Type: `BlockMatcher`) | **Yes**   | A list of conditions that the target block must match or this condition will fail.<br />**Note: This field is technically not required but there is a bug that makes it dangerous to not provide at the time of this writing.**<br />**Note: If no conditions are added to this array, the interaction will fail, counterintuitively.** |
+
+**BlockMatcher Fields**
+
+| Field Name | Type                       | Required? | Notes                                                                          |
+| ---------- | -------------------------- | --------- | ------------------------------------------------------------------------------ |
+| Block      | `BlockIdMatcher`           | **No**    | If provided, requires the block itself match some set of conditions.           |
+| Face       | `BlockFace`                | **No**    | If provided and not 'None', requires a specific block face be targeted.        |
+| StaticFace | `Boolean` (Default: false) | **No**    | If false, the face condition will be adjusted by the block's current rotation. |
+
+**BlockFace Values**
+
+- `Up`
+- `Down`
+- `North`
+- `South`
+- `East`
+- `West`
+- `None`
+
+**BlockIdMatcher Fields**
+
+| Field Name | Type                                   | Required? | Notes                                                                      |
+| ---------- | -------------------------------------- | --------- | -------------------------------------------------------------------------- |
+| Id         | `Asset`<br />(Asset Type: `BlockType`) | **No**    | If provided, the block must match the specified `BlockType`.               |
+| State      | `String`                               | **No**    | If provided, the block's current state must match the provided state name. |
+| Tag        | `String`                               | **No**    | If provided, the block type's asset tags must contain the provided tag.    |
+
+### DestroyCondition
+
+This interaction fails if the current User entity cannot destroy the current target blcok.
+
+**DestroyCondition Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+
+### PlacementCountCondition
+
+This interaction accepts the name of a BlockType that has the TrackedPlacement BlockEntity. The interaction will fail if the number of
+blocks of the provided BlockType in the world do not match the provided condition.
+
+**PlacementCountCondition Fields**
+
+| Field Name | Type                           | Required? | Notes                                                                                                                                                                                                                                                           |
+| ---------- | ------------------------------ | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Block      | `String`                       | **Yes**   | The BlockType to examine. The number of instances of the BlockType in the world will be compared to Value.<br />**Note: The specified BlockType must have the TrackedPlacement BlockEntity. Otherwise, the number of blocks in the world will always be zero.** |
+| Value      | `Integer`<br />(Default: 0)    | **No**    | The value to compare the number of blocks in the world with.                                                                                                                                                                                                    |
+| LessThan   | \`Boolean<br />(Default: true) | **No**    | If true, the interaction will fail if the number of blocks in the world is greater than or equal to Value. If false, the interaction will fail if the number of blocks in the world is less than or equal to Value.                                             |
+
+### BreakBlock
+
+This interaction attempts to break the target block while acting as the User entity. The User entity must be a player. It
+is not guaranteed to work, depending on world settings and the User entity's current state, it may not work.  If it
+fails, it will fail the interaction under some circumstances, but not others.
+
+**Note: In particular, if `Harvest`=false and the player is in Survival mode, the player will simply execute a damage operation
+against the block. Even when the Tool field is specified, the player's currently-held item can impact the results in unintuitive
+ways.**
+
+This interaction will fail if there is no block target, if `Harvest`=true and the
+block is not harvestable, or if the world settings prevent the Harvest/Break operation.
+It will generally not fail otherwise, even if the block was not broken or damaged.
+The block will generally break every time if `Harvest`=true or the player is in
+Creative mode.
+
+**BreakBlock Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                                                                                                                                                                                                  |
+| ---------------- | ------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction.                                                                                                                                                                      |
+| Harvest          | `Boolean` (Default: false)      | **No**    | If true, harvest the block and deposit the drops in the player's inventory. This operation will generally always succeed.  If false, this interaction will effectively perform whatever action would have occurred if the player had left-clicked the block.                                           |
+| Tool             | `String`                        | **No**    | If `Harvest`=true, the player is in Survival mode, and this field is provided, then the break operation will be performed as though with this tool type.<br />**This field mostly doesn't work.  Your held item will be used for most block damage calculations regardless of this field's contents.** |
+| MatchTool        | `Boolean` (Default: false)      | **No**    | If true, `Harvest`=true, the player is in Survival mode, and `Tool` is provided, block breaking will be prevented unless `Tool` is a valid gathering tool for the target block. The interaction will not be failed, even if block breaking is prevented in this manner.                                |
+
+### ChangeBlock
+
+This interaction requires a mapping from one or more current BlockTypes to one or more target BlockTypes.  If the
+target block is one of the key BlockTypes, then it will be changed to the mapped target BlockType.  If the current
+BlockType of the target block does not appear as a key in the Changes field, then this interaction fails.
+
+**ChangeBlock Fields**
+
+| Field Name        | Type                                                        | Required? | Notes                                                                                                                             |
+| ----------------- | ----------------------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget  | `Boolean`<br />(Default: false)                             | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+| Changes           | `Map`<br />(Key Type: `BlockType`, Value Type: `BlockType`) | **No**    | A list of potential block type changes, with each entry having a current and new BlockType id.                                    |
+| WorldSoundEventId | `Asset`<br />(Asset Type: `SoundEvent`)                     | **No**    | If provided, this SoundEvent is played in the world at the position of the block if the block successfully changes.               |
+| RequireNotBroken  | `Boolean`<br />(Default: false)                             | **No**    | If true, this interaction will fail if the player's held item is broken (durability 0), and the block change will not take place. |
+
+### ChangeState
+
+This interaction requires a mapping from one or more current block state names to one or more state names. If the
+target block is in one of the key block states, then it will be changed to the mapped target blocks tate. If the
+current block state of the target block does nto appear as a key in the Changes field, then this interaction fails.
+
+All blocks start out with a null state by default.  This null state can be referenced by the key "default" and the block
+can be returned to that state with the value "default".
+
+**ChangeState Fields**
+
+| Field Name       | Type                                                  | Required? | Notes                                                                                                                                          |
+| ---------------- | ----------------------------------------------------- | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false)                       | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction.              |
+| Changes          | `Map`<br />(Key Type: `String`, Value Type: `String`) | **No**    | A list of potential block state changes, with each entry having a current and new state name.                                                  |
+| UpdateBlockState | `Boolean`<br />(Default: false)                       | **No**    | If true, performs a full refresh of the block's BlockEntity component and notifies nearby players as though a full block type change occurred. |
+
+### CycleBlockGroup
+
+This interaction will attempt to change the target block to the next block type in one of the BlockGroups it belongs to.
+If the block type belongs to multiple BlockGroups, which one is used is effectively arbitrary. The User entity must be
+a player. If the block cannot be changed for any reason (entity not a player, no block target, block does not belong
+to a BlockGroup, etc.). If the block is the only entry in the BlockGroup, this interaction will succeed and the block
+will be considered changed despite nothing happening.  Unlike most other block-changing interactions, this one will
+fail if the world settings prevent players from breaking blocks.
+
+**This interaction always reduces the player's held item's durability by a single 'hit' worth of damage if the block
+changes. There is no way to prevent it. The block type will change and the interaction will succeed even if the player's
+held item is broken, however.**
+
+**CycleBlockGroup Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+
+### DestroyBlock
+
+This interaction destroys the target block without dropping anything.  It will successfully destroy the block if the
+target block exists and this interaction has no failure conditions.
+
+**This interaction has no additional fields.**
+
+### PickBlock
+
+This interaction is effectively equivalent to using the middle mouse button in creative mode. In survival mode, the
+block's item will be moved to the user's current active hotbar slot if it is in the player's inventory.  This
+interaction is performed entirely on the client and cannot be performed by non-players.  It is unclear if this
+interaction has failure conditions.
+
+**PickBlock Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+
+### PlaceBlock
+
+This interaction is effectively identical to a right clicking while holding a block in their hand, with some
+additional options. For one, it can be executed with any LivingEntity as the User entity. For another, it has some
+useful fields.  For the most part, though, it follows the same behaviors and rules as any ordinary block placement
+by a player.
+
+It's not clear under what circumstances this interaction can fail. The server will not fail the interaction under any
+special circumstances (including when there is no target block, or when `BlockTypeToPlace` is not provided and the
+LivingEntity is not holding a block). However, the client is very involved with the function of this interaction and
+its behavior is unknown.
+
+**PlaceBlock Fields**
+
+| Field Name         | Type                                   | Required? | Notes                                                                                                                                                                                                                                                                                                                                                           |
+| ------------------ | -------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| BlockTypeToPlace   | `Asset`<br />(Asset Type: `BlockType`) | **No**    | If provided, the block placed by this interaction will be the specified BlockType. If not provided, the User entity's held item will be used, instead, if it is a block.                                                                                                                                                                                        |
+| RemoveItemInHand   | `Boolean`<br />(Default: True)         | **No**    | If true and the User entity is not a player in Creative mode, the item in the player's hand must match the block being placed and one quantity will be removed for each block placed. If the item does not match, the block cannot be placed.  If false, the player's hand item is ignored entirely.\*\*                                                        |
+| AllowDragPlacement | `Boolean`<br />(Default: True)         | **No**    | If true and the interaction was triggered on the client by a player, then the player can hold the input that was used to activate this interaction chain and move the mouse around in order to execute this interaction repeatedly and place several blocks. The interaction chain will not move onto the next interaction until the player releases the input. |
+
+### RunOnBlockTypes
+
+This interaction retrieves all blocks within a provided radius of the User entity. For each block that matches any of
+the provided BlockSets, a new interaction chain will be forked that uses the matching block as the target block.
+This interaction will continue executing until all forked interaction chains have completed.  The interaction will fail if no
+blocks within the radius match the provided BlockSets or if all of the forked interaction chains fail.
+
+**RunOnBlockTypes Fields**
+
+| Field Name   | Type                                         | Required?        | Notes                                                                                                                                                                                                                                                                                      |
+| ------------ | -------------------------------------------- | ---------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| Range        | `Integer`                                    | **Yes**          | The spherical radius around the User entity to search for blocks. Must be at least 1.                                                                                                                                                                                                      |
+| BlockSets    | `AssetArray`<br />(Element Type: `BlockSet`) | **No**           | A list of BlockSets to match nearby blocks again. Only blocks that match any of the BlockSets will have interaction chains forked for them.                                                                                                                                                |
+| MaxCount     | `Integer`                                    | **Yes**          | The maximum number of blocks that will be located with the search. Further blocks will be ignored. If there are more matching blocks within the radius than this number, the specific set of blocks that will be found is completely arbitrary and may change from execution to execution. |
+| Interactions | `Asset`<br />(Asset Type: `RootInteraction`) | **No, but yes.** | The RootInteraction that will be forked for each matching block.  This interaction will not fail to validate if it is missing, but every execution of this interaction will fail.                                                                                                          |
+
+### UseBlock
+
+If the target block has an interaction for this interaction chain's interaction type, execute it immediately as part of
+this interaction chain. The execution will be wrapped in UseBlockEvent.Pre and UseBlockEvent.Post events, and cancellations
+of the UserBlockEvent.Pre event are respected. The User entity is considered the triggering entity for both events.
+
+If the target block does not have an interaction for this interaction chain's interaction type, this interaction fails.
+
+**This interaction has no additional fields.**
+
+## Items
+
+These are interactions intended to interface with an entity's inventory. There is no concept of an "item target",
+unfortunately, so these generally either interact with the entity's held item or the entity's inventory at a high level.
+
+### AddItem
+
+Adds a specified quantity of a specified item to the User entity's inventory, preferring to add it to the
+entity's hotbar where possible. This interaction will have no effect on User entities that are not LivingEntities.
+This interaction has no failure states.
+
+**Note: This interaction has a bug in its field validators that will cause interactions that reference items declared
+in the same mod to fail validation on startup.  Additionally, this interaction has a bug that will cause it to
+fail and have no effect if the User entity has no block target. Use ModifyInventory instead.**
+
+**AddItem Fields**
+
+| Field Name       | Type                              | Required? | Notes                                                                                                                             |
+| ---------------- | --------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false)   | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+| ItemId           | `Asset`<br />(Asset Type: `Item`) | **Yes**   | The item id of the item to add to the player's inventory.                                                                         |
+| Quantity         | `Integer`<br />(Default: 0)       | **No**    | The quantity of the item to add to the player's inventory.                                                                        |
+
+### CheckUniqueItemUsage
+
+This interaction will check whether it has run once for the User entity with their currently-held item before. If it hasn't,
+it will succeed. If it has, it will fail. It will also fail if the User entity is not a player. The interaction will record
+the item id of the User entity's currently-held item on success, ensuring it cannot be successfully run with that player
+and item id combination again.
+
+**This interaction has no additional fields.**
+
+### ChangeActiveSlot
+
+This interaction does not inherit from SimpleInteraction and therefore has no Next or Failed fields.  The `CancelOnItemChange`
+field is ignored for this interaction and is always treated as false. This interaction will set the User entity's currently-
+active hotbar slot to the specified slot index. If none is specified, the interaction chain's target slot will be used,
+if any. Otherwise, slot 0 will be used.  If a slot is specified and it is already active, then this interaction will
+have no effect, but if no slot is specified and the interaction chain's target slot is already active, the logic in
+the next paragraph will still be executed. This interaction will also have no effect if the User entity is not a
+LivingEntity.
+
+Once the slot has changed, a new SwapTo interaction chain will be forked off for the selected slot.
+If a target slot was specified, then the interaction chain's current target slot will be set to the specified slot, as will
+the forked SwapTo interaction chain. If this interaction chain was initiated by a player swapping an item into or out of
+an occupied active hotbar slot, then the swap will be executed after the slot is changed and before the SwapTo
+interaction is forked. Not running this interaction in the resulting SwapFrom interaction chain is a way for the server
+to cancel players performing these sorts of swap interactions. The default behavior for these swap interactions is that
+the SwapFrom interaction chain will be initiated with the currently-active-slot as the target slot. As a result, the
+target slot will usually not change when this interaction runs, it merely exists as a signal for the server to continue the
+item swap.
+
+**ChangeActiveSlot Fields**
+
+| Field Name | Type      | Required? | Notes                                                                                                                                                                                                     |
+| ---------- | --------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| TargetSlot | `Integer` | **No**    | If not provided, indicates the slot the player's active hotbar slot should be changed to.  Otherwise, the interaction chain's target slot will be used (which is usually the already-active hotbar slot). |
+
+### EquipItem
+
+This interaction will equip the User entity's currently-held item into the appropriate armor slot, if it is armor. The
+interaction will fail if the item is armor but it cannot be equipped for some reason. The interaction will succeed but
+take no action if the User entity cannot equip armor or if the item is not armor.
+
+**This interaction has no additional fields.**
+
+### IncreaseBackpackCapacity
+
+This interaction will increase the User entity's backpack size by the provided amount.  **It will additionally remove one
+quantity from the player's currently-held item. There is no way to prevent this.**  This interaction will have no effect
+if the User entity is not a player.  This interaction has no special failure conditions, even if the User entity
+is not a player, or the player is not currently holding an item.
+
+| Field Name | Type                        | Required? | Notes                                                                                   |
+| ---------- | --------------------------- | --------- | --------------------------------------------------------------------------------------- |
+| Capacity   | `Integer`<br />(Default: 1) | **No**    | The additional backpack capacity to add to the player. **Must be between 1 and 32767.** |
+
+### ModifyInventory
+
+This interaction attempts to perform one or more inventory-modifying actions against the User entity. The User entity must
+be a player. If they are not, no actions will be performed, but the interaction will not fail. Any item removals performed
+by this interaction, either as a result of `ItemToRemove` or `AdjustHeldItemQuantity`, are both atomic (meaning the entire
+quantity must be removed, or none) and required (meaning that the interaction will fail and no further actions taken if
+the removal fails for any reason).  Item additions performed by this interaction, either as a result of `ItemToAdd` or
+`AdjustHeldItemQuantity` will drop excess items on the ground near the player if necesary and continue on.
+
+This interaction first executes the item removal in `ItemToRemove`, if any, then adjusts the held item as specified by
+`AdjustHeldItemQuantity`, if provided, then executes the item addition in `ItemToAdd`, if any, and then finally executes
+the damage/healing of the held item in `AdjustHeldItemDurability`, if provided.
+
+**ModifyDurability Fields**
+
+| Field Name               | Type                            | Required? | Notes                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
+| ------------------------ | ------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| RequiredGameMode         | `GameMode`                      | **No**    | If provided, only execute the inventory-modifying actions if the player is in the provided GameMode. The interaction will not fail if the GameMode doesn't match.                                                                                                                                                                                                                                                                                                                                                                               |
+| ItemToRemove             | `ItemStack`                     | **No**    | If provided, a matching item will be removed in the provided quantity. If there is no matching item in the player inventory in the required quantity, then the interaction will fail and further actions will not be executed.                                                                                                                                                                                                                                                                                                                  |
+| AdjustHeldItemQuantity   | `Integer`<br />(Default: 0)     | **No**    | The player's held item, if any, will have its quantity will be modified by the provided amount- subtracted from if this number is negative or added to if this item is positive.  If the player has no held item, then this field will have no effect regardless of its value and the interaction will NOT fail.  If the player's inventory does not have sufficient quantity of items to support the removal, this interaction will fail and further actions will not be executed. Excess items will be dropped on the ground near the player. |
+| ItemToAdd                | `ItemStack`                     | **No**    | If provided, the ItemStack will be added to the player's inventory. Excess items will be dropped on the ground near the player.                                                                                                                                                                                                                                                                                                                                                                                                                 |
+| AdjustHeldItemDurability | `Double`<br />(Default: 0.0)    | **No**    | The player's held item, if any, will have its durability adjusted by the specified amount.  The durability cannot go below 0 or raise above the item's maximum durability. Invalid durability values in this field will not cause the interaction to fail. Neither will it fail if the player has no held item.                                                                                                                                                                                                                                 |
+| BrokenItem               | `String`                        | **No**    | This field should contain an ItemId, but it is not validated by the server on startup, so be careful.  This field can have the value of "Empty" to specify no item, or an empty hand. If specified and the `AdjustHeldItemDurability` operation reduces the player's held item to 0 durability, the player's held item is changed to this ItemId. If the inventory replacement fails, this interaction will fail.                                                                                                                               |
+| NotifyOnBreak            | `Boolean`<br />(Default: false) | **No**    | If true and the `AdjustHeldItemDurability` operation reduces the player's held item to 0 durability, this interaction will perform the usual audiovisual feedback of a broken tool. It will play the usual tool breaking sound and send the player a text message in chat that their item has broken.                                                                                                                                                                                                                                           |
+| NotifyOnBreakMessage     | `String`                        | **No**    | If provided, and `NotifyOnBreak` is true, when the player is notified of a broken tool by this interaction, the message sent to their chat will instead be the translation key specified by this field. The translation key supports the templating parameter `{itemName}`. See the translation key `server.general.repair.itemBroken_Hoe` for an example.                                                                                                                                                                                      |
+
+**GameMode Values**
+
+- `Creative`: The game is currently in Creative Mode
+- `Adventure`: The game is currently in Adventure Mode
+
+**ItemStack Fields**
+
+| Field Name                   | Type                              | Required? | Notes                                                                                |
+| ---------------------------- | --------------------------------- | --------- | ------------------------------------------------------------------------------------ |
+| Id                           | `Asset`<br />(Asset Type: `Item`) | **Yes**   | The id of the Item asset this stack contains.                                        |
+| Quantity                     | `Integer`<br />(Default: 1)       | **No**    | The number of items in this stack.<br />**Must be greater than 0.**                  |
+| Durability                   | `Double`<br />(Default: 0.0)      | **No**    | The durability of the item stack.<br />**Cannot be negative.**                       |
+| MaxDurability                | `Double`<br />(Default: 0.0)      | **No**    | The maximum durability of the item this stack contains.<br />**Cannot be negative.** |
+| Metadata                     | `Bson Document`                   | **No**    | If provided, applies the bson to the item stack metadata.                            |
+| OverrideDroppedItemAnimation | `Boolean`\*(Default: false)       | **No**    | ???                                                                                  |
+
+### PickupItem
+
+This interaction will attempt to pick up the User entity's current target entity and add it to their inventory. It will
+fail if the User entity is not a player, if they do not have a target entity, or if the target entity is not an item
+located in the world.  It will not fail if the player simply cannot pick up the item.
+
+**This interaction has no additional fields.**
+
+### RefillContainer
+
+This interaction will fail if the User entity is not a player. The interaction will draw a ray from the player's head
+down their look direction until the edge of the player's held item's interaction range or until the first solid block.
+The nearest fluid block of a type listed in this interaction's `States` map will result in the one of the player's
+currently-held items being converted to the fluid's related item state.  If the `States` map indicates a durability
+for the new item state, then the converted item will use that durability. If the item is already in the fluid's related
+item state, then this interaction will fail if the player's held item is already at maximum durability (unless the
+`States` map indicates a durability value greater than the item's maximum, in which case the interaction will succeed
+but the item will not change).  Otherwise, the durability listed for the fluid in the `States` map will be added to the
+item's current durability.
+
+If the interaction has not failed by this point, the fluid block in the world may be transformed to a different type if one is listed
+in the `States` map.
+
+If any part of this process does not proceed for any reason (for instance, if the player is not holding an item),
+then this interaction will fail.
+
+**RefillContainer Fields**
+
+| Field Name | Type                                                       | Required? | Notes                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| ---------- | ---------------------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| States     | `Map`<br />(Key Type: `String`, Value Type: `RefillState`) | **Yes**   | A map from item state names to `RefillState` objects, which contain information such as acceptable fluid block types, durability increases, and what fluid type to convert the targeted fluid block to after refill, if any. If the player targets a fluid block that matches one of the fluid types in the `RefillState`, the item will be converted to the keyed item state and the `RefillState` will be used to decide what happens next. |
+
+**RefillState Fields**
+
+| Field Name     | Type                                  | Required? | Notes                                                                                                                                                                                                                                                                                                                           |
+| -------------- | ------------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| AllowedFluids  | `Array`<br />(Element Type: `String`) | **Yes**   | If any of these fluids are targeted by the player, the player's held item will be converted to the keyed item state and `Durability` and `TransformFluid` will be used.                                                                                                                                                         |
+| Durability     | `Double`<br />(Default: -1.0)         | **No**    | If the player's held item changes item states, this value is the new item's durability, unless it is negative, in which case the item will begin at full durability. If the player's held item is already in the item state, and the item is not already at full durability, this value will be added to the item's durability. |
+| TransformFluid | `String`                              | **No**    | If provided, this field is a fluid id that the targeted fluid block should be transformed to if the player's held item is successfully updated.                                                                                                                                                                                 |
+
+## Entities
+
+### DamageEntity
+
+This interaction does not inherit from SimpleInteraction, but adds its own Next and Failed fields that
+work similarly.
+
+This interaction will cause the User entity to damage the Target entity.  It has the capability to apply different
+damage based on the direction of the attack or what body part was targeted by the User entity, with each possibility
+providing different damage calculations, effects, and Next interaction. If multiple entires match the attack, `TargetedDamage`
+(body part damage) takes highest priority, then the first matching `AngledDamage` in the list, then the default
+damage in the base interaction fields.  It is possible for elements of these different damage priorities to be taken peacemeal if higher-priority
+damage fields do not overwrite lower-priority damage fields. For instance,
+damage calculation could be taken from `TargetedDamage`, the damage effects could be taken from the first matching
+`AngledDamage`, and the Next interaction coming from the default damage field.
+
+If all damage dealt by this interaction is cancelled, then this interaction will fail, and the `Failed` interaction
+will be executed next in the chain. If any damage dealt by this interaction is blocked, then this interaction will
+succeed, but the `Blocked` interaction wil lbe executed next in the chain. Otherwise, the highest-precedent matching
+`Next` interaction that you provide will be executed.  For instance, if you provide `Next` interactions for all
+`TargetedDamage` and `AngledDamage` entries, and one in the interaction's `Next` field, then a headshot could result
+in a unique `Next` interaction being executed, even if there is a matching `AngledDamage` entry. However, if you leave
+the `Next` interaction out of your `TargetedDamage` entries, a special `Next` interaction for backstabs could be
+executed.  Otherwise, the `Next` field in the root of the interaction will be executed instead.
+
+DamageEntity has an unusual relationship with `RunTime`. This interaction always ends immediately after its first tick,
+regardless of the status of `RunTime` or `WaitForAnimationToFinish`.  However, if damage dealt by this interaction is
+calculated as `DamageCalculatorType` `Dps`, then the `RunTime` will be used to determine the precise amount of damage to
+deal. If `RunTime` is 0, then no damage will be dealt.
+
+**DamageEntity Fields**
+
+| Field Name       | Type                                                          | Required?                                                                                                                    | Notes                                                                                                                                                                                                                                                                                                                                                                         |
+| ---------------- | ------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| DamageCalculator | `DamageCalculator`                                            | **No**                                                                                                                       | If provided, describes the damage amounts and types to apply to the Target entity.                                                                                                                                                                                                                                                                                            |
+| DamageEffects    | `DamageEffects`                                               | **No**                                                                                                                       | If provided, describes particles, sounds, knockback, etc. to apply to the target entity on damage.                                                                                                                                                                                                                                                                            |
+| Next             | `Asset`<br />(Asset Type: `Interaction`)                      | **No**  After this interaction has finished, "Next" will be executed if damage was dealt to the target and none was blocked. |                                                                                                                                                                                                                                                                                                                                                                               |
+| AngledDamage     | `Array`<br />(Element Type: `AngledDamage`)                   | **No**                                                                                                                       | If provided, allows alternative `DamageCalculator`, `DamageEffects`, and `Next` entries for attacks that approach the target from certain angles.                                                                                                                                                                                                                             |
+| TargetedDamage   | `Map`<br />(Key Type: `String`, Value Type: `TargetedDamage`) | **Yes**                                                                                                                      | This field must be provided, but is not required to have any entries.  This is a map from body part names to `TargetedDamage` values. Hypixel only uses one body part name: `Head`, and it is not clear whether there are others.  If provided, allows alternative `DamageCalculator`, `DamageEffects`, and `Next` entries for attacks that damage specific enemy body parts. |
+| EntityStatsOnHit | `Array`<br />(Element Type: `EntityStatOnHit`)                | **No**                                                                                                                       | If provided, allows this attack to reduce enemy stats other than health.  Each individual damage application dealt by the same ability will apply stat reductions, at diminishing returns. All damage dealt in interaction chains forked by a Selector interaction will share the number of hits across all targets.                                                          |
+| Failed           | `Asset`<br />(Asset Type: `Interaction`)                      | **No**                                                                                                                       | After this interaction has finished, "Failed" will be executed if no damage hits were applied to the player, or if all damage hits were cancelled.                                                                                                                                                                                                                            |
+| Blocked          | `Asset`<br />(Asset Type: `Interaction`)                      | **No**                                                                                                                       | After this interaction has finished, "Blocked" will be executed if any damage hits were blocked by the target.                                                                                                                                                                                                                                                                |
+
+**DamageCalculator Fields**
+
+| Field Name                | Type                                                      | Required? | Notes                                                                                                                                                                                                                                                 |
+| ------------------------- | --------------------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Type                      | `DamageCalculatorType`<br />(Default: Absolute)           | **No**    | Whether the damage being applied is `Absolute` or \`Dps'.                                                                                                                                                                                             |
+| Class                     | `DamageClass`<br />(Default: Unknown)                     | **No**    | The type of attack producing the damage. Some weapon systems apply equipment modifiers based on this value.                                                                                                                                           |
+| BaseDamage                | `Map`<br />(Key Type: `DamageCause`, Value Type: `Float`) | **No**    | A set of DamageCauses and how much base damage is dealt for each.                                                                                                                                                                                     |
+| SequentialModifierStep    | `Float`<br />(Default: 0.0)                               | **No**    | Value between 0.0-1.0. Each additional hit from a single ability will have its damage reduced by this much as a percentage. All damage dealt in interaction chains forked by a Selector interaction will share the number of hits across all targets. |
+| SequentialModifierMinimum | `Float`<br />(Default: 0.0)                               | **No**    | Value between 0.0-1.0. `SequentialModifierStep` cannot reduce damage below this percentage regardless of the number of hits.                                                                                                                          |
+| RandomPercentageModifier  | `Float`<br />(Default: 0.0)                               | **No**    | A random value between +/- this amount multiplied by the base damage will be added to the base damage.                                                                                                                                                |
+
+**DamageEffects Fields**
+
+| Field Name             | Type                                         | Required? | Notes                                                                                   |
+| ---------------------- | -------------------------------------------- | --------- | --------------------------------------------------------------------------------------- |
+| ModelParticles         | `Array`<br />(Element Type: `ModelParticle`) | **No**    | Particle systems to trigger in the first-person view.                                   |
+| WorldParticles         | `Array`<br />(Element Type: `WorldParticle`) | **No**    | Particle systems to trigger in the third-person view.                                   |
+| LocalSoundEventId      | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | 2D sound to play locally to the attacking entity if they are a player.                  |
+| WorldSoundEventId      | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | Sound to play in the world at the Target entity's location.                             |
+| PlayerSoundEventId     | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | 2D sound to play locally to the Target entity if they are a player.                     |
+| ViewDistance           | `Double`<br />(Default: 75.0)                | **No**    | Distance at which these effects should play for other players.                          |
+| Knockback              | `Knockback`                                  | **No**    | The properties of the knockback that will be applied.                                   |
+| CameraEffect           | `Asset`<br />(Asset Type: `CameraEffect`)    | **No**    | CameraEffect to briefly apply locally to the Target entity if they are a player.        |
+| StaminaDrainMultiplier | `Float`<br />(Default: 1.0)                  | **No**    | This multiplier is applied to the stamina cost incurred by the target blocking, if any. |
+
+**AngledDamage Fields**
+
+| Field Name       | Type                                     | Required? | Notes                                                                                                                                                                                                     |
+| ---------------- | ---------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| AngleDistance    | `Float`<br />(Default: 0)                | **No**    | The width in degrees of the matching arc around the Target entity. If the attack against the Target originates from within the arc, then the properties below will be applied to the attack, if provided. |
+| Angle            | `Float`<br />(Default: 0.0)              | **No**    | The angle in degrees around the Target entity at which the matching arc is centered.                                                                                                                      |
+| DamageCalculator | `DamageCalculator`                       | **No**    | If provided and the attack against the Target entity originates from within the provided arc, this DamageCalculator will override the interaction's `DamageCalculator` field.                             |
+| DamageEffects    | `DamageEffects`                          | **No**    | If provided and the attack against the Target entity originates from within the provided arc, this DamageEffects will override the interaction's `DamageEffects` field.                                   |
+| Next             | `Asset`<br />(Asset Type: `Interaction`) | **No**    | If provided and the attack against the Target entity originates from within the provided arc, this Interaction will override the interaction's `Next` field.                                              |
+
+**TargetedDamage Fields**
+
+| Field Name       | Type                                     | Required? | Notes                                                                                                                                                                                            |
+| ---------------- | ---------------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| DamageCalculator | `DamageCalculator`                       | **No**    | If provided and this TargetedDamage was matched, this DamageCalculator will override the interaction's `DamageCalculator` field and the `DamageCalculator` field of any matching `AngledDamage`. |
+| DamageEffects    | `DamageEffects`                          | **No**    | If provided and this TargetedDamage was matched, this DamageEffects will override the interaction's `DamageEffects` field and the `DamageEffects` field of any matching `AngledDamage`.          |
+| Next             | `Asset`<br />(Asset Type: `Interaction`) | **No**    | If provided and this TargetedDamage was matched, this Interaction will override the interaction's `Next` field and the `Next` field of any matching `AngledDamage`.                              |
+
+**EntityStatOnHit Fields**
+
+| Field Name                  | Type                                                                       | Required? | Notes                                                                                                                                                                                                                                                                                        |
+| --------------------------- | -------------------------------------------------------------------------- | --------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| EntityStatId                | `Asset`<br />(AssetType: `EntityStatType`)                                 | **Yes**   | Which entity stat to affect.                                                                                                                                                                                                                                                                 |
+| Amount                      | `Float`<br />(Default: 0.0)                                                | **No**    | How much of the stat to apply for each damage application. Use negative numbers to reduce stats.                                                                                                                                                                                             |
+| MultipliersPerEntitiesHit   | `Array`<br />(Element Type: `Float`, Default: `[1.0, 0.6, 0.4, 0.2, 0.1]`) | **No**    | The diminishing returns curve to be applied for multiple damage applications by the same ability. Each hit's stat impact will be multiplied by the next value in the list.  If there are more hits than array elements, subsequent hits will be multiplied by `MultiplierPerExtraEntityHit`. |
+| MultiplierPerExtraEntityHit | `Float`<br />(Default: 0.05)                                               | **No**    | If an ability carries out more damage applications than there are elements in the `MultipliersPerEntitiesHit` array, then subsequent stat values will be multiplied by this number.                                                                                                          |
+
+**Knockback Fields**
+
+| Field Name     | Type                                       | Required? | Notes                                                                                                                      |
+| -------------- | ------------------------------------------ | --------- | -------------------------------------------------------------------------------------------------------------------------- |
+| Type           | `String`                                   | **No**    | If provided, specifies a type of knockback to use. Each Target type may come with additional fields.                       |
+| Force          | `Double`<br />(Default: 0.0)               | **No**    | The amount of force to apply to the Owner entity.                                                                          |
+| Duration       | `Double`<br />(Default: 0.0)               | **No**    | If 0.0, apply the force as a single impulse.  If more, continuously apply the force over a period of time.                 |
+| VelocityType   | `ChangeVelocityType`<br />(Default: `Add`) | **No**    | How to apply the force, either adding it to the entity's current velocity, or setting the velocity to the knockback force. |
+| VelocityConfig | `VelocityConfig`                           | **No**    | Characteristics of friction as the Owner entity is thrown by this knockback.                                               |
+
+**Knockback Type: Force**
+
+Apply the calculated knockback force along the provided direction.
+
+| Field Name | Type                         | Required? | Notes                                                                                |
+| ---------- | ---------------------------- | --------- | ------------------------------------------------------------------------------------ |
+| Direction  | `Vector3`<br />(Default: Up) | **No**    | Which direction the entity should be flung, relative to the direction of the attack. |
+
+**Knockback Type: Point**
+
+Apply the calculated knockback force laterally along the XZ plane, plus provided Y velocity.
+
+| Field Name | Type                        | Required? | Notes                                                                                                   |
+| ---------- | --------------------------- | --------- | ------------------------------------------------------------------------------------------------------- |
+| OffsetX    | `Integer`<br />(Default: 0) | **No**    | Offset the source position of the knockback left or right perpendicular to the direction of the attack. |
+| OffsetZ    | `Integer`<br />(Default: 0) | **No**    | Offset the source position of the knockback, forward or backward along the directon of the attack.      |
+| RotateY    | `Integer`<br />(Default: 0) | **No**    | Rotate the knockback direction around the Y axis, where 0 is the default attack direction.              |
+| VelocityY  | `Float`<br />(Default: 0.0) | **No**    | Add vertical velocity to the knockback force after the direction and force has been calculated.         |
+
+**Knockback Type: Directional**
+
+Apply the calculated knockback force along the attack direction, removing any vertical component and replacing it with a provided Y velocity.
+
+| Field Name | Type                      | Required? | Notes                                                                                                                                            |
+| ---------- | ------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------ |
+| RelativeX  | `Float`<br />(Default: 0) | **No**    | Apply additional force left or right perpendicular to the direction of the attack. The additional force is multiplied by the knockback strength. |
+| RelativeZ  | `Float`<br />(Default: 0) | **No**    | Apply additional force forward or backward along the attack direction. The additional force is multiplied by the knockback strength.             |
+| VelocityY  | `Float`<br />(Default: 0) | **No**    | Replace the vertical velocity of the knockback with this value.  This value is not multiplied by knockback strength.                             |
+
+**VelocityConfig Fields**
+
+| Field Name          | Type                                              | Required? | Notes                                                                                                                                                                                           |
+| ------------------- | ------------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| GroundResistance    | `Float`<br />(Default: 0.82)                      | **No**    | The minimum amount of friction applied when the entity is in contact with the ground.  1.0 = no friction, 0.0 = total friction                                                                  |
+| GroundResistanceMax | `Float`<br />(Default: 0.0)                       | **No**    | The maximum amount of friction applied when the entity is in contact with the ground.  1.0 = no friction, 0.0 = total friction                                                                  |
+| AirResistance       | `Float`<br />(Default: 0.96)                      | **No**    | The minimum amount of friction applied when the entity is in the air. 1.0 = no friction, 0.0 = total friction                                                                                   |
+| AirResistanceMax    | `Float`<br />(Default: 0.0)                       | **No**    | The maximum amount of friction applied when the entity is in the air. 1.0 = no friction, 0.0 = total friction                                                                                   |
+| Threshold           | `Float`<br />(Default: 1.0)                       | **No**    | The speed at which the maximum amount of friction will be applied to the entity. The amount of friction applied will increase from minimum to maximum as the entity moves from 0 to this speed. |
+| Style               | `VelocityThresholdStyle`<br />(Default: `Linear`) | **No**    | The curve that friction follows as the entity's speed increases toward the `Threshold`.                                                                                                         |
+
+**DamageCalculatorType Values**
+
+- `Absolute`
+- `Dps`
+
+**DamageClass Values**
+
+- `Unknown`
+- `Light`
+- `Charged`
+- `Signature`
+
+**ChangeVelocityType Values**
+
+- `Add`
+- `Set`
+
+**VelocityThresholdStyle Values**
+
+- `Linear`
+- `Exp`
+
+### LaunchProjectile
+
+This is just a worse version of Projectile and is slated to be removed.  Use Projectile.
+
+### Projectile
+
+This interaction will spawn a new projectile at the User entity's eye position that will travel in its look direction.
+
+| Field Name | Type                                          | Required? | Notes                                                  |
+| ---------- | --------------------------------------------- | --------- | ------------------------------------------------------ |
+| Config     | `Asset`<br />(Asset Type: `ProjectileConfig`) | **No**    | Configuration describing the projectile to be spawned. |
+
+### RemoveEntity
+
+Despawns the specified entity from the world. This interaction will have no effect if the specified entity is a player. This
+interaction has no special failure conditions.
+
+| Field Name | Type                                     | Required? | Notes                  |
+| ---------- | ---------------------------------------- | --------- | ---------------------- |
+| Entity     | `InteractionTarget`<br />(Default: User) | **No**    | The entity to despawn. |
+
+**InteractionTarget Values**
+
+- `User` - The user of this interaction chain. The entity whose actions caused this interaction chain to be executed. This is usually the same as the Owner.
+- `Owner` - The owner of this interaction chain. The entity upon whom this interaction chain is executing.
+- `Target` - The entity target of this interaction chain, if any.  This value is mutable (and can therefore come from many places) but most commonly, it is an entity the User was targeting when this interaction chain began executing.
+
+### SendMessage
+
+This interaction sends a message to the Owner entity if that entity can receive messages.  Otherwise, the message
+is written to the server logs.  If the entity is a player, the message will appear in the player's chat window.
+
+\*\*SendMessage
+
+| Field Name | Type     | Required? | Notes                                                                                                                 |
+| ---------- | -------- | --------- | --------------------------------------------------------------------------------------------------------------------- |
+| Message    | `String` | **No**    | A text message to be sent to the Owner entity.  If this field is not provided, `Key` is used instead.                 |
+| Key        | `String` | **No**    | A translation key for a message to be sent to the Owner entity. If `Message` is provided, then this field is ignored. |
+
+### UseEntity
+
+This interaction is not in use by Hypixel and has some unusual qualities that mean it probably won't do what you want it
+to.  Do not use it.
+
+This interaction will retrieve the entity currently targeted by the client (NOT the interaction chain's current Target
+entity) and execute that entity's RootInteraction for this interaction chain's current interaction type. The
+RootInteraction will be executed as part of this current interaction chain. None of the properties of this interaction
+chain will be modified.
+
+This interaction will fail if the client is not currently targeting an entity, or if no interaction for the current
+interaction type exists on the entity.
+
+## Stats
+
+Hytale's resource system has been written about fairly extensively.  You can use these interactions to modify stats in
+response to actions or use stats as a cost for abilities.
+
+### ChangeStat
+
+This interaction applies a set of raw stat changes to the User entity. It has no special failure conditions.
+
+| Field Name    | Type                                                         | Required? | Notes                                                                                                                                                                                                                      |
+| ------------- | ------------------------------------------------------------ | --------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| StatModifiers | `Map`<br />(Key Type: `EntityStatType`, Value Type: `Float`) | **Yes**   | A set of stats to modify and what value to apply to them.                                                                                                                                                                  |
+| ValueType     | `ValueType`<br />(Default: Absolute)                         | **No**    | Whether the values in the `StatModifiers` map represent flat values to apply to the stat total, or percentages (0.0-100.0). Percentage values are percentage of the difference between the maximum and minimum stat value. |
+| Behaviour     | `ChangeStatBehavior`<br />(Default: Add)                     | **No**    | Whether the values in the `StatModifiers` map represent deltas to add into the User entity's current stat values, or fixed values to set the entity's stats to.                                                            |
+
+**ValueType Values**
+
+- `Absolute`
+- `Percent`
+
+**ChangeStatBehaviour Values**
+
+- `Add`
+- `Set`
+
+### ChangeStatWithModifier
+
+This interaction is like ChangeStat, except an armor stat modifier can be chosen which will apply bonuses and penalties
+to a stat from the User entity's equipped armor before it is applied.
+
+| Field Name            | Type                                                         | Required? | Notes                                                                                                                                                                                                                      |
+| --------------------- | ------------------------------------------------------------ | --------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| StatModifiers         | `Map`<br />(Key Type: `EntityStatType`, Value Type: `Float`) | **Yes**   | A set of stats to modify and what value to apply to them.                                                                                                                                                                  |
+| ValueType             | `ValueType`<br />(Default: Absolute)                         | **No**    | Whether the values in the `StatModifiers` map represent flat values to apply to the stat total, or percentages (0.0-100.0). Percentage values are percentage of the difference between the maximum and minimum stat value. |
+| Behaviour             | `ChangeStatBehavior`<br />(Default: Add)                     | **No**    | Whether the values in the `StatModifiers` map represent deltas to add into the User entity's current stat values, or fixed values to set the entity's stats to.                                                            |
+| InteractionModifierId | `InteractionModifierId`                                      | **Yes**   | The armor interaction modifier to apply bonuses and penalties for.                                                                                                                                                         |
+
+**ValueType Values**
+
+- `Absolute`
+- `Percent`
+
+**ChangeStatBehaviour Values**
+
+- `Add`
+- `Set`
+
+**InteractionModifierId Values**
+
+- `Dodge`
+
+### StatsCondition
+
+This interaction will fail if the User entity cannot afford the specified stats costs, or if it does not have the
+requested stats.
+
+| Field Name | Type                                                         | Required? | Notes                                                                                                                                                                                    |
+| ---------- | ------------------------------------------------------------ | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Costs      | `Map`<br />(Key Type:` EntityStatType`, Value Type: `Float`) | **Yes**   | A set of costs that the User entity needs to be able to afford for this interaction to succeed.                                                                                          |
+| ValueType  | `ValueType`<br />(Default: Absolute)                         | **No**    | Whether the values in the `Costs` map represetn flat values or percentages (0.0-100.0).  Percentage values are percentage of the difference between the maximum and minimum value.       |
+| LessThan   | `Boolean`<br />(Default: false)                              | **No**    | If true, this interaction will fail unless the User entity's current stat values are at or **below** the specified levels.  If false, they must be at or **above** the specified levels. |
+| Lenient    | `Boolean`<br />(Default: false)                              | **No**    | If true and `LessThan` is true, and a player's minimum stat value is below zero, then the player can afford a stat cost if the current value of a stat if above 0.                       |
+
+**ValueType Values**
+
+- `Absolute`
+- `Percent`
+
+### StatsConditionWithModifier
+
+This interaction is like StatsCondition, except an armor stat modifier can be chosen which will apply bonuses and penalties
+to a stat's cost from the User entity's equipped armor before it is compared.
+
+| Field Name            | Type                                                         | Required? | Notes                                                                                                                                                                                    |
+| --------------------- | ------------------------------------------------------------ | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Costs                 | `Map`<br />(Key Type:` EntityStatType`, Value Type: `Float`) | **Yes**   | A set of costs that the User entity needs to be able to afford for this interaction to succeed.                                                                                          |
+| ValueType             | `ValueType`<br />(Default: Absolute)                         | **No**    | Whether the values in the `Costs` map represetn flat values or percentages (0.0-100.0).  Percentage values are percentage of the difference between the maximum and minimum value.       |
+| LessThan              | `Boolean`<br />(Default: false)                              | **No**    | If true, this interaction will fail unless the User entity's current stat values are at or **below** the specified levels.  If false, they must be at or **above** the specified levels. |
+| Lenient               | `Boolean`<br />(Default: false)                              | **No**    | If true and `LessThan` is true, and a player's minimum stat value is below zero, then the player can afford a stat cost if the current value of a stat if above 0.                       |
+| InteractionModifierId | `InteractionModifierId`                                      | **Yes**   | The armor interaction modifier to apply bonuses and penalties for.                                                                                                                       |
+
+**ValueType Values**
+
+- `Absolute`
+- `Percent`
+
+**InteractionModifierId Values**
+
+- `Dodge`
+
+## EntityEffects
+
+EntityEffects are buff or debuff effects that can be applied to a LivingEntity.  These can have a variety of effects from
+movement speed changes to periodic damage.
+
+### EffectCondition
+
+This interaction will fail if the specified entity's EntityEffects do not match the provided conditions.
+
+**EffectCondition Fields**
+
+| Field Name      | Type                                             | Required? | Notes                                                                                                                                                                                                             |
+| --------------- | ------------------------------------------------ | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Entity          | `InteractionTarget`<br />(Default: User)         | **Yes**   | The entity to examine for EntityEffects. This field can indicate the Owner, User, or Target of this interaction chain.                                                                                            |
+| Match           | `Match`<br />(Default: All)                      | **No**    | If `All`, then this interaction will fail if any EntityEffect in the `EntityEffectIds` is not on the specified entity. If `None`, then this interaction will fail if any EntityEffect IS on the specified entity. |
+| EntityEffectIds | `AssetArray`<br />(Element Type: `EntityEffect`) | **Yes**   | The set of EntityEffects to check against the specified entity and `Match`.                                                                                                                                       |
+
+**InteractionTarget Values**
+
+- `User` - The user of this interaction chain. The entity whose actions caused this interaction chain to be executed. This is usually the same as the Owner.
+- `Owner` - The owner of this interaction chain. The entity upon whom this interaction chain is executing.
+- `Target` - The entity target of this interaction chain, if any.  This value is mutable (and can therefore come from many places) but most commonly, it is an entity the User was targeting when this interaction chain began executing.
+
+**Match Values**
+
+- `All` - All EntityEffects must be on the specified entity for this interaction to succeed.
+- `None` - None of the EntityEffects must be on the specified entity for this interaction to succeed.
+
+### ApplyEffect
+
+This interaction will apply the specified EntityEffect to the specified Entity.  It has no special failure conditions.
+
+**ApplyEffect Fields**
+
+| Field Name | Type                                      | Required? | Notes                                                                                                                  |
+| ---------- | ----------------------------------------- | --------- | ---------------------------------------------------------------------------------------------------------------------- |
+| Entity     | `InteractionTarget`<br />(Default: User)  | **Yes**   | The entity to apply the EntityEffect to. This field can indicate the Owner, User, or Target of this interaction chain. |
+| EffectId   | `Asset`<br />(Asset Type: `EntityEffect`) | **Yes**   | The effect to apply.                                                                                                   |
+
+**InteractionTarget Values**
+
+- `User` - The user of this interaction chain. The entity whose actions caused this interaction chain to be executed. This is usually the same as the Owner.
+- `Owner` - The owner of this interaction chain. The entity upon whom this interaction chain is executing.
+- `Target` - The entity target of this interaction chain, if any.  This value is mutable (and can therefore come from many places) but most commonly, it is an entity the User was targeting when this interaction chain began executing.
+
+### ClearEntityEffect
+
+This interaction will remove the specified EntityEffect from the specified Entity. It has no special failure conditions.
+It will not fail if the Entity does not have the EntityEffect.
+
+**ClearEntityEffect Fields**
+
+| Field Name | Type                                      | Required? | Notes                                                                                                                     |
+| ---------- | ----------------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------- |
+| Entity     | `InteractionTarget`<br />(Default: User)  | **Yes**   | The entity to remove the EntityEffect from. This field can indicate the Owner, User, or Target of this interaction chain. |
+| EffectId   | `Asset`<br />(Asset Type: `EntityEffect`) | **Yes**   | The effect to remove.                                                                                                     |
+
+**InteractionTarget Values**
+
+- `User` - The user of this interaction chain. The entity whose actions caused this interaction chain to be executed. This is usually the same as the Owner.
+- `Owner` - The owner of this interaction chain. The entity upon whom this interaction chain is executing.
+- `Target` - The entity target of this interaction chain, if any.  This value is mutable (and can therefore come from many places) but most commonly, it is an entity the User was targeting when this interaction chain began executing.
+
+## Farming
+
+These are interaction types built to support the in-game farming system in Hytale. They are mostly block-related interactions
+with a few exceptions.
+
+### ChangeFarmingStage
+
+If the target block is a farming block, this interaction will attempt to modify the current farming stage in one of
+three ways.  The interaction can optionally specify which StageSet to use for the new stage. If it is not specified,
+the current StageSet will be used. If any part of the the process of changing the growth stage fails, this interaction
+will fail, with the one exception that attempting to set the stage to the crop's existing stage will have no effect but
+still succeed.
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                                                                                                                                                                          |
+| ---------------- | ------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction.                                                                                                                                              |
+| StageSet         | `String`                        | **No**    | If provided, set the block's current stage to one in the provided StageSet. Otherwise, use the crop's current StageSet.                                                                                                                                                        |
+| Increase         | `Integer`                       | **No**    | If provided, increase the current stage by the specified amount. If the specified stage does not exist, the block will be set to the closest extant stage.                                                                                                                     |
+| Decrease         | `Integer`                       | **No**    | If provided and `Increase` is not provided, decrease the current stage by the specified amount. If the specified stage does not exist, the block will be set to the closest extant stage.                                                                                      |
+| Stage            | `Integer`<br />(Default: -1)    | **No**    | If provided and `Increase`/`Decrease` are not provided, set the current stage to the specified stage. If this value is less than 0, set the current stage to the final growth stage. If the specified stage does not exist, the block will be set to the closest extant stage. |
+
+### FertilizeSoil
+
+If the target block is unfertilized tilled soil or a farming block on top of unfertilized tilled soil, fertilizes the soil.
+The interaction will fail otherwise.
+
+**FertilizeSoil Fields**
+
+| Field Name       | Type                                  | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false)       | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+| RefreshModifiers | `Array`<br />(Element Type: `String`) | **No**    | Does nothing.                                                                                                                     |
+
+### HarvestCrop
+
+This interaction will attempt to execute the harvest action on the current block target and add the crop's drops to the User entity's
+inventory.  The block will either be destroyed or set to its post-harvest growth stage, depending on the farming
+configuration of the block.  This will happen (and the player will receive the full harvest drops) regardless of the
+block's current growth stage. This interaction has no special failure conditions, even if the block target isn't a
+farming block or gathering isn't permitted in the current world, but nothing will occur in those cases.
+
+**HarvestCrop Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+
+### UseWateringCan
+
+If the target block is tilled soil or a farming block on top of tilled soil, waters the soil for the specified duration.
+The interaction will fail otherwise.
+
+**UseWateringCan Fields**
+
+| Field Name       | Type                                  | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false)       | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+| Duration         | `Integer`<br />(Default: 0)           | **No**    | The duration in seconds to water the soil for.                                                                                    |
+| RefreshModifiers | `Array`<br />(Element Type: `String`) | **No**    | Does nothing.                                                                                                                     |
diff --git a/content/docs/da-DK/contributing/pr-guidelines.mdx b/content/docs/da-DK/contributing/pr-guidelines.mdx
index 903272b9..ba7d59ea 100644
--- a/content/docs/da-DK/contributing/pr-guidelines.mdx
+++ b/content/docs/da-DK/contributing/pr-guidelines.mdx
@@ -19,6 +19,8 @@ For at sikre en blød og effektiv gennemgangsproces skal både bidragsydere og a
 4. **Kode kvalitet**
    - Sørg for, at din kode følger projektets kodestandarder og best practices.
    - Inkluder kommentarer, hvor det er nødvendigt, for at forklare kompleks logik.
+   - Always test your changes locally before submitting the PR to catch any issues early.
+   - Format your code using `bun format` to maintain consistency across the codebase.
 5. **Testing**
    - Test dine ændringer grundigt, før du indsender PR'en.
    - Hvis relevant, så inkluder unit tests eller integrationstests for at verificere dine ændringer.
diff --git a/content/docs/da-DK/contributing/translate.mdx b/content/docs/da-DK/contributing/translate.mdx
new file mode 100644
index 00000000..c62ffdde
--- /dev/null
+++ b/content/docs/da-DK/contributing/translate.mdx
@@ -0,0 +1,74 @@
+---
+title: Translate
+description: How to translate HytaleModding to your language
+---
+
+# Translating HytaleModding
+
+HytaleModding is translated with the help of the community using **Crowdin**. If you want to help translate or improve existing translations, this is the right place.
+
+## Steps to Translate
+
+All translations are managed **via Crowdin**.
+
+1. Visit [our Crowdin project](https://crowdin.com/project/hytalemodding) and log in if required.
+2. Click on your language.
+3. Click on the file/article you wish to translate. We recommend starting with Official Documentation, and then Server Plugin Documentation.
+4. Start translating!
+5. Approved translations will appear on the website.
+
+### Video Guide
+
+<iframe src="https://www.youtube.com/embed/NHiG1rDRgks" allowFullScreen />
+
+## How to discuss
+
+You can always report issues or discuss specific topics directly on Crowdin, but we recommend using Discord instead of the Crowdin comment system to keep everything organized in one place.
+
+1. Join [our Discord](https://discord.gg/hytalemodding)
+2. Open `#translations` channel. Here you can discuss or ask questions that are not related to a specific language.
+3. If you want to join a thread, you are required to run `/translator <your-language>` command here. The bot will add you to the thread for your language.
+
+## Translation Guidelines
+
+- You need to be confident in what you are translating. You should be able to read the text you just translated and understand the meaning of it very easily.
+- It should use the simplest form of language possible. Use English words if the translation is unknown to the majority in your country.
+- Use your imagination, trust yourself. Feel free to change any context as you wish as long as it can still get the same point across and is understandable.
+- These guidelines are more important than language-specific guidelines, but less important than Hytale terminology and rules.
+
+## What not to translate
+
+We request you all to not translate these specific sections of the website:
+
+### Callout types
+
+Callouts are the boxes that contain important information. We request you to not translate the types as they only work in English.
+
+**Example:**
+
+```mdx
+<Callout type="warning" title="Translate this title!">
+Translate the text inside the callout!
+</Callout>
+```
+
+In this example, please don't translate the word warning, the rest you can translate.
+
+### Icons
+
+Icon names must not be translated.
+They are technical identifiers mapped directly to existing icons. Translating them will break the icon rendering.
+
+```mdx
+icon: Globe
+```
+
+---
+
+{/* 
+For translators who will edit this page:
+
+- You are required to translate the Guidelines as they change.
+- General guidelines should be translated but not edited.
+- Learn how to use Markdown from writing_guides.mdx
+*/}
diff --git a/content/docs/da-DK/established-information/server/content-categories/art-assets.mdx b/content/docs/da-DK/established-information/server/content-categories/art-assets.mdx
index 39c2ed37..1e926874 100644
--- a/content/docs/da-DK/established-information/server/content-categories/art-assets.mdx
+++ b/content/docs/da-DK/established-information/server/content-categories/art-assets.mdx
@@ -14,7 +14,7 @@ Hytale provides comprehensive support for 3D modeling and texture art creation,
 Hytale uses **Blockbench** as the primary tool for 3D modeling and animation:
 
 * **Official support**: Used for "creating Hytale models, textures, and animations"
-* **Special plugin**: Hytale will have a dedicated Blockbench plugin, to be released ASAP
+* **Special plugin**: Hytale has a dedicated [Blockbench Plugin](https://www.blockbench.net/plugins/hytale_plugin).
 * **Direct compatibility**: The plugin allows creators to "create Hytale-compatible models, textures, and animations directly in Blockbench"
 * **Replaces legacy tools**: Fully replaces the old Hytale Model Maker to better support established creative workflows in the community
 * **Safety features**: Only allows you to add things compatible with the engine, so no need to worry about breaking anything
diff --git a/content/docs/da-DK/guides/ecs/block-components.mdx b/content/docs/da-DK/guides/ecs/block-components.mdx
new file mode 100644
index 00000000..ca68b38a
--- /dev/null
+++ b/content/docs/da-DK/guides/ecs/block-components.mdx
@@ -0,0 +1,247 @@
+---
+title: Block Components
+description: Learn how to use the block components.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+  - name: oskarscot
+    link: https://oskar.scot
+---
+
+# Overview
+
+In this guide, you'll learn how to use block components to create a ticking block.
+
+<Callout>
+  For a more complete reference, you may also want to review FarmingSystems.Ticking, as much of the underlying logic is based on its implementation.
+</Callout>
+
+## Steps
+
+### 1. ExampleBlock - holds block behavior
+
+```java
+public class ExampleBlock implements Component<ChunkStore> {
+
+    public static final BuilderCodec CODEC = BuilderCodec.builder(ExampleBlock.class, ExampleBlock::new).build();
+
+    // Components usually require a copy constructor as well but since we don't actually hold any data in this component this is not neccessary
+    public ExampleBlock() { }
+
+    public static ComponentType getComponentType() {
+        return ExamplePlugin.get().getExampleBlockComponentType();
+    }
+
+    @Nullable
+    public Component<ChunkStore> clone() {
+        return new ExampleBlock();
+    }
+}
+```
+
+ExampleBlock is a custom component that stores the behavior and data for your ticking block. Here, it simply places an Ice Block at x + 1 relative to its current position when it ticks.
+
+---
+
+### 2. ExampleInitializer - marks blocks as ticking when placed
+
+```java
+public class ExampleInitializer extends RefSystem {
+
+    @Override
+    public void onEntityAdded(@Nonnull Ref ref, @Nonnull AddReason reason, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+        BlockModule.BlockStateInfo info = (BlockModule.BlockStateInfo) commandBuffer.getComponent(ref, BlockModule.BlockStateInfo.getComponentType());
+        if (info == null) return;
+
+        ExampleBlock generator = (ExampleBlock) commandBuffer.getComponent(ref, ExamplePlugin.get().getExampleBlockComponentType());
+        if (generator != null) {
+            int x = ChunkUtil.xFromBlockInColumn(info.getIndex());
+            int y = ChunkUtil.yFromBlockInColumn(info.getIndex());
+            int z = ChunkUtil.zFromBlockInColumn(info.getIndex());
+
+            WorldChunk worldChunk = (WorldChunk) commandBuffer.getComponent(info.getChunkRef(), WorldChunk.getComponentType());
+            if (worldChunk != null) {
+				worldChunk.setTicking(x, y, z, true);
+            }
+        }
+    }
+
+    @Override
+    public void onEntityRemove(@Nonnull Ref ref, @Nonnull RemoveReason reason, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+    }
+
+    @Override
+    public Query getQuery() {
+        return Query.and(BlockModule.BlockStateInfo.getComponentType(), ExamplePlugin.get().getExampleBlockComponentType());
+    }
+}
+```
+
+ExampleInitializer is a RefSystem that reacts when block entities with the ExampleBlock component are added or removed. This is crucial for marking blocks as ticking when they're first placed.
+
+**Key Points:**
+
+- Tells the game that this block should tick, allowing `ExampleSystem` to process it.
+
+```java
+worldChunk.setTicking(x, y, z, true);
+```
+
+---
+
+### 3. ExampleSystem - handles ticking
+
+```java
+public class ExampleSystem extends EntityTickingSystem {
+
+    public void tick(float dt, int index, @Nonnull ArchetypeChunk archetypeChunk, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+        BlockSection blocks = (BlockSection) archetypeChunk.getComponent(index, BlockSection.getComponentType());
+
+        assert blocks != null;
+
+        if (blocks.getTickingBlocksCountCopy() != 0) {
+            ChunkSection section = (ChunkSection) archetypeChunk.getComponent(index, ChunkSection.getComponentType());
+
+            assert section != null;
+
+            BlockComponentChunk blockComponentChunk = (BlockComponentChunk) commandBuffer.getComponent(section.getChunkColumnReference(), BlockComponentChunk.getComponentType());
+
+            assert blockComponentChunk != null;
+
+            blocks.forEachTicking(blockComponentChunk, commandBuffer, section.getY(), (blockComponentChunk1, commandBuffer1, localX, localY, localZ, blockId) -> {
+                Ref<ChunkStore> blockRef = blockComponentChunk.getEntityReference(ChunkUtil.indexBlockInColumn(localX, localY, localZ));
+                if (blockRef == null) {
+                    return BlockTickStrategy.IGNORED;
+                } else {
+                    ExampleBlock exampleBlock = (ExampleBlock) commandBuffer1.getComponent(blockRef, ExampleBlock.getComponentType());
+                    if (exampleBlock != null) {
+                        WorldChunk worldChunk = (WorldChunk) commandBuffer.getComponent(section.getChunkColumnReference(), WorldChunk.getComponentType());
+                        World world = worldChunk.getWorld();
+
+                        int globalX = localX + (worldChunk.getX() * 32);
+                        int globalZ = localZ + (worldChunk.getZ() * 32);
+
+                        // We need to execute setBlock on the world thread as you cannot call store functions from a system
+                        // This is because of the architecture of the server, depending on your needs you can also use the CommandBuffer
+                        world.execute(() -> {
+                            world.setBlock(globalX + 1, localY, globalZ, "Rock_Ice");
+                        });
+
+                        return BlockTickStrategy.CONTINUE;
+
+                    } else {
+                        return BlockTickStrategy.IGNORED;
+                    }
+                }
+            });
+        }
+    }
+
+    @Nullable
+    public Query getQuery() {
+        return Query.and(BlockSection.getComponentType(), ChunkSection.getComponentType());;
+    }
+}
+```
+
+ExampleSystem is an EntityTickingSystem that runs every tick to execute the logic for all ticking blocks with the ExampleBlock component.
+
+**Key Points:**
+
+- **Get the block component**
+
+```java
+ExampleBlock exampleBlock = (ExampleBlock) commandBuffer.getComponent(blockRef, ExampleBlock.getComponentType());
+```
+
+- **Convert local chunk coordinates to world coordinates**
+
+```java
+int globalX = localX + (worldChunk.getX() * 32);
+int globalZ = localZ + (worldChunk.getZ() * 32);
+```
+
+- **Run the block logic**
+
+```java
+exampleBlock.runBlockAction(globalX, localY, globalZ, worldChunk.getWorld());
+```
+
+- **Keep the block ticking in the next tick**
+
+```java
+return BlockTickStrategy.CONTINUE;
+```
+
+---
+
+### 4. ExamplePlugin - registers components and systems
+
+```java
+public class ExamplePlugin extends JavaPlugin {
+    protected static ExamplePlugin instance;
+    private static final HytaleLogger LOGGER = HytaleLogger.forEnclosingClass();
+    private ComponentType exampleBlockComponentType;
+
+    public static ExamplePlugin get() {
+        return instance;
+    }
+
+    public ExamplePlugin(@Nonnull JavaPluginInit init) {
+        super(init);
+        LOGGER.atInfo().log("Hello from " + this.getName() + " version " + this.getManifest().getVersion().toString());
+    }
+
+    @Override
+    protected void setup() {
+        instance = this;
+        LOGGER.atInfo().log("Setting up plugin " + this.getName());
+        this.exampleBlockComponentType = this.getChunkStoreRegistry().registerComponent(ExampleBlock.class, "ExampleBlock", ExampleBlock.CODEC);
+    }
+	
+	@Override
+	protected void start() {
+		this.getChunkStoreRegistry().registerSystem(new ExampleSystem());
+		this.getChunkStoreRegistry().registerSystem(new ExampleInitializer());
+	}
+
+    public ComponentType getExampleBlockComponentType() {
+        return this.exampleBlockComponentType;
+    }
+}
+```
+
+---
+
+### 5. Configure In-Game
+
+![block-component-1](/assets/guides/block-component-1.png)
+
+![block-component-2](/assets/guides/block-component-2.png)
+
+With this logic, the block will now continuously place an Ice Block at the coordinates x + 1 relative to its current position every time it ticks.
+
+---
+
+## Common Issues
+
+### NullPointerException on Startup
+
+**Error message:**
+
+```java
+java.lang.NullPointerException: Cannot invoke "com.hypixel.hytale.component.query.Query.validateRegistry(com.hypixel.hytale.component.ComponentRegistry)" because "query" is null
+```
+
+**Cause:**
+This error occurs when your module is loaded **before** the required Hytale modules.
+
+**Fix:**
+Add `EntityModule` and `BlockModule` as dependencies in your `manifest.json` to ensure proper load order.
+
+```json
+"Dependencies": {
+  "Hytale:EntityModule": "*",
+  "Hytale:BlockModule": "*"
+}
+```
diff --git a/content/docs/da-DK/guides/ecs/hytale-ecs-theory.mdx b/content/docs/da-DK/guides/ecs/hytale-ecs-theory.mdx
index 20c3a94d..52d8b1f5 100644
--- a/content/docs/da-DK/guides/ecs/hytale-ecs-theory.mdx
+++ b/content/docs/da-DK/guides/ecs/hytale-ecs-theory.mdx
@@ -29,7 +29,7 @@ for now this is the basic understanding for the `ChunkStore`. You can use it to
 
 ## Holder
 
-A Holder is essentially a blueprint for an entity. Before an entity exists in the Store (and thus in the world), is exists as a `Holder`. It collects and holds all the necessary components (data). You can compare it analogous to shopping cart. You grab all components you need and once you have everything, check out at the store which will take your cart and create a valid entity ID and hand you back a receipt (a Ref).
+A Holder is essentially a blueprint for an entity. Before an entity exists in the Store (and thus in the world), it exists as a `Holder`. It collects and holds all the necessary components (data). You can compare it analogous to shopping cart. You grab all components you need and once you have everything, check out at the store which will take your cart and create a valid entity ID and hand you back a receipt (a Ref).
 
 Let's take a look at an example: initializing players. In `Universe`, the `addPlayer` method demonstrates it perfectly.
 When a player connects, we don't immediately throw them into the ECS. We first construct their data in a Holder.
@@ -167,7 +167,7 @@ MyComponent comp = commandBuffer.getComponent(ref, componentType);
 
 Codecs handle serialization and deserialization of components. Hytale uses them to save and load entity data to and from disk as well as sending component data over the network. When creating a custom component, you must also create a corresponding Codec.
 
-There are mutliple Codec types already implemented in the default Codec Interface:
+There are multiple Codec types already implemented in the default Codec Interface:
 
 - Codec.STRING
 - Codec.BOOLEAN
@@ -215,7 +215,7 @@ This might seem tedious at first but it ensures that your component can be corre
   KeyedCodec<Integer> exampleInt = new KeyedCodec<Integer>("ExampleIntIdForCodec", Codec.INTEGER);
   ```
 
-- **Setter Function**: This is a lambda function that takes an instance of your component and returns the value of the field you want to serialize. For example, if you have a field called `myCustomField` in your custom component, your getter function would look like this:
+- **Setter Function**: This is a lambda function that takes an instance of your component + the value to set and sets the field value on the component. For example, if you have a field called `myCustomField` in your custom component, your setter function would look like this:
   ```java
   (data, value) -> data.myCustomField = value
   ```
@@ -276,7 +276,7 @@ public class PoisonComponent implements Component<EntityStore> {
 
 You can also add validators to your Codec fields to ensure that the data being serialized/deserialized meets certain criteria. For example, if you want to ensure that the `damagePerTick` field is always non-negative or the poison name is never null, you can add a validator like this:
 
-````java
+```java
 .append(
     new KeyedCodec<Float>("DamagePerTick", Codec.FLOAT),
     (data, value) -> data.damagePerTick = value,
@@ -292,14 +292,15 @@ You can also add validators to your Codec fields to ensure that the data being s
 )
 .addValidator(Validators.nonNull())
 .add()
+```
 
 ### Complex Codec Examples
 
-If you want to have a map inside your component, you can use the MapCodec class to build a KeyedCoded for it. Here's an example of how to create a Codec for a Map field:
+If you want to have a map inside your component, you can use the MapCodec class to build a KeyedCodec for it. Here's an example of how to create a Codec for a Map field:
 
 ```java
 var damagePerTick = new KeyedCodec<>("DamagePerTick", new MapCodec<>(Codec.FLOAT, HashMap<String, Float>::new));
-````
+```
 
 <Callout type="info">
   This also works with custom Objects as long as you have a Codec defined for the Object type.
diff --git a/content/docs/da-DK/guides/java-basics/00-introduction.mdx b/content/docs/da-DK/guides/java-basics/00-introduction.mdx
index a03ad638..b0130d74 100644
--- a/content/docs/da-DK/guides/java-basics/00-introduction.mdx
+++ b/content/docs/da-DK/guides/java-basics/00-introduction.mdx
@@ -7,7 +7,7 @@ Welcome to your journey into Java Programming! This guide is designed to introdu
 
 ## What is Java?
 
-Java is a powerful, object-oriented programming language created in 1995. It's one of the most popular programming languages in the world and is used for everything from mobile apps to enterprise software. Most importantly for us, it's the language Hytale uses for it's servers & modding API.
+Java is a powerful, object-oriented programming language created in 1995. It's one of the most popular programming languages in the world and is used for everything from mobile apps to enterprise software. Most importantly for us, it's the language Hytale uses for its servers & modding API.
 
 ## What You'll Learn
 
diff --git a/content/docs/da-DK/guides/java-basics/02-operators.mdx b/content/docs/da-DK/guides/java-basics/02-operators.mdx
index a132b1c0..18634665 100644
--- a/content/docs/da-DK/guides/java-basics/02-operators.mdx
+++ b/content/docs/da-DK/guides/java-basics/02-operators.mdx
@@ -119,7 +119,7 @@ String greetingWithName = "Hello, " + name + "!"; // "Hello, Alice!"
 
 ## Operator Precedence
 
-Operator Precendence means which operator gets evaluated first in an line of code. Think of it like BODMAS/PEMDAS in math!
+Operator Precedence means which operator gets evaluated first in an line of code. Think of it like BODMAS/PEMDAS in math!
 
 ```java
 int result = 10 + 5 * 2; // result is 20, not 30
diff --git a/content/docs/da-DK/guides/java-basics/03-control-flow-if.mdx b/content/docs/da-DK/guides/java-basics/03-control-flow-if.mdx
index b9d6c479..af2d1c22 100644
--- a/content/docs/da-DK/guides/java-basics/03-control-flow-if.mdx
+++ b/content/docs/da-DK/guides/java-basics/03-control-flow-if.mdx
@@ -7,7 +7,7 @@ Programs need to make decisions. If statements let your code choose different pa
 
 ## Basic If Statement
 
-The simplest form checks one condition;
+The simplest form checks one condition:
 
 ```java
 int health = 20;
diff --git a/content/docs/da-DK/guides/java-basics/08-access-modifiers.mdx b/content/docs/da-DK/guides/java-basics/08-access-modifiers.mdx
index af560932..da2bf33b 100644
--- a/content/docs/da-DK/guides/java-basics/08-access-modifiers.mdx
+++ b/content/docs/da-DK/guides/java-basics/08-access-modifiers.mdx
@@ -484,7 +484,7 @@ class Data {
     // Static member:
     // cannot access to non-static variables
     public static void bar() {
-        x = 100; // Error: non-static variable x cannot be renference from a static context
+        x = 100; // Error: non-static variable x cannot be referenced from a static context
         y = 100; // OK
     }
 }
@@ -504,7 +504,7 @@ Data.x = 1000; // Error: cannot access instanced variables in a static context
 
 ### Static Fields
 
-A static field represents a data member owned by the class type rather then the object. Static fields are also stored in a specific memory location that's been shared between all the object instances that are created.
+A static field represents a data member owned by the class type rather than the object. Static fields are also stored in a specific memory location that's been shared between all the object instances that are created.
 
 It is declared as following:
 
diff --git a/content/docs/da-DK/guides/plugin/animated-block-textures.mdx b/content/docs/da-DK/guides/plugin/animated-block-textures.mdx
new file mode 100644
index 00000000..42bfa51f
--- /dev/null
+++ b/content/docs/da-DK/guides/plugin/animated-block-textures.mdx
@@ -0,0 +1,101 @@
+---
+title: Animated Block Textures
+description: Learn how to attach a .blockyanim to a block
+authors:
+  - name: Burkino
+---
+
+import { File, Folder, Files } from 'fumadocs-ui/components/files';
+
+So, you want to make your blocks feel more alive through animations, do you?\
+Now for the most part this is the exact same as [Creating custom blocks](./creating-block).
+![blue fire gif](/assets/guides/blue_fire.gif)
+
+## Prerequisites
+
+This is NOT a guide on animating or texturing or even using BlockBench, why? Because I don't know how to do that.\
+The only thing we will be doing is taking the fire texture, changing the color, and applying it to our new fire block.
+
+## Setup
+
+To start, you're obviously going to want to grab the `Common/VFX/Fire/Fire.png` file. How you do it is up to you, in the Asset Editor you'll need to switch to the Common tab.\
+I'll assume you know how colorize or change the hue of an image, so go ahead and do that now and save it as `Blue_Fire.png`.
+
+The other assets used in this guide are `Common/VFX/Fire/Fire.blockymodel` and `Common/Blocks/Animations/Fire/Fire_Burn.blockyanim` (both renamed to `Blue_Fire`) but since we won't be changing them it's probably fine to leave them. I will reference the `Blue_Fire` versions as a way to point out what should be custom assets.\
+I will also duplicate `Server/Item/Item/Deco/Deco_Fire.json` and call it `Deco_Blue_Fire.json`.
+
+## Applying the changes
+
+The `Deco_Blue_Fire` block is actually just a particle emitter, however we will not be using particles, so lets start by removing them in `Block > Particles`.\
+Next we want to set the Block Model (called `CustomModel` in JSON) to `VFX/Blue_Fire/Blue_Fire.blockymodel` and Block Model Textures (`CustomModelTexture` in JSON) to
+
+```json
+[
+    {
+        "Texture": "VFX/Blue_Fire/Blue_Fire.png",
+        "Weight": 1
+    }
+]
+```
+
+Finally, we will apply the .blockyanim to our model, this is done through the Block Model Animation property (`CustomModelAnimation` in JSON) and the value should be `Blocks/Animations/Blue_Fire/Blue_Fire_Burn.blockyanim`.
+
+## Final Code
+
+With that your new blue fire should be done. Here is the minimal JSON for our blue fire.\
+There is an additional `Looping` and `RequiresAlphaBlending` property that I have not gone over, however I hope it is self-explanatory.
+
+```json
+{
+  "BlockType": {
+    "DrawType": "Model",
+    "CustomModel": "VFX/Blue_Fire/Blue_Fire.blockymodel",
+    "CustomModelAnimation": "Blocks/Animations/Blue_Fire/Blue_Fire_Burn.blockyanim",
+    "CustomModelTexture": [
+      {
+        "Texture": "VFX/Blue_Fire/Blue_Fire.png",
+        "Weight": 1
+      }
+    ],
+    "Looping": true,
+    "RequiresAlphaBlending": false
+  },
+  "PlayerAnimationsId": "Block"
+}
+```
+
+<Files>
+  <Folder name="resources" defaultOpen>
+    <Folder name="Server" defaultOpen>
+      <Folder name="Item" defaultOpen>
+        <Folder name="Items" defaultOpen>
+          <Folder name="Deco" defaultOpen>
+            <File name="Deco_Blue_Fire.json" />
+          </Folder>
+        </Folder>
+      </Folder>
+    </Folder>
+
+    <Folder name="Common" defaultOpen>
+      <Folder name="Blocks" defaultOpen>
+        <Folder name="Animations" defaultOpen>
+          <Folder name="Blue_Fire" defaultOpen>
+            <File name="Blue_Fire_Burn.blockyanim" />
+          </Folder>
+        </Folder>
+      </Folder>
+
+      <Folder name="VFX" defaultOpen>
+        <Folder name="Blue_Fire" defaultOpen>
+          <File name="Blue_Fire.blockymodel" />
+
+          <File name="Blue_Fire.png" />
+        </Folder>
+      </Folder>
+    </Folder>
+  </Folder>
+</Files>
+
+## Next steps
+
+Now that you know how to attach an animation to a block, try adding it to a block state.
diff --git a/content/docs/da-DK/guides/plugin/build-and-test.mdx b/content/docs/da-DK/guides/plugin/build-and-test.mdx
index 0e7fe7eb..f37534c3 100644
--- a/content/docs/da-DK/guides/plugin/build-and-test.mdx
+++ b/content/docs/da-DK/guides/plugin/build-and-test.mdx
@@ -9,18 +9,18 @@ If you followed along with the [Setting Up Your Development Environment](./setti
 
 ## Building Your Mod
 
-In our case, we've **Maven** as the build system. Maven is a powerful build automation tool that manages dependencies, compiles your code, and packages everything into a distributable JAR file.
+In our case, we've **Gradle** as the build system. Gradle is a powerful build automation tool that manages dependencies, compiles your code, and packages everything into a distributable JAR file.
 
-### Understanding Maven
+### Understanding Gradle
 
-Maven uses a `pom.xml` file (Project Object Model) to define your project's configuration, dependencies, and build settings. You can learn more about Maven at the [official Apache Maven website](https://maven.apache.org/).
+Gradle can use a `build.gradle.kts` file (Kotlin DSL) to define your project's configuration, dependencies, and build settings. You can learn more about Gradle at the [official Gradle website](https://gradle.org/).
 
-### Building with Maven
+### Building with Gradle
 
 To build your mod, open a terminal in your project directory and run:
 
 ```bash
-mvn package
+./gradlew build
 ```
 
 This command will:
@@ -29,16 +29,35 @@ This command will:
 2. Run any tests (if present)
 3. Package everything into a JAR file
 
+<Callout type="info">
+  If you are using the plugin template from the [Setting Up Your Development Environment](./setting-up-env) guide, then the build script is already set up for you. It includes paths to your Hytale game library and handles the packaging of your mod, managing hytale dependencies and manifest changes.
+
+  If you have a different path to your Hytale installation, you may receive the following error:
+
+  ```bash
+  FAILURE: Build failed with an exception.
+
+  * What went wrong:
+  Failed to find Hytale at the expected location. Please make sure you have installed the game. The expected location can be changed using the hytale.home_path property. Currently looking in 'C:\Path\To\Hytale'
+  ```
+
+  You can change the path by adding a property to your `gradle.properties` file (if it doesn't exist, create it in the root of your project):
+
+  ```properties
+  hytale.home_path=C:\Correct\Path\To\Hytale
+  ```
+</Callout>
+
 ### Build Output
 
-Once the build completes successfully, your mod will be located in the `target` directory and named:
+Once the build completes successfully, your mod will be located in the `build/libs` directory and named:
 
 ```
-ExamplePlugin-1.0-SNAPSHOT.jar
+ExamplePlugin-1.0.jar
 ```
 
 <Callout type="info">
-  The exact name may vary depending on what you configured in your `pom.xml` file. Check the `artifactId` and `version` fields to see what your JAR will be named.
+  The exact name may vary depending on what you configured in your `build.gradle.kts` and `settings.gradle.kts` file. Check the `rootProject.name` and `version` fields to see what your JAR will be named.
 </Callout>
 
 ## Testing Your Mod
@@ -49,11 +68,11 @@ Now that you've built your mod, it's time to test it in Hytale!
 
 First, you need to find Hytale's mods directory:
 
-1. Press **Win + R** on your keyboard
-2. Type `%appdata%` and press Enter
-3. Navigate to: `Hytale\UserData\Mods`
+1. Go to your Hytale installation directory (The default location is usually in your AppData folder)
+   > On Windows, you can access it by clicking `windows + R` and typing `%appdata%`.
+2. Navigate to: `/UserData/Mods`
 
-The full path should look like:
+The default path would look like:
 
 ```
 C:\Users\YourUsername\AppData\Roaming\Hytale\UserData\Mods
@@ -65,7 +84,7 @@ C:\Users\YourUsername\AppData\Roaming\Hytale\UserData\Mods
 
 ### 2. Copy Your Mod
 
-Copy the `ExamplePlugin-1.0-SNAPSHOT.jar` file from your project's `target` directory into the `Mods` folder you just located.
+Copy the `ExamplePlugin-1.0.jar` file from your project's `build/libs` directory into the `Mods` folder you just located.
 
 ### 3. Launch Hytale and Verify
 
@@ -84,7 +103,7 @@ If your mod doesn't appear in the mods list:
 - Make sure the JAR file is in the correct `Mods` folder
 - Check that your `manifest.json` file is properly configured
 - Look for any error messages in the Hytale logs
-- Verify that you're using the correct version of Java and Maven
+- Verify that you're using the correct version of Java and Gradle
 
 ## Next Steps
 
diff --git a/content/docs/da-DK/guides/plugin/creating-commands.mdx b/content/docs/da-DK/guides/plugin/creating-commands.mdx
index d33597f3..08572f16 100644
--- a/content/docs/da-DK/guides/plugin/creating-commands.mdx
+++ b/content/docs/da-DK/guides/plugin/creating-commands.mdx
@@ -8,6 +8,8 @@ authors:
     url: https://oskar.scot
   - name: jacobwojoski
     url: https://github.com/jacobwojoski
+  - name: Marcel-TO
+    url: https://marcel-to.net
 ---
 
 In this guide, you will learn how to create custom commands for your Hytale mod.
@@ -36,7 +38,7 @@ The most basic command is an `AbstractAsyncCommand`. It has very minimal data av
   `AbstractAsyncCommand` runs on its own background thread. This means its execute is not tied to any world instance and because of this it can not edit any **Stores** or **Refs** without getting the desired world first. To access this data any of the other command types would be preferred and are likely what you will want to use instead.
 </Callout>
 
-The main purpose for a command like this would be for something that can happen everywhere and is not tied to a specific world. For example a `serverRules` command to tell the user thats running the command in chat what the servers rules are nomatter what world they are in.
+The main purpose for a command like this would be for something that can happen everywhere and is not tied to a specific world. For example a `serverRules` command to tell the user that's running the command in chat what the server's rules are no matter what world they are in.
 
 ```java
 // Command that can be run that lists the server rules in chat to the player
@@ -49,7 +51,7 @@ public class ServerRulesCommand extends AbstractAsyncCommand {
     }
 
     // Run the command
-    // conetext - info about who ran the command. Server console?, Some player?
+    // context - info about who ran the command. Server console?, Some player?
     @Override
     protected CompletableFuture<Void> executeAsync(@Nonnull CommandContext context) {
         context.sendMessage(Message.raw("The only rule is there are no rules."));
@@ -134,7 +136,7 @@ Uses a Ray to see what the player is looking at and tries to run the command on
 
 ## Adding Arguments
 
-Arguments are additional fields that the user can input when running a command. The different types of arguments along with small snipits and a large example can be seen below.
+Arguments are additional fields that the user can input when running a command. The different types of arguments along with small snippets and a large example can be seen below.
 
 ### Command Argument Types
 
@@ -163,14 +165,14 @@ this.messageArg = this.withOptionalArg("message", "Message to print while healin
 
 ### Default Arguments
 
-Adding a default argument has two additional arguemnt for the default value and default value description. You need to use `withDefaultArg` method.
+Adding a default argument has two additional argument for the default value and default value description. You need to use `withDefaultArg` method.
 
 ```java
 // args <Command String> <Description> <Default Value> <Desc of default value>
 this.healthArg = this.withDefaultArg("health", "Amount to heal player", ArgTypes.FLOAT, (float)100, "Desc of Default: 100");
 ```
 
-### Flag Arguemnts
+### Flag Arguments
 
 Similar as above but the flags return is either true if it exists or false if it does not. You need to use `withFlagArg` method.
 
@@ -181,20 +183,13 @@ this.debugArg = this.withFlagArg("debug", "Add debug logs");
 
 ### ArgTypes
 
-The following ArgTypes are available (only lists common types):
-
-- `ArgTypes.STRING`
-- `ArgTypes.INTEGER`
-- `ArgTypes.BOOLEAN`
-- `ArgTypes.FLOAT`
-- `ArgTypes.DOUBLE`
-- `ArgTypes.UUID`
+You can find all the available argument types on the [ArgTypes](../../argtypes) page.
 
 ### Example Command Arg Types
 
-Shows all Command arguemnt types with different various input types.
+Shows all Command argument types with different various input types.
 
-**NOTE:** When getting the value of an argument during execute you need to pass the context with `someArg.get(commandContext)`. Where `commandContext` is the first variable in the execute funtion.
+**NOTE:** When getting the value of an argument during execute you need to pass the context with `someArg.get(commandContext)`. Where `commandContext` is the first variable in the execute function.
 
 ```java
 // Example usage: /healplayer --health 50 --message "Feels Good" --debug
@@ -204,7 +199,7 @@ public class HealPlayerCommand extends AbstractTargetPlayerCommand {
     private final FlagArg debugArg;
 
     public HealPlayerCommand() {
-        super("healplayer", "Healing a player for an <input> ammount of HP (default: 100)");
+        super("healplayer", "Healing a player for an <input> amount of HP (default: 100)");
 
         // Abstract TargetPlayerCommand passes the player that ran the command by default and implements
         // the use of `--player <value>` to specify someone else
@@ -213,10 +208,10 @@ public class HealPlayerCommand extends AbstractTargetPlayerCommand {
         this.healthArg = this.withDefaultArg("health", "Amount to heal player", ArgTypes.FLOAT, (float)100, "Desc of Default: 100");
 
         // Or you could do the following making the health value required instead of with a default.
-        //    You would need to change the decleration to RequiredArg<Float>
+        //    You would need to change the declaration to RequiredArg<Float>
         // this.healthArg = this.withRequiredArg("health", "Amount to heal player", ArgTypes.FLOAT);
 
-        // Optional args reguare the user the input `--<key> <value>` so the following would require `--message "Good Luck"`
+// Optional args require the user the input `--<key> <value>` so the following would require `--message "Good Luck"`
         this.messageArg = this.withOptionalArg("message", "Message to print while healing", ArgTypes.STRING);
 
         // No type needed due to being a bool
@@ -230,7 +225,7 @@ public class HealPlayerCommand extends AbstractTargetPlayerCommand {
             commandContext.sendMessage(Message.raw("We are debugging"));
         }
 
-        // Health is stored in a generic stat map to allowing mods/future contect to easily add more stats if desired.
+        // Health is stored in a generic stat map to allowing mods/future content to easily add more stats if desired.
         EntityStatMap stats = store.getComponent(ref, EntityStatMap.getComponentType());
         int healthIdx = DefaultEntityStatTypes.getHealth();
         EntityStatValue health = stats.get(healthIdx);
@@ -252,7 +247,7 @@ public class HealPlayerCommand extends AbstractTargetPlayerCommand {
 
 ## Argument Validators
 
-Argument validators are a way to check the command before the command gets executed. They are added with the `addValidator` method on an argument when calling `withXxxArg`. They provide a nice output to the user when an input value is invalid.
+Argument validators are a way to check the command before the command gets executed. They are added with the `addValidator` method on an argument when calling `withXxxArg`. They provide a nice output to the user when an input value is invalid. There are some common validators provided in the `Validators` class such as `greaterThan`, `lessThan`, and `or`, `max`, `range`, etc.
 
 ```java
 ...
@@ -260,18 +255,59 @@ Argument validators are a way to check the command before the command gets execu
     OptionalArg<Integer> healAmount = withOptionalArg("amount", "Heal Amount", ArgTypes.INTEGER)
         .addValidator(Validators.greaterThan(0))
         .addValidator(Validators.lessThan(1000));
-
-    // Custom check example
-    OptionalArg<Integer> healAmount = withOptionalArg("amount", "Heal Amount", ArgTypes.INTEGER)
-            .addValidator( value -> {
-                if (value != null && value <= 0) {
-                    return ValidationResult.error("ammount argument must be a positive number");
-                }
-                return ValidationResult.success();
-            });
 ...
 ```
 
+### Custom Validators
+
+You can also create custom validators by implementing the `com.hypixel.hytale.codec.validation.Validator` interface. The interfaces forces you to implement the `accept` and `updateSchema` method. The `accept` method takes in the argument value and validates it. If the validation fails, you can use the `fail` method of the `com.hypixel.hytale.codec.validation.ValidationResults` class to return an error message.
+The `updateSchema` method is used to update the schema of the command argument. This is used for commands that have dynamic schemas based on the input value. For example, if you have a command that takes in a player name as an argument, you can use the `updateSchema` method to update the schema to include a list of online players for validation.
+
+Here is an example of a custom validator that checks if a string value is equal to a banned word. In this example, the banned word is "badword". If the input value is "badword", the validator will fail and return an error message.
+
+```java
+import com.hypixel.hytale.codec.schema.SchemaContext;
+import com.hypixel.hytale.codec.schema.config.Schema;
+import com.hypixel.hytale.codec.validation.ValidationResults;
+import com.hypixel.hytale.codec.validation.Validator;
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+
+public class MyCustomValidator implements Validator<String> {
+    @Nonnull
+    private final String value;
+
+    public MyCustomValidator(@Nonnull String value) {
+        this.value = value;
+    }
+
+    @Override
+    public void accept(@Nullable String input, @Nonnull ValidationResults results) {
+        if (this.value.equalsIgnoreCase(input)) {
+            results.fail("The given role has been banned.");
+        }
+    }
+
+    @Override
+    public void updateSchema(SchemaContext context, @Nonnull Schema target) {
+        // This method can be used to update the schema of the command argument. This is useful for commands that have dynamic schemas based on the input value. For example, if you have a command that takes in a player name as an argument, you can use the `updateSchema` method to update the schema to include a list of online players for validation.
+        throw new UnsupportedOperationException("Not implemented yet.");
+    }
+}
+```
+
+After the custom validator is created, you can add it to an argument like the following example. In this example, we add the `MyCustomValidator` to a string argument called "role". If the user inputs "badword" as the role, the command will fail and return the error message defined in the `MyCustomValidator`.
+
+```java
+    ...
+    // Custom validator example
+    String bannedRole = "badword";
+
+    OptionalArg<String> roleArg = withOptionalArg("role", "Role to assign", ArgTypes.STRING)
+        .addValidator(new MyCustomValidator(bannedRole));
+    ...
+```
+
 ---
 
 ## Permissions
@@ -312,7 +348,7 @@ This allows the server to control who has access to specific commands. You add t
 
 If you want variants of the same command without doing argument parsing you can instead use `addUsageVariant(new OtherCommandClass())` in the original commands constructor.
 
-The only difference is in the `OtherCommandClass()` constrcutor you don't pass the command name to the super class.
+The only difference is in the `OtherCommandClass()` constructor you don't pass the command name to the super class.
 
 <Callout type="info">
   You can also use `addAliases("some_alias", "some_other_alias")` as a way to add shorthand or other ways to write the same command.
@@ -387,7 +423,7 @@ public class AdminCommand extends AbstractCommandCollection {
     public AdminCommand () {
         super("admin", "Admin commands");
         addSubCommand(new UserCommandCollection());
-        addSybCommand(new ServerCommandCollection);
+        addSubCommand(new ServerCommandCollection);
     }
 }
 ```
@@ -417,5 +453,5 @@ public class MyPlugin extends JavaPlugin {
 
 ## Video Link
 
-_Special Thanks to [TroubleDev](https://www.youtube.com/@TroubleDEV) for his excelent video guide on all of these features._
+_Special Thanks to [TroubleDev](https://www.youtube.com/@TroubleDEV) for his excellent video guide on all of these features._
 _Video Link: [TroubleDev - Hytale's Command API Explained](https://www.youtube.com/watch?v=KnmhG9MDMgo)_
diff --git a/content/docs/da-DK/guides/plugin/creating-events.mdx b/content/docs/da-DK/guides/plugin/creating-events.mdx
index 95863990..d3f0925d 100644
--- a/content/docs/da-DK/guides/plugin/creating-events.mdx
+++ b/content/docs/da-DK/guides/plugin/creating-events.mdx
@@ -1,6 +1,6 @@
 ---
-title: Creating Events
-description: Learn how to create custom events for your Hytale mod.
+title: Creating Events Listeners
+description: Learn how to create event listeners for your Hytale mod.
 authors:
   - name: Neil Revin
     url: https://itsneil.dev
@@ -10,7 +10,7 @@ authors:
 
 ## Event Class
 
-You can import a Event class and create a function with the Event as a argument. [Click here](../../server/events) to look at all available events.
+You can import an Event class and create a function with the Event as an argument. [Click here](../../server/events) to look at all available events.
 
 Example plugin when a player is ready (joins a server):
 
diff --git a/content/docs/da-DK/guides/plugin/item-registry.mdx b/content/docs/da-DK/guides/plugin/item-registry.mdx
new file mode 100644
index 00000000..9a0fd53a
--- /dev/null
+++ b/content/docs/da-DK/guides/plugin/item-registry.mdx
@@ -0,0 +1,95 @@
+---
+title: Working with the Item Registry
+description: Learn how to access and query the game's item registry to list all items, check if items exist, and retrieve item properties.
+authors:
+  - name: Denis
+---
+
+In this guide, you'll learn how to work with Hytale's Item Registry system. This is useful when you need to programmatically list all available items, validate item IDs, or retrieve item properties at runtime.
+
+## Prerequisites
+
+Before diving in, you should be familiar with:
+
+- [Setting up your development environment](./setting-up-env)
+- [Creating commands](./creating-commands) (optional, for testing)
+
+## Required Imports
+
+To work with the Item Registry, you'll need the following imports:
+
+```java
+import com.hypixel.hytale.assetstore.map.DefaultAssetMap;
+import com.hypixel.hytale.server.core.asset.type.item.config.Item;
+```
+
+## Getting the Item Registry
+
+The Item Registry is accessed through the `Item.getAssetMap()` method, which returns a `DefaultAssetMap<String, Item>` containing all registered items in the game:
+
+```java
+DefaultAssetMap<String, Item> itemMap = Item.getAssetMap();
+```
+
+## Listing All Items
+
+To iterate through all items in the registry, you can get the underlying map and loop through its entries:
+
+```java
+DefaultAssetMap<String, Item> itemMap = Item.getAssetMap();
+var map = itemMap.getAssetMap();
+
+for (var entry : map.entrySet()) {
+    String itemId = String.valueOf(entry.getKey());
+    Item item = entry.getValue();
+    
+    // Do something with the item
+    LOGGER.atInfo().log("Item ID: " + itemId);
+}
+```
+
+You can also get the total count of registered items:
+
+```java
+int totalItems = map.size();
+```
+
+## Checking if an Item Exists
+
+To check if a specific item exists in the registry, use `getAsset()` and verify the result:
+
+```java
+public boolean itemExists(String itemId) {
+    var assetMap = Item.getAssetMap();
+    if (assetMap != null) {
+        Item item = assetMap.getAsset(itemId);
+        return item != null && item != Item.UNKNOWN;
+    }
+    return false;
+}
+```
+
+<Callout type="info">
+  The `Item.UNKNOWN` constant represents an invalid or unrecognized item. Always check for both `null` and `Item.UNKNOWN` when validating items.
+</Callout>
+
+## Accessing Item Properties
+
+Once you have an `Item` instance, you can access various properties:
+
+```java
+var assetMap = Item.getAssetMap();
+Item item = assetMap.getAsset("Soil_Grass");
+
+if (item != null && item != Item.UNKNOWN) {
+    String id = item.getId(); // Soil_Grass
+    int maxStack = item.getMaxStack(); // 100
+    boolean isBlock = item.hasBlockType(); // true
+    boolean isConsumable = item.isConsumable(); // false
+}
+```
+
+## Related Guides
+
+- [Inventory Management](./inventory-management) - Learn how to add and remove items from player inventories
+- [Create Custom Item and Interaction](./item-interaction) - Learn how to create your own custom items
diff --git a/content/docs/da-DK/guides/plugin/permission-management.mdx b/content/docs/da-DK/guides/plugin/permission-management.mdx
index 6b7cfd46..55f06101 100644
--- a/content/docs/da-DK/guides/plugin/permission-management.mdx
+++ b/content/docs/da-DK/guides/plugin/permission-management.mdx
@@ -10,132 +10,569 @@ authors:
     link: https://discord.com/users/292656109939064833
   - name: Ivan
     link: https://discord.com/users/505770451218333717
+  - name: ZenithDevHQ
+    link: https://github.com/ZenithDevHQ
 ---
 
-In this guide, you'll learn how to manage permission nodes and groups in your Hytale plugin.
+In this guide, you'll learn how to manage permission nodes and groups in your Hytale plugin. Permissions control what actions players can perform on your server, from basic commands to advanced administrative functions.
 
-## The `PermissionsModule` class
+## What Are Permissions?
 
-The `PermissionsModule` class is responsible for managing permission nodes and groups in your plugin. It provides methods to check, grant and revoke permissions and groups for players. It allows the following operations
+Permissions are string identifiers that control access to features and commands. When a player tries to perform an action (like using a command), the server checks if they have the required permission.
 
-- Add permissions to user
-- Remove permissions from user
-- Add permissions to group (this also creates the group if it doesn't exist)
-- Remove permissions from group
-- Add user to group
-- Remove user from group
-- List all groups for a user
-- Check if a user has a permission (it checks both user and group permissions for the given player UUID)
+**Example permission nodes:**
 
-With this class you cannot:
+- `hytale.command.gamemode` - Permission to use the gamemode command
+- `hytale.editor.brush.use` - Permission to use brush tools
+- `myplugin.teleport.home` - A custom permission for your plugin
 
-- List all defined groups
-- Remove a group
+Permissions follow a hierarchical naming pattern: `namespace.category.action`
 
-### Adding Permission Nodes
+## Key Concepts
 
-You need a `Set<String>` containing all the permission nodes you want to add, these are added on top of the already existing permission nodes the user may have, it is not a replacement.
+Before diving into code, let's understand the core concepts:
+
+| Concept             | Description                                                                |
+| ------------------- | -------------------------------------------------------------------------- |
+| **Permission Node** | A string like `myplugin.feature.use` that represents a specific permission |
+| **Group**           | A named collection of permissions (e.g., "Admin", "VIP", "Default")        |
+| **Provider**        | The backend that stores and retrieves permissions                          |
+| **Wildcard**        | A pattern like `*` or `myplugin.*` that matches multiple permissions       |
+
+### How Permissions Are Checked
+
+When checking if a player has a permission, Hytale follows this order:
+
+1. **User's direct permissions** - Permissions granted directly to the player
+2. **Group permissions** - Permissions from groups the player belongs to
+3. **Virtual groups** - Game-mode-based permissions (e.g., Creative mode grants builder tools)
+4. **Default value** - Falls back to `false` if no match found
+
+<Callout type="info">
+  The first definitive match wins. If a player has a permission granted at the user level, group permissions won't override it.
+</Callout>
+
+---
+
+## The `PermissionsModule` Class
+
+The `PermissionsModule` class is the central hub for managing permissions. Access it using the singleton pattern:
 
 ```java
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.addUserPermission(playerUUID, permissions);
 ```
 
-### Removing Permission Nodes
+### Available Operations
+
+The module supports these operations:
+
+| Operation                     | Method                                          |
+| ----------------------------- | ----------------------------------------------- |
+| Add permissions to user       | `addUserPermission(uuid, permissions)`          |
+| Remove permissions from user  | `removeUserPermission(uuid, permissions)`       |
+| Add permissions to group      | `addGroupPermission(groupName, permissions)`    |
+| Remove permissions from group | `removeGroupPermission(groupName, permissions)` |
+| Add user to group             | `addUserToGroup(uuid, groupName)`               |
+| Remove user from group        | `removeUserFromGroup(uuid, groupName)`          |
+| Get user's groups             | `getGroupsForUser(uuid)`                        |
+| Check permission              | `hasPermission(uuid, permissionNode)`           |
+
+<Callout type="warning">
+  The module does **not** support:
+
+  - Listing all defined groups
+  - Deleting a group entirely
+
+  Groups are implicitly created when you first add permissions to them.
+</Callout>
+
+---
 
-Same as above, we just use the `removeUserPermission` method instead to remove permission nodes.
+## Checking Permissions
+
+The most common operation is checking if a player has a permission.
+
+### Basic Permission Check
+
+```java
+// Returns true if player has the permission, false otherwise
+boolean canUse = PermissionsModule.get().hasPermission(playerUUID, "myplugin.feature.use");
+
+if (canUse) {
+    // Player has permission, allow the action
+} else {
+    // Player lacks permission, deny or show error
+}
+```
+
+### Permission Check with Default Value
+
+You can specify what to return when no permission is explicitly set:
+
+```java
+// Returns true by default if no explicit permission is found
+boolean canUse = PermissionsModule.get().hasPermission(playerUUID, "myplugin.feature.use", true);
+```
+
+This is useful for features that should be enabled by default but can be revoked.
+
+### Using PermissionHolder Interface
+
+Players and command senders implement `PermissionHolder`, allowing direct checks:
+
+```java
+// In a command or event handler where you have access to the player
+if (player.hasPermission("myplugin.admin.manage")) {
+    // Player has admin permission
+}
+```
+
+---
+
+## Managing User Permissions
+
+### Adding Permissions to a User
+
+Permissions are additive - new permissions are added on top of existing ones, not replaced.
+
+```java
+PermissionsModule perms = PermissionsModule.get();
+
+// Add a single permission
+perms.addUserPermission(playerUUID, Set.of("myplugin.vip.chat"));
+
+// Add multiple permissions at once
+Set<String> newPerms = Set.of(
+    "myplugin.vip.chat",
+    "myplugin.vip.fly",
+    "myplugin.vip.kit"
+);
+perms.addUserPermission(playerUUID, newPerms);
+```
+
+### Removing Permissions from a User
 
 ```java
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.removeUserPermission(playerUUID, permissions);
+
+// Remove specific permissions
+Set<String> toRemove = Set.of("myplugin.vip.fly");
+perms.removeUserPermission(playerUUID, toRemove);
 ```
 
-### Add permissions to group
+---
+
+## Managing Groups
+
+Groups let you assign a collection of permissions to multiple players. This is more manageable than assigning permissions individually.
+
+### Adding Permissions to a Group
+
+If the group doesn't exist, it will be created automatically.
 
 ```java
-String groupName = "testGroup";
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.addGroupPermission(groupName, permissions);
+
+// Create/update the "VIP" group with permissions
+Set<String> vipPerms = Set.of(
+    "myplugin.vip.chat",
+    "myplugin.vip.fly",
+    "myplugin.vip.kit"
+);
+perms.addGroupPermission("VIP", vipPerms);
 ```
 
-### Remove permissions from group
+### Removing Permissions from a Group
 
 ```java
-String groupName = "testGroup";
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.removeGroupPermission(groupName, permissions);
+
+// Remove specific permissions from the group
+Set<String> toRemove = Set.of("myplugin.vip.fly");
+perms.removeGroupPermission("VIP", toRemove);
 ```
 
-### Add user to group
+### Adding a User to a Group
 
 ```java
-String groupName = "testGroup";
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.addUserToGroup(playerUUID, groupName);
+
+// Add player to the VIP group - they now have all VIP permissions
+perms.addUserToGroup(playerUUID, "VIP");
 ```
 
-### Remove user from group
+### Removing a User from a Group
 
 ```java
-String groupName = "testGroup";
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.removeUserFromGroup(playerUUID, groupName);
+
+// Remove player from VIP group
+perms.removeUserFromGroup(playerUUID, "VIP");
 ```
 
-### List all groups for a user
+### Getting a User's Groups
 
 ```java
 PermissionsModule perms = PermissionsModule.get();
-perms.getGroupsForUser(playerUUID);
+
+// Get all groups the player belongs to
+Set<String> groups = perms.getGroupsForUser(playerUUID);
+
+for (String group : groups) {
+    System.out.println("Player is in group: " + group);
+}
 ```
 
-### Check Permission Nodes
+---
+
+## Built-in Groups
+
+Hytale includes two default groups:
+
+| Group     | Default Permissions   | Purpose                           |
+| --------- | --------------------- | --------------------------------- |
+| `OP`      | `*` (all permissions) | Server operators with full access |
+| `Default` | None                  | Base group for all players        |
+
+Players without any explicit group assignment are automatically part of the `Default` group.
 
-To check if a player has a specific permission node, you can use the `hasPermission` method.
+---
+
+## Wildcards
+
+Wildcards let you grant or deny multiple permissions with a single pattern.
+
+### Wildcard Patterns
+
+| Pattern             | Meaning                                          |
+| ------------------- | ------------------------------------------------ |
+| `*`                 | Grants **all** permissions                       |
+| `myplugin.*`        | Grants all permissions starting with `myplugin.` |
+| `-*`                | Denies **all** permissions                       |
+| `-myplugin.admin.*` | Denies all admin permissions in your plugin      |
+
+### Example: Admin Group with Wildcards
 
 ```java
-boolean hasPermission = PermissionsModule.hasPermission(playerUUID, "permission.node");
+// Grant all permissions to admins
+perms.addGroupPermission("Admin", Set.of("*"));
+
+// Grant all plugin permissions to moderators
+perms.addGroupPermission("Moderator", Set.of("myplugin.*"));
+
+// Grant all permissions except admin commands
+perms.addGroupPermission("Helper", Set.of(
+    "*",
+    "-myplugin.admin.*"  // Deny admin permissions
+));
 ```
 
-## Additional: Defining your own provider for permissions and groups
+<Callout type="warning">
+  Negation permissions (starting with `-`) take precedence at each level. Use them carefully to avoid accidentally blocking permissions.
+</Callout>
+
+---
+
+## Built-in Permission Nodes
+
+Hytale provides constants for common permissions in the `HytalePermissions` class:
+
+### Command Permissions
+
+```java
+// Generate permission for a command
+String perm = HytalePermissions.fromCommand("gamemode");
+// Result: "hytale.command.gamemode"
+
+// Generate permission for a subcommand
+String perm = HytalePermissions.fromCommand("gamemode", "creative");
+// Result: "hytale.command.gamemode.creative"
+```
+
+### Common Permission Nodes
+
+| Permission                    | Description                  |
+| ----------------------------- | ---------------------------- |
+| `hytale.command.op.add`       | Add players to OP group      |
+| `hytale.command.op.remove`    | Remove players from OP group |
+| `hytale.editor.brush.use`     | Use brush tools              |
+| `hytale.editor.prefab.use`    | Use prefabs                  |
+| `hytale.editor.selection.use` | Use selection tools          |
+| `hytale.editor.history`       | Undo/redo operations         |
+| `hytale.camera.flycam`        | Use fly camera mode          |
+
+---
+
+## Listening to Permission Events
+
+You can react to permission changes using Hytale's event system.
+
+### Available Events
+
+| Event                                            | Triggered When                   |
+| ------------------------------------------------ | -------------------------------- |
+| `PlayerPermissionChangeEvent.PermissionsAdded`   | Permissions added to a user      |
+| `PlayerPermissionChangeEvent.PermissionsRemoved` | Permissions removed from a user  |
+| `PlayerGroupEvent.Added`                         | User added to a group            |
+| `PlayerGroupEvent.Removed`                       | User removed from a group        |
+| `GroupPermissionChangeEvent.Added`               | Permissions added to a group     |
+| `GroupPermissionChangeEvent.Removed`             | Permissions removed from a group |
 
-The PermissionsModule also enables us to define our own PermissionProvider's, this can be useful for:
+### Example: Reacting to Permission Changes
 
-- Cross server permission systems
-- Implementing features missing in the `HytalePermissionsProvider` like permission expiry
+```java
+public class PermissionListener {
+
+    public static void onPermissionsAdded(PlayerPermissionChangeEvent.PermissionsAdded event) {
+        UUID playerUUID = event.getPlayerUuid();
+        Set<String> added = event.getAddedPermissions();
+
+        System.out.println("Permissions added to " + playerUUID + ": " + added);
 
-To implement our PermissionProvider, first we need to define a provider class that implements PermissionProvider:
+        // Maybe notify the player or update cached data
+    }
+
+    public static void onGroupAdded(PlayerGroupEvent.Added event) {
+        UUID playerUUID = event.getPlayerUuid();
+        String groupName = event.getGroupName();
+
+        System.out.println("Player " + playerUUID + " joined group: " + groupName);
+    }
+}
+```
+
+### Registering the Events
 
 ```java
-public class DatabasePermissionProvider implements PermissionProvider
+public class MyPlugin extends JavaPlugin {
+
+    @Override
+    public void setup() {
+        EventRegistry events = this.getEventRegistry();
+
+        events.registerGlobal(
+            PlayerPermissionChangeEvent.PermissionsAdded.class,
+            PermissionListener::onPermissionsAdded
+        );
+
+        events.registerGlobal(
+            PlayerGroupEvent.Added.class,
+            PermissionListener::onGroupAdded
+        );
+    }
+}
 ```
 
-Then we just implement the required methods using a database implementation.
+---
+
+## Creating a Custom Permission Provider
+
+For advanced use cases, you can create your own permission provider. This is useful for:
+
+- Database-backed permissions (MySQL, MongoDB, etc.)
+- Cross-server permission synchronization
+- Custom features like permission expiry or contexts
+
+### Implementing PermissionProvider
+
+```java
+public class DatabasePermissionProvider implements PermissionProvider {
+
+    @Nonnull
+    @Override
+    public String getName() {
+        return "DatabasePermissionProvider";
+    }
+
+    // User permission methods
+    @Override
+    public void addUserPermissions(@Nonnull UUID uuid, @Nonnull Set<String> permissions) {
+        // Save to your database
+    }
+
+    @Override
+    public void removeUserPermissions(@Nonnull UUID uuid, @Nonnull Set<String> permissions) {
+        // Remove from your database
+    }
+
+    @Override
+    public Set<String> getUserPermissions(@Nonnull UUID uuid) {
+        // Query your database
+        return Set.of();
+    }
+
+    // Group permission methods
+    @Override
+    public void addGroupPermissions(@Nonnull String group, @Nonnull Set<String> permissions) {
+        // Save to your database
+    }
+
+    @Override
+    public void removeGroupPermissions(@Nonnull String group, @Nonnull Set<String> permissions) {
+        // Remove from your database
+    }
+
+    @Override
+    public Set<String> getGroupPermissions(@Nonnull String group) {
+        // Query your database
+        return Set.of();
+    }
+
+    // User-group membership methods
+    @Override
+    public void addUserToGroup(@Nonnull UUID uuid, @Nonnull String group) {
+        // Save to your database
+    }
+
+    @Override
+    public void removeUserFromGroup(@Nonnull UUID uuid, @Nonnull String group) {
+        // Remove from your database
+    }
+
+    @Override
+    public Set<String> getGroupsForUser(@Nonnull UUID uuid) {
+        // Query your database
+        return Set.of("Default");
+    }
+}
+```
 
 <Callout type="warning">
-  Hytale will try to use the first available permissions provider to add/remove gamemode groups (i.e. `Creative`, `Adventure`).
+  Hytale automatically assigns players to game-mode groups (like `Creative` or `Adventure`) using the first available provider.
+
+  If your provider throws an error when the group doesn't exist, the player will be disconnected! Always handle missing groups gracefully.
+</Callout>
+
+### Registering Your Provider
 
-  If your provider throws an error (for instance, if the group does not exist) when the server is preparing the player, the player will be disconnected.
+```java
+public class MyPlugin extends JavaPlugin {
+
+    @Override
+    public void setup() {
+        // Add your provider alongside the default one
+        PermissionsModule.get().addProvider(new DatabasePermissionProvider());
+    }
+}
+```
+
+The `PermissionsModule` aggregates permissions from all registered providers. This means:
+
+- Permission checks query all providers
+- Write operations (add/remove) use the **first** provider
+
+### Replacing the Default Provider
+
+If you want full control, you can remove the default provider:
+
+```java
+public class MyPlugin extends JavaPlugin {
+
+    @Override
+    public void setup() {
+        PermissionsModule perms = PermissionsModule.get();
+
+        // Remove the default provider FIRST
+        perms.removeProvider(perms.getFirstPermissionProvider());
+
+        // Then add your provider
+        perms.addProvider(new DatabasePermissionProvider());
+    }
+}
+```
+
+<Callout type="info">
+  When you remove the default provider, the `/op self` command will stop working since it checks for provider tampering.
 </Callout>
 
-We can then register the provider using the built-in permission module:
+---
+
+## Best Practices
+
+### Permission Naming Conventions
+
+Follow the pattern: `namespace.category.action`
 
 ```java
-PermissionsModule.get().addProvider(new DatabasePermissionProvider());
+// Good - clear hierarchy
+"myplugin.admin.ban"
+"myplugin.user.teleport.home"
+"myplugin.vip.chat.color"
+
+// Bad - unclear structure
+"myplugin_ban"
+"teleport"
+"vipChatColor"
 ```
 
-Please note that the `HytalePermissionsProvider` will still be enabled alongside your provider.
-The `PermissionsModule` will aggregate groups and permissions from all available providers.
+### Use Constants for Permissions
 
-If you want to disable the default `HytalePermissionsProvider`, you can use:
+Define your permissions as constants to avoid typos:
 
 ```java
-// put this **before** you add your provider
-PermissionsModule.get().removeProvider(PermissionsModule.get().getFirstPermissionProvider());
+public final class MyPermissions {
+    public static final String ADMIN_BAN = "myplugin.admin.ban";
+    public static final String ADMIN_KICK = "myplugin.admin.kick";
+    public static final String USER_HOME = "myplugin.user.home";
+    public static final String VIP_FLY = "myplugin.vip.fly";
+}
+
+// Usage
+if (player.hasPermission(MyPermissions.ADMIN_BAN)) {
+    // ...
+}
 ```
+
+### Don't Over-Permission
+
+Only create permissions for actions that genuinely need access control. Not everything needs a permission check.
+
+### Thread Safety
+
+If you create a custom provider, ensure it's thread-safe. Permission checks can occur from multiple threads simultaneously. Use `ReadWriteLock` or `ConcurrentHashMap` for your data structures.
+
+---
+
+## In-Game Commands
+
+Hytale provides built-in commands for managing permissions:
+
+### `/op` Command
+
+| Command               | Description                                                        |
+| --------------------- | ------------------------------------------------------------------ |
+| `/op self`            | Toggle your own OP status (singleplayer or with `--allow-op` flag) |
+| `/op add <player>`    | Add a player to the OP group                                       |
+| `/op remove <player>` | Remove a player from the OP group                                  |
+
+### `/perm` Command
+
+Use `/perm --help` in-game for full usage. Common operations:
+
+| Command                                  | Description                   |
+| ---------------------------------------- | ----------------------------- |
+| `/perm user list <uuid>`                 | List user's permissions       |
+| `/perm user add <uuid> <perm>`           | Add permission to user        |
+| `/perm user remove <uuid> <perm>`        | Remove permission from user   |
+| `/perm user group list <uuid>`           | List user's groups            |
+| `/perm user group add <uuid> <group>`    | Add user to group             |
+| `/perm user group remove <uuid> <group>` | Remove user from group        |
+| `/perm group list <group>`               | List group's permissions      |
+| `/perm group add <group> <perm>`         | Add permission to group       |
+| `/perm group remove <group> <perm>`      | Remove permission from group  |
+| `/perm test <perm>`                      | Test if you have a permission |
+
+---
+
+## Summary
+
+You've learned how to:
+
+- **Check permissions** using `PermissionsModule.hasPermission()`
+- **Manage user permissions** with `addUserPermission()` and `removeUserPermission()`
+- **Work with groups** using `addGroupPermission()`, `addUserToGroup()`, etc.
+- **Use wildcards** like `*` and `myplugin.*` for bulk permissions
+- **Listen to events** for permission changes
+- **Create custom providers** for database-backed permissions
+
+For more advanced permission systems with features like inheritance, expiry, and contexts, we're looking into expanding this guide with advanced permission management techniques in the future.
diff --git a/content/docs/da-DK/guides/plugin/setting-up-env.mdx b/content/docs/da-DK/guides/plugin/setting-up-env.mdx
index d2718098..5be5e9e0 100644
--- a/content/docs/da-DK/guides/plugin/setting-up-env.mdx
+++ b/content/docs/da-DK/guides/plugin/setting-up-env.mdx
@@ -4,6 +4,10 @@ description: Learn how to set up your development environment for modding Hytale
 authors:
   - name: Neil Revin
     link: https://itsneil.dev
+  - name: Marcel-TO
+    url: https://marcel-to.net
+  - name: Ádám Liszkai
+    link: https://adaliszk.dev
 ---
 
 This guide will walk you through setting up a complete development environment for Hytale modding, including all necessary tools and dependencies.
@@ -19,24 +23,73 @@ Before we begin, make sure you have:
 
 ## Required Software
 
-### 1. Java Development Kit (JDK)
+### Integrated Development Environment (IDE)
 
+We recommend IntelliJ IDEA Community Edition for Hytale modding. If you use IntelliJ IDEA, **almost everything is built-in**. You can clone a template, open a new project, and start working right away!
+
+1. Download from [JetBrains website](https://www.jetbrains.com/idea/download/)
+2. Install with default settings
+3. Launch and complete the initial setup wizard
+
+When opening a project, wait for indexing to finish, then start coding.
+Now, IDEA may say "No JDK configured" at the top of the source file you have.
+In that case, you can click Download JDK and choose JetBrains JDK 25.
+
+<Callout type="success">
+  If IDEA opened the project without errors, your environment is ready.
+</Callout>
+
+More details by [JetBrains](https://www.jetbrains.com/help/idea/2026.1/run-for-the-first-time.html)
+help page, where we recommend that you also check the
+[SDK configuration](https://www.jetbrains.com/help/idea/2026.1/sdk.html) guide.
+
+<Callout type="info">
+  We recommened following
+  [TheNullicorn's](https://gist.github.com/TheNullicorn/90a619796c40f20ae1fcf13094c1a57d) guide to ensure
+  you are using the correct `Nonnull` in your projects.
+</Callout>
+
+#### What the IDE Does for You
+
+When opened in IntelliJ IDEA, the project automatically:
+
+- Detects and configures Gradle or Maven
+- Downloads all dependencies
+- Sets up project structure and classpaths
+- Configures run/build tasks
+
+You do **not** need to manually install or configure Maven or Gradle if you stay inside the IDE.
+
+Skip to the [Setting Up Your Workspace](#setting-up-your-workspace).
+
+### Manual Setup: Java Development Kit (JDK)
+
+For any other setup, you will need to install and configure your system to have and load Java.
 Hytale modding requires Java 25 or later. We recommend using OpenJDK.
 
-#### Windows
+#### Windows via Installer
 
 1. Download OpenJDK 25 from [Adoptium](https://adoptium.net/)
 2. Run the installer with default settings
+   - Optionally enable feature `Set or Override JAVA_HOME variable` to resolve version related build issues with your project.
 3. Verify installation by opening Command Prompt and running:
 
+#### Windows via Scoop
+
+1. Install Scoop via PowerShell using [scoop.sh](https://scoop.sh/)
+2. Install OpenJDK 25:
+
 ```bash
-java -version
+scoop bucket add java
+scoop install java/openjdk25
 ```
 
 #### macOS
 
+1. Install Brew via Terminal using [brew.sh](https://brew.sh)
+2. Install JDK via Homebrew:
+
 ```bash
-# Using Homebrew
 brew install openjdk@25
 ```
 
@@ -51,22 +104,41 @@ brew install openjdk@25
 
 #### Linux (Ubuntu/Debian)
 
+1. Install JDK via the built-in package repository:
+
 ```bash
 sudo apt update
 sudo apt install openjdk-25-jdk
 ```
 
-### 2. Integrated Development Environment (IDE)
+### Verify installation:
 
-We recommend IntelliJ IDEA Community Edition for Hytale modding.
+Run the following command to see what version of Java you have:
 
-1. Download from [JetBrains website](https://www.jetbrains.com/idea/download/)
-2. Install with default settings
-3. Launch and complete the initial setup wizard
+```bash
+java -version
+```
+
+### Java Build Tool (Optional)
+
+We recommend using a Gradle Wrapper for managing dependencies and building your Hytale plugins. It provides benefits by eliminating the need for a system-wide Gradle installation and ensuring consistent Gradle versions across different environments. (Alternatively you can use Maven, but this guide focuses on Gradle since it is the default for our plugin template.)
+
+The plugin template in the following sections includes a Gradle Wrapper, so you can skip this step if you plan to use the template.
+
+#### Choosing Gradle (if not using the template)
+
+If you prefer to install Gradle manually, follow these steps:
 
-### 3) Java Build Tool
+1. Visit the official website: https://gradle.org/releases/
+2. Download the newest gradle binary: `gradle-9.3.1-bin.zip` (Binary zip archive)
+3. Unzip it
+4. Add the `gradle-9.3.1/bin/` folder to your PATH
+
+You can now try the command `gradle -version` to verify Gradle is installed correctly. Make sure to do this in a fresh new terminal instead of one you had opened from before!
+
+#### Choosing Maven (if not using the template)
 
-We recommend using Apache Maven for managing dependencies and building your Hytale plugins. (Alternatively you can use Gradle, but this guide focuses on Maven.)
+If you prefer to use Maven instead of Gradle, follow these steps to install Maven:
 
 1. Visit the official website: https://maven.apache.org/download.cgi
 2. Download this file: `apache-maven-3.9.12-bin.zip` (Binary zip archive)
@@ -89,22 +161,61 @@ cd MyFirstMod
 
 If you don't have Git installed, you can download the ZIP file from the repository page and extract it to a folder named `MyFirstMod`.
 
-### 2. Open Plugin in your IDEA
+### 2. Open Plugin in your IDE
 
-1. Open IntelliJ IDEA
+1. Open Your IDE (e.g., IntelliJ IDEA)
 2. Click "Open" and navigate to your `MyFirstMod` directory
-3. IntelliJ will automatically detect it as a Maven project
+3. Most IDEs like IntelliJ will automatically detect it as a Gradle project
 4. Wait for the project to index and dependencies to download
 
-<Callout type="info">
-  We recommened following [this](https://gist.github.com/TheNullicorn/90a619796c40f20ae1fcf13094c1a57d) guide to ensure you are using the correct `Nonnull` in your projects.
-</Callout>
+## Alternate Approach: Hytale Dependency
+
+If you prefer to set up your project from scratch without using the template and importing the hytale dependencies manually, ensure your build configuration includes the Hytale repositories and dependencies:
+
+For Gradle, add the following to your `build.gradle.kts`:
+
+```kotlin
+repositories {
+    mavenCentral()
+    maven {
+        name = "hytale"
+        url = uri("https://maven.hytale.com/release") // Or "hytale-pre-release" for pre-release versions
+    }
+}
+dependencies {
+    // + here means the latest version, but you can hard-wire any known version!
+    implementation("com.hypixel.hytale:Server:+")
+}
+```
+
+For Maven, add the following to your `pom.xml`:
+
+```xml
+<project>
+    <repositories>
+        <repository>
+            <id>hytale-release</id> <!-- Or "hytale-pre-release" for pre-release versions -->
+            <url>https://maven.hytale.com/release</url> <!-- Or "https://maven.hytale.com/pre-release" -->
+        </repository>
+    </repositories>
+
+    <dependencies>
+        <dependency>
+            <groupId>com.hypixel.hytale</groupId>
+            <artifactId>Server</artifactId>
+            <!-- Replace with latest version, Hytale provides jars for the last five releases -->
+            <version>LATEST_VERSION_HERE</version>
+            <scope>provided</scope>
+        </dependency>
+    </dependencies>
+</project>
+```
 
 ## Next Steps
 
 Now that you have your development environment set up with the plugin template:
 
-1. **Customize the template** - Edit the `pom.xml` and `manifest.json` file to change your mod's name and details
+1. **Customize the template** - Edit the `settings.gradle.kts`, `build.gradle.kts` and `manifest.json` file to change your mod's name and details
 2. **Explore the code structure** - Familiarize yourself with the template's organization
 3. **Start modding** - Begin writing your first Hytale plugin!
 
diff --git a/content/docs/da-DK/guides/plugin/spawning-entities.mdx b/content/docs/da-DK/guides/plugin/spawning-entities.mdx
index e12c0aea..15be2fb3 100644
--- a/content/docs/da-DK/guides/plugin/spawning-entities.mdx
+++ b/content/docs/da-DK/guides/plugin/spawning-entities.mdx
@@ -36,7 +36,7 @@ Store<EntityStore> store = world.getEntityStore().getStore();
 
 ## Creating Entities
 
-Once you have the `EntityStore` instance, you can start to create a entity and give it components. Entities are just instances of `Holder<EntityStore>` with several components attached to them.
+Once you have the `EntityStore` instance, you can start to create an entity and give it components. Entities are just instances of `Holder<EntityStore>` with several components attached to them.
 
 <Callout type="warning">
   To interact with the `World` instance, some methods require you to run the code inside the world's execution context.
@@ -118,3 +118,48 @@ Finally, we can add the entity to the world by calling the `addEntity` method on
 ```java
 store.addEntity(holder, AddReason.SPAWN);
 ```
+
+## Making the entity persist
+
+Hytale automatically saves all entities, but the `NetworkId` component (required for players to be able to see the entity) needs to be manually added every time the entity is loaded.
+
+### Using a system
+
+If you have a component that is unique to your entities, this can be done by creating and registering a custom system as follows:
+
+```java
+public class AddNetworkIdToMyEntitySystem extends HolderSystem<EntityStore> {
+    private final ComponentType<EntityStore, MyEntityComponent> myEntityComponentType = MyEntityComponent.getComponentType();
+    private final ComponentType<EntityStore, NetworkId> networkIdComponentType = NetworkId.getComponentType();
+    private final Query<EntityStore> query = Query.and(this.myEntityComponentType, Query.not(this.networkIdComponentType));
+
+    @Override
+    public void onEntityAdd(@NotNull Holder<EntityStore> holder, @NotNull AddReason reason, @NotNull Store<EntityStore> store) {
+        if (!holder.getArchetype().contains(NetworkId.getComponentType())) {
+            holder.addComponent(NetworkId.getComponentType(), new NetworkId(store.getExternalData().takeNextNetworkId()));
+        }
+    }
+
+    @Override
+    public void onEntityRemoved(@NotNull Holder<EntityStore> holder, @NotNull RemoveReason reason, @NotNull Store<EntityStore> store) {}
+
+    @Override
+    public @Nullable Query<EntityStore> getQuery() {
+        return query;
+    }
+}
+```
+
+In your plugin's `setup()` function
+
+```java
+this.getEntityStoreRegistry().registerSystem(new AddNetworkIdToMyEntitySystem())
+```
+
+### Using PropComponent
+
+Alternatively you can add `PropComponent` to your entity. Hytale adds `PropComponent` to entities spawned with the Entity Tool, and such entities automatically get `NetworkId` and `PrefabCopyableComponent` (which makes the entity work with prefabs).
+
+<Callout type="warning">
+  There is no guarantee, that Hytale will not add some other behavior to this component in the future, which may break your entity, so be careful if you decide to rely on it.
+</Callout>
diff --git a/content/docs/da-DK/guides/plugin/store-persistent-data.mdx b/content/docs/da-DK/guides/plugin/store-persistent-data.mdx
new file mode 100644
index 00000000..1071dff3
--- /dev/null
+++ b/content/docs/da-DK/guides/plugin/store-persistent-data.mdx
@@ -0,0 +1,171 @@
+---
+title: Storing Persistent Data on the Player
+description: Learn how to save and load persistent data using Components
+authors:
+  - name: Neil Revin
+    url: https://itsneil.dev/
+  - name: ArcticDev
+    url: https://github.com/ArcticRaven
+  - name: oskarscot
+    url: https://oskar.scot
+  - name: JammingEng
+    url: https://github.com/JammingEnd
+---
+
+Here is how to store persistent data using a custom component on a Player.
+
+## Build your Component Class
+
+Creating a custom component class leverages the Component system made with the ECS architecture in mind. For more information on Components, check out the [ECS Guide](../ecs/hytale-ecs-theory#components).
+
+Start by creating your custom component class. This will be extremely similar to how regular components are created, however we'll setup a custom Codec so the server can translate this data to BSON, or the server's internal json encoder.
+
+<Callout type="info">
+  Each variable you want to store in your component must have its own Codec field defined in the BuilderCodec.
+  For more information on how to create custom Codecs, check out the [ECS Codec Guide](../ecs/hytale-ecs-theory#codec).
+</Callout>
+
+```java
+public class YourPlayerData implements Component<EntityStore> {
+
+    // define some vars!
+    private int someInteger;
+    private String someString;
+    private Map<String, String> someMap;
+
+    public static final BuilderCodec<YourPlayerData> CODEC =
+            BuilderCodec.builder(YourPlayerData.class, YourPlayerData::new)
+            .append(new KeyedCodec<>("SomeInteger", Codec.INTEGER),
+                    (data, value) -> data.someInteger = value, // setter
+                    data -> data.someInteger) // getter
+            .addValidator(Validators.nonNull())
+            .add()
+            .append(new KeyedCodec<>("SomeString", Codec.STRING),
+                    (data, value) -> data.someString = value, // setter
+                    data -> data.someString) // getter
+            .add()
+            .append(new KeyedCodec<>("SomeMap",
+                            new MapCodec<>(Codec.STRING, HashMap::new, false)),
+                    (data, value) -> data.someMap = value, // setter
+                    data -> data.someMap) // getter
+            .add()
+            .build();
+
+
+
+    // Getters and Setters are for the purpose of this example omitted.
+
+    // constructor
+    public YourPlayerData() {
+        this.someInteger = 0;
+        this.someString = "";
+        this.someMap = new HashMap<>();
+    }
+
+    // copy constructor for cloning
+    public YourPlayerData(YourPlayerData clone) {
+        this.someInteger = clone.someInteger;
+        this.someString = clone.someString;
+        this.someMap = clone.someMap;
+    }
+
+    @Nonnull
+    @Override
+    public Component<EntityStore> clone() {
+        return new YourPlayerData(this);
+    }
+}
+```
+
+## Register your Component
+
+Inside your main class's `setup()` method, register your new Component.
+
+```java
+public class YourPlugin extends JavaPlugin {
+
+    private ComponentType<EntityStore, YourPlayerData> yourPlayerDataComponent;
+
+    public YourPlugin(@Nonnull JavaPluginInit init) {
+        super(init);
+    }
+
+    @Override
+    protected void setup(){
+        this.yourPlayerDataComponent = this.getEntityStoreRegistry().registerComponent(
+            YourPlayerData.class,
+            "YourPlayerDataComponent",
+            YourPlayerData.CODEC
+        );
+    }
+
+    public ComponentType<EntityStore, YourPlayerData> getYourPlayerDataComponent() {
+        return this.yourPlayerDataComponent;
+    }
+}
+```
+
+## Using your Component
+
+To use your newly created component, you can add the Component to a player using the `addComponent` method, although this only adds it temporarily, meaning when the player/entity leaves the world, the component is removed. You can use `putComponent` to ensure the component persists between sessions.
+
+```java
+// You will need the Ref and Store to apply components
+private void someEntryMethod(@Nonnull Ref<EntityStore> ref, @Nonnull Store<EntityStore> store)
+{
+       // Any entity will work, for now we will use the player
+      Player player = (Player) store.getComponent(ref, Player.getComponentType());
+
+      // since we're using putComponent, it could be useful to check if it already exists on the player in case we want to update it
+     if(store.getComponent(ref, YourPlugin.instance().getYourPlayerDataComponent()) != null)
+     {
+          // here we implement logic that updates the component
+         var comp = store.getComponent(ref, YourPlugin.instance().getYourPlayerDataComponent())
+         // declare public fields or methods in the component class
+         comp.SomeString = "An Updated Field";
+     } else {
+          // Here we put the component
+          var myCustomComp = new CustomComponent();
+          // declare public fields or methods in the component class
+          myCustomComp.SomeString = "Edited String";
+
+          // putComponent allows you to insert declared objects
+          store.putComponent(ref, YourPlugin.instance().getYourPlayerDataComponent(), myCustomComp);
+     }
+}
+```
+
+## Using your Data
+
+Your component will be stored within the `Store<EntityStore>` when added to the player. In the provided example,
+we'll fetch this data off the player using the `ensureAndGetComponent()` method, which will add the component to
+the player if it does not exist with the default values.
+
+```java
+public class IncompleteCustomCommand extends AbstractPlayerCommand {
+
+    public IncompleteCustomCommand() {
+        super("nope", "don't use this command");
+    }
+
+    @Override
+    protected void execute(
+        @NonNullDecl CommandContext commandContext,
+        @NonNullDecl Store<EntityStore> store,
+        @NonNullDecl Ref<EntityStore> ref,
+        @NonNullDecl PlayerRef playerRef,
+        @NonNullDecl World world
+    ) {
+        YourPlayerData customData = store.ensureAndGetComponent(ref, YourPlugin.instance().getYourPlayerDataComponent());
+        // ensureAndGetComponent adds the component to the ref, with the default values defined inside your component.
+ 		// use your data
+    }
+}
+```
+
+And that's it! Your data will now be saved and loaded automatically with the player.
+
+Using custom components to store persistent data on players is a powerful way to maintain state across sessions.
+By following the steps outlined above, you can easily create, register, and utilize your own data structures within the Hytale ECS framework.
+This approach ensures that your data is seamlessly integrated with the game's existing systems.
+For more information about Hytale's Entity Component System visit the [Hytale ECS Theory](https://hytalemodding.dev/en/docs/guides/ecs/hytale-ecs-theory) guide.
diff --git a/content/docs/da-DK/guides/plugin/teleporting-players.mdx b/content/docs/da-DK/guides/plugin/teleporting-players.mdx
index 57cee77f..32ce0435 100644
--- a/content/docs/da-DK/guides/plugin/teleporting-players.mdx
+++ b/content/docs/da-DK/guides/plugin/teleporting-players.mdx
@@ -1,26 +1,32 @@
 ---
 title: Teleporting the player
 description: Learn how to teleport the player.
+authors:
+  - name: oskarscot
+    url: https://oskar.scot
 ---
 
-To teleport players in Hytale, you will need to get a `World` object so we can safely run the teleport on the world thread. The world thread manages all entity updates, so modifying entities off-thread can crash the server or cause inconsistent state.
-Next, we get the entity store and make a `Teleport` object.
-We add a `Teleport` component to the player’s entity reference in the entity store. This triggers the teleportation logic for that player.
+Teleporting players in Hytale works by simply attaching a `Teleport` component to a player with the desired world and transform.
+You can only trigger teleports from a world where the player is currently present.
+Teleport itself is a component but it also provides factory methods to configure the Teleport. Just as with any entity component, an EntityStore and a Ref to the EntityStore is required
+
+We can create a simple teleport utility like this:
 
 ```java
-public static void teleportPlayer(Player player, int x, int y, int z) {
-        World world = player.getWorld();
-        if (world == null) return;
-        world.execute(() -> {
-            if (player.getReference() == null) return;
-            Store<EntityStore> store = player.getReference().getStore();
-            Teleport teleport = Teleport.createForPlayer(world,
-                new Vector3d(x ,y, z), // Target position
-                new Vector3f(0, 0, 0)  // Target rotation (pitch, yaw, roll)
-            );
+public static void teleportPlayer(Ref<EntityStore> ref, Store<EntityStore> store, World targetWorld, double x, double y, double z) {                                                                                       
+    Transform transform = new Transform(x, y, z);                                                                                                                           
+    Teleport teleport = Teleport.createForPlayer(targetWorld, transform);                                                                                                   
+    store.addComponent(ref, Teleport.getComponentType(), teleport);                                                                                                         
+}  
+```
 
-            store.addComponent(player.getReference(), Teleport.getComponentType(), teleport);
-        });
+A `Transform` is a representation of a position Vector3d and rotation Vector3f which works in the following way:
 
-}
+```java
+Transform transform = new Transform(
+    new Vector3d(x, y, z),      // Position
+    new Rotation(yaw, pitch, 0) // Rotation, last value seems to always be 0
+);
+Teleport teleport = Teleport.createForPlayer(targetWorld, transform);
+store.addComponent(ref, Teleport.getComponentType(), teleport);
 ```
diff --git a/content/docs/da-DK/guides/plugin/tracking-mod-analytics-with-hstats.mdx b/content/docs/da-DK/guides/plugin/tracking-mod-analytics-with-hstats.mdx
new file mode 100644
index 00000000..45c022e0
--- /dev/null
+++ b/content/docs/da-DK/guides/plugin/tracking-mod-analytics-with-hstats.mdx
@@ -0,0 +1,65 @@
+---
+title: Tracking Mod Analytics with HStats
+description: Learn how you can track Analytics for your Hytale Mod for Free using hstats.dev
+authors:
+  - name: Al3x
+    url: https://hstats.dev
+---
+
+In this guide, you will learn how to integrate HStats into your Plugin/Mod which will allow you to track how many Servers are using it along with other stats.
+
+<Callout type="info">
+  HStats is a third-party tool and is not affiliated with HytaleModding or Hypixel Studios
+</Callout>
+
+# Step 1: Register your Mod to HStats
+
+Before you touch any code, you will need to add your mod to the HStats website which will give you a UUID for your mod.
+
+- Create or Login to an Account on https://hstats.dev
+- Navigate to the dashboard page (https://hstats.dev/dashboard)
+- On the left, type in your mod's name and click "Add Mod"
+- Keep note of the UUID generated for later.
+
+# Step 2: Add the HStats Class to Your Project
+
+To keep things simple, HStats uses a single Java class file that handles everything for you.
+
+- Download / Copy the File from the GitHub page (https://github.com/hstats-dev/HStatsExamplePlugin/blob/main/src/main/java/com/al3x/HStats.java)
+- Paste into your Project. You should now have a HStats.java file somewhere in your projects directory.
+- Update the package name from com.al3x to whatever fits your project.
+
+# Step 3: Initialize HStats in your code
+
+You only need to add one line of code to your mod's setup method in your main class to start tracking.
+
+`new HStats("YOUR-MOD-UUID", "1.0.0");`
+
+Replace `YOUR-MOD-UUID` with the Mod UUID we made note of earlier and change the `1.0.0` version to whatever version your mod is currently on.
+
+Your setup method should now look something like this:
+
+```java
+@Override
+protected void setup() {
+  super.setup();
+  new HStats("c34a2b2a-afd8-4d6a-821e-7a63e12c5ea6", "1.0.0");
+}
+```
+
+# Extras
+
+Your done! Your mod should now be listed under the Mods page (https://hstats.dev/mods) as well as under your dashboard.
+
+Servers using your mod should now post updates about every minute to HStats which you can view in the Dashboard.
+
+### Embeds
+
+HStats allows you to generate an Embed Card that you can place on your CurseForge or GitHub page. This is useful for server owners to be able to see how many other servers are using your mod.
+
+- In your dashboard, scroll down to the Embed Card section.
+- Customize the appearance (Light/Dark mode, layout, etc).
+- Copy the generated URL to display your "Active Servers" and "Players Online" live on your mod's description page
+
+Heres an example of what they look like:
+![HStats Example](https://api.hstats.dev/api/embed/d52fa672-6966-47b2-b501-1a11bddebac3/card.svg?theme=light\&layout=compact\&size=md\&show_id=true\&dark=false)
diff --git a/content/docs/da-DK/guides/plugin/world-gen.mdx b/content/docs/da-DK/guides/plugin/world-gen.mdx
index 4c23b0c9..7b193ffd 100644
--- a/content/docs/da-DK/guides/plugin/world-gen.mdx
+++ b/content/docs/da-DK/guides/plugin/world-gen.mdx
@@ -100,7 +100,7 @@ Biome biome = biomeGen.generateBiomeAt(zoneResult, seed, x, z);
 
 ### Zone & Cave Integration
 
-Each zone defines it's own cave patterns:
+Each zone defines its own cave patterns:
 
 ```java
 Zone zone = /* ... */;
diff --git a/content/docs/da-DK/guides/prefabs.mdx b/content/docs/da-DK/guides/prefabs.mdx
index 08404b30..b1a55109 100644
--- a/content/docs/da-DK/guides/prefabs.mdx
+++ b/content/docs/da-DK/guides/prefabs.mdx
@@ -14,7 +14,7 @@ Prefabs are Hytale's way of creating reusable structures.
 There are a few fundamental concepts to understand about prefabs:
 
 - Users interact with prefabs via a prefab editing world.
-- Prefabs the physical structures in the game world, and are saved as JSON files.
+- Prefabs are the physical structures in the game world, and are saved as JSON files.
 
 ## How to Create a Prefab
 
diff --git a/content/docs/da-DK/official-documentation/custom-ui/common-styling.mdx b/content/docs/da-DK/official-documentation/custom-ui/common-styling.mdx
new file mode 100644
index 00000000..c36e3e3a
--- /dev/null
+++ b/content/docs/da-DK/official-documentation/custom-ui/common-styling.mdx
@@ -0,0 +1,50 @@
+---
+title: Common Styling
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# Common Styling
+
+## Common UI Styling Library
+
+This document describes the shared UI components and styles defined in `Common.ui`.
+
+---
+
+### Styles
+
+We are providing some styles that can be re-used in any custom UI that, provide a cohesive UI experience with the core game UI. These styles are available in the `Common.ui` file.
+
+You can find a list of all the styles defined with live examples by running the `/ui-gallery` command ingame.
+
+<Callout type="warning">
+  This command is not available yet, but will be in a future patch.
+</Callout>
+
+![Gallery](/assets/official-documentation/ui/gallery.png)
+
+### Importing
+
+To use these styles in your UI file:
+
+```
+$Common = "Common.ui";
+
+// Then reference styles and components:
+$Common.@TextButton { @Text = "My Button"; }
+$Common.@Container { ... }
+```
+
+<Callout type="info">
+  The `Common.ui` file is at `Common/UI/Custom/Common.ui` within the Hytale pack. If your custom ui document is in a subfolder of `Common/UI/Custom/`, reference it via relative path traversal:
+
+  ```
+  $Common = "../Common.ui";
+  ```
+
+  You can find more info about paths [here](markup#path).
+</Callout>
diff --git a/content/docs/da-DK/official-documentation/custom-ui/index.mdx b/content/docs/da-DK/official-documentation/custom-ui/index.mdx
new file mode 100644
index 00000000..f94c4e88
--- /dev/null
+++ b/content/docs/da-DK/official-documentation/custom-ui/index.mdx
@@ -0,0 +1,125 @@
+---
+title: Custom UI
+icon: LayoutDashboard
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# Custom UI
+
+## What is Custom UI?
+
+Custom UI is Hytale's framework for creating **custom user interfaces** controlled by the game server. Unlike the built-in Client UI (which is part of the game client and cannot be modified), Server UI allows you to create interactive screens and HUD overlays through Java plugins and asset packs.
+
+As a modder, Custom UI gives you the power to:
+
+- **Create custom interactive pages** - Shop interfaces, quest dialogs, server settings menus, admin panels
+- **Add custom HUD overlays** - Quest trackers, status displays, custom health bars, server information
+- **Design with markup** - Use `.ui` files to define reusable UI templates
+- **Handle user interactions** - Respond to button clicks, form submissions, and other events
+- **Localize your UI** - Support multiple languages using the game's translation system
+
+## How Custom UI Fits Into Hytale's UI
+
+Hytale's user interface is divided into two main categories:
+
+### Client UI (Not Moddable)
+
+Built-in interfaces controlled by the C# game client:
+
+- Main menu and settings
+- Character creation
+- Built-in HUD (health, hotbar, chat)
+- Inventory and crafting screens
+- Development tools
+
+**You cannot modify these** - they are part of the core game client.
+
+### In-Game UI (Moddable via Server)
+
+Server-controlled interfaces that you can create and customize:
+
+#### Custom Pages
+
+Full-screen interactive overlays that appear during gameplay:
+
+- Can be dismissed by the player (ESC key)
+- Capture all input (keyboard and mouse)
+- Support loading states while waiting for server responses
+- Perfect for: shops, dialogs, menus, configuration screens
+
+#### Custom HUDs
+
+Persistent overlay elements drawn on top of the game world:
+
+- Display-only (no user interaction)
+- Always visible during gameplay
+- Lightweight and non-intrusive
+- Perfect for: quest objectives, status indicators, server info panels
+
+## Architecture Overview
+
+Server UI uses a **command-based architecture**:
+
+```
+┌─────────────────────┐         ┌──────────────────────┐
+│   Java Server       │         │    C# Client         │
+│   (Your Plugin)     │         │    (Game)            │
+├─────────────────────┤         ├──────────────────────┤
+│                     │         │                      │
+│ InteractiveCustomUI │         │   CustomPage or      │
+│ Page                │         │   CustomHud          │
+│   ↓ build()         ├────────→│     ↓ Apply          │
+│ UICommandBuilder    │         │   Element Tree       │
+│   - append()        │         │     ↓ Layout         │
+│   - set()           │         │   Rendered UI        │
+│   - clear()         │         │                      │
+│                     │         │                      │
+│ ↓ handleDataEvent() │← Events │   User Interaction   │
+│   Process input     │         │   (click, type, etc) │
+│   sendUpdate()      │         │                      │
+└─────────────────────┘         └──────────────────────┘
+```
+
+**The flow:**
+
+1. Your Java code builds UI using `UICommandBuilder`
+2. Commands are sent to the client as data
+3. Client parses `.ui` markup files and creates visual elements
+4. User interacts with the UI
+5. Events are sent back to your Java code
+6. You process events and send updates back
+
+## Key Principles
+
+### Declarative, Not Imperative
+
+You don't create UI objects directly. Instead, you send **commands** that describe what you want:
+
+- "Append this button template to that container"
+- "Set this label's text to 'Hello World'"
+- "Clear all children from this list"
+
+### Asset-Driven
+
+UI structure is defined in `.ui` markup files (assets), not hardcoded in Java. This enables:
+
+- Designers to modify layouts without touching code
+- Reusable UI components
+- Consistent visual language
+
+### Event-Driven
+
+User interactions trigger events that flow back to your server code. You register event bindings and handle them in `handleDataEvent()`.
+
+### Selector-Based
+
+You target specific UI elements using **selectors:**
+
+- `#MyButton` - Element with ID "MyButton"
+- `#List[0]` - First child of element "List"
+- `#List[0] #Title` - Element with ID "Title" in the first child of element "List"
+- `#Label.TextColor` - The TextColor property of element "Label"
diff --git a/content/docs/da-DK/official-documentation/custom-ui/layout.mdx b/content/docs/da-DK/official-documentation/custom-ui/layout.mdx
new file mode 100644
index 00000000..0a24ca09
--- /dev/null
+++ b/content/docs/da-DK/official-documentation/custom-ui/layout.mdx
@@ -0,0 +1,492 @@
+---
+title: Layout
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# Layout
+
+The layout system determines how UI elements are positioned and sized on screen. Understanding layout is crucial for creating well-structured, responsive interfaces.
+
+## Layout Fundamentals
+
+Every UI element has:
+
+- **Container Rectangle** - The space allocated by the parent
+- **Anchor** - How the element positions/sizes itself within the container
+- **Padding** - Inner spacing that affects child layout
+- **LayoutMode** - How the element arranges its children (if it's a container)
+
+```
+┌─────────────────────────────────────┐
+│  Container Rectangle (from parent)  │
+│  ┌───────────────────────────────┐  │
+│  │  Anchored Rectangle           │  │
+│  │  ┌─────────────────────────┐  │  │
+│  │  │ Padding                 │  │  │
+│  │  │  ┌───────────────────┐  │  │  │
+│  │  │  │  Content Area     │  │  │  │
+│  │  │  └───────────────────┘  │  │  │
+│  │  └─────────────────────────┘  │  │
+│  └───────────────────────────────┘  │
+└─────────────────────────────────────┘
+```
+
+## Anchor
+
+`Anchor` controls how an element positions and sizes itself within its container rectangle.
+
+### Fixed Size
+
+```
+Button {
+    Anchor: (Width: 200, Height: 40);
+}
+```
+
+Creates a 200×40 pixel button.
+
+### Positioning
+
+```
+Label {
+    Anchor: (Top: 10, Left: 20, Width: 100, Height: 30);
+}
+```
+
+- **Top**: 10 pixels from container's top edge
+- **Left**: 20 pixels from container's left edge
+- **Width**: 100 pixels wide
+- **Height**: 30 pixels tall
+
+### Anchoring to Edges
+
+```
+Button {
+    Anchor: (Bottom: 10, Right: 10, Width: 100, Height: 30);
+}
+```
+
+Anchors the button to the bottom-right corner, 10 pixels from each edge.
+
+### Stretching
+
+```
+Group {
+    Anchor: (Top: 0, Bottom: 0, Left: 0, Right: 0);
+}
+```
+
+Stretches to fill the entire container (all edges at 0 pixels).
+
+**Shorthand:**
+
+```
+Group {
+    Anchor: (Full: 0);
+}
+```
+
+### Mixed Anchoring
+
+```
+Panel {
+    Anchor: (Top: 10, Bottom: 10, Left: 20, Width: 300);
+}
+```
+
+- Fixed width of 300 pixels
+- Stretches vertically between top and bottom edges
+- 10 pixels from top and bottom
+- 20 pixels from left
+
+## Padding
+
+`Padding` creates inner spacing, affecting where children are positioned.
+
+### Uniform Padding
+
+```
+Group {
+    Padding: (Full: 20);
+}
+```
+
+20 pixels of padding on all sides.
+
+### Directional Padding
+
+```
+Group {
+    Padding: (Top: 10, Bottom: 20, Left: 15, Right: 15);
+}
+```
+
+Different padding per edge.
+
+### Shorthand
+
+```
+// Horizontal and vertical
+Group {
+    Padding: (Horizontal: 20, Vertical: 10);
+}
+
+// Equivalent to:
+// Top: 10, Bottom: 10, Left: 20, Right: 20
+```
+
+### Effect on Children
+
+```
+Group {
+    Anchor: (Width: 200, Height: 100);
+    Padding: (Full: 10);
+
+    Label {
+        Anchor: (Full: 0);
+    }
+}
+```
+
+The label fills the group, but there's a 10-pixel gap on all sides due to padding.
+
+```
+┌──────────────────────┐
+│ Group (200×100)      │
+│  ┌────────────────┐  │
+│  │ Label          │  │ ← 10px padding all around
+│  │                │  │
+│  └────────────────┘  │
+└──────────────────────┘
+```
+
+## LayoutMode
+
+`LayoutMode` determines how a container arranges its children.
+
+### Top (Vertical Stack)
+
+```
+Group {
+    LayoutMode: Top;
+
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+}
+```
+
+Children stack vertically from top to bottom:
+
+```
+┌──────────┐
+│ Button 1 │
+├──────────┤
+│ Button 2 │
+├──────────┤
+│ Button 3 │
+└──────────┘
+
+
+```
+
+Each child's `Anchor.Bottom` adds spacing between elements:
+
+```
+Button { Anchor: (Height: 30, Bottom: 10); }  // 10px gap after this button
+```
+
+### Bottom (Vertical Stack)
+
+```
+Group {
+    LayoutMode: Bottom;
+
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+}
+```
+
+Children stack vertically from top to bottom but aligned to the bottom edge of the parent:
+
+```
+
+
+
+┌──────────┐
+│ Button 1 │
+├──────────┤
+│ Button 2 │
+├──────────┤
+│ Button 3 │
+└──────────┘
+```
+
+### Left (Horizontal Stack)
+
+```
+Group {
+    LayoutMode: Left;
+
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+}
+```
+
+Children arrange horizontally from left to right:
+
+```
+┌────────┬────────┬────────┐
+│ Button │ Button │ Button │
+│   1    │   2    │   3    │
+└────────┴────────┴────────┘
+```
+
+Use `Anchor.Right` for spacing between elements.
+
+### Right (Horizontal Stack)
+
+```
+Group {
+    LayoutMode: Right;
+
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+}
+```
+
+Children arrange horizontally from left to right but aligned to the right side of the parent:
+
+```
+                                                                 ┌────────┬────────┬────────┐
+                                                                 │ Button │ Button │ Button │
+                                                                 │   1    │   2    │   3    │
+                                                                 └────────┴────────┴────────┘
+```
+
+### Center
+
+```
+Group {
+    LayoutMode: Center;
+
+    Group #Dialog {
+        Anchor: (Width: 400, Height: 300);
+    }
+}
+```
+
+Centers the children horizontally.
+
+### Middle
+
+```
+Group {
+    LayoutMode: Middle;
+
+    Group #Dialog {
+        Anchor: (Width: 400, Height: 300);
+    }
+}
+```
+
+Centers the children vertically.
+
+### CenterMiddle (Horizontal Stack, Fully Centered)
+
+```
+Group {
+    LayoutMode: CenterMiddle;
+
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+}
+```
+
+Children stack horizontally from left to right, centered both horizontally and vertically within the parent:
+
+```
+┌────────────────────────────────────────────┐
+│                                            │
+│                                            │
+│         ┌──────┐ ┌──────┐ ┌──────┐         │
+│         │  B1  │ │  B2  │ │  B3  │         │
+│         └──────┘ └──────┘ └──────┘         │
+│                                            │
+│                                            │
+└────────────────────────────────────────────┘
+```
+
+---
+
+### MiddleCenter (Vertical Stack, Fully Centered)
+
+```
+Group {
+    LayoutMode: MiddleCenter;
+
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+}
+```
+
+Children stack vertically from top to bottom, centered both horizontally and vertically within the parent:
+
+```
+┌────────────────────────────────────────────┐
+│                                            │
+│              ┌──────────┐                  │
+│              │ Button 1 │                  │
+│              ├──────────┤                  │
+│              │ Button 2 │                  │
+│              ├──────────┤                  │
+│              │ Button 3 │                  │
+│              └──────────┘                  │
+│                                            │
+└────────────────────────────────────────────┘
+```
+
+---
+
+### Full
+
+```
+Group {
+    LayoutMode: Full;
+
+    Label {
+        Anchor: (Top: 20, Left: 20, Width: 100, Height: 30);
+    }
+}
+```
+
+Children use absolute positioning via their `Anchor` properties.
+
+### TopScrolling
+
+```
+Group {
+    LayoutMode: TopScrolling;
+    ScrollbarStyle: $Common.@DefaultScrollbar;
+
+    // ... many children
+}
+```
+
+Like `Top`, but adds a scrollbar if content exceeds container height.
+
+Or use `BottomScrolling` for bottom-aligned content.
+
+### LeftScrolling
+
+```
+Group {
+    LayoutMode: LeftScrolling;
+    ScrollbarStyle: $Common.@DefaultScrollbar;
+
+    // ... many children
+}
+```
+
+Like `Left`, but adds a scrollbar for horizontal scrolling.
+
+Or use `RightScrolling` for right-aligned content.
+
+### LeftCenterWrap (Wrapping Horizontal Stack, Horizontally Centered)
+
+```
+Group {
+    LayoutMode: LeftCenterWrap;
+
+    Button { Anchor: (Width: 80, Height: 30); }
+    Button { Anchor: (Width: 80, Height: 30); }
+    Button { Anchor: (Width: 80, Height: 30); }
+    Button { Anchor: (Width: 80, Height: 30); }
+    Button { Anchor: (Width: 80, Height: 30); }
+}
+```
+
+Children flow left to right. When there's no more horizontal space, they wrap to the next row. Each row is horizontally centered within the parent:
+
+```
+┌────────────────────────────────────────────┐
+│                                            │
+│       ┌──────┐ ┌──────┐ ┌──────┐           │
+│       │  B1  │ │  B2  │ │  B3  │           │
+│       └──────┘ └──────┘ └──────┘           │
+│            ┌──────┐ ┌──────┐               │
+│            │  B4  │ │  B5  │               │
+│            └──────┘ └──────┘               │
+│                                            │
+└────────────────────────────────────────────┘
+```
+
+## FlexWeight
+
+`FlexWeight` distributes remaining space among children.
+
+```
+Group {
+    LayoutMode: Left;
+    Anchor: (Width: 400);
+
+    Button {
+        Anchor: (Width: 100);
+    }
+
+    Group {
+        FlexWeight: 1;  // Takes all remaining space
+    }
+
+    Button {
+        Anchor: (Width: 100);
+    }
+}
+```
+
+Result:
+
+- First button: 100px
+- Middle group: 200px (400 - 100 - 100 = 200)
+- Last button: 100px
+
+### Multiple FlexWeights
+
+```
+Group {
+    LayoutMode: Left;
+    Anchor: (Width: 600);
+
+    Group { FlexWeight: 1; }
+    Group { FlexWeight: 2; }
+    Group { FlexWeight: 1; }
+}
+```
+
+Remaining space (600px) is split:
+
+- First group: 600 × (1/4) = 150px
+- Second group: 600 × (2/4) = 300px
+- Third group: 600 × (1/4) = 150px
+
+## Visibility
+
+```
+Button #HiddenButton {
+    Visible: false;
+}
+```
+
+**Effect:**
+
+- Element and its children are not displayed
+- Element is **not included in layout** (doesn't take up space)
diff --git a/content/docs/da-DK/official-documentation/custom-ui/markup.mdx b/content/docs/da-DK/official-documentation/custom-ui/markup.mdx
new file mode 100644
index 00000000..564110ed
--- /dev/null
+++ b/content/docs/da-DK/official-documentation/custom-ui/markup.mdx
@@ -0,0 +1,226 @@
+---
+title: Markup
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# Markup
+
+## Markup
+
+An element is the basic building block of a user interface. There are various types of elements with different properties, which are documented below.
+
+Here's what the syntax looks like:
+
+```
+// Basic declaration of an element
+// with its Anchor property set to attach on all sides of its parent
+// with 10 pixels of margin
+Group { Anchor: (Left: 10, Top: 10, Right: 10, Bottom: 10); }
+
+Group { Anchor: (Full: 10); } // More concise version
+
+// Declaration of a Label with a name
+// (can be used to access the element from game code)
+Label #MyLabel {
+  Style: LabelStyle(FontSize: 16); // or just Style: (FontSize: 16), type can be inferred.
+  Text: "Hi! I am text.";
+}
+
+// Declaration of a Group containing 2 children
+// You can use FlexWeight to distribute any left-over space after explicit widths/heights have been subtracted
+Group {
+  LayoutMode: Left;
+  Label { Text: "Child 1"; FlexWeight: 2; }
+  Label { Text: "Child 2"; FlexWeight: 1; }
+}
+```
+
+### Documents
+
+A UI document (_.ui_ file) contains trees of elements. There can be multiple root elements.
+
+### Named Expressions
+
+Named expressions can be declared at any level of a document (including at the root) and will be scoped to that subtree, though they need to be declared at the top of the block.
+
+```
+// Example of named expressions, declared and used with @ prefix
+@Title = "Hytale";
+@ExtraSpacing = 5;
+
+Label {
+  Text: @Title;
+  Style: (LetterSpacing: 2 + @ExtraSpacing);
+}
+```
+
+You can use the spread operator `...` to reuse a named expression while overriding some of its fields:
+
+```
+@MyBaseStyle = LabelStyle(FontSize: 24, LetterSpacing: 2);
+
+Label {
+  Style: (...@MyBaseStyle, FontSize: 36);
+}
+```
+
+You can even layer multiple named expressions like so:
+
+```
+@TitleStyle = LabelStyle(FontSize: 24, HorizontalAlignment: Center);
+@SpacedTextStyle = LabelStyle(LetterSpacing: 2);
+
+Label {
+  Style: (...@BigTextStyle, ...@SpacedTextStyle);
+}
+```
+
+#### Document references
+
+A document can reference another document and access its named expressions.
+
+```
+// Document references are defined with $ prefix
+$Common = "../Common.ui";
+
+TextButton {
+  Style: $Common.@DefaultButtonStyle;
+}
+```
+
+### Templates
+
+You can declare a reusable bit of interface as a named expression and then instantiate it as many times as you want in the tree while customizing it.
+
+You can override local named expressions as well as insert additional children at any point in the template tree. However, local named expressions must be defined at the very top of the block, before properties and child elements.
+
+```
+// This is the template
+@Row = Group {
+  Anchor: (Height: 50);
+  Label #Label { Anchor: (Left: 0, Width: 100); Text: @LabelText; }
+  Group #Content { Anchor: (Left: 100); }
+};
+
+// Here we'll be using it twice in the document tree
+Group #Rows {
+  LayoutMode: TopScrolling;
+
+  @Row #MyFirstRow {
+    @LabelText = "First row";
+    #Content { TextInput {} }
+  }
+
+  @Row #MySecondRow {
+    @LabelText = "Second row";
+  }
+}
+```
+
+### Property Types
+
+#### Basic Types
+
+- **Boolean**
+  - `Visible: false;`
+  - `Visible: true;`
+- **Int**
+  - `Height: 20;`
+- **Float, Double, Decimal**
+  - `Min: 0.2;`
+- **String**
+  - `Text: "Hi!";`
+- **Char**
+  - `PasswordChar: "*";`
+  - _Note: The syntax is the same as a string, however a value of this type cannot contain more than one character!_
+- **Color**
+  - `Background: #ffffff;`&#x20;
+- **Objects**
+  - `Style: (Background: #ffffff)`
+- **Array**&#x20;
+  - `TextSpans: [(Text: "Hi", IsBold: true)]`
+
+#### Translations
+
+Translation keys can be referenced anywhere in markup where you can provide a string, and they are then converted to a string when an element gets instantiated.
+
+**Example:**
+
+```
+Label {
+  Text: %ui.general.cancel;
+}
+```
+
+#### Colors
+
+A color literal can be written as follows:
+
+- `#rrggbb`: 6-digit hexadecimal representation for red, green, blue (fully opaque)
+- `#rrggbb(a.a)`: 6-digit hexadecimal representation for red, green, blue with alpha between 0 and 1
+- `#rrggbbaa`: 8-digit hexadecimal representation for red, green, blue and alpha
+
+```
+Group {
+  Background: #000000(0.3);
+}
+```
+
+<Callout>
+  The `#rrggbb(a.a)` format is prefered over the `#rrggbbaa` format for
+  readability reasons.
+</Callout>
+
+#### Font Name
+
+Font names can be referenced directly by their string ID. Internally this is using a custom type called `UIFontName`, however strings will be converted automatically to this type in markup.
+
+```
+Label {
+  Text: "Hi";
+  Style: (FontName: "Secondary");
+}
+```
+
+**Available Font Names**
+
+- _Default_ - This is the default font that is used for most text and is always used unless a different option has been specified
+- _Secondary_ - This font is mostly used for headlines or elements that are supposed to stick out
+- _Mono_ - This is only used for development; For things such as profiling or error overlays.
+
+#### Path
+
+We can reference other UI assets with the `UIPath` type. Similar to `UIFontName`_,_ Strings are automatically converted to a `UIPath`. Paths are always relative to the file where they have been declared in. Looking up _MyButton.png_ in _Menu/MyAwesomeMenu.ui_ will result in _Menu/MyButton.png_. If you want to reference a file that is in a parent folder you can go back one directory by writing two dots (_../MyButton.png_).
+
+The markup syntax of a `UIPath` is the same as a String. (e.g. `Path: "Test.png"`)
+
+Here are some more examples:
+
+| UIPath             | .ui File                              | Resulting Path    |
+| ------------------ | ------------------------------------- | ----------------- |
+| MyButton.png       | Menu/MyAwesomeMenu.ui                 | Menu/MyButton.png |
+| ../MyButton.png    | Menu/MyAwesomeMenu.ui                 | MyButton.png      |
+| ../../MyButton.png | Menu/Popup/Templates/MyAwesomeMenu.ui | Menu/MyButton.png |
+
+#### Objects
+
+Objects contain a set of properties. In this example we are assigning an Anchor object to the _Anchor_ property:
+
+```
+Group {
+  Anchor: (
+   Height: 10,
+   Width: 20
+ );
+}
+```
+
+You can find all objects that can be used in markup [here](type-documentation#elements).
+
+## Visual Studio Code Extension
+
+There is an official extension for Visual Studio Code which adds syntax highlighting for .ui files. You can find it [here](https://marketplace.visualstudio.com/items?itemName=HypixelStudiosCanadaInc.vscode-hytaleui).
diff --git a/content/docs/da-DK/official-documentation/custom-ui/type-documentation/index.mdx b/content/docs/da-DK/official-documentation/custom-ui/type-documentation/index.mdx
new file mode 100644
index 00000000..69cea406
--- /dev/null
+++ b/content/docs/da-DK/official-documentation/custom-ui/type-documentation/index.mdx
@@ -0,0 +1,127 @@
+---
+title: Type Documentation
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# Type Documentation
+
+This is a generated list of UI elements accessible by markup. More information about the User Interface framework can be found in the main documentation.
+
+## Elements
+
+- [ActionButton](type-documentation/elements/actionbutton)
+- [AssetImage](type-documentation/elements/assetimage)
+- [BackButton](type-documentation/elements/backbutton)
+- [BlockSelector](type-documentation/elements/blockselector)
+- [Button](type-documentation/elements/button)
+- [CharacterPreviewComponent](type-documentation/elements/characterpreviewcomponent)
+- [CheckBox](type-documentation/elements/checkbox)
+- [CheckBoxContainer](type-documentation/elements/checkboxcontainer)
+- [CircularProgressBar](type-documentation/elements/circularprogressbar)
+- [CodeEditor](type-documentation/elements/codeeditor)
+- [ColorOptionGrid](type-documentation/elements/coloroptiongrid)
+- [ColorPicker](type-documentation/lements/colorpicker)
+- [ColorPickerDropdownBox](type-documentation/elements/colorpickerdropdownbox)
+- [CompactTextField](type-documentation/elements/compacttextfield)
+- [DropdownBox](type-documentation/elements/dropdownbox)
+- [DropdownEntry](type-documentation/elements/dropdownentry)
+- [DynamicPane](type-documentation/elements/dynamicpane)
+- [DynamicPaneContainer](type-documentation/elements/dynamicpanecontainer)
+- [FloatSlider](type-documentation/elements/floatslider)
+- [FloatSliderNumberField](type-documentation/elements/floatslidernumberfield)
+- [Group](type-documentation/elements/group)
+- [HotkeyLabel](type-documentation/elements/hotkeylabel)
+- [ItemGrid](type-documentation/elements/itemgrid)
+- [ItemIcon](type-documentation/elements/itemicon)
+- [ItemPreviewComponent](type-documentation/elements/itempreviewcomponent)
+- [ItemSlot](type-documentation/elements/itemslot)
+- [ItemSlotButton](type-documentation/elements/itemslotbutton)
+- [Label](type-documentation/elements/label)
+- [LabeledCheckBox](type-documentation/elements/labeledcheckbox)
+- [MenuItem](type-documentation/elements/menuitem)
+- [MultilineTextField](type-documentation/elements/multilinetextfield)
+- [NumberField](type-documentation/elements/numberfield)
+- [Panel](type-documentation/elements/panel)
+- [ProgressBar](type-documentation/elements/progressbar)
+- [ReorderableList](type-documentation/elements/reorderablelist)
+- [ReorderableListGrip](type-documentation/elements/reorderablelistgrip)
+- [SceneBlur](type-documentation/elements/sceneblur)
+- [Slider](type-documentation/elements/slider)
+- [SliderNumberField](type-documentation/elements/slidernumberfield)
+- [Sprite](type-documentation/elements/sprite)
+- [TabButton](type-documentation/elements/tabbutton)
+- [TabNavigation](type-documentation/elements/tabnavigation)
+- [TextButton](type-documentation/elements/textbutton)
+- [TextField](type-documentation/elements/textfield)
+- [TimerLabel](type-documentation/elements/timerlabel)
+- [ToggleButton](type-documentation/elements/togglebutton)
+
+## Property Types
+
+- [Anchor](type-documentation/property-types/anchor)
+- [BlockSelectorStyle](type-documentation/property-types/blockselectorstyle)
+- [ButtonSounds](type-documentation/property-types/buttonsounds)
+- [ButtonStyle](type-documentation/property-types/buttonstyle)
+- [ButtonStyleState](type-documentation/property-types/buttonstylestate)
+- [CheckBoxStyle](type-documentation/property-types/checkboxstyle)
+- [CheckBoxStyleState](type-documentation/property-types/checkboxstylestate)
+- [ClientItemStack](type-documentation/property-types/clientitemstack)
+- [ColorOptionGridStyle](type-documentation/property-types/coloroptiongridstyle)
+- [ColorPickerDropdownBoxStateBackground](type-documentation/property-types/colorpickerdropdownboxstatebackground)
+- [ColorPickerDropdownBoxStyle](type-documentation/property-types/colorpickerdropdownboxstyle)
+- [ColorPickerStyle](type-documentation/property-types/colorpickerstyle)
+- [DropdownBoxSearchInputStyle](type-documentation/property-types/dropdownboxsearchinputstyle)
+- [DropdownBoxSounds](type-documentation/property-types/dropdownboxsounds)
+- [DropdownBoxStyle](type-documentation/property-types/dropdownboxstyle)
+- [InputFieldButtonStyle](type-documentation/property-types/inputfieldbuttonstyle)
+- [InputFieldDecorationStyle](type-documentation/property-types/inputfielddecorationstyle)
+- [InputFieldDecorationStyleState](type-documentation/property-types/inputfielddecorationstylestate)
+- [InputFieldIcon](type-documentation/property-types/inputfieldicon)
+- [InputFieldStyle](type-documentation/property-types/inputfieldstyle)
+- [ItemGridSlot](type-documentation/property-types/itemgridslot)
+- [ItemGridStyle](type-documentation/property-types/itemgridstyle)
+- [LabeledCheckBoxStyle](type-documentation/property-types/labeledcheckboxstyle)
+- [LabeledCheckBoxStyleState](type-documentation/property-types/labeledcheckboxstylestate)
+- [LabelSpan](type-documentation/property-types/labelspan)
+- [LabelStyle](type-documentation/property-types/labelstyle)
+- [NumberFieldFormat](type-documentation/property-types/numberfieldformat)
+- [Padding](type-documentation/property-types/padding)
+- [PatchStyle](type-documentation/property-types/patchstyle)
+- [PopupStyle](type-documentation/property-types/popupstyle)
+- [ScrollbarStyle](type-documentation/property-types/scrollbarstyle)
+- [SliderStyle](type-documentation/property-types/sliderstyle)
+- [SoundStyle](type-documentation/property-types/soundstyle)
+- [SpriteFrame](type-documentation/property-types/spriteframe)
+- [SubMenuItemStyle](type-documentation/property-types/submenuitemstyle)
+- [SubMenuItemStyleState](type-documentation/property-types/submenuitemstylestate)
+- [Tab](type-documentation/property-types/tab)
+- [TabNavigationStyle](type-documentation/property-types/tabnavigationstyle)
+- [TabStyle](type-documentation/property-types/tabstyle)
+- [TabStyleState](type-documentation/property-types/tabstylestate)
+- [TextButtonStyle](type-documentation/property-types/textbuttonstyle)
+- [TextButtonStyleState](type-documentation/property-types/textbuttonstylestate)
+- [TextTooltipStyle](type-documentation/property-types/texttooltipstyle)
+- [ToggleButtonStyle](type-documentation/property-types/togglebuttonstyle)
+- [ToggleButtonStyleState](type-documentation/property-types/togglebuttonstylestate)
+
+## Enums
+
+- [ActionButtonAlignment](type-documentation/enums/actionbuttonalignment)
+- [CodeEditorLanguage](type-documentation/enums/codeeditorlanguage)
+- [ColorFormat](type-documentation/enums/colorformat)
+- [DropdownBoxAlign](type-documentation/enums/dropdownboxalign)
+- [InputFieldButtonSide](type-documentation/enums/inputfieldbuttonside)
+- [InputFieldIconSide](type-documentation/enums/inputfieldiconside)
+- [ItemGridInfoDisplayMode](type-documentation/enums/itemgridinfodisplaymode)
+- [LabelAlignment](type-documentation/enums/labelalignment)
+- [LayoutMode](type-documentation/enums/layoutmode)
+- [MouseWheelScrollBehaviourType](type-documentation/enums/mousewheelscrollbehaviourtype)
+- [ProgressBarAlignment](type-documentation/enums/progressbaralignment)
+- [ProgressBarDirection](type-documentation/enums/progressbardirection)
+- [ResizeType](type-documentation/enums/resizetype)
+- [TimerDirection](type-documentation/enums/timerdirection)
+- [TooltipAlignment](type-documentation/enums/tooltipalignment)
diff --git a/content/docs/da-DK/official-documentation/npc/2-getting-started-with-templates.mdx b/content/docs/da-DK/official-documentation/npc/2-getting-started-with-templates.mdx
index 91081ca1..99d078e0 100644
--- a/content/docs/da-DK/official-documentation/npc/2-getting-started-with-templates.mdx
+++ b/content/docs/da-DK/official-documentation/npc/2-getting-started-with-templates.mdx
@@ -9,7 +9,7 @@ authors:
 
 There are no hard and fast rules for making a start on a template. I like to duplicate **BlankTemplate** and start from there because it already provides the basic structure of the file.
 
-This leaves me with the following template (`Template_Goblin_Ogre.json`): (note: the file could be looking different in the current version of the game)
+This leaves me with the following template (`Template_Goblin_Ogre.json`): (**note: the file could be looking different in the current version of the game**)
 
 ```json
 {
@@ -33,7 +33,7 @@ This leaves me with the following template (`Template_Goblin_Ogre.json`): (note:
     }
   },
   "Appearance": { "Compute": "Appearance" },
-  "DropList": { "Compute": "Droplist" },
+  "DropList": { "Compute": "DropList" },
   "MaxHealth": { "Compute": "MaxHealth" },
   "MotionControllerList": [
     {
@@ -65,10 +65,10 @@ And the following variant (`Goblin_Ogre.json`) next to the template. There's a t
   "Type": "Variant",
   "Reference": "Template_Goblin_Ogre",
   "Modify": {
-    "Appearance": "Goblin_Ogre",
+    "Appearance": "Goblin",
     "MaxHealth": 124
   }
 }
 ```
 
-Our artists have defined the `Goblin_Ogre` appearance already so I'm going to use that.
+Our artists have not yet finished animations for the `Goblin_Ogre`, for that sake of the tutorial I am going to use appearance `Goblin`, because it offers a more complete set of animations that we will need.
diff --git a/content/docs/da-DK/official-documentation/worldgen/pack-tutorial/asset-packs.mdx b/content/docs/da-DK/official-documentation/worldgen/pack-tutorial/asset-packs.mdx
index 38809fad..dcf1f3b9 100644
--- a/content/docs/da-DK/official-documentation/worldgen/pack-tutorial/asset-packs.mdx
+++ b/content/docs/da-DK/official-documentation/worldgen/pack-tutorial/asset-packs.mdx
@@ -9,13 +9,13 @@ authors:
 
 <OfficialDocumentationNotice />
 
-# How to modify Hytale
+# How to modify Hytale?
 
-## What's an Asset Pack
+## What's an Asset Pack?
 
-Hytales gameplay is driven by assets in the game that can be modified by creators. Asset Packs are our solution to let you override or add features to the base game with your own work. These can in the form of zip files of folders, which contain a custom set of assets. This is not the only way for a creator to change Hytale but this is the most accessible form.;
+Hytales gameplay is driven by assets in the game that can be modified by creators. Asset Packs are our solution to let you override or add features to the base game with your own work. These can be the form of zip files of folders, which contain a custom set of assets. This is not the only way for a creator to change Hytale but this is the most accessible form.;
 
-### How do I make an Asset Pack
+### How do I make an Asset Pack?
 
 <video controls className="my-6 aspect-video w-full rounded-lg border">
   <source src="https://cdn.internal.hytalemodding.dev/guides/official/how-to-asset-pack.mp4" type="video/mp4" />
@@ -48,7 +48,7 @@ An asset pack is typically a zip or folder, with a `manifest.json` inside. This
 }
 ```
 
-### Where are they stored
+### Where are they stored?
 
 Asset Packs are stored with other mods in the Mods folder.
 
@@ -76,7 +76,7 @@ C:\Users\<user>\AppData\Roaming\Hytale\UserData\Saves\New World 5\mods
 
 When you have Asset Packs or Mods installed, these will appear in the New World menu under the Options menu.;
 
-### How do I change an existing asset
+### How do I change an existing asset?
 
 <video controls className="my-6 aspect-video w-full rounded-lg border">
   <source src="https://cdn.internal.hytalemodding.dev/guides/official/how-to-asset.mp4" type="video/mp4" />
diff --git a/content/docs/da-DK/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx b/content/docs/da-DK/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx
index 44528376..24e628b5 100644
--- a/content/docs/da-DK/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx
+++ b/content/docs/da-DK/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx
@@ -106,7 +106,7 @@ If a BaseHeight is provided, the TopY and BottomY values are relative to the Bas
 
 Applies a Material Provider slot on a set of horizontal stripes of blocks of varying thickness and position. Below is an example image of basalt stripes into a stone cliff.
 
-{/* ![](https://540086904-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F7KAmBkOg6d13nZCkf9ku%2Fuploads%2FbcxO9LpArn8gPCaBwFg5%2Funknown.png?alt=media&token=1c72b67a-8253-4d03-8c64-1ad5f6830050) */}
+![Example of basalt stripes](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/basalt-stripes-example.png)
 
 #### Parameters:
 
diff --git a/content/docs/da-DK/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx b/content/docs/da-DK/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx
index 5e34acd4..a4418473 100644
--- a/content/docs/da-DK/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx
+++ b/content/docs/da-DK/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx
@@ -294,7 +294,7 @@ Combines all the positions into a single Positioins field.
 
 ---
 
-### SimpleHoritontal
+### SimpleHorizontal
 
 Keeps only the positions that are within the provided range.
 
diff --git a/content/docs/da-DK/official-documentation/worldgen/worldgen-tutorial/README.mdx b/content/docs/da-DK/official-documentation/worldgen/worldgen-tutorial/README.mdx
new file mode 100644
index 00000000..5f66d245
--- /dev/null
+++ b/content/docs/da-DK/official-documentation/worldgen/worldgen-tutorial/README.mdx
@@ -0,0 +1,166 @@
+---
+title: How to edit and create Biomes
+description: Explores where world generation assets can be found and how to edit them.
+---
+
+### Where are the Assets
+
+World generation assets are kept in the HytaleGenerator directory within the assets.
+
+```
+/Server/HytaleGenerator/
+```
+
+<div className="flex flex-row rounded-lg border p-4">
+  <div className="flex-1/2 border-r pr-4">
+    ```
+    /Biomes
+    ```
+
+    Biome assets, with content configurations.
+  </div>
+
+  <div className="flex-1/2 pl-4">
+    ```
+    /WorldStructure
+    ```
+
+    Generator files that define which biomes spawn together.
+  </div>
+</div>
+
+<div className="flex flex-row rounded-lg border p-4">
+  <div className="flex-1/2 border-r pr-4">
+    ```
+    /Density
+    ```
+
+    Density assets that can be referenced by any other assets.
+  </div>
+
+  <div className="flex-1/2 pl-4">
+    ```
+    /Assignments
+    ```
+
+    Prop assets that can be referenced by any Biome assets.
+  </div>
+</div>
+
+***
+
+An example of this structure can be found bellow, packed in an asset pack with the instance configuration.
+
+[https://drive.google.com/file/d/1sIz_CluANIIe3n8vNiOi-4PQdeqCO0qY/view?usp=drive_link](https://drive.google.com/file/d/1sIz_CluANIIe3n8vNiOi-4PQdeqCO0qY/view?usp=drive_link)
+
+<Callout>
+  Ensure you place your asset pack in the correct directory, under Mods.
+</Callout>
+
+### How to visit our worlds
+
+https://drive.google.com/file/d/1BJurxyj-taE-PXWm04bk7Dl6X7ZHTH92/view?usp=sharing
+
+#### Requirements
+
+- You must be an **Operator** in the world.
+  - To do this, run <mark style="color:$danger;">`/op self`</mark>
+- You must be in **Creative mode**.
+  - Press the <mark style="color:$danger;">`O`</mark> key, O for Orange.&#x20;
+
+The generation assets define a set of generators but on their own you cannot visit these. Currently you require an Instance with a generator that will allow you to visit your work.
+
+```
+/Server/Instances/
+```
+
+Instances are separate worlds that players can join using the `/instances` command. Each instance has an `Instance.bson` configuration asset that specifies which generator to use, among other worldly settings.
+
+```json
+{
+  "WorldGen": {
+    "Type": "HytaleGenerator",
+    "WorldStructure": "Basic",
+    "playerSpawn" : {
+      "X" : 123,
+      "Y" : 480,
+      "Z" : 10000,
+      "Pitch" : 0,
+      "Yaw" : 0,
+      "Roll" : 0
+    }
+  }
+}
+```
+
+<Callout>
+  You can create custom instances for different world structures and biomes as you need them.
+</Callout>
+
+### How to edit Biomes
+
+<video>
+  <source src="https://cdn.internal.hytalemodding.dev/guides/official/How-to-edit-Biomes.mp4" type="video/mp4" />
+</video>
+
+We currently use the Hytale Node Editor when editing world generation assets. This can be accessed while in-game from the Content Creation menu when pressing B. The node editor is then found under the asset editor dropdown on the upper left.&#x20;
+
+![Node Editor 1](/assets/official-documentation/worldgen/worldgen-tutorial/biomes/node-editor-1.png)
+
+Once you have the Hytale Node Editor open, through the file menu you can open Biomes by navigating to the Biomes directory and selecting one from your pack.&#x20;
+
+```
+/Server/HytaleGenerator/Biomes/
+```
+
+### Biome Asset Structure
+
+Every Biome has a root Biome node, this node splits into 5 structures. This is covered briefly but more information on each field can be found on the World Generation Concepts page.
+
+![Node Editor 2](/assets/official-documentation/worldgen/worldgen-tutorial/biomes/node-editor-2.png)
+
+<Callout>
+  Each biome is for the most part self contained, meaning it has control over what appears with the biome. The only exception to this are Base Heights.
+</Callout>
+
+<Tabs>
+  <Tab value="Terrain">
+    Mathematical function nodes that calculate the physical shape of the Biome's terrain.
+  </Tab>
+
+  <Tab value="Materials">
+    Logical nodes that determine what materials (blocks) make up a Biome's terrain.
+  </Tab>
+
+  <Tab value="Props">
+    Function nodes that add objects like prefabs and decorations to the terrain.
+  </Tab>
+
+  <Tab value="Environments">
+    Logical nodes that determine the environment asset at a given coordinate within the biome. This asset determines things like weather, NPC spawns, and sounds.
+  </Tab>
+
+  <Tab value="Tints">
+    Logical function nodes that determine a colour code that can be used by certain blocks in the world. Typically this will be grasses and soils.
+  </Tab>
+</Tabs>
+
+### How to preview your work
+
+[https://drive.google.com/file/d/1mNcHn9LhFnWDF0DzWFH6_YllmKAUvUry/view?t=6](https://drive.google.com/file/d/1mNcHn9LhFnWDF0DzWFH6_YllmKAUvUry/view?t=6)
+
+Once you are in an Instance world with the Hytale Generator active you will only be able to see your work by generating new chunks. There are a few ways to do this.
+
+The viewport command selects an area around the Player that will live reload as you make changes to the generator.&#x20;
+
+```
+/viewport --radius 5 
+```
+
+You can also create a new world to show your changes.&#x20;
+
+```
+/instances spawn <instance> 
+```
+
+The last option is to simply fly south, new chunks will generate with the changes made.
diff --git a/content/docs/da-DK/quick-start.mdx b/content/docs/da-DK/quick-start.mdx
index 653644f4..249d803a 100644
--- a/content/docs/da-DK/quick-start.mdx
+++ b/content/docs/da-DK/quick-start.mdx
@@ -9,3 +9,8 @@ Welcome to the Hytale modding documentation! Here you'll find everything you nee
 * [Setting up your dev environment](./guides/plugin/setting-up-env)
 * [Entity Component System (ECS)](./guides/ecs/entity-component-system)
 * [Publishing your mod](./publishing)
+
+### Useful Links
+
+* [Kaupenjoe's Modding Videos](https://www.youtube.com/@ModdingByKaupenjoe)
+* [TroubleDEV's Modding Videos](https://www.youtube.com/@TroubleDEV)
diff --git a/content/docs/da-DK/server/argtypes.mdx b/content/docs/da-DK/server/argtypes.mdx
new file mode 100644
index 00000000..e54a442e
--- /dev/null
+++ b/content/docs/da-DK/server/argtypes.mdx
@@ -0,0 +1,61 @@
+---
+title: ArgTypes
+description: Available ArgTypes
+icon: List
+full: true
+authors:
+  - name: Valeena
+---
+
+| Name                        | Target Class                           | Description                                                                                                                               |   |
+| :-------------------------- | :------------------------------------- | :---------------------------------------------------------------------------------------------------------------------------------------- | - |
+| Boolean                     | java.lang.Boolean                      | A 'true' or 'false' input                                                                                                                 |   |
+| Integer                     | java.lang.Integer                      | A whole number                                                                                                                            |   |
+| String                      | java.lang.String                       | Words, text, numbers, letters. To input more than one word at a time, you may need to wrap it with double quotes (`"my fancy sentence"`). |   |
+| Float                       | java.lang.Float                        | A floating-pointer number                                                                                                                 |   |
+| Double                      | java.lang.Double                       | A decimal number                                                                                                                          |   |
+| UUID                        | java.util.UUID                         | A UUID (Universally Unique IDentifier)                                                                                                    |   |
+| Player_UUID                 | java.util.UUID                         | A UUID or an online player username                                                                                                       |   |
+| Game_Profile_Lookup_Async   | ProfileServiceClient.PublicGameProfile | A player UUID or username. If not found locally, performs a remote lookup via the Profile Service.                                        |   |
+| Relative_Double_Coord       | Coord                                  | An x, y, or z coordinate as a decimal, optionally relative by specifying a tilde (~) in front of the number                               |   |
+| Relative_Int_Coord          | IntCoord                               | An x, y, or z coordinate as a whole number, optionally relative by specifying a tilde (~) in front of the number                          |   |
+| Relative_Integer            | RelativeInteger                        | A tilde to mark an integer relative to a base                                                                                             |   |
+| Relative_Float              | RelativeFloat                          | A tilde to mark a float relative to a base                                                                                                |   |
+| Player_Ref                  | PlayerRef                              | A UUID or an online player's username                                                                                                     |   |
+| World                       | World                                  | A world folder name                                                                                                                       |   |
+| Model_Asset                 | ModelAsset                             | A reference to an Asset of type Model                                                                                                     |   |
+| Weather_Asset               | Weather                                | A reference to an Asset of type Weather                                                                                                   |   |
+| Interaction_Asset           | Interaction                            | A reference to an Asset of type Interaction                                                                                               |   |
+| Root_Interaction_Asset      | RootInteraction                        | A reference to an Asset of type Root Interaction                                                                                          |   |
+| Effect_Asset                | EntityEffect                           | A refernece to an Asset of type EntityEffect                                                                                              |   |
+| Environment_Asset           | Environment                            | A reference to an Asset of type Environment                                                                                               |   |
+| Item_Asset                  | Item                                   | A reference to an Asset of type Item                                                                                                      |   |
+| Block_Type_Asset            | BlockType                              | A reference to an Asset of type BlockType                                                                                                 |   |
+| Particle_System             | ParticleSystem                         | A reference to an Asset of type ParticleSystem                                                                                            |   |
+| Hitbox_Collision_Config     | HitboxCollisionConfig                  | A reference to an Asset of type HitboxCollisionConfig                                                                                     |   |
+| Repulsion_Config            | RepulsionConfig                        | A reference to an Asset of type RepulsionConfig                                                                                           |   |
+| Sound_Event_Asset           | SoundEvent                             | A reference to an Asset of type SoundEvent                                                                                                |   |
+| Ambiance_Fx_Asset           | AmbianceFX                             | A reference to an Asset of type AmbianceFX                                                                                                |   |
+| Sound_Category              | SoundCategory                          | A sound category (sfx, music, ambient, ui)                                                                                                |   |
+| Entity_ID                   | `ArgWrapper<EntityWrappedArg, UUID>`   | A UUID representing an entity id                                                                                                          |   |
+| Integer_Comparison_Operator | IntegerComparisonOperator              | A mathematical sign for integer comparison                                                                                                |   |
+| Integer_Operation           | IntegerOperation                       | A mathematical sign for performing an operation                                                                                           |   |
+| Int_Range                   | `Pair<Integer, Integer>`               | Two integers representing a minimum and maximum of a range                                                                                |   |
+| Relative_Int_Range          | RelativeIntRange                       | Two integers representing a minimum and maximum of a range                                                                                |   |
+| Vector2I                    | Vector2i                               | Two integers, generally corresponding to x/z axis                                                                                         |   |
+| Vector3I                    | Vector3i                               | Three integers, generally corresponding to x/y/z axis                                                                                     |   |
+| Relative_Vector3I           | RelativeVector3i                       | Three optionally relative integers, generally corresponding to x/y/z axis                                                                 |   |
+| Relative_Block_Position     | RelativeIntPosition                    | A position with three integer coordinates, representing a block's location in world space.                                                |   |
+| Relative_Position           | Relative                               | A position with three decimal coordinates, representing a location in world space.                                                        |   |
+| Relative_Chunk_Position     | RealtiveChunkPosition                  | A position with two integer coordinates (x, z), representing a chunk's location.                                                          |   |
+| Rotation                    | Vector3f                               | A rotation with three coordinates, representing the pitch, yaw, and roll respectively                                                     |   |
+| Block_Type_Key              | String                                 | A block type                                                                                                                              |   |
+| Block_ID                    | Integer                                | A block type, converted to an int id                                                                                                      |   |
+| Color                       | Integer                                | A color value in hex format, hex integer, or decimal integer                                                                              |   |
+| Weighted_Block_Type         | `Pair<Integer, String>`                | A weight corresponding to a blocktype                                                                                                     |   |
+| Weighted_Block_Entry        | String                                 | A block with optional weight prefix                                                                                                       |   |
+| Block_Pattern               | BlockPattern                           | A list of blocks with optional weights                                                                                                    |   |
+| Individual_Block_Mask       | BlockMask                              | Create a block mask using symbols and block names                                                                                         |   |
+| Block_Mask                  | BlockMask                              | A tick rate value (e.g., 30tps, 33ms, or 30)                                                                                              |   |
+| Tick_Rate                   | Integer                                | A list of block masks that combine together                                                                                               |   |
+| Game_Mode                   | GameMode                               | GameMode                                                                                                                                  |   |
diff --git a/content/docs/da-DK/server/interaction-reference.mdx b/content/docs/da-DK/server/interaction-reference.mdx
new file mode 100644
index 00000000..6c0d01b3
--- /dev/null
+++ b/content/docs/da-DK/server/interaction-reference.mdx
@@ -0,0 +1,1586 @@
+---
+title: Interactions
+description: A list of most Interaction types provided by Hypixel, along with the meaning of their fields, and how they fit together.
+icon: List
+authors:
+  - name: Stephen Baynham
+    url: https://github.com/cannibalvox
+---
+
+### The Interaction Base Type
+
+All interactions of every type below are inherited from Interaction and have these fields.
+
+**Interaction Fields**
+
+| Field Name                | Type                                                                 | Required? | Notes                                                                                                                                                                                                                       |
+| ------------------------- | -------------------------------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| ViewDistance              | `Double`<br />(Default: 96.0)                                        | **No**    | Distance in blocks at which other players can see the effects from this interaction.                                                                                                                                        |
+| Effects                   | `InteractionEffects`                                                 | **No**    | Sound, animations, and particle effects that should trigger when this interaction begins executing.                                                                                                                         |
+| HorizontalSpeedMultiplier | `Float`<br />(Default: 1.0)                                          | **No**    | Multiplier applied to the User entity's movement speed while this interaction is executing                                                                                                                                  |
+| RunTime                   | `Float`                                                              | **No**    | If provided, this interaction will continue executing for at least this long before the interaction chain moves onto the next interaction.                                                                                  |
+| CancelOnItemChange        | `Boolean`<br />(Default: true)                                       | **No**    | If true, this interaction will be cancelled if the User entity's held item changes during execution. This can happen either due to the selected hotbar slot changing or the contents of the item's inventory slot changing. |
+| Rules                     | `InteractionRules`                                                   | **Yes**   | If provided, adds additional limitations and cancellation conditions to this interaction.                                                                                                                                   |
+| Settings                  | `Map`<br />(Key Type: `GameMode`, Value Type: `InteractionSettings`) | **No**    | If provided, adds additional per-GameMode settings to the interaction.                                                                                                                                                      |
+| Camera                    | `InteractionCameraSettings`                                          | **No**    | Arrays of camera motion keyframes for cutscenes and reveals.                                                                                                                                                                |
+
+**GameMode Values**
+
+- `Creative`: The game is currently in Creative Mode
+- `Adventure`: The game is currently in Adventure Mode
+
+**InteractionEffects Fields**
+
+| Field Name               | Type                                              | Required? | Notes                                                                                                                                                 |
+| ------------------------ | ------------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Particles                | `Array`<br />(Element Type: `ModelParticle`)      | **No**    | Particle systems to activate when this interaction begins if the player is in third-person mode.                                                      |
+| FirstPersonParticles     | `Array`<br />(Element Type: `ModelParticle`)      | **No**    | Particle systems to activate when this interaction begins if the player is in first-person mode.                                                      |
+| WorldSoundEventId        | `Asset`<br />(Asset Type: `SoundEvent`)           | **No**    | A sound to play in the world at the User entity's location when this interaction begins.<br />**The SoundEvent must be single-channel (mono) sound.** |
+| LocalSoundEventId        | `Asset`<br />(Asset Type: `SoundEvent`)           | **No**    | A 2D sound to play for the User entity when this interaction begins. Ignored if the User entity is not a player.                                      |
+| Trails                   | `Array`<br />(Element Type: `ModelTrail`)         | **No**    | Trail effects to activate on the User entity when this interaction begins.                                                                            |
+| WaitForAnimationToFinish | `Boolean`<br />(Default: false)                   | **No**    | If true, this interaction will continue executing for at least the length of any animations in this InteractionEffects object.                        |
+| ItemPlayerAnimationsId   | `Asset`<br />(Asset Type: `ItemPlayerAnimations`) | **No**    | If provided, the User entity will use this ItemPlayerAnimations set while this interaction is executing.                                              |
+| ItemAnimationId          | `String`                                          | **No**    | Id of an animation to trigger when this interaction begins executing.<br />**This animation id is not validated on server start.**                    |
+| ClearAnimationOnFinish   | `Boolean`<br />(Default: false)                   | **No**    | If true, animations triggered by this interaction will be halted when the interaction completes.                                                      |
+| ClearSoundEventOnFinish  | `Boolean`<br />(Default: false)                   | **No**    | If true, sounds triggered by this interaction will be halted when the interaction completes.                                                          |
+| CameraEffect             | `Asset`<br />(Asset Type: `CameraEffect` )        | **No**    | If provided, the CameraEffect will be applied while this interaction is executing.                                                                    |
+| MovementEffects          | `MovementEffects`                                 | **No**    | If provided, apply the movement effects to the User entity while this interaction is executing.                                                       |
+| StartDelay               | `Float`<br />(Default: 0.0f)                      | **No**    | The interaction will wait this many seconds before triggering the effects in this object.                                                             |
+
+**InteractionRules Fields**
+
+| Field Name          | Type                                                                                                | Required? | Notes                                                                                                                                                                                                                                     |
+| ------------------- | --------------------------------------------------------------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| BlockedBy           | `Array`<br />(Element Type: `InteractionType`)<br />(Default: Based on the chain's InteractionType) | **No**    | If provided, this RootInteraction cannot be executed while interaction chains of the provided types are executing.<br />**This field only functions for rules attached to a RootInteraction. It has no effect on an Interaction.**        |
+| Blocking            | `Array`<br />(Element Type: `InteractionType`)                                                      | **No**    | If provided, interaction chains with the specified InteractionTypes cannot be executed while this interaction is executing.                                                                                                               |
+| InterruptedBy       | `Array`<br />(Element Type: `InteractionType`)                                                      | **No**    | If provided, interaction chains with the specified InteractionTypes will cancel this interaction chain when they execute.<br />**This field only functions for rules attached to a RootInteraction. It has no effect on an Interaction.** |
+| Interrupting        | `Array`<br />(Element Type: `InteractionType`)                                                      | **No**    | If provided, interaction chains with the specified InteractionTypes will be canceled when this interaction begins.                                                                                                                        |
+| BlockedByBypass     | `String`                                                                                            | **No**    | If provided, this RootInteraction cannot be blocked by interaction chains whose RootInteraction has this value as an asset tag.                                                                                                           |
+| BlockingBypass      | `String`                                                                                            | **No**    | If provided, this interaction will not block RootInteractions that have the this value as an asset tag.                                                                                                                                   |
+| InterruptedByBypass | `String`                                                                                            | **No**    | If provided, this RootInteraction cannot be canceled by RootInteractions that have this value as an asset tag.                                                                                                                            |
+| InterruptingBypass  | `String`                                                                                            | **No**    | If provided, this interaction will not cancel interaction chains whose RootInteraction has this value as an asset tag.                                                                                                                    |
+
+**InteractionType Values**
+
+- `Primary`
+- `Secondary`
+- `Ability1`
+- `Ability2`
+- `Ability3`
+- `Use`
+- `Pick`
+- `Pickup`
+- `CollisionEnter`
+- `CollisionLeave`
+- `Collision`
+- `EntityStatEffect`
+- `SwapTo`
+- `SwapFrom`
+- `Death`
+- `Wielding`
+- `ProjectileSpawn`
+- `ProjectileHit`
+- `ProjectileMiss`
+- `ProjectileBounce`
+- `Held`
+- `HeldOffhand`
+- `Equipped`
+- `Dodge`
+- `GameModeSwap`
+
+**InteractionSettings Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                        |
+| ---------------- | ------------------------------- | --------- | -------------------------------------------------------------------------------------------- |
+| AllowSkipOnClick | `Boolean`<br />(Default: false) | **No**    | If true, the user will be able to skip this interaction by clicking shortly after it starts. |
+
+**InteractionCameraSettings Fields**
+
+| Field Name  | Type                                             | Required? | Notes                                                                                                                                                           |
+| ----------- | ------------------------------------------------ | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| FirstPerson | `Array`<br />(Element Type: `InteractionCamera`) | **No**    | A list of camera keyframes to be played if the player is in first-person.<br />**The time of each keyframe must be after the keyframe before it in the array.** |
+| ThirdPerson | `Array`<br />(Element Type: `InteractionCamera`) | **No**    | A list of camera keyframes to be played if the player is in third-person.<br />**The time of each keyframe must be after the keyframe before it in the array.** |
+
+**InteractionCamera Fields**
+
+| Field Name | Type                         | Required? | Notes                                                                                                                                       |
+| ---------- | ---------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------- |
+| Time       | `Float`<br />(Default: 0.1f) | **No**    | How long after the interaction begins executing that the camera should arrive at this keyframe.<br />**Cannot be less than or equal to 0.** |
+| Position   | `Vector3`                    | **Yes**   | Where the camera should be located when it arrives at this keyframe.                                                                        |
+| Rotation   | `Direction`                  | **Yes**   | Where the camera should be pointing when it arrives at this keyframe.                                                                       |
+
+### SimpleInteraction
+
+Most interaction types below are inherited from SimpleInteraction and have these
+fields.  If a type does not have these fields, the documentation will mention it.
+
+The purpose of SimpleInteraction is to facilitate Interaction chaining by taking different paths
+based on whether the Interaction succeeded or failed.  The circumstances under which
+a given Interaction fails are generally type-specific (and described in the documentation
+below), but all interactions will be marked failed if they are cancelled via one of the
+many, many mechanisms for doing so.
+
+It is valid to create an interaction asset of type "Simple", which can be valuable when you want to use the
+interaction fields with no additional functionality.
+
+**SimpleInteraction Fields**
+
+| Field Name | Type                                     | Required? | Notes                                                                                          |
+| ---------- | ---------------------------------------- | --------- | ---------------------------------------------------------------------------------------------- |
+| Next       | `Asset`<br />(Asset Type: `Interaction`) | **No**    | After this Interaction has finished, "Next" will be executed if this Interaction did not fail. |
+| Failed     | `Asset`<br />(Asset Type: `Interaction`) | **No**    | After this Interaction has finished, "Failed" will be executed if this Interaction failed.     |
+
+## Flow Control
+
+These are interaction types used to control the flow of an interaction chain and allow interactions
+to be composed into more complex behaviors.  These interaction types generally do not pertain to
+the game and instead pertain to the interaction system itself.
+
+### Condition
+
+This interaction will fail if one of the fields is provided but does not match the current state.
+
+**Condition Fields**
+
+| Field Name       | Type       | Required? | Notes                                                                                                                                                                                    |
+| ---------------- | ---------- | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| RequiredGameMode | `GameMode` | **No**    | If provided, the interaction will fail if the current GameMode does not match the provided value.                                                                                        |
+| Jumping          | `Boolean`  | **No**    | If provided, the interaction will fail if the player's Jumping state does not match the provided value. (i.e. if True, the player must be jumping, if False, the player must not be)     |
+| Swimming         | `Boolean`  | **No**    | If provided, the interaction will fail if the player's Swimming state does not match the provided value. (i.e. if True, the player must be swimming, if False, the player must not be)   |
+| Crouching        | `Boolean`  | **No**    | If provided, the interaction will fail if the player's Crouching state does not match the provided value. (i.e. if True, the player must be crouching, if False, the player must not be) |
+| Running          | `Boolean`  | **No**    | If provided, the interaction will fail if the player's Running state does not match the provided value. (i.e. if True, the player must be running, if False, the player must not be)     |
+| Flying           | `Boolean`  | **No**    | If provided, the interaction will fail if the player's Flying state does not match the provided value. (i.e. if True, the player must be flying, if False, the player must not be)       |
+
+**GameMode Values**
+
+- `Creative`: The game is currently in Creative Mode
+- `Adventure`: The game is currently in Adventure Mode
+
+### FirstClick
+
+This interaction does not inherit from SimpleInteraction and therefore has no Next or Failed fields.
+
+This interaction has two fields that each contain a reference to an Interaction: Click and Hold.  If the root interaction
+of the chain was initiated by a client button/key press (or simulated NPC input) and the input was a tap, then
+the Click interaction is run. if it was a longer press, then the Hold interaction is run.
+
+As a minor implementation detail, this interaction is internally marked as failed when the Hold path is followed.
+This generally shouldn't matter.  If the interaction was not initiated by a key press at all, the Click path will be followed,
+but it seems risky to rely on that behavior.
+
+**FirstClick Fields**
+
+| Field Name | Type                                     | Required? | Notes                                                                                                                                                    |
+| ---------- | ---------------------------------------- | --------- | -------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Click      | `Asset`<br />(Asset Type: `Interaction`) | **No**    | If provided and the root interaction of the chain was initiated by button/key press, this interaction is executed next if the press was a quick tap.     |
+| Hold       | `Asset`<br />(Asset Type: `Interaction`) | **No**    | If provided and the root interaction of the chain was initiated by a button/key press, this interaction is executed next if the press was a longer hold. |
+
+### Interrupt
+
+This interaction can be used to cancel one or more running interaction chains on an entity and **all forked interaction
+chains those chains have spawned that are still currently running**.  All interaction chains canceled in this manner will be marked as
+Failed, which may have additional implications if the canceled chains are themselves forked from
+other chains that are still running.
+
+**Interrupt Fields**
+
+| Field Name     | Type                                           | Required? | Notes                                                                                                                                                                                               |
+| -------------- | ---------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Entity         | `InteractionTarget`<br />(Default: User)       | **Yes**   | The entity that is the owner of the target interaction chains.  This field can indicate the Owner, User, or Target of this interaction chain.                                                       |
+| InterruptTypes | `Array`<br />(Element Type: `InteractionType`) | **No**    | A set of InteractionTypes that are to be interrupted. Only interactions of these types are affected. If null, all types will be interrupted.<br />**(Note: An empty set will interrupt NO TYPES.)** |
+| RequiredTag    | `String`                                       | **No**    | An asset tag that, if provided, the RootInteraction of the interaction chain must have in order to be canceled.                                                                                     |
+| ExcludedTag    | `String`                                       | **No**    | An asset tag that, if provided, the RootInteraction of the interaction chain must not have in order to be canceled.                                                                                 |
+
+**InteractionTarget Values**
+
+- `User` - The user of this interaction chain. The entity whose actions caused this interaction chain to be executed. This is usually the same as the Owner.
+- `Owner` - The owner of this interaction chain. The entity upon whom this interaction chain is executing.
+- `Target` - The entity target of this interaction chain, if any.  This value is mutable (and can therefore come from many places) but most commonly, it is an entity the User was targeting when this interaction chain began executing.
+
+**InteractionType Values**
+
+- `Primary`
+- `Secondary`
+- `Ability1`
+- `Ability2`
+- `Ability3`
+- `Use`
+- `Pick`
+- `Pickup`
+- `CollisionEnter`
+- `CollisionLeave`
+- `Collision`
+- `EntityStatEffect`
+- `SwapTo`
+- `SwapFrom`
+- `Death`
+- `Wielding`
+- `ProjectileSpawn`
+- `ProjectileHit`
+- `ProjectileMiss`
+- `ProjectileBounce`
+- `Held`
+- `HeldOffhand`
+- `Equipped`
+- `Dodge`
+- `GameModeSwap`
+
+### Parallel
+
+This interaction does not inherit from SimpleInteraction and therefore has no Next or Failed fields.
+
+This interaction has a field `Interactions` that is an array of RootInteraction assets. The list must contain at least
+two RootInteractions.  This interaction will fork all of its children except for the first into their
+own interaction chains and immediately complete. After this interaction completes, this interaction chain will
+execute the first RootInteraction in the `Interactions` list.
+
+This interaction does not have any failure conditions and is indifferent to the fate of the forked interaction chains.
+
+**Parallel Fields**
+
+| Field Name   | Type                                                | Required? | Notes                                                         |
+| ------------ | --------------------------------------------------- | --------- | ------------------------------------------------------------- |
+| Interactions | `AssetArray`<br />(Element Type: `RootInteraction`) | **Yes**   | An array of RootInteractions that will be forked or executed. |
+
+### Repeat
+
+This interaction has a field `ForkInteractions` that is an asset of type RootInteraction. This interaction will fork that
+RootInteraction into its own interaction chain and then wait for it to complete. If the RootInteraction fails, this
+interaction will complete immediately and be marked failed. Otherwise, the RootInteraction will be forked and run again,
+up to a specified total number of times.
+
+**Repeat Fields**
+
+| Field Name       | Type                                                                                   | Required? | Notes                                                                                                                                                                                                              |
+| ---------------- | -------------------------------------------------------------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| ForkInteractions | `Asset`<br />(Asset Type: `RootInteraction`)                                           | **Yes**   | A RootInteraction that will be forked.                                                                                                                                                                             |
+| Repeat           | `Integer`<br />(Default: 1)<br />**Must be -1 or a positive integer. 0 is not valid.** | **No**    | The total number of times to fork ForkInteractions. If -1 is provided, ForkInteractions will continue being forked and executed indefinitely, until this interaction is cancelled or until ForkInteractions fails. |
+
+### Replace
+
+This interaction does not inherit from SimpleInteraction and therefore has no Next or Failed fields.
+
+This interaction uses the InteractionVars system that is avaiable for items. InteractionVars are RootInteractions that
+can be attached to an Item asset with a name.
+
+This interaction specifies a var name, and if this interaction chain was executed through
+an item and that item has an InteractionVar of the same name, then this interaction will immediately execute
+the RootInteraction on the var.  Otherwise, it will execute the default RootInteraction specified in this interaction.
+If no default is specified, then this interaction will be marked as failed.
+
+**Replace Fields**
+
+| Field Name   | Type                                         | Required? | Notes                                                                                                                                                                                                           |
+| ------------ | -------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Var          | `String`                                     | **Yes**   | The name of the InteractionVar to execute.                                                                                                                                                                      |
+| DefaultValue | `Asset`<br />(Asset Type: `RootInteraction`) | **No**    | The RootInteraction to execute if the owning item does not have an InteractionVar by the specified name. If not provided, the interaction will be marked as failed instead.                                     |
+| DefaultOk    | `Boolean`<br />(Default: false)              | **No**    | If false, then an angry message will be printed to the server logs if the owning item does not have an InteractionVar by the specified name.  The functioning of this interaction will be otherwise unaffected. |
+
+### RunRootInteraction
+
+This interaction immediately executes the provided RootInteraction as part of this interaction chain. This interaction
+does not have any failure conditions.
+
+**RunRootInteraction Fields**
+
+| Field Name      | Type                                         | Required? | Notes                           |
+| --------------- | -------------------------------------------- | --------- | ------------------------------- |
+| RootInteraction | `Asset`<br />(Asset Type: `RootInteraction`) | **Yes**   | The RootInteraction to execute. |
+
+### Selector
+
+This interaction will execute a Selector to find entities and/or blocks (depending on the Selector) and fork off an
+interaction chain for each located entity or block. This interaction will not wait for those interaction chains
+to complete and is indifferent to their fate. The forked interaction chains will use the located entity/block as
+their target entity/target block. Each entity or block will only fork one interaction chain over the life of this
+interaction.  The Selector is guaranteed to run once for each execution of this interaction, but some Selectors
+are intended to be run over a period of time and sweep across an area to locate targets. In order to use those Selectors
+properly, you will need to extend the execution time of this interaction using `RunTime` or `WaitForAnimationToFinish`.
+The Selector will be executed repeatedly over the lifetime of the interaction.
+
+If the Selector is configured to locate entities, you can add additional sets of entity matching rules. If a located entity
+matches one of the rules, the matching RootInteraction will be forked instead of the standard `HitEntity` RootInteraction.
+
+Entities located by the Selector will be ignored if they do not have a NetworkId, if they are dead, or if they are invulnerable.
+The only exception to this rule is that players in Creative Mode that are marked to receive hits will not be ignored.
+
+This interaction's failure conditions are configurable via the `FailOn` field. You can configure this interaction to never
+fail, to fail if the Selector does not locate any blocks before this interaction finishes executing, to fail if the
+Selector does not locate any entities before this interaction finishes executing, or to fail in either case.
+
+**Selector Fields**
+
+| Field Name     | Type                                         | Required? | Notes                                                                                                                                                                                                                                     |
+| -------------- | -------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Selector       | `Selector`                                   | **Yes**   | The Selector is executed at least once and may be executed repeatedly to locate blocks and/or entities in an area.                                                                                                                        |
+| HitEntity      | `Asset`<br />(Asset Type: `RootInteraction`) | **No**    | If included and the `Selector` locates an entity that does not match any `HitEntityRules`, this RootInteraction will be forked into a new interaction chain with the located entity as the target entity.                                 |
+| HitEntityRules | `Array`<br />(Element Type: `HitEntity`)     | **No**    | If included, these rules will be matched against any entity located by the `Selector`. If an entity matches a set of rules, the RootInteraction associated with the rules will be forked instead of the standard `HitEntity` interaction. |
+| HitBlock       | `Asset`<br />(Asset Type: `RootInteraction`) | **No**    | If included and the `Selector` locates a block, this RootInteraction will be forked into a new interaction chain with the located block as the block target.                                                                              |
+| FailOn         | `FailOnType`<br />(Default: `Neither`)       | **No**    | Defines under what circumstances this interaction will fail.  It can be marked to fail when it completes without locating any blocks, it can be marked to fail when it completes without locating any entities, both, or neither.         |
+| IgnoreOwner    | `Boolean`<br />(Default: true)               | **No**    | If true, the Selector will not locate the User entity of this interaction.                                                                                                                                                                |
+
+**HitEntity Fields**
+
+| Field Name | Type                                         | Required? | Notes                                                                                                 |
+| ---------- | -------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------- |
+| Matchers   | `Array`<br />(Element Type: `EntityMatcher`) | **Yes**   | A set of rules that an entity must match. An entity must successful match all rules to be considered. |
+| Next       | `Asset`<br />(Asset Type: `RootInteraction`) | **Yes**   | The RootInteraction to fork if an entity matches all rules.                                           |
+
+**EntityMatcher Fields**
+
+| Field Name | Type                            | Required? | Notes                                                                                                     |
+| ---------- | ------------------------------- | --------- | --------------------------------------------------------------------------------------------------------- |
+| Type       | `String`                        | **Yes**   | If provided, specifies a type of EntityMatcher to use. Each matcher type may come with additional fields. |
+| Invert     | `Boolean`<br />(Default: false) | **No**    | If true, an entity must fail this rule for it to be marked as succeeded.                                  |
+
+**EntityMatcher Type: Player**
+
+This EntityMatcher will succesfully match the entity only if they are a player.
+
+**EntityMatcher Type: Vulnerable**
+
+This Entitymatcher will successfully match the entity only if they are not marked as invulnerable.
+
+**FailOnType Values**
+
+- `Neither`
+- `Entity`
+- `Block`
+- `Either`
+
+### Serial
+
+This interaction does not inherit from SimpleInteraction and therefore has no Next or Failed fields.
+
+This interaction has a field `Interactions` which is a list of Interaction assets. This interaction immediately
+completes and the interaction chain continues by executing the interactions in the list one at a time. This
+interaction does not have any failure conditions.
+
+**Serial Fields**
+
+| Field Name   | Type                                            | Required? | Notes                                      |
+| ------------ | ----------------------------------------------- | --------- | ------------------------------------------ |
+| Interactions | `AssetArray`<br />(Element Type: `Interaction`) | **Yes**   | An array of Interaction assets to execute. |
+
+## Cooldowns
+
+RootInteractions interface with a complex cooldown system that can be used for a variety of purposes. Aside from simply
+adding an important aspect of resource management to your game design, cooldowns can be used to ensure that click-activated
+interaction chains don't repeatedly spam if the player holds down the input.
+
+By default, every RootInteraction has a cooldown timer that is keyed to the RootInteraction name, and by default, it
+will launch a cooldown of 0.35 seconds when activated by client input.  Otherwise, no cooldown will be activated.  However,
+by configuring your RootInteraction, you can change the key for the cooldown (so that multiple RootInteractions can share
+a single cooldown), set the cooldown timer to whatever you like, and configure multiple charges that can build up over time
+to allow the entity to activate the RootInteraction multiple times before being forced to pause.
+
+One important concept to keep in mind is the difference between **cooldown** and **charge time**.  The cooldown, if any,
+is activated each time a RootInteraction triggers, even if the player has more available charges. If the RootInteraction
+is configured to use charges, then they will gradually build up over time. In order for a RootInteraction to be activated,
+the cooldown (if any) must be expired, and the RootInteraction must have at least one charge (if it has been
+configured to use charges).
+
+Bear in mind that the entire Cooldown configuration is shared between different RootInteractions with the same cooldown id.
+If you activate an ability with 5 charges and a short cooldown and then another ability with a much longer cooldown and no
+charges, the second ability will use the cooldown properties of the first ability until/unless the first ability finishes
+charging and is cleared from the system.  You should generally only have multiple RootInteractions share a cooldown id
+if they have the same configuration.
+
+The interactions below interact with the cooldown system to allow you to manipulate cooldowns via the interaction system. By
+using these interactions, you can have several interaction chains with different cooldown configurations share cooldowns
+that are checked and activated as part of the interaction chain itself, or have some components of an interaction change
+use a second cooldown separate from the main one.
+
+### CooldownCondition
+
+**CooldownCondition Fields**
+
+This interaction will fail if the specified cooldown id is on cooldown for the User entity.  This interaction will only
+function for players- the interaction will always succeed for NPCs.  In order for this interaction to succeed, the
+cooldown, if any, must have expired and at least one charge, if any, must have filled.
+
+| Field Name | Type     | Required? | Notes                     |
+| ---------- | -------- | --------- | ------------------------- |
+| Id         | `String` | **Yes**   | The cooldown id to check. |
+
+### IncrementCooldown
+
+**IncrementCooldown Fields**
+
+This interaction will modify a cooldown that is currently active on the User entity, allowing charges and remaining
+cooldown to be modified.
+Despite its name, this interaction can be used to reduce a cooldown as well as increase it. If the cooldown is not
+currently active, this interaction will have no effect. The interaction has no special failure conditions.
+
+| Field Name        | Type                        | Required? | Notes                                                                                                                                                                                                                                                                                     |
+| ----------------- | --------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Id                | `String`                    | **No**    | If provided, the cooldown id of the cooldown to be manipulated. If not provided, the cooldown id of the current chain's RootInteraction will be used.                                                                                                                                     |
+| Time              | `Float`<br />(Default: 0.0) | **No**    | The amount to increase the remaining cooldown by. Can be negative. The remaining cooldown time will not be reduced below zero or increased above the maximum cooldown time.                                                                                                               |
+| ChargeTime        | `Float`<br />(Default: 0.0) | **No**    | The amount to increase the remaining time until the next charge is filled by. Can be negative. The remaining charge time cannot be reduced below zero or increased above the maximum cooldown time. **This will not work on abilities that have a maximum of 1 charge, for some reason.** |
+| Charge            | `Integer`<br />(Default: 0) | **No**    | The amount to increase the number of charges by. Can be negative. The number of charges cannot be reduced below 0 or increased above the maximum.                                                                                                                                         |
+| InterruptRecharge | `Boolean`(Default: false)   | **No**    | If true and `Charge` is not 0, will reset the remaining time to the next charge to the maximum value after changing the charge count.                                                                                                                                                     |
+
+### ResetCooldown
+
+This interaction will trigger a cooldown on the User entity with a specified configuration. The charges will be refilled
+but the cooldown will be immediately triggered.  The mechanisms for deciding on the configuration are a little bit complicated.
+You may specify a cooldown configuration via the `Cooldown` field. If you do not include an `Id` field, then the
+interaction chain's RootInteraction will be used for any field not specified in the configuration. If there is an active
+cooldown under the specified `Id` (or under the RootInteraction's cooldown id if none is specified) then the fields
+from that active cooldown will overwrite data in the RootInteraction's cooldown, but not data in your `Cooldown` field.
+
+**ResetCooldown Fields**
+
+| Field Name | Type                  | Required? | Notes                                                        |
+| ---------- | --------------------- | --------- | ------------------------------------------------------------ |
+| Cooldown   | `InteractionCooldown` | **No**    | A cooldown configuration to use for the new, reset cooldown. |
+
+**InteractionCooldown Fields**
+
+| Field Name        | Type                                 | Required? | Notes                                                                                                                                                                                                 |
+| ----------------- | ------------------------------------ | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Id                | `String`                             | **No**    | The cooldown id to use for this cooldown. If not provided, the RootInteraction's cooldown id will be used, if any.                                                                                    |
+| Cooldown          | `Float`<br />(Default: 0.0)          | **No**    | The duration of the cooldown, in seconds.                                                                                                                                                             |
+| Charges           | `Array`<br />(Element Type: `Float`) | **No**    | If provided, a list of how many charges this cooldown can build, and how long each charge takes to build, in seconds.                                                                                 |
+| InterruptRecharge | `Boolean`<br />(Default: false)      | **No**    | If true, the charge time will be reset when the number of charges changes.                                                                                                                            |
+| ClickBypass       | `Boolean`<br />(Default: false)      | **No**    | If true, RootInteractions keyed to this cooldown can still be activated when it is on cooldown provided that the RootInteraction was triggered by a distinct key or mouse button press on the client. |
+
+### TriggerCooldown
+
+This interaction is similar to ResetCooldown, except instead of refilling the cooldown's charges, one charge will be deducted
+as normal.
+
+**TriggerCooldown Fields**
+
+| Field Name | Type                  | Required? | Notes                                                        |
+| ---------- | --------------------- | --------- | ------------------------------------------------------------ |
+| Cooldown   | `InteractionCooldown` | **No**    | A cooldown configuration to use for the new, reset cooldown. |
+
+**InteractionCooldown Fields**
+
+| Field Name        | Type                                 | Required? | Notes                                                                                                                                                                                                 |
+| ----------------- | ------------------------------------ | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Id                | `String`                             | **No**    | The cooldown id to use for this cooldown. If not provided, the RootInteraction's cooldown id will be used, if any.                                                                                    |
+| Cooldown          | `Float`<br />(Default: 0.0)          | **No**    | The duration of the cooldown, in seconds.                                                                                                                                                             |
+| Charges           | `Array`<br />(Element Type: `Float`) | **No**    | If provided, a list of how many charges this cooldown can build, and how long each charge takes to build, in seconds.                                                                                 |
+| InterruptRecharge | `Boolean`<br />(Default: false)      | **No**    | If true, the charge time will be reset when the number of charges changes.                                                                                                                            |
+| ClickBypass       | `Boolean`<br />(Default: false)      | **No**    | If true, RootInteractions keyed to this cooldown can still be activated when it is on cooldown provided that the RootInteraction was triggered by a distinct key or mouse button press on the client. |
+
+## Combo Chains
+
+Hytale additionally comes with a rich "combo chaining" system, which allows several inputs in a row to result in different
+attacks and special moves.  Rather than being attached to the RootInteraction like the cooldown system, these are
+primarily driven by the `Chaining` interaction.
+
+### Chaining
+
+This interaction does not inherit from SimpleInteraction and therefore has no Failed field. Its Next field works differently
+from most interaction types.
+
+Chaining is a type of flow control interaction- each time a Chaining interaction with the same `ChainId` is called, a single
+interaction in the `Next` list is chosen and the others are ignored. The first time the `ChainId` is used, the first
+interaction in the list is chosen, the next time the second, etc. Once the end of the list is reached, the first
+interaction will be chosen again.
+
+Bear in mind: the progress through the Next list is based on the **ChainId**, not the interaction!  That means that two
+different Chaining interactions can share a single combo chain. You could have a pair of daggers that attacks with
+the left when the left mouse button is clicked and with the right when the right mouse button is clicked.  You could give
+both interaction chains a Chaining interaction with the same `ChainId` and three `Next` entries that do a light-light-heavy
+combo.  Each specific hit would occur with either the left or the right knife based on which button you clicked, but
+the combo would be otherwise identical regardless of which you chose.
+
+The Chaining interaction also has a concept called "flags".  It is possible to attach named flags to a `ChainId` by using
+the ChainFlag interaction.  Then, you specify the flag name in Chaining's `Flags` field. If a Flag is active when the
+Chaining interaction is run, the Flag's interaction will be run instead of the appropriate interaction in `Next`.
+Bear in mind: the entity's progress through the `Next` list still advances, the resulting `Next` interaction is just not
+run.  Only one flag can be active at a time.
+
+Lastly, it is possible to cancel the entity's progress through the combo chain and reset them to the first interaction in
+the list. This can be done with the CancelChain interaction, but it will also happen automatically if the player does
+not trigger an interaction with the ChainId for the specified ChainingAllowance.  When either of these happen, all flags will be
+canceled as well.
+
+All of these effects are triggered on the User entity only. Non-players can use the chaining system, but Flags do not currently
+work for non-players.  This interaction has no special failure conditions.
+
+**Chaining Fields**
+
+| Field Name        | Type                                                       | Required? | Notes                                                                                                                                                                                                                       |
+| ----------------- | ---------------------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| ChainId           | `String`                                                   | **No**    | If provided, acts as a key that multiple Chaining interactions can use to share combo chain progress and flags. If not provided, a unique ChainId will be generated for this interaction.                                   |
+| ChainingAllowance | `Double`<br />(Default: 0.0)                               | **No**    | If, at the time this interaction is triggered, it has been this long in seconds since the last time a Chaining interaction with the same ChainId was executed, all state for this ChainId will be cleared before execution. |
+| Next              | `AssetArray`<br />(Element Type: `Interaction`)            | **Yes**   | A list of interactions to cycle between each time this interaction is run.                                                                                                                                                  |
+| Flags             | `Map`<br />(Key Type: `String`, Value Type: `Interaction`) | **No**    | A map of flag names to interactions to run if the flag is active when this interaction executes.                                                                                                                            |
+
+### CancelChain
+
+This interaction resets all progress and flag data on the User entity for the provided `ChainId`.  The next time a Chaining
+interaction is called for the provided `ChainId`, it will begin at the first interaction in the `Next` list. This
+interaction has no special failure conditions.
+
+**CancelChain Fields**
+
+| Field Name | Type     | Required? | Notes                                 |
+| ---------- | -------- | --------- | ------------------------------------- |
+| ChainId    | `String` | **Yes**   | A ChainId whose data should be reset. |
+
+### ChainFlag
+
+This interaction activates a flag on the User entity for the provided `ChainId`, which can be used to change behavior the
+next time a Chaining interaction with this `ChainId` is run. This will overwrite any flag that has
+already been raised. This interaction will have no effect for non-players. This interaction has no special failure
+conditions.
+
+| Field Name | Type     | Required? | Notes                                        |
+| ---------- | -------- | --------- | -------------------------------------------- |
+| ChainId    | `String` | **Yes**   | A ChainId on whom the flag should be raised. |
+| Flag       | `String` | **Yes**   | The name of the flag to raise.               |
+
+## Charging
+
+A unique flow-control interaction that is frequently used is the Charging interaction.  It is a flow-control interaction
+that delays while the input button used to trigger the interaction chain is held.  When it is released (or the interaction
+is forced to end), the interaction chain can continue with a different interaction based on how long the input was held
+for.
+
+These interactions are all related by either being the Charging interaction, or other interaction types that inherit the
+Charging interaction's behavior.
+
+### Charging
+
+This interaction does not inherit from SimpleInteraction and therefore its Next field works different from most interactions.
+This interaction adds its own Failed field which works the same way that SimpleInteraction's does.
+
+This interaction only works properly when its interaction chain was triggered by a client key or button press (or
+NPC-simulated equivalent). This interaction will continue executing for as long as the key or button press is held (with
+some exceptions, covered below) by the User entity.  Like other interactions, it has a `Next` field indicating which interaction to execute
+after this one, but the field is a map from `Float` values to `Interaction` assets. When this interaction ends, either
+due to the input being released or the charge duration completing, this interaction will determine the largest `Float` key that is less
+than the amount of time in seconds that the interaction was executing for.  The Interaction mapped to that key will be
+executed next.
+
+The interaction includes some cancellation conditions that are specific to this interaction. For instance, the interaction
+has a `CancelOnOtherClick` field that matches the field on RootInteraction. If it is active on this interaction but not
+the RootInteraction, then clicking while charging will cancel this interaction (and execute the `Failed` interaction rather
+than any of the `Next` interactions) but otherwise continue the interaction chain.
+
+Another valuable feature Charging has is the `Forks` field.  For input-triggered interactions that are triggered while the
+Charging interaction is executing, you can add an entry for the relevant InteractionType to this field and instead of
+triggering the usual interaction chain based on held item, targeted block, etc. the RootInteraction specified in the
+`Forks` field will be triggered.  This can unlock rich attack modes and behaviors. For instance, having a shield bash attack
+triggered off left click while blocking, or a special attack that triggers when both mouse buttons are pressed at the
+same time.
+
+There are two modes of operation for the Charging interaction. One is to have the ability charge for as long
+as the input is held and only end execution when the entity releases the input.  Bows in the main Hytale game work
+that way.  That is accomplished by setting `AllowIndefiniteHold` to true.  Another mode of operation is to have the
+interaction complete execution when the execution time has surpassed the largest key value in the `Next` field and
+immediately begin executing the Interaction mapped to that key.  Food in the main Hytale game work like this.  It
+is accomplished by setting `AllowIndefiniteHold` to false.
+
+One pitfall to be careful of when setting `AllowIndefiniteHold` to false is the way it interacts with cooldowns.\
+Normally, input-initiated interaction chains start a 0.35s cooldown on the triggered RootInteraction that prevents
+holding the mouse button from immediately spamming a new interaction when the first one completes.  However, if the
+duration of a Charging interaction is longer than 0.35s, then the cooldown will have already completed when the
+interaction chain finishes, which will often result in a new execution beginning immediately before the player can
+stop pressing the mouse button.  One solution for this problem is to add a `Simple` interaction to the end of your
+interaction chain with a `RunTime` of 0.35s to simulate the cooldown.  Alternatively, you can add a longer cooldown
+(the maximum duration of your Charging interaction plus 0.35s) to the RootInteraction. However, the longer cooldown is
+not always desirable, as the interaction may have ended prematurely, resulting in an unusually long lockout between
+executions.
+
+**Charging Fields**
+
+| Field Name                         | Type                                                                    | Required? | Notes                                                                                                                                                                                                                                                                                                                                                                                       |
+| ---------------------------------- | ----------------------------------------------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| FailOnDamage                       | `Boolean`<br />(Default: false)                                         | **No**    | If true, this interaction will fail and end immediately if the User entity takes any damage while it is executing.                                                                                                                                                                                                                                                                          |
+| CancelOnOtherClick                 | `Boolean`<br />(Default: true)                                          | **No**    | If true, this interaction will fail and end immediately if the User entity sends another button or key press while it is executing.                                                                                                                                                                                                                                                         |
+| Forks                              | `Map`<br />(Key Type: `InteractionType`, Value Type: `RootInteraction`) | **No**    | A map of InteractionType to RootInteraction. If entity input triggers the InteractionType while this interaction is executing, the mapped RootInteraction will be forked into its own interaction chain. This will happen instead of the usual handling for that InteractionType.  This fork will occur even if `CancelOnOtherClick` is set to true.                                        |
+| Failed                             | `Asset`<br />(Asset Type: `Interaction`)                                | **No**    | After this Interaction has finished, "Failed" will be executed if this Interaction failed.                                                                                                                                                                                                                                                                                                  |
+| AllowIndefiniteHold                | `Boolean`<br />(Default: false)                                         | **No**    | If true, this interaction will continue executing for as long as the User entity continues to hold the input. If false, execution will end as soon as the execution time in seconds reaches the largest key value in the `Next` map.                                                                                                                                                        |
+| DisplayProgress                    | `Boolean`<br />(Default: true)                                          | **No**    | If true, players executing this interaction will see a progress bar will be displayed below their cursor indicating how close to reaching the highest key value in `Next` they are.                                                                                                                                                                                                         |
+| Next                               | `Map`<br />(Key Type: `Float`, Value Type: `Interaction`)               | **No**    | A map from `Float` to `Interaction`.  When this interaction successfully finishes executing (either because the input was released or because the maximum duration was reached), this interaction will find the `Float` value with the largest duration in seconds that is less than the amount of time this interaction executed for. That key's mapped Interaction will then be executed. |
+| MouseSensitivityAdjustmentTarget   | `Float`<br />(Default: 1.0)                                             | **No**    | While charging, this mouse sensitivity multiplier will gradually be applied.                                                                                                                                                                                                                                                                                                                |
+| MouseSensitivityAdjustmentDuration | `Float`<br />(Default: 1.0)                                             | **No**    | Duration in seconds. After this many seconds, `MouseSensitivityAdjustmentTarget` will be fully applied to the mouse sensitivity.                                                                                                                                                                                                                                                            |
+| Delay                              | `ChargingDelay`                                                         | **No**    | Settings that allow charging progress to be pushed back when the User entity takes damage.                                                                                                                                                                                                                                                                                                  |
+
+**ChargingDelay Fields**
+
+| Field Name    | Type                        | Required? | Notes                                                                                                                                                                                                                                                                     |
+| ------------- | --------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| MinHealth     | `Float`<br />(Default: 0.0) | **No**    | Damage taken as a percentage of entity health (0.0-1.0). If a hit deals less than this much damage, no pushback will be applied.  If a hit deals exactly this much damage, `MinDelay` seconds worth of pushback will be applied.                                          |
+| MaxHealth     | `Float`<br />(Default: 0.0) | **No**    | Damage taken as a percentage of entity health (0.0-1.0). If a hit deals at least this much damage, `MaxDelay` seconds worth of pushback will be applied.                                                                                                                  |
+| MinDelay      | `Float`<br />(Default: 0)   | **No**    | The amount of pushback, in seconds, to apply if the entity takes a hit that deals `MinHealth` damage. The amount of pushback applied by a hit is a gradiant between `MinDelay` and `MaxDelay` based on the amount of damage between `MinHealth` and `MaxHealth`.          |
+| MaxDelay      | `Float`<br />(Default: 0)   | **No**    | The amount of pushback, in seconds, to apply if the entity takes a hit that deals at least `MaxHealth` damage. The amount of pushback applied by a hit is a gradiant between `MinDelay` and `MaxDelay` based on the amount of damage between `MinHealth` and `MaxHealth`. |
+| MaxTotalDelay | `Float`<br />(Deault: 0)    | **No**    | The maximum amount of pushback the entity can receive over the course of a single charge, regardless of how many times they are hit.                                                                                                                                      |
+
+**InteractionType Values**
+
+- `Primary`
+- `Secondary`
+- `Ability1`
+- `Ability2`
+- `Ability3`
+- `Use`
+- `Pick`
+- `Pickup`
+- `CollisionEnter`
+- `CollisionLeave`
+- `Collision`
+- `EntityStatEffect`
+- `SwapTo`
+- `SwapFrom`
+- `Death`
+- `Wielding`
+- `ProjectileSpawn`
+- `ProjectileHit`
+- `ProjectileMiss`
+- `ProjectileBounce`
+- `Held`
+- `HeldOffhand`
+- `Equipped`
+- `Dodge`
+- `GameModeSwap`
+
+### Wielding
+
+This interaction is inherited from Charging rather than SimpleInteraction.  However, its `Failed` and `Next` fields function
+identically to SimpleInteraction.  It does not inherit all fields from Charging, so be sure to pay close attention to
+the field list below.
+
+This interaction drives most blocking behavior in the game. While this interaction is executing, attacks made against
+the Owner entity will (conditionally) trigger effects defined in this interaction.  Unlike the Charging interaction,
+this interaction can always execute indefinitely and will only end when it fails or when the input is released.
+
+One option available in Wielding is `AngledWielding`, which allows damage and knockback modifiers to only be applied
+depending on the direction the attack against the Owner entity is coming from.  The AngledWielding type has a
+field `Angle` which determines which direction the protection points relative to the player (0 is the player's
+front), and `AngleDistance` which determines how wide the cone of protection extends around the player.  Block effects
+from this interaction (such as `BlockedEffects`, `BlockedInteractions`, and `StaminaCost`) will only apply if
+the DamageCause matches `DamageModifiers` OR if the DamageCause matches `AngledWielding.DamageModifiers` and
+the source of the damage matches `Angle` and `AngleDistance`.  It is possible for damage and knockback multipliers
+specified on both this interaction's modifier fields and `AngledWielding`'s modifier fields to stack, if both
+have entries for the same DamageCause.
+
+This interaction will only have an effect on damage taken by one of the DamageCause entries in `DamageModifiers` or
+`AngledWielding.DamageModifiers`.  If a DamageCause is in `DamageModifiers`, then the block effect will be triggered
+and the damage modifier applied regardless of what direction the Owner entity is attacked from.  If a DamageCause is in
+`AngledWielding.DamageModifiers`, then the damage modifier is only applied if the
+
+\*\* Wielding Fields\*\*
+
+| Field Name          | Type                                                                    | Required? | Notes                                                                                                                                                                                                                                                                                                                                                                                                      |
+| ------------------- | ----------------------------------------------------------------------- | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| FailOnDamage        | `Boolean`<br />(Default: false)                                         | **No**    | If true, this interaction will fail and end immediately if the User entity takes any damage while it is executing.                                                                                                                                                                                                                                                                                         |
+| CancelOnOtherClick  | `Boolean`<br />(Default: true)                                          | **No**    | If true, this interaction will fail and end immediately if the User entity sends another button or key press while it is executing.                                                                                                                                                                                                                                                                        |
+| Forks               | `Map`<br />(Key Type: `InteractionType`, Value Type: `RootInteraction`) | **No**    | A map of InteractionType to RootInteraction. If entity input triggers the InteractionType while this interaction is executing, the mapped RootInteraction will be forked into its own interaction chain. This will happen instead of the usual handling for that InteractionType.  This fork will occur even if `CancelOnOtherClick` is set to true (after which this interaction chain will be canceled). |
+| Next                | `Asset`<br />(Asset Type: `Interaction`)                                | **No**    | After this interaction has finished, "Next" will be executed if this interaction did not fail.                                                                                                                                                                                                                                                                                                             |
+| Failed              | `Asset`<br />(Asset Type: `Interaction`)                                | **No**    | After this interaction has finished, "Failed" will be executed if this interaction failed.                                                                                                                                                                                                                                                                                                                 |
+| DamageModifiers     | `Map`<br />(Key Type: `DamageCause`, Value Type: `Float`)               | **No**    | A map from DamageCause to Float, where the Float is multiplied against any damage received from the mapped DamageCause while this interaction is executing.                                                                                                                                                                                                                                                |
+| KnockbackModifiers  | `Map`<br />(Key Type: `DamageCause`, Value Type: `Float`)               | **No**    | A map from DamageCause to Float, where the Float is multiplied against any knockback force received from the mapped DamageCause while this interaction is executing.                                                                                                                                                                                                                                       |
+| AngledWielding      | `AngledWielding`                                                        | **No**    | Configuration to only trigger block effects from certain angles.                                                                                                                                                                                                                                                                                                                                           |
+| StaminaCost         | `StaminaCost`                                                           | **No**    | If the Owner entity receives damage that matches `DamageModifiers` or `AngledWielding` while this interaction is executing, then the entity's stamina will be deducted according to this configuration.                                                                                                                                                                                                    |
+| BlockedEffects      | `DamageEffects`                                                         | **No**    | If the Owner entity receives damage that matches `DamageModifiers` or `AngledWielding` while this interaction is executing, then these effects will be applied to the instance of damage.                                                                                                                                                                                                                  |
+| BlockedInteractions | `Asset`<br />(Asset Type: `RootInteraction`)                            | **No**    | If the Owner entity receives damage that matches `DamageModifiers` or `AngledWielding` while this interaction is executing, then this RootInteraction will be launched as a brand new interaction chain with the Owner entity as both Owner and User, and the attacker as the Target entity.  This new interaction chain is, notably, brand new, **not** forked from the current one.                      |
+
+**AngledWielding Fields**
+
+| Field Name         | Type                                                      | Required? | Notes                                                                                                                                                                                                            |
+| ------------------ | --------------------------------------------------------- | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Angle              | `Float`<br />(Default: 0.0)                               | **No**    | Angle in degrees relative to the Owner entity where the angled protection is centered. 0.0 means pointed towards the front of the Owner entity.                                                                  |
+| AngleDistance      | `Float`<br />(Default: 0.0)                               | **No**    | Angle in degrees indicating how wide the cone of protection is.                                                                                                                                                  |
+| DamageModifiers    | `Map`<br />(Key Type: `DamageCause`, Value Type: `Float`) | **No**    | A map from DamageCause to Float, where the Float is multiplied against any damage received from the mapped DamageCause received from within the cone of protection while this interaction is executing.          |
+| KnockbackModifiers | `Map`<br />(Key Type: `DamageCause`, Value Type: `Float`) | **No**    | A map from DamageCause to Float, where the Float is multiplied against any knockback force received from the mapped DamageCause received from within the cone of protection while this interaction is executing. |
+
+**StaminaCost Fields**
+
+| Field Name | Type                                             | Required? | Notes                                                                                                                                                                                                                                                |
+| ---------- | ------------------------------------------------ | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| CostType   | `CostType`<br />(Default: `MaxHealthPercentage`) | **No**    | How to calculate stamina consumed by blocking from the raw pre-block damage. If `Damage`, then the stamina consumed will be `rawDamage / Value`. If `MaxHealthPercentage`, then the stamina consumed will be `rawDamage / (EntityMaxHealth * Value)` |
+| Value      | `Float`<br />(Default: 0.04)                     | **No**    | The value to use in the `CostType` formula.                                                                                                                                                                                                          |
+
+**DamageEffects Fields**
+
+| Field Name             | Type                                         | Required? | Notes                                                                           |
+| ---------------------- | -------------------------------------------- | --------- | ------------------------------------------------------------------------------- |
+| ModelParticles         | `Array`<br />(Element Type: `ModelParticle`) | **No**    | Particle systems to trigger in the first-person view.                           |
+| WorldParticles         | `Array`<br />(Element Type: `WorldParticle`) | **No**    | Particle systems to trigger in the third-person view.                           |
+| LocalSoundEventId      | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | 2D sound to play locally to the attacking entity if they are a player.          |
+| WorldSoundEventId      | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | Sound to play in the world at the Owner entity's location.                      |
+| PlayerSoundEventId     | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | 2D sound to play locally to the Owner entity if they are a player.              |
+| ViewDistance           | `Double`<br />(Default: 75.0)                | **No**    | Distance at which these effects should play for other players.                  |
+| Knockback              | `Knockback`                                  | **No**    | The properties of the knockback that will be applied.                           |
+| CameraEffect           | `Asset`<br />(Asset Type: `CameraEffect`)    | **No**    | CameraEffect to briefly apply locally to the Owner entity if they are a player. |
+| StaminaDrainMultiplier | `Float`<br />(Default: 1.0)                  | **No**    | This multiplier is applied to the `StaminaCost`, if any.                        |
+
+**Knockback Fields**
+
+| Field Name     | Type                                       | Required? | Notes                                                                                                                      |
+| -------------- | ------------------------------------------ | --------- | -------------------------------------------------------------------------------------------------------------------------- |
+| Type           | `String`                                   | **No**    | If provided, specifies a type of knockback to use. Each knockback type may come with additional fields.                    |
+| Force          | `Double`<br />(Default: 0.0)               | **No**    | The amount of force to apply to the Owner entity.                                                                          |
+| Duration       | `Double`<br />(Default: 0.0)               | **No**    | If 0.0, apply the force as a single impulse.  If more, continuously apply the force over a period of time.                 |
+| VelocityType   | `ChangeVelocityType`<br />(Default: `Add`) | **No**    | How to apply the force, either adding it to the entity's current velocity, or setting the velocity to the knockback force. |
+| VelocityConfig | `VelocityConfig`                           | **No**    | Characteristics of friction as the Owner entity is thrown by this knockback.                                               |
+
+**Knockback Type: Force**
+
+Apply the calculated knockback force along the provided direction.
+
+| Field Name | Type                         | Required? | Notes                                                                                |
+| ---------- | ---------------------------- | --------- | ------------------------------------------------------------------------------------ |
+| Direction  | `Vector3`<br />(Default: Up) | **No**    | Which direction the player should be flung, relative to the direction of the attack. |
+
+**Knockback Type: Point**
+
+Apply the calculated knockback force laterally along the XZ plane, plus provided Y velocity.
+
+| Field Name | Type                        | Required? | Notes                                                                                                   |
+| ---------- | --------------------------- | --------- | ------------------------------------------------------------------------------------------------------- |
+| OffsetX    | `Integer`<br />(Default: 0) | **No**    | Offset the source position of the knockback left or right perpendicular to the direction of the attack. |
+| OffsetZ    | `Integer`<br />(Default: 0) | **No**    | Offset the source position of the knockback, forward or backward along the directon of the attack.      |
+| RotateY    | `Integer`<br />(Default: 0) | **No**    | Rotate the knockback direction around the Y axis, where 0 is the default attack direction.              |
+| VelocityY  | `Float`<br />(Default: 0.0) | **No**    | Add vertical velocity to the knockback force after the direction and force has been calculated.         |
+
+**Knockback Type: Directional**
+
+Apply the calculated knockback force along the attack direction, removing any vertical component and replacing it with a provided Y velocity.
+
+| Field Name | Type                      | Required? | Notes                                                                                                                                            |
+| ---------- | ------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------ |
+| RelativeX  | `Float`<br />(Default: 0) | **No**    | Apply additional force left or right perpendicular to the direction of the attack. The additional force is multiplied by the knockback strength. |
+| RelativeZ  | `Float`<br />(Default: 0) | **No**    | Apply additional force forward or backward along the attack direction. The additional force is multiplied by the knockback strength.             |
+| VelocityY  | `Float`<br />(Default: 0) | **No**    | Replace the vertical velocity of the knockback with this value.  This value is not multiplied by knockback strength.                             |
+
+**VelocityConfig Fields**
+
+| Field Name          | Type                                              | Required? | Notes                                                                                                                                                                                           |
+| ------------------- | ------------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| GroundResistance    | `Float`<br />(Default: 0.82)                      | **No**    | The minimum amount of friction applied when the entity is in contact with the ground.  1.0 = no friction, 0.0 = total friction                                                                  |
+| GroundResistanceMax | `Float`<br />(Default: 0.0)                       | **No**    | The maximum amount of friction applied when the entity is in contact with the ground.  1.0 = no friction, 0.0 = total friction                                                                  |
+| AirResistance       | `Float`<br />(Default: 0.96)                      | **No**    | The minimum amount of friction applied when the entity is in the air. 1.0 = no friction, 0.0 = total friction                                                                                   |
+| AirResistanceMax    | `Float`<br />(Default: 0.0)                       | **No**    | The maximum amount of friction applied when the entity is in the air. 1.0 = no friction, 0.0 = total friction                                                                                   |
+| Threshold           | `Float`<br />(Default: 1.0)                       | **No**    | The speed at which the maximum amount of friction will be applied to the entity. The amount of friction applied will increase from minimum to maximum as the entity moves from 0 to this speed. |
+| Style               | `VelocityThresholdStyle`<br />(Default: `Linear`) | **No**    | The curve that friction follows as the entity's speed increases toward the `Threshold`.                                                                                                         |
+
+**CostType Values**
+
+- `MaxHealthPercentage`
+- `Damage`
+
+**ChangeVelocityType Values**
+
+- `Add`
+- `Set`
+
+**VelocityThresholdStyle Values**
+
+- `Linear`
+- `Exp`
+
+## Blocks
+
+These are interaction types meant to reason about and modify blocks in the world.  The most important concept unique
+to these interactions is the Block Target.  Like the Entity Target, it is mutable and can come from many places.
+However, for interaction chains initiated by the client, the block target will initially be the block that the player's cursor was
+over, if any.
+
+Additionally, for interaction chains initiated by the client, the client will send along which face of the block is targeted,
+which is used by a few block-related interactions.
+It is left up to each interaction type that cares about block faces as to how to handle this behavior for simulated input
+(i.e. NPCs initiating chains that are normally initated by the client).  At the time of this writing, all block-related
+interactions choose the top face where relevant in simulated input.
+
+### BlockCondition
+
+This interaction has a field `Matchers` which specifies certain conditions, such as block type, state, etc.  This
+interaction fails if the current target block does not match all of them.
+
+**BlockCondition Fields**
+
+| Field Name       | Type                                        | Required? | Notes                                                                                                                                                                                                                                                                                                                                   |
+| ---------------- | ------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false)             | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction.                                                                                                                                                                                                       |
+| Matchers         | `Array`<br />(Element Type: `BlockMatcher`) | **Yes**   | A list of conditions that the target block must match or this condition will fail.<br />**Note: This field is technically not required but there is a bug that makes it dangerous to not provide at the time of this writing.**<br />**Note: If no conditions are added to this array, the interaction will fail, counterintuitively.** |
+
+**BlockMatcher Fields**
+
+| Field Name | Type                       | Required? | Notes                                                                          |
+| ---------- | -------------------------- | --------- | ------------------------------------------------------------------------------ |
+| Block      | `BlockIdMatcher`           | **No**    | If provided, requires the block itself match some set of conditions.           |
+| Face       | `BlockFace`                | **No**    | If provided and not 'None', requires a specific block face be targeted.        |
+| StaticFace | `Boolean` (Default: false) | **No**    | If false, the face condition will be adjusted by the block's current rotation. |
+
+**BlockFace Values**
+
+- `Up`
+- `Down`
+- `North`
+- `South`
+- `East`
+- `West`
+- `None`
+
+**BlockIdMatcher Fields**
+
+| Field Name | Type                                   | Required? | Notes                                                                      |
+| ---------- | -------------------------------------- | --------- | -------------------------------------------------------------------------- |
+| Id         | `Asset`<br />(Asset Type: `BlockType`) | **No**    | If provided, the block must match the specified `BlockType`.               |
+| State      | `String`                               | **No**    | If provided, the block's current state must match the provided state name. |
+| Tag        | `String`                               | **No**    | If provided, the block type's asset tags must contain the provided tag.    |
+
+### DestroyCondition
+
+This interaction fails if the current User entity cannot destroy the current target blcok.
+
+**DestroyCondition Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+
+### PlacementCountCondition
+
+This interaction accepts the name of a BlockType that has the TrackedPlacement BlockEntity. The interaction will fail if the number of
+blocks of the provided BlockType in the world do not match the provided condition.
+
+**PlacementCountCondition Fields**
+
+| Field Name | Type                           | Required? | Notes                                                                                                                                                                                                                                                           |
+| ---------- | ------------------------------ | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Block      | `String`                       | **Yes**   | The BlockType to examine. The number of instances of the BlockType in the world will be compared to Value.<br />**Note: The specified BlockType must have the TrackedPlacement BlockEntity. Otherwise, the number of blocks in the world will always be zero.** |
+| Value      | `Integer`<br />(Default: 0)    | **No**    | The value to compare the number of blocks in the world with.                                                                                                                                                                                                    |
+| LessThan   | \`Boolean<br />(Default: true) | **No**    | If true, the interaction will fail if the number of blocks in the world is greater than or equal to Value. If false, the interaction will fail if the number of blocks in the world is less than or equal to Value.                                             |
+
+### BreakBlock
+
+This interaction attempts to break the target block while acting as the User entity. The User entity must be a player. It
+is not guaranteed to work, depending on world settings and the User entity's current state, it may not work.  If it
+fails, it will fail the interaction under some circumstances, but not others.
+
+**Note: In particular, if `Harvest`=false and the player is in Survival mode, the player will simply execute a damage operation
+against the block. Even when the Tool field is specified, the player's currently-held item can impact the results in unintuitive
+ways.**
+
+This interaction will fail if there is no block target, if `Harvest`=true and the
+block is not harvestable, or if the world settings prevent the Harvest/Break operation.
+It will generally not fail otherwise, even if the block was not broken or damaged.
+The block will generally break every time if `Harvest`=true or the player is in
+Creative mode.
+
+**BreakBlock Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                                                                                                                                                                                                  |
+| ---------------- | ------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction.                                                                                                                                                                      |
+| Harvest          | `Boolean` (Default: false)      | **No**    | If true, harvest the block and deposit the drops in the player's inventory. This operation will generally always succeed.  If false, this interaction will effectively perform whatever action would have occurred if the player had left-clicked the block.                                           |
+| Tool             | `String`                        | **No**    | If `Harvest`=true, the player is in Survival mode, and this field is provided, then the break operation will be performed as though with this tool type.<br />**This field mostly doesn't work.  Your held item will be used for most block damage calculations regardless of this field's contents.** |
+| MatchTool        | `Boolean` (Default: false)      | **No**    | If true, `Harvest`=true, the player is in Survival mode, and `Tool` is provided, block breaking will be prevented unless `Tool` is a valid gathering tool for the target block. The interaction will not be failed, even if block breaking is prevented in this manner.                                |
+
+### ChangeBlock
+
+This interaction requires a mapping from one or more current BlockTypes to one or more target BlockTypes.  If the
+target block is one of the key BlockTypes, then it will be changed to the mapped target BlockType.  If the current
+BlockType of the target block does not appear as a key in the Changes field, then this interaction fails.
+
+**ChangeBlock Fields**
+
+| Field Name        | Type                                                        | Required? | Notes                                                                                                                             |
+| ----------------- | ----------------------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget  | `Boolean`<br />(Default: false)                             | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+| Changes           | `Map`<br />(Key Type: `BlockType`, Value Type: `BlockType`) | **No**    | A list of potential block type changes, with each entry having a current and new BlockType id.                                    |
+| WorldSoundEventId | `Asset`<br />(Asset Type: `SoundEvent`)                     | **No**    | If provided, this SoundEvent is played in the world at the position of the block if the block successfully changes.               |
+| RequireNotBroken  | `Boolean`<br />(Default: false)                             | **No**    | If true, this interaction will fail if the player's held item is broken (durability 0), and the block change will not take place. |
+
+### ChangeState
+
+This interaction requires a mapping from one or more current block state names to one or more state names. If the
+target block is in one of the key block states, then it will be changed to the mapped target blocks tate. If the
+current block state of the target block does nto appear as a key in the Changes field, then this interaction fails.
+
+All blocks start out with a null state by default.  This null state can be referenced by the key "default" and the block
+can be returned to that state with the value "default".
+
+**ChangeState Fields**
+
+| Field Name       | Type                                                  | Required? | Notes                                                                                                                                          |
+| ---------------- | ----------------------------------------------------- | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false)                       | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction.              |
+| Changes          | `Map`<br />(Key Type: `String`, Value Type: `String`) | **No**    | A list of potential block state changes, with each entry having a current and new state name.                                                  |
+| UpdateBlockState | `Boolean`<br />(Default: false)                       | **No**    | If true, performs a full refresh of the block's BlockEntity component and notifies nearby players as though a full block type change occurred. |
+
+### CycleBlockGroup
+
+This interaction will attempt to change the target block to the next block type in one of the BlockGroups it belongs to.
+If the block type belongs to multiple BlockGroups, which one is used is effectively arbitrary. The User entity must be
+a player. If the block cannot be changed for any reason (entity not a player, no block target, block does not belong
+to a BlockGroup, etc.). If the block is the only entry in the BlockGroup, this interaction will succeed and the block
+will be considered changed despite nothing happening.  Unlike most other block-changing interactions, this one will
+fail if the world settings prevent players from breaking blocks.
+
+**This interaction always reduces the player's held item's durability by a single 'hit' worth of damage if the block
+changes. There is no way to prevent it. The block type will change and the interaction will succeed even if the player's
+held item is broken, however.**
+
+**CycleBlockGroup Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+
+### DestroyBlock
+
+This interaction destroys the target block without dropping anything.  It will successfully destroy the block if the
+target block exists and this interaction has no failure conditions.
+
+**This interaction has no additional fields.**
+
+### PickBlock
+
+This interaction is effectively equivalent to using the middle mouse button in creative mode. In survival mode, the
+block's item will be moved to the user's current active hotbar slot if it is in the player's inventory.  This
+interaction is performed entirely on the client and cannot be performed by non-players.  It is unclear if this
+interaction has failure conditions.
+
+**PickBlock Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+
+### PlaceBlock
+
+This interaction is effectively identical to a right clicking while holding a block in their hand, with some
+additional options. For one, it can be executed with any LivingEntity as the User entity. For another, it has some
+useful fields.  For the most part, though, it follows the same behaviors and rules as any ordinary block placement
+by a player.
+
+It's not clear under what circumstances this interaction can fail. The server will not fail the interaction under any
+special circumstances (including when there is no target block, or when `BlockTypeToPlace` is not provided and the
+LivingEntity is not holding a block). However, the client is very involved with the function of this interaction and
+its behavior is unknown.
+
+**PlaceBlock Fields**
+
+| Field Name         | Type                                   | Required? | Notes                                                                                                                                                                                                                                                                                                                                                           |
+| ------------------ | -------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| BlockTypeToPlace   | `Asset`<br />(Asset Type: `BlockType`) | **No**    | If provided, the block placed by this interaction will be the specified BlockType. If not provided, the User entity's held item will be used, instead, if it is a block.                                                                                                                                                                                        |
+| RemoveItemInHand   | `Boolean`<br />(Default: True)         | **No**    | If true and the User entity is not a player in Creative mode, the item in the player's hand must match the block being placed and one quantity will be removed for each block placed. If the item does not match, the block cannot be placed.  If false, the player's hand item is ignored entirely.\*\*                                                        |
+| AllowDragPlacement | `Boolean`<br />(Default: True)         | **No**    | If true and the interaction was triggered on the client by a player, then the player can hold the input that was used to activate this interaction chain and move the mouse around in order to execute this interaction repeatedly and place several blocks. The interaction chain will not move onto the next interaction until the player releases the input. |
+
+### RunOnBlockTypes
+
+This interaction retrieves all blocks within a provided radius of the User entity. For each block that matches any of
+the provided BlockSets, a new interaction chain will be forked that uses the matching block as the target block.
+This interaction will continue executing until all forked interaction chains have completed.  The interaction will fail if no
+blocks within the radius match the provided BlockSets or if all of the forked interaction chains fail.
+
+**RunOnBlockTypes Fields**
+
+| Field Name   | Type                                         | Required?        | Notes                                                                                                                                                                                                                                                                                      |
+| ------------ | -------------------------------------------- | ---------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| Range        | `Integer`                                    | **Yes**          | The spherical radius around the User entity to search for blocks. Must be at least 1.                                                                                                                                                                                                      |
+| BlockSets    | `AssetArray`<br />(Element Type: `BlockSet`) | **No**           | A list of BlockSets to match nearby blocks again. Only blocks that match any of the BlockSets will have interaction chains forked for them.                                                                                                                                                |
+| MaxCount     | `Integer`                                    | **Yes**          | The maximum number of blocks that will be located with the search. Further blocks will be ignored. If there are more matching blocks within the radius than this number, the specific set of blocks that will be found is completely arbitrary and may change from execution to execution. |
+| Interactions | `Asset`<br />(Asset Type: `RootInteraction`) | **No, but yes.** | The RootInteraction that will be forked for each matching block.  This interaction will not fail to validate if it is missing, but every execution of this interaction will fail.                                                                                                          |
+
+### UseBlock
+
+If the target block has an interaction for this interaction chain's interaction type, execute it immediately as part of
+this interaction chain. The execution will be wrapped in UseBlockEvent.Pre and UseBlockEvent.Post events, and cancellations
+of the UserBlockEvent.Pre event are respected. The User entity is considered the triggering entity for both events.
+
+If the target block does not have an interaction for this interaction chain's interaction type, this interaction fails.
+
+**This interaction has no additional fields.**
+
+## Items
+
+These are interactions intended to interface with an entity's inventory. There is no concept of an "item target",
+unfortunately, so these generally either interact with the entity's held item or the entity's inventory at a high level.
+
+### AddItem
+
+Adds a specified quantity of a specified item to the User entity's inventory, preferring to add it to the
+entity's hotbar where possible. This interaction will have no effect on User entities that are not LivingEntities.
+This interaction has no failure states.
+
+**Note: This interaction has a bug in its field validators that will cause interactions that reference items declared
+in the same mod to fail validation on startup.  Additionally, this interaction has a bug that will cause it to
+fail and have no effect if the User entity has no block target. Use ModifyInventory instead.**
+
+**AddItem Fields**
+
+| Field Name       | Type                              | Required? | Notes                                                                                                                             |
+| ---------------- | --------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false)   | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+| ItemId           | `Asset`<br />(Asset Type: `Item`) | **Yes**   | The item id of the item to add to the player's inventory.                                                                         |
+| Quantity         | `Integer`<br />(Default: 0)       | **No**    | The quantity of the item to add to the player's inventory.                                                                        |
+
+### CheckUniqueItemUsage
+
+This interaction will check whether it has run once for the User entity with their currently-held item before. If it hasn't,
+it will succeed. If it has, it will fail. It will also fail if the User entity is not a player. The interaction will record
+the item id of the User entity's currently-held item on success, ensuring it cannot be successfully run with that player
+and item id combination again.
+
+**This interaction has no additional fields.**
+
+### ChangeActiveSlot
+
+This interaction does not inherit from SimpleInteraction and therefore has no Next or Failed fields.  The `CancelOnItemChange`
+field is ignored for this interaction and is always treated as false. This interaction will set the User entity's currently-
+active hotbar slot to the specified slot index. If none is specified, the interaction chain's target slot will be used,
+if any. Otherwise, slot 0 will be used.  If a slot is specified and it is already active, then this interaction will
+have no effect, but if no slot is specified and the interaction chain's target slot is already active, the logic in
+the next paragraph will still be executed. This interaction will also have no effect if the User entity is not a
+LivingEntity.
+
+Once the slot has changed, a new SwapTo interaction chain will be forked off for the selected slot.
+If a target slot was specified, then the interaction chain's current target slot will be set to the specified slot, as will
+the forked SwapTo interaction chain. If this interaction chain was initiated by a player swapping an item into or out of
+an occupied active hotbar slot, then the swap will be executed after the slot is changed and before the SwapTo
+interaction is forked. Not running this interaction in the resulting SwapFrom interaction chain is a way for the server
+to cancel players performing these sorts of swap interactions. The default behavior for these swap interactions is that
+the SwapFrom interaction chain will be initiated with the currently-active-slot as the target slot. As a result, the
+target slot will usually not change when this interaction runs, it merely exists as a signal for the server to continue the
+item swap.
+
+**ChangeActiveSlot Fields**
+
+| Field Name | Type      | Required? | Notes                                                                                                                                                                                                     |
+| ---------- | --------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| TargetSlot | `Integer` | **No**    | If not provided, indicates the slot the player's active hotbar slot should be changed to.  Otherwise, the interaction chain's target slot will be used (which is usually the already-active hotbar slot). |
+
+### EquipItem
+
+This interaction will equip the User entity's currently-held item into the appropriate armor slot, if it is armor. The
+interaction will fail if the item is armor but it cannot be equipped for some reason. The interaction will succeed but
+take no action if the User entity cannot equip armor or if the item is not armor.
+
+**This interaction has no additional fields.**
+
+### IncreaseBackpackCapacity
+
+This interaction will increase the User entity's backpack size by the provided amount.  **It will additionally remove one
+quantity from the player's currently-held item. There is no way to prevent this.**  This interaction will have no effect
+if the User entity is not a player.  This interaction has no special failure conditions, even if the User entity
+is not a player, or the player is not currently holding an item.
+
+| Field Name | Type                        | Required? | Notes                                                                                   |
+| ---------- | --------------------------- | --------- | --------------------------------------------------------------------------------------- |
+| Capacity   | `Integer`<br />(Default: 1) | **No**    | The additional backpack capacity to add to the player. **Must be between 1 and 32767.** |
+
+### ModifyInventory
+
+This interaction attempts to perform one or more inventory-modifying actions against the User entity. The User entity must
+be a player. If they are not, no actions will be performed, but the interaction will not fail. Any item removals performed
+by this interaction, either as a result of `ItemToRemove` or `AdjustHeldItemQuantity`, are both atomic (meaning the entire
+quantity must be removed, or none) and required (meaning that the interaction will fail and no further actions taken if
+the removal fails for any reason).  Item additions performed by this interaction, either as a result of `ItemToAdd` or
+`AdjustHeldItemQuantity` will drop excess items on the ground near the player if necesary and continue on.
+
+This interaction first executes the item removal in `ItemToRemove`, if any, then adjusts the held item as specified by
+`AdjustHeldItemQuantity`, if provided, then executes the item addition in `ItemToAdd`, if any, and then finally executes
+the damage/healing of the held item in `AdjustHeldItemDurability`, if provided.
+
+**ModifyDurability Fields**
+
+| Field Name               | Type                            | Required? | Notes                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
+| ------------------------ | ------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| RequiredGameMode         | `GameMode`                      | **No**    | If provided, only execute the inventory-modifying actions if the player is in the provided GameMode. The interaction will not fail if the GameMode doesn't match.                                                                                                                                                                                                                                                                                                                                                                               |
+| ItemToRemove             | `ItemStack`                     | **No**    | If provided, a matching item will be removed in the provided quantity. If there is no matching item in the player inventory in the required quantity, then the interaction will fail and further actions will not be executed.                                                                                                                                                                                                                                                                                                                  |
+| AdjustHeldItemQuantity   | `Integer`<br />(Default: 0)     | **No**    | The player's held item, if any, will have its quantity will be modified by the provided amount- subtracted from if this number is negative or added to if this item is positive.  If the player has no held item, then this field will have no effect regardless of its value and the interaction will NOT fail.  If the player's inventory does not have sufficient quantity of items to support the removal, this interaction will fail and further actions will not be executed. Excess items will be dropped on the ground near the player. |
+| ItemToAdd                | `ItemStack`                     | **No**    | If provided, the ItemStack will be added to the player's inventory. Excess items will be dropped on the ground near the player.                                                                                                                                                                                                                                                                                                                                                                                                                 |
+| AdjustHeldItemDurability | `Double`<br />(Default: 0.0)    | **No**    | The player's held item, if any, will have its durability adjusted by the specified amount.  The durability cannot go below 0 or raise above the item's maximum durability. Invalid durability values in this field will not cause the interaction to fail. Neither will it fail if the player has no held item.                                                                                                                                                                                                                                 |
+| BrokenItem               | `String`                        | **No**    | This field should contain an ItemId, but it is not validated by the server on startup, so be careful.  This field can have the value of "Empty" to specify no item, or an empty hand. If specified and the `AdjustHeldItemDurability` operation reduces the player's held item to 0 durability, the player's held item is changed to this ItemId. If the inventory replacement fails, this interaction will fail.                                                                                                                               |
+| NotifyOnBreak            | `Boolean`<br />(Default: false) | **No**    | If true and the `AdjustHeldItemDurability` operation reduces the player's held item to 0 durability, this interaction will perform the usual audiovisual feedback of a broken tool. It will play the usual tool breaking sound and send the player a text message in chat that their item has broken.                                                                                                                                                                                                                                           |
+| NotifyOnBreakMessage     | `String`                        | **No**    | If provided, and `NotifyOnBreak` is true, when the player is notified of a broken tool by this interaction, the message sent to their chat will instead be the translation key specified by this field. The translation key supports the templating parameter `{itemName}`. See the translation key `server.general.repair.itemBroken_Hoe` for an example.                                                                                                                                                                                      |
+
+**GameMode Values**
+
+- `Creative`: The game is currently in Creative Mode
+- `Adventure`: The game is currently in Adventure Mode
+
+**ItemStack Fields**
+
+| Field Name                   | Type                              | Required? | Notes                                                                                |
+| ---------------------------- | --------------------------------- | --------- | ------------------------------------------------------------------------------------ |
+| Id                           | `Asset`<br />(Asset Type: `Item`) | **Yes**   | The id of the Item asset this stack contains.                                        |
+| Quantity                     | `Integer`<br />(Default: 1)       | **No**    | The number of items in this stack.<br />**Must be greater than 0.**                  |
+| Durability                   | `Double`<br />(Default: 0.0)      | **No**    | The durability of the item stack.<br />**Cannot be negative.**                       |
+| MaxDurability                | `Double`<br />(Default: 0.0)      | **No**    | The maximum durability of the item this stack contains.<br />**Cannot be negative.** |
+| Metadata                     | `Bson Document`                   | **No**    | If provided, applies the bson to the item stack metadata.                            |
+| OverrideDroppedItemAnimation | `Boolean`\*(Default: false)       | **No**    | ???                                                                                  |
+
+### PickupItem
+
+This interaction will attempt to pick up the User entity's current target entity and add it to their inventory. It will
+fail if the User entity is not a player, if they do not have a target entity, or if the target entity is not an item
+located in the world.  It will not fail if the player simply cannot pick up the item.
+
+**This interaction has no additional fields.**
+
+### RefillContainer
+
+This interaction will fail if the User entity is not a player. The interaction will draw a ray from the player's head
+down their look direction until the edge of the player's held item's interaction range or until the first solid block.
+The nearest fluid block of a type listed in this interaction's `States` map will result in the one of the player's
+currently-held items being converted to the fluid's related item state.  If the `States` map indicates a durability
+for the new item state, then the converted item will use that durability. If the item is already in the fluid's related
+item state, then this interaction will fail if the player's held item is already at maximum durability (unless the
+`States` map indicates a durability value greater than the item's maximum, in which case the interaction will succeed
+but the item will not change).  Otherwise, the durability listed for the fluid in the `States` map will be added to the
+item's current durability.
+
+If the interaction has not failed by this point, the fluid block in the world may be transformed to a different type if one is listed
+in the `States` map.
+
+If any part of this process does not proceed for any reason (for instance, if the player is not holding an item),
+then this interaction will fail.
+
+**RefillContainer Fields**
+
+| Field Name | Type                                                       | Required? | Notes                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| ---------- | ---------------------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| States     | `Map`<br />(Key Type: `String`, Value Type: `RefillState`) | **Yes**   | A map from item state names to `RefillState` objects, which contain information such as acceptable fluid block types, durability increases, and what fluid type to convert the targeted fluid block to after refill, if any. If the player targets a fluid block that matches one of the fluid types in the `RefillState`, the item will be converted to the keyed item state and the `RefillState` will be used to decide what happens next. |
+
+**RefillState Fields**
+
+| Field Name     | Type                                  | Required? | Notes                                                                                                                                                                                                                                                                                                                           |
+| -------------- | ------------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| AllowedFluids  | `Array`<br />(Element Type: `String`) | **Yes**   | If any of these fluids are targeted by the player, the player's held item will be converted to the keyed item state and `Durability` and `TransformFluid` will be used.                                                                                                                                                         |
+| Durability     | `Double`<br />(Default: -1.0)         | **No**    | If the player's held item changes item states, this value is the new item's durability, unless it is negative, in which case the item will begin at full durability. If the player's held item is already in the item state, and the item is not already at full durability, this value will be added to the item's durability. |
+| TransformFluid | `String`                              | **No**    | If provided, this field is a fluid id that the targeted fluid block should be transformed to if the player's held item is successfully updated.                                                                                                                                                                                 |
+
+## Entities
+
+### DamageEntity
+
+This interaction does not inherit from SimpleInteraction, but adds its own Next and Failed fields that
+work similarly.
+
+This interaction will cause the User entity to damage the Target entity.  It has the capability to apply different
+damage based on the direction of the attack or what body part was targeted by the User entity, with each possibility
+providing different damage calculations, effects, and Next interaction. If multiple entires match the attack, `TargetedDamage`
+(body part damage) takes highest priority, then the first matching `AngledDamage` in the list, then the default
+damage in the base interaction fields.  It is possible for elements of these different damage priorities to be taken peacemeal if higher-priority
+damage fields do not overwrite lower-priority damage fields. For instance,
+damage calculation could be taken from `TargetedDamage`, the damage effects could be taken from the first matching
+`AngledDamage`, and the Next interaction coming from the default damage field.
+
+If all damage dealt by this interaction is cancelled, then this interaction will fail, and the `Failed` interaction
+will be executed next in the chain. If any damage dealt by this interaction is blocked, then this interaction will
+succeed, but the `Blocked` interaction wil lbe executed next in the chain. Otherwise, the highest-precedent matching
+`Next` interaction that you provide will be executed.  For instance, if you provide `Next` interactions for all
+`TargetedDamage` and `AngledDamage` entries, and one in the interaction's `Next` field, then a headshot could result
+in a unique `Next` interaction being executed, even if there is a matching `AngledDamage` entry. However, if you leave
+the `Next` interaction out of your `TargetedDamage` entries, a special `Next` interaction for backstabs could be
+executed.  Otherwise, the `Next` field in the root of the interaction will be executed instead.
+
+DamageEntity has an unusual relationship with `RunTime`. This interaction always ends immediately after its first tick,
+regardless of the status of `RunTime` or `WaitForAnimationToFinish`.  However, if damage dealt by this interaction is
+calculated as `DamageCalculatorType` `Dps`, then the `RunTime` will be used to determine the precise amount of damage to
+deal. If `RunTime` is 0, then no damage will be dealt.
+
+**DamageEntity Fields**
+
+| Field Name       | Type                                                          | Required?                                                                                                                    | Notes                                                                                                                                                                                                                                                                                                                                                                         |
+| ---------------- | ------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| DamageCalculator | `DamageCalculator`                                            | **No**                                                                                                                       | If provided, describes the damage amounts and types to apply to the Target entity.                                                                                                                                                                                                                                                                                            |
+| DamageEffects    | `DamageEffects`                                               | **No**                                                                                                                       | If provided, describes particles, sounds, knockback, etc. to apply to the target entity on damage.                                                                                                                                                                                                                                                                            |
+| Next             | `Asset`<br />(Asset Type: `Interaction`)                      | **No**  After this interaction has finished, "Next" will be executed if damage was dealt to the target and none was blocked. |                                                                                                                                                                                                                                                                                                                                                                               |
+| AngledDamage     | `Array`<br />(Element Type: `AngledDamage`)                   | **No**                                                                                                                       | If provided, allows alternative `DamageCalculator`, `DamageEffects`, and `Next` entries for attacks that approach the target from certain angles.                                                                                                                                                                                                                             |
+| TargetedDamage   | `Map`<br />(Key Type: `String`, Value Type: `TargetedDamage`) | **Yes**                                                                                                                      | This field must be provided, but is not required to have any entries.  This is a map from body part names to `TargetedDamage` values. Hypixel only uses one body part name: `Head`, and it is not clear whether there are others.  If provided, allows alternative `DamageCalculator`, `DamageEffects`, and `Next` entries for attacks that damage specific enemy body parts. |
+| EntityStatsOnHit | `Array`<br />(Element Type: `EntityStatOnHit`)                | **No**                                                                                                                       | If provided, allows this attack to reduce enemy stats other than health.  Each individual damage application dealt by the same ability will apply stat reductions, at diminishing returns. All damage dealt in interaction chains forked by a Selector interaction will share the number of hits across all targets.                                                          |
+| Failed           | `Asset`<br />(Asset Type: `Interaction`)                      | **No**                                                                                                                       | After this interaction has finished, "Failed" will be executed if no damage hits were applied to the player, or if all damage hits were cancelled.                                                                                                                                                                                                                            |
+| Blocked          | `Asset`<br />(Asset Type: `Interaction`)                      | **No**                                                                                                                       | After this interaction has finished, "Blocked" will be executed if any damage hits were blocked by the target.                                                                                                                                                                                                                                                                |
+
+**DamageCalculator Fields**
+
+| Field Name                | Type                                                      | Required? | Notes                                                                                                                                                                                                                                                 |
+| ------------------------- | --------------------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Type                      | `DamageCalculatorType`<br />(Default: Absolute)           | **No**    | Whether the damage being applied is `Absolute` or \`Dps'.                                                                                                                                                                                             |
+| Class                     | `DamageClass`<br />(Default: Unknown)                     | **No**    | The type of attack producing the damage. Some weapon systems apply equipment modifiers based on this value.                                                                                                                                           |
+| BaseDamage                | `Map`<br />(Key Type: `DamageCause`, Value Type: `Float`) | **No**    | A set of DamageCauses and how much base damage is dealt for each.                                                                                                                                                                                     |
+| SequentialModifierStep    | `Float`<br />(Default: 0.0)                               | **No**    | Value between 0.0-1.0. Each additional hit from a single ability will have its damage reduced by this much as a percentage. All damage dealt in interaction chains forked by a Selector interaction will share the number of hits across all targets. |
+| SequentialModifierMinimum | `Float`<br />(Default: 0.0)                               | **No**    | Value between 0.0-1.0. `SequentialModifierStep` cannot reduce damage below this percentage regardless of the number of hits.                                                                                                                          |
+| RandomPercentageModifier  | `Float`<br />(Default: 0.0)                               | **No**    | A random value between +/- this amount multiplied by the base damage will be added to the base damage.                                                                                                                                                |
+
+**DamageEffects Fields**
+
+| Field Name             | Type                                         | Required? | Notes                                                                                   |
+| ---------------------- | -------------------------------------------- | --------- | --------------------------------------------------------------------------------------- |
+| ModelParticles         | `Array`<br />(Element Type: `ModelParticle`) | **No**    | Particle systems to trigger in the first-person view.                                   |
+| WorldParticles         | `Array`<br />(Element Type: `WorldParticle`) | **No**    | Particle systems to trigger in the third-person view.                                   |
+| LocalSoundEventId      | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | 2D sound to play locally to the attacking entity if they are a player.                  |
+| WorldSoundEventId      | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | Sound to play in the world at the Target entity's location.                             |
+| PlayerSoundEventId     | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | 2D sound to play locally to the Target entity if they are a player.                     |
+| ViewDistance           | `Double`<br />(Default: 75.0)                | **No**    | Distance at which these effects should play for other players.                          |
+| Knockback              | `Knockback`                                  | **No**    | The properties of the knockback that will be applied.                                   |
+| CameraEffect           | `Asset`<br />(Asset Type: `CameraEffect`)    | **No**    | CameraEffect to briefly apply locally to the Target entity if they are a player.        |
+| StaminaDrainMultiplier | `Float`<br />(Default: 1.0)                  | **No**    | This multiplier is applied to the stamina cost incurred by the target blocking, if any. |
+
+**AngledDamage Fields**
+
+| Field Name       | Type                                     | Required? | Notes                                                                                                                                                                                                     |
+| ---------------- | ---------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| AngleDistance    | `Float`<br />(Default: 0)                | **No**    | The width in degrees of the matching arc around the Target entity. If the attack against the Target originates from within the arc, then the properties below will be applied to the attack, if provided. |
+| Angle            | `Float`<br />(Default: 0.0)              | **No**    | The angle in degrees around the Target entity at which the matching arc is centered.                                                                                                                      |
+| DamageCalculator | `DamageCalculator`                       | **No**    | If provided and the attack against the Target entity originates from within the provided arc, this DamageCalculator will override the interaction's `DamageCalculator` field.                             |
+| DamageEffects    | `DamageEffects`                          | **No**    | If provided and the attack against the Target entity originates from within the provided arc, this DamageEffects will override the interaction's `DamageEffects` field.                                   |
+| Next             | `Asset`<br />(Asset Type: `Interaction`) | **No**    | If provided and the attack against the Target entity originates from within the provided arc, this Interaction will override the interaction's `Next` field.                                              |
+
+**TargetedDamage Fields**
+
+| Field Name       | Type                                     | Required? | Notes                                                                                                                                                                                            |
+| ---------------- | ---------------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| DamageCalculator | `DamageCalculator`                       | **No**    | If provided and this TargetedDamage was matched, this DamageCalculator will override the interaction's `DamageCalculator` field and the `DamageCalculator` field of any matching `AngledDamage`. |
+| DamageEffects    | `DamageEffects`                          | **No**    | If provided and this TargetedDamage was matched, this DamageEffects will override the interaction's `DamageEffects` field and the `DamageEffects` field of any matching `AngledDamage`.          |
+| Next             | `Asset`<br />(Asset Type: `Interaction`) | **No**    | If provided and this TargetedDamage was matched, this Interaction will override the interaction's `Next` field and the `Next` field of any matching `AngledDamage`.                              |
+
+**EntityStatOnHit Fields**
+
+| Field Name                  | Type                                                                       | Required? | Notes                                                                                                                                                                                                                                                                                        |
+| --------------------------- | -------------------------------------------------------------------------- | --------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| EntityStatId                | `Asset`<br />(AssetType: `EntityStatType`)                                 | **Yes**   | Which entity stat to affect.                                                                                                                                                                                                                                                                 |
+| Amount                      | `Float`<br />(Default: 0.0)                                                | **No**    | How much of the stat to apply for each damage application. Use negative numbers to reduce stats.                                                                                                                                                                                             |
+| MultipliersPerEntitiesHit   | `Array`<br />(Element Type: `Float`, Default: `[1.0, 0.6, 0.4, 0.2, 0.1]`) | **No**    | The diminishing returns curve to be applied for multiple damage applications by the same ability. Each hit's stat impact will be multiplied by the next value in the list.  If there are more hits than array elements, subsequent hits will be multiplied by `MultiplierPerExtraEntityHit`. |
+| MultiplierPerExtraEntityHit | `Float`<br />(Default: 0.05)                                               | **No**    | If an ability carries out more damage applications than there are elements in the `MultipliersPerEntitiesHit` array, then subsequent stat values will be multiplied by this number.                                                                                                          |
+
+**Knockback Fields**
+
+| Field Name     | Type                                       | Required? | Notes                                                                                                                      |
+| -------------- | ------------------------------------------ | --------- | -------------------------------------------------------------------------------------------------------------------------- |
+| Type           | `String`                                   | **No**    | If provided, specifies a type of knockback to use. Each Target type may come with additional fields.                       |
+| Force          | `Double`<br />(Default: 0.0)               | **No**    | The amount of force to apply to the Owner entity.                                                                          |
+| Duration       | `Double`<br />(Default: 0.0)               | **No**    | If 0.0, apply the force as a single impulse.  If more, continuously apply the force over a period of time.                 |
+| VelocityType   | `ChangeVelocityType`<br />(Default: `Add`) | **No**    | How to apply the force, either adding it to the entity's current velocity, or setting the velocity to the knockback force. |
+| VelocityConfig | `VelocityConfig`                           | **No**    | Characteristics of friction as the Owner entity is thrown by this knockback.                                               |
+
+**Knockback Type: Force**
+
+Apply the calculated knockback force along the provided direction.
+
+| Field Name | Type                         | Required? | Notes                                                                                |
+| ---------- | ---------------------------- | --------- | ------------------------------------------------------------------------------------ |
+| Direction  | `Vector3`<br />(Default: Up) | **No**    | Which direction the entity should be flung, relative to the direction of the attack. |
+
+**Knockback Type: Point**
+
+Apply the calculated knockback force laterally along the XZ plane, plus provided Y velocity.
+
+| Field Name | Type                        | Required? | Notes                                                                                                   |
+| ---------- | --------------------------- | --------- | ------------------------------------------------------------------------------------------------------- |
+| OffsetX    | `Integer`<br />(Default: 0) | **No**    | Offset the source position of the knockback left or right perpendicular to the direction of the attack. |
+| OffsetZ    | `Integer`<br />(Default: 0) | **No**    | Offset the source position of the knockback, forward or backward along the directon of the attack.      |
+| RotateY    | `Integer`<br />(Default: 0) | **No**    | Rotate the knockback direction around the Y axis, where 0 is the default attack direction.              |
+| VelocityY  | `Float`<br />(Default: 0.0) | **No**    | Add vertical velocity to the knockback force after the direction and force has been calculated.         |
+
+**Knockback Type: Directional**
+
+Apply the calculated knockback force along the attack direction, removing any vertical component and replacing it with a provided Y velocity.
+
+| Field Name | Type                      | Required? | Notes                                                                                                                                            |
+| ---------- | ------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------ |
+| RelativeX  | `Float`<br />(Default: 0) | **No**    | Apply additional force left or right perpendicular to the direction of the attack. The additional force is multiplied by the knockback strength. |
+| RelativeZ  | `Float`<br />(Default: 0) | **No**    | Apply additional force forward or backward along the attack direction. The additional force is multiplied by the knockback strength.             |
+| VelocityY  | `Float`<br />(Default: 0) | **No**    | Replace the vertical velocity of the knockback with this value.  This value is not multiplied by knockback strength.                             |
+
+**VelocityConfig Fields**
+
+| Field Name          | Type                                              | Required? | Notes                                                                                                                                                                                           |
+| ------------------- | ------------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| GroundResistance    | `Float`<br />(Default: 0.82)                      | **No**    | The minimum amount of friction applied when the entity is in contact with the ground.  1.0 = no friction, 0.0 = total friction                                                                  |
+| GroundResistanceMax | `Float`<br />(Default: 0.0)                       | **No**    | The maximum amount of friction applied when the entity is in contact with the ground.  1.0 = no friction, 0.0 = total friction                                                                  |
+| AirResistance       | `Float`<br />(Default: 0.96)                      | **No**    | The minimum amount of friction applied when the entity is in the air. 1.0 = no friction, 0.0 = total friction                                                                                   |
+| AirResistanceMax    | `Float`<br />(Default: 0.0)                       | **No**    | The maximum amount of friction applied when the entity is in the air. 1.0 = no friction, 0.0 = total friction                                                                                   |
+| Threshold           | `Float`<br />(Default: 1.0)                       | **No**    | The speed at which the maximum amount of friction will be applied to the entity. The amount of friction applied will increase from minimum to maximum as the entity moves from 0 to this speed. |
+| Style               | `VelocityThresholdStyle`<br />(Default: `Linear`) | **No**    | The curve that friction follows as the entity's speed increases toward the `Threshold`.                                                                                                         |
+
+**DamageCalculatorType Values**
+
+- `Absolute`
+- `Dps`
+
+**DamageClass Values**
+
+- `Unknown`
+- `Light`
+- `Charged`
+- `Signature`
+
+**ChangeVelocityType Values**
+
+- `Add`
+- `Set`
+
+**VelocityThresholdStyle Values**
+
+- `Linear`
+- `Exp`
+
+### LaunchProjectile
+
+This is just a worse version of Projectile and is slated to be removed.  Use Projectile.
+
+### Projectile
+
+This interaction will spawn a new projectile at the User entity's eye position that will travel in its look direction.
+
+| Field Name | Type                                          | Required? | Notes                                                  |
+| ---------- | --------------------------------------------- | --------- | ------------------------------------------------------ |
+| Config     | `Asset`<br />(Asset Type: `ProjectileConfig`) | **No**    | Configuration describing the projectile to be spawned. |
+
+### RemoveEntity
+
+Despawns the specified entity from the world. This interaction will have no effect if the specified entity is a player. This
+interaction has no special failure conditions.
+
+| Field Name | Type                                     | Required? | Notes                  |
+| ---------- | ---------------------------------------- | --------- | ---------------------- |
+| Entity     | `InteractionTarget`<br />(Default: User) | **No**    | The entity to despawn. |
+
+**InteractionTarget Values**
+
+- `User` - The user of this interaction chain. The entity whose actions caused this interaction chain to be executed. This is usually the same as the Owner.
+- `Owner` - The owner of this interaction chain. The entity upon whom this interaction chain is executing.
+- `Target` - The entity target of this interaction chain, if any.  This value is mutable (and can therefore come from many places) but most commonly, it is an entity the User was targeting when this interaction chain began executing.
+
+### SendMessage
+
+This interaction sends a message to the Owner entity if that entity can receive messages.  Otherwise, the message
+is written to the server logs.  If the entity is a player, the message will appear in the player's chat window.
+
+\*\*SendMessage
+
+| Field Name | Type     | Required? | Notes                                                                                                                 |
+| ---------- | -------- | --------- | --------------------------------------------------------------------------------------------------------------------- |
+| Message    | `String` | **No**    | A text message to be sent to the Owner entity.  If this field is not provided, `Key` is used instead.                 |
+| Key        | `String` | **No**    | A translation key for a message to be sent to the Owner entity. If `Message` is provided, then this field is ignored. |
+
+### UseEntity
+
+This interaction is not in use by Hypixel and has some unusual qualities that mean it probably won't do what you want it
+to.  Do not use it.
+
+This interaction will retrieve the entity currently targeted by the client (NOT the interaction chain's current Target
+entity) and execute that entity's RootInteraction for this interaction chain's current interaction type. The
+RootInteraction will be executed as part of this current interaction chain. None of the properties of this interaction
+chain will be modified.
+
+This interaction will fail if the client is not currently targeting an entity, or if no interaction for the current
+interaction type exists on the entity.
+
+## Stats
+
+Hytale's resource system has been written about fairly extensively.  You can use these interactions to modify stats in
+response to actions or use stats as a cost for abilities.
+
+### ChangeStat
+
+This interaction applies a set of raw stat changes to the User entity. It has no special failure conditions.
+
+| Field Name    | Type                                                         | Required? | Notes                                                                                                                                                                                                                      |
+| ------------- | ------------------------------------------------------------ | --------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| StatModifiers | `Map`<br />(Key Type: `EntityStatType`, Value Type: `Float`) | **Yes**   | A set of stats to modify and what value to apply to them.                                                                                                                                                                  |
+| ValueType     | `ValueType`<br />(Default: Absolute)                         | **No**    | Whether the values in the `StatModifiers` map represent flat values to apply to the stat total, or percentages (0.0-100.0). Percentage values are percentage of the difference between the maximum and minimum stat value. |
+| Behaviour     | `ChangeStatBehavior`<br />(Default: Add)                     | **No**    | Whether the values in the `StatModifiers` map represent deltas to add into the User entity's current stat values, or fixed values to set the entity's stats to.                                                            |
+
+**ValueType Values**
+
+- `Absolute`
+- `Percent`
+
+**ChangeStatBehaviour Values**
+
+- `Add`
+- `Set`
+
+### ChangeStatWithModifier
+
+This interaction is like ChangeStat, except an armor stat modifier can be chosen which will apply bonuses and penalties
+to a stat from the User entity's equipped armor before it is applied.
+
+| Field Name            | Type                                                         | Required? | Notes                                                                                                                                                                                                                      |
+| --------------------- | ------------------------------------------------------------ | --------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| StatModifiers         | `Map`<br />(Key Type: `EntityStatType`, Value Type: `Float`) | **Yes**   | A set of stats to modify and what value to apply to them.                                                                                                                                                                  |
+| ValueType             | `ValueType`<br />(Default: Absolute)                         | **No**    | Whether the values in the `StatModifiers` map represent flat values to apply to the stat total, or percentages (0.0-100.0). Percentage values are percentage of the difference between the maximum and minimum stat value. |
+| Behaviour             | `ChangeStatBehavior`<br />(Default: Add)                     | **No**    | Whether the values in the `StatModifiers` map represent deltas to add into the User entity's current stat values, or fixed values to set the entity's stats to.                                                            |
+| InteractionModifierId | `InteractionModifierId`                                      | **Yes**   | The armor interaction modifier to apply bonuses and penalties for.                                                                                                                                                         |
+
+**ValueType Values**
+
+- `Absolute`
+- `Percent`
+
+**ChangeStatBehaviour Values**
+
+- `Add`
+- `Set`
+
+**InteractionModifierId Values**
+
+- `Dodge`
+
+### StatsCondition
+
+This interaction will fail if the User entity cannot afford the specified stats costs, or if it does not have the
+requested stats.
+
+| Field Name | Type                                                         | Required? | Notes                                                                                                                                                                                    |
+| ---------- | ------------------------------------------------------------ | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Costs      | `Map`<br />(Key Type:` EntityStatType`, Value Type: `Float`) | **Yes**   | A set of costs that the User entity needs to be able to afford for this interaction to succeed.                                                                                          |
+| ValueType  | `ValueType`<br />(Default: Absolute)                         | **No**    | Whether the values in the `Costs` map represetn flat values or percentages (0.0-100.0).  Percentage values are percentage of the difference between the maximum and minimum value.       |
+| LessThan   | `Boolean`<br />(Default: false)                              | **No**    | If true, this interaction will fail unless the User entity's current stat values are at or **below** the specified levels.  If false, they must be at or **above** the specified levels. |
+| Lenient    | `Boolean`<br />(Default: false)                              | **No**    | If true and `LessThan` is true, and a player's minimum stat value is below zero, then the player can afford a stat cost if the current value of a stat if above 0.                       |
+
+**ValueType Values**
+
+- `Absolute`
+- `Percent`
+
+### StatsConditionWithModifier
+
+This interaction is like StatsCondition, except an armor stat modifier can be chosen which will apply bonuses and penalties
+to a stat's cost from the User entity's equipped armor before it is compared.
+
+| Field Name            | Type                                                         | Required? | Notes                                                                                                                                                                                    |
+| --------------------- | ------------------------------------------------------------ | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Costs                 | `Map`<br />(Key Type:` EntityStatType`, Value Type: `Float`) | **Yes**   | A set of costs that the User entity needs to be able to afford for this interaction to succeed.                                                                                          |
+| ValueType             | `ValueType`<br />(Default: Absolute)                         | **No**    | Whether the values in the `Costs` map represetn flat values or percentages (0.0-100.0).  Percentage values are percentage of the difference between the maximum and minimum value.       |
+| LessThan              | `Boolean`<br />(Default: false)                              | **No**    | If true, this interaction will fail unless the User entity's current stat values are at or **below** the specified levels.  If false, they must be at or **above** the specified levels. |
+| Lenient               | `Boolean`<br />(Default: false)                              | **No**    | If true and `LessThan` is true, and a player's minimum stat value is below zero, then the player can afford a stat cost if the current value of a stat if above 0.                       |
+| InteractionModifierId | `InteractionModifierId`                                      | **Yes**   | The armor interaction modifier to apply bonuses and penalties for.                                                                                                                       |
+
+**ValueType Values**
+
+- `Absolute`
+- `Percent`
+
+**InteractionModifierId Values**
+
+- `Dodge`
+
+## EntityEffects
+
+EntityEffects are buff or debuff effects that can be applied to a LivingEntity.  These can have a variety of effects from
+movement speed changes to periodic damage.
+
+### EffectCondition
+
+This interaction will fail if the specified entity's EntityEffects do not match the provided conditions.
+
+**EffectCondition Fields**
+
+| Field Name      | Type                                             | Required? | Notes                                                                                                                                                                                                             |
+| --------------- | ------------------------------------------------ | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Entity          | `InteractionTarget`<br />(Default: User)         | **Yes**   | The entity to examine for EntityEffects. This field can indicate the Owner, User, or Target of this interaction chain.                                                                                            |
+| Match           | `Match`<br />(Default: All)                      | **No**    | If `All`, then this interaction will fail if any EntityEffect in the `EntityEffectIds` is not on the specified entity. If `None`, then this interaction will fail if any EntityEffect IS on the specified entity. |
+| EntityEffectIds | `AssetArray`<br />(Element Type: `EntityEffect`) | **Yes**   | The set of EntityEffects to check against the specified entity and `Match`.                                                                                                                                       |
+
+**InteractionTarget Values**
+
+- `User` - The user of this interaction chain. The entity whose actions caused this interaction chain to be executed. This is usually the same as the Owner.
+- `Owner` - The owner of this interaction chain. The entity upon whom this interaction chain is executing.
+- `Target` - The entity target of this interaction chain, if any.  This value is mutable (and can therefore come from many places) but most commonly, it is an entity the User was targeting when this interaction chain began executing.
+
+**Match Values**
+
+- `All` - All EntityEffects must be on the specified entity for this interaction to succeed.
+- `None` - None of the EntityEffects must be on the specified entity for this interaction to succeed.
+
+### ApplyEffect
+
+This interaction will apply the specified EntityEffect to the specified Entity.  It has no special failure conditions.
+
+**ApplyEffect Fields**
+
+| Field Name | Type                                      | Required? | Notes                                                                                                                  |
+| ---------- | ----------------------------------------- | --------- | ---------------------------------------------------------------------------------------------------------------------- |
+| Entity     | `InteractionTarget`<br />(Default: User)  | **Yes**   | The entity to apply the EntityEffect to. This field can indicate the Owner, User, or Target of this interaction chain. |
+| EffectId   | `Asset`<br />(Asset Type: `EntityEffect`) | **Yes**   | The effect to apply.                                                                                                   |
+
+**InteractionTarget Values**
+
+- `User` - The user of this interaction chain. The entity whose actions caused this interaction chain to be executed. This is usually the same as the Owner.
+- `Owner` - The owner of this interaction chain. The entity upon whom this interaction chain is executing.
+- `Target` - The entity target of this interaction chain, if any.  This value is mutable (and can therefore come from many places) but most commonly, it is an entity the User was targeting when this interaction chain began executing.
+
+### ClearEntityEffect
+
+This interaction will remove the specified EntityEffect from the specified Entity. It has no special failure conditions.
+It will not fail if the Entity does not have the EntityEffect.
+
+**ClearEntityEffect Fields**
+
+| Field Name | Type                                      | Required? | Notes                                                                                                                     |
+| ---------- | ----------------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------- |
+| Entity     | `InteractionTarget`<br />(Default: User)  | **Yes**   | The entity to remove the EntityEffect from. This field can indicate the Owner, User, or Target of this interaction chain. |
+| EffectId   | `Asset`<br />(Asset Type: `EntityEffect`) | **Yes**   | The effect to remove.                                                                                                     |
+
+**InteractionTarget Values**
+
+- `User` - The user of this interaction chain. The entity whose actions caused this interaction chain to be executed. This is usually the same as the Owner.
+- `Owner` - The owner of this interaction chain. The entity upon whom this interaction chain is executing.
+- `Target` - The entity target of this interaction chain, if any.  This value is mutable (and can therefore come from many places) but most commonly, it is an entity the User was targeting when this interaction chain began executing.
+
+## Farming
+
+These are interaction types built to support the in-game farming system in Hytale. They are mostly block-related interactions
+with a few exceptions.
+
+### ChangeFarmingStage
+
+If the target block is a farming block, this interaction will attempt to modify the current farming stage in one of
+three ways.  The interaction can optionally specify which StageSet to use for the new stage. If it is not specified,
+the current StageSet will be used. If any part of the the process of changing the growth stage fails, this interaction
+will fail, with the one exception that attempting to set the stage to the crop's existing stage will have no effect but
+still succeed.
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                                                                                                                                                                          |
+| ---------------- | ------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction.                                                                                                                                              |
+| StageSet         | `String`                        | **No**    | If provided, set the block's current stage to one in the provided StageSet. Otherwise, use the crop's current StageSet.                                                                                                                                                        |
+| Increase         | `Integer`                       | **No**    | If provided, increase the current stage by the specified amount. If the specified stage does not exist, the block will be set to the closest extant stage.                                                                                                                     |
+| Decrease         | `Integer`                       | **No**    | If provided and `Increase` is not provided, decrease the current stage by the specified amount. If the specified stage does not exist, the block will be set to the closest extant stage.                                                                                      |
+| Stage            | `Integer`<br />(Default: -1)    | **No**    | If provided and `Increase`/`Decrease` are not provided, set the current stage to the specified stage. If this value is less than 0, set the current stage to the final growth stage. If the specified stage does not exist, the block will be set to the closest extant stage. |
+
+### FertilizeSoil
+
+If the target block is unfertilized tilled soil or a farming block on top of unfertilized tilled soil, fertilizes the soil.
+The interaction will fail otherwise.
+
+**FertilizeSoil Fields**
+
+| Field Name       | Type                                  | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false)       | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+| RefreshModifiers | `Array`<br />(Element Type: `String`) | **No**    | Does nothing.                                                                                                                     |
+
+### HarvestCrop
+
+This interaction will attempt to execute the harvest action on the current block target and add the crop's drops to the User entity's
+inventory.  The block will either be destroyed or set to its post-harvest growth stage, depending on the farming
+configuration of the block.  This will happen (and the player will receive the full harvest drops) regardless of the
+block's current growth stage. This interaction has no special failure conditions, even if the block target isn't a
+farming block or gathering isn't permitted in the current world, but nothing will occur in those cases.
+
+**HarvestCrop Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+
+### UseWateringCan
+
+If the target block is tilled soil or a farming block on top of tilled soil, waters the soil for the specified duration.
+The interaction will fail otherwise.
+
+**UseWateringCan Fields**
+
+| Field Name       | Type                                  | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false)       | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+| Duration         | `Integer`<br />(Default: 0)           | **No**    | The duration in seconds to water the soil for.                                                                                    |
+| RefreshModifiers | `Array`<br />(Element Type: `String`) | **No**    | Does nothing.                                                                                                                     |
diff --git a/content/docs/de-DE/contributing/pr-guidelines.mdx b/content/docs/de-DE/contributing/pr-guidelines.mdx
index 7a251032..c226da04 100644
--- a/content/docs/de-DE/contributing/pr-guidelines.mdx
+++ b/content/docs/de-DE/contributing/pr-guidelines.mdx
@@ -19,6 +19,8 @@ To ensure a smooth and efficient review process, both contributors and reviewers
 4. **Code Quality**
    - Ensure your code follows the project's coding standards and best practices.
    - Include comments where necessary to explain complex logic.
+   - Always test your changes locally before submitting the PR to catch any issues early.
+   - Format your code using `bun format` to maintain consistency across the codebase.
 5. **Testing**
    - Test your changes thoroughly before submitting the PR.
    - If applicable, include unit tests or integration tests to verify your changes.
diff --git a/content/docs/de-DE/contributing/translate.mdx b/content/docs/de-DE/contributing/translate.mdx
new file mode 100644
index 00000000..c62ffdde
--- /dev/null
+++ b/content/docs/de-DE/contributing/translate.mdx
@@ -0,0 +1,74 @@
+---
+title: Translate
+description: How to translate HytaleModding to your language
+---
+
+# Translating HytaleModding
+
+HytaleModding is translated with the help of the community using **Crowdin**. If you want to help translate or improve existing translations, this is the right place.
+
+## Steps to Translate
+
+All translations are managed **via Crowdin**.
+
+1. Visit [our Crowdin project](https://crowdin.com/project/hytalemodding) and log in if required.
+2. Click on your language.
+3. Click on the file/article you wish to translate. We recommend starting with Official Documentation, and then Server Plugin Documentation.
+4. Start translating!
+5. Approved translations will appear on the website.
+
+### Video Guide
+
+<iframe src="https://www.youtube.com/embed/NHiG1rDRgks" allowFullScreen />
+
+## How to discuss
+
+You can always report issues or discuss specific topics directly on Crowdin, but we recommend using Discord instead of the Crowdin comment system to keep everything organized in one place.
+
+1. Join [our Discord](https://discord.gg/hytalemodding)
+2. Open `#translations` channel. Here you can discuss or ask questions that are not related to a specific language.
+3. If you want to join a thread, you are required to run `/translator <your-language>` command here. The bot will add you to the thread for your language.
+
+## Translation Guidelines
+
+- You need to be confident in what you are translating. You should be able to read the text you just translated and understand the meaning of it very easily.
+- It should use the simplest form of language possible. Use English words if the translation is unknown to the majority in your country.
+- Use your imagination, trust yourself. Feel free to change any context as you wish as long as it can still get the same point across and is understandable.
+- These guidelines are more important than language-specific guidelines, but less important than Hytale terminology and rules.
+
+## What not to translate
+
+We request you all to not translate these specific sections of the website:
+
+### Callout types
+
+Callouts are the boxes that contain important information. We request you to not translate the types as they only work in English.
+
+**Example:**
+
+```mdx
+<Callout type="warning" title="Translate this title!">
+Translate the text inside the callout!
+</Callout>
+```
+
+In this example, please don't translate the word warning, the rest you can translate.
+
+### Icons
+
+Icon names must not be translated.
+They are technical identifiers mapped directly to existing icons. Translating them will break the icon rendering.
+
+```mdx
+icon: Globe
+```
+
+---
+
+{/* 
+For translators who will edit this page:
+
+- You are required to translate the Guidelines as they change.
+- General guidelines should be translated but not edited.
+- Learn how to use Markdown from writing_guides.mdx
+*/}
diff --git a/content/docs/de-DE/established-information/server/content-categories/art-assets.mdx b/content/docs/de-DE/established-information/server/content-categories/art-assets.mdx
index d88fb2f1..6d9de522 100644
--- a/content/docs/de-DE/established-information/server/content-categories/art-assets.mdx
+++ b/content/docs/de-DE/established-information/server/content-categories/art-assets.mdx
@@ -14,7 +14,7 @@ Hytale provides comprehensive support for 3D modeling and texture art creation,
 Hytale benutzt **Blockbench** als Haupttool für die 3D-Modellierung und Animationen:
 
 * **Official support**: Used for "creating Hytale models, textures, and animations"
-* **Special plugin**: Hytale will have a dedicated Blockbench plugin, to be released ASAP
+* **Special plugin**: Hytale has a dedicated [Blockbench Plugin](https://www.blockbench.net/plugins/hytale_plugin).
 * **Direct compatibility**: The plugin allows creators to "create Hytale-compatible models, textures, and animations directly in Blockbench"
 * **Replaces legacy tools**: Fully replaces the old Hytale Model Maker to better support established creative workflows in the community
 * **Safety features**: Only allows you to add things compatible with the engine, so no need to worry about breaking anything
diff --git a/content/docs/de-DE/guides/ecs/block-components.mdx b/content/docs/de-DE/guides/ecs/block-components.mdx
new file mode 100644
index 00000000..ca68b38a
--- /dev/null
+++ b/content/docs/de-DE/guides/ecs/block-components.mdx
@@ -0,0 +1,247 @@
+---
+title: Block Components
+description: Learn how to use the block components.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+  - name: oskarscot
+    link: https://oskar.scot
+---
+
+# Overview
+
+In this guide, you'll learn how to use block components to create a ticking block.
+
+<Callout>
+  For a more complete reference, you may also want to review FarmingSystems.Ticking, as much of the underlying logic is based on its implementation.
+</Callout>
+
+## Steps
+
+### 1. ExampleBlock - holds block behavior
+
+```java
+public class ExampleBlock implements Component<ChunkStore> {
+
+    public static final BuilderCodec CODEC = BuilderCodec.builder(ExampleBlock.class, ExampleBlock::new).build();
+
+    // Components usually require a copy constructor as well but since we don't actually hold any data in this component this is not neccessary
+    public ExampleBlock() { }
+
+    public static ComponentType getComponentType() {
+        return ExamplePlugin.get().getExampleBlockComponentType();
+    }
+
+    @Nullable
+    public Component<ChunkStore> clone() {
+        return new ExampleBlock();
+    }
+}
+```
+
+ExampleBlock is a custom component that stores the behavior and data for your ticking block. Here, it simply places an Ice Block at x + 1 relative to its current position when it ticks.
+
+---
+
+### 2. ExampleInitializer - marks blocks as ticking when placed
+
+```java
+public class ExampleInitializer extends RefSystem {
+
+    @Override
+    public void onEntityAdded(@Nonnull Ref ref, @Nonnull AddReason reason, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+        BlockModule.BlockStateInfo info = (BlockModule.BlockStateInfo) commandBuffer.getComponent(ref, BlockModule.BlockStateInfo.getComponentType());
+        if (info == null) return;
+
+        ExampleBlock generator = (ExampleBlock) commandBuffer.getComponent(ref, ExamplePlugin.get().getExampleBlockComponentType());
+        if (generator != null) {
+            int x = ChunkUtil.xFromBlockInColumn(info.getIndex());
+            int y = ChunkUtil.yFromBlockInColumn(info.getIndex());
+            int z = ChunkUtil.zFromBlockInColumn(info.getIndex());
+
+            WorldChunk worldChunk = (WorldChunk) commandBuffer.getComponent(info.getChunkRef(), WorldChunk.getComponentType());
+            if (worldChunk != null) {
+				worldChunk.setTicking(x, y, z, true);
+            }
+        }
+    }
+
+    @Override
+    public void onEntityRemove(@Nonnull Ref ref, @Nonnull RemoveReason reason, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+    }
+
+    @Override
+    public Query getQuery() {
+        return Query.and(BlockModule.BlockStateInfo.getComponentType(), ExamplePlugin.get().getExampleBlockComponentType());
+    }
+}
+```
+
+ExampleInitializer is a RefSystem that reacts when block entities with the ExampleBlock component are added or removed. This is crucial for marking blocks as ticking when they're first placed.
+
+**Key Points:**
+
+- Tells the game that this block should tick, allowing `ExampleSystem` to process it.
+
+```java
+worldChunk.setTicking(x, y, z, true);
+```
+
+---
+
+### 3. ExampleSystem - handles ticking
+
+```java
+public class ExampleSystem extends EntityTickingSystem {
+
+    public void tick(float dt, int index, @Nonnull ArchetypeChunk archetypeChunk, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+        BlockSection blocks = (BlockSection) archetypeChunk.getComponent(index, BlockSection.getComponentType());
+
+        assert blocks != null;
+
+        if (blocks.getTickingBlocksCountCopy() != 0) {
+            ChunkSection section = (ChunkSection) archetypeChunk.getComponent(index, ChunkSection.getComponentType());
+
+            assert section != null;
+
+            BlockComponentChunk blockComponentChunk = (BlockComponentChunk) commandBuffer.getComponent(section.getChunkColumnReference(), BlockComponentChunk.getComponentType());
+
+            assert blockComponentChunk != null;
+
+            blocks.forEachTicking(blockComponentChunk, commandBuffer, section.getY(), (blockComponentChunk1, commandBuffer1, localX, localY, localZ, blockId) -> {
+                Ref<ChunkStore> blockRef = blockComponentChunk.getEntityReference(ChunkUtil.indexBlockInColumn(localX, localY, localZ));
+                if (blockRef == null) {
+                    return BlockTickStrategy.IGNORED;
+                } else {
+                    ExampleBlock exampleBlock = (ExampleBlock) commandBuffer1.getComponent(blockRef, ExampleBlock.getComponentType());
+                    if (exampleBlock != null) {
+                        WorldChunk worldChunk = (WorldChunk) commandBuffer.getComponent(section.getChunkColumnReference(), WorldChunk.getComponentType());
+                        World world = worldChunk.getWorld();
+
+                        int globalX = localX + (worldChunk.getX() * 32);
+                        int globalZ = localZ + (worldChunk.getZ() * 32);
+
+                        // We need to execute setBlock on the world thread as you cannot call store functions from a system
+                        // This is because of the architecture of the server, depending on your needs you can also use the CommandBuffer
+                        world.execute(() -> {
+                            world.setBlock(globalX + 1, localY, globalZ, "Rock_Ice");
+                        });
+
+                        return BlockTickStrategy.CONTINUE;
+
+                    } else {
+                        return BlockTickStrategy.IGNORED;
+                    }
+                }
+            });
+        }
+    }
+
+    @Nullable
+    public Query getQuery() {
+        return Query.and(BlockSection.getComponentType(), ChunkSection.getComponentType());;
+    }
+}
+```
+
+ExampleSystem is an EntityTickingSystem that runs every tick to execute the logic for all ticking blocks with the ExampleBlock component.
+
+**Key Points:**
+
+- **Get the block component**
+
+```java
+ExampleBlock exampleBlock = (ExampleBlock) commandBuffer.getComponent(blockRef, ExampleBlock.getComponentType());
+```
+
+- **Convert local chunk coordinates to world coordinates**
+
+```java
+int globalX = localX + (worldChunk.getX() * 32);
+int globalZ = localZ + (worldChunk.getZ() * 32);
+```
+
+- **Run the block logic**
+
+```java
+exampleBlock.runBlockAction(globalX, localY, globalZ, worldChunk.getWorld());
+```
+
+- **Keep the block ticking in the next tick**
+
+```java
+return BlockTickStrategy.CONTINUE;
+```
+
+---
+
+### 4. ExamplePlugin - registers components and systems
+
+```java
+public class ExamplePlugin extends JavaPlugin {
+    protected static ExamplePlugin instance;
+    private static final HytaleLogger LOGGER = HytaleLogger.forEnclosingClass();
+    private ComponentType exampleBlockComponentType;
+
+    public static ExamplePlugin get() {
+        return instance;
+    }
+
+    public ExamplePlugin(@Nonnull JavaPluginInit init) {
+        super(init);
+        LOGGER.atInfo().log("Hello from " + this.getName() + " version " + this.getManifest().getVersion().toString());
+    }
+
+    @Override
+    protected void setup() {
+        instance = this;
+        LOGGER.atInfo().log("Setting up plugin " + this.getName());
+        this.exampleBlockComponentType = this.getChunkStoreRegistry().registerComponent(ExampleBlock.class, "ExampleBlock", ExampleBlock.CODEC);
+    }
+	
+	@Override
+	protected void start() {
+		this.getChunkStoreRegistry().registerSystem(new ExampleSystem());
+		this.getChunkStoreRegistry().registerSystem(new ExampleInitializer());
+	}
+
+    public ComponentType getExampleBlockComponentType() {
+        return this.exampleBlockComponentType;
+    }
+}
+```
+
+---
+
+### 5. Configure In-Game
+
+![block-component-1](/assets/guides/block-component-1.png)
+
+![block-component-2](/assets/guides/block-component-2.png)
+
+With this logic, the block will now continuously place an Ice Block at the coordinates x + 1 relative to its current position every time it ticks.
+
+---
+
+## Common Issues
+
+### NullPointerException on Startup
+
+**Error message:**
+
+```java
+java.lang.NullPointerException: Cannot invoke "com.hypixel.hytale.component.query.Query.validateRegistry(com.hypixel.hytale.component.ComponentRegistry)" because "query" is null
+```
+
+**Cause:**
+This error occurs when your module is loaded **before** the required Hytale modules.
+
+**Fix:**
+Add `EntityModule` and `BlockModule` as dependencies in your `manifest.json` to ensure proper load order.
+
+```json
+"Dependencies": {
+  "Hytale:EntityModule": "*",
+  "Hytale:BlockModule": "*"
+}
+```
diff --git a/content/docs/de-DE/guides/ecs/hytale-ecs-theory.mdx b/content/docs/de-DE/guides/ecs/hytale-ecs-theory.mdx
index 20c3a94d..52d8b1f5 100644
--- a/content/docs/de-DE/guides/ecs/hytale-ecs-theory.mdx
+++ b/content/docs/de-DE/guides/ecs/hytale-ecs-theory.mdx
@@ -29,7 +29,7 @@ for now this is the basic understanding for the `ChunkStore`. You can use it to
 
 ## Holder
 
-A Holder is essentially a blueprint for an entity. Before an entity exists in the Store (and thus in the world), is exists as a `Holder`. It collects and holds all the necessary components (data). You can compare it analogous to shopping cart. You grab all components you need and once you have everything, check out at the store which will take your cart and create a valid entity ID and hand you back a receipt (a Ref).
+A Holder is essentially a blueprint for an entity. Before an entity exists in the Store (and thus in the world), it exists as a `Holder`. It collects and holds all the necessary components (data). You can compare it analogous to shopping cart. You grab all components you need and once you have everything, check out at the store which will take your cart and create a valid entity ID and hand you back a receipt (a Ref).
 
 Let's take a look at an example: initializing players. In `Universe`, the `addPlayer` method demonstrates it perfectly.
 When a player connects, we don't immediately throw them into the ECS. We first construct their data in a Holder.
@@ -167,7 +167,7 @@ MyComponent comp = commandBuffer.getComponent(ref, componentType);
 
 Codecs handle serialization and deserialization of components. Hytale uses them to save and load entity data to and from disk as well as sending component data over the network. When creating a custom component, you must also create a corresponding Codec.
 
-There are mutliple Codec types already implemented in the default Codec Interface:
+There are multiple Codec types already implemented in the default Codec Interface:
 
 - Codec.STRING
 - Codec.BOOLEAN
@@ -215,7 +215,7 @@ This might seem tedious at first but it ensures that your component can be corre
   KeyedCodec<Integer> exampleInt = new KeyedCodec<Integer>("ExampleIntIdForCodec", Codec.INTEGER);
   ```
 
-- **Setter Function**: This is a lambda function that takes an instance of your component and returns the value of the field you want to serialize. For example, if you have a field called `myCustomField` in your custom component, your getter function would look like this:
+- **Setter Function**: This is a lambda function that takes an instance of your component + the value to set and sets the field value on the component. For example, if you have a field called `myCustomField` in your custom component, your setter function would look like this:
   ```java
   (data, value) -> data.myCustomField = value
   ```
@@ -276,7 +276,7 @@ public class PoisonComponent implements Component<EntityStore> {
 
 You can also add validators to your Codec fields to ensure that the data being serialized/deserialized meets certain criteria. For example, if you want to ensure that the `damagePerTick` field is always non-negative or the poison name is never null, you can add a validator like this:
 
-````java
+```java
 .append(
     new KeyedCodec<Float>("DamagePerTick", Codec.FLOAT),
     (data, value) -> data.damagePerTick = value,
@@ -292,14 +292,15 @@ You can also add validators to your Codec fields to ensure that the data being s
 )
 .addValidator(Validators.nonNull())
 .add()
+```
 
 ### Complex Codec Examples
 
-If you want to have a map inside your component, you can use the MapCodec class to build a KeyedCoded for it. Here's an example of how to create a Codec for a Map field:
+If you want to have a map inside your component, you can use the MapCodec class to build a KeyedCodec for it. Here's an example of how to create a Codec for a Map field:
 
 ```java
 var damagePerTick = new KeyedCodec<>("DamagePerTick", new MapCodec<>(Codec.FLOAT, HashMap<String, Float>::new));
-````
+```
 
 <Callout type="info">
   This also works with custom Objects as long as you have a Codec defined for the Object type.
diff --git a/content/docs/de-DE/guides/java-basics/00-introduction.mdx b/content/docs/de-DE/guides/java-basics/00-introduction.mdx
index 82e744d3..6d3641ff 100644
--- a/content/docs/de-DE/guides/java-basics/00-introduction.mdx
+++ b/content/docs/de-DE/guides/java-basics/00-introduction.mdx
@@ -7,7 +7,7 @@ Willkommen zu deiner Reise in die Java-Programmierung! Dieser Leitfaden soll dir
 
 ## Was ist Java?
 
-Java ist eine leistungsstarke, objektorientierte Programmiersprache, die 1995 geschaffen wurde. Sie ist eine der beliebtesten Programmiersprachen der Welt und wird für alles von Handy-Apps bis hin zu Unternehmenssoftware verwendet. Am wichtigsten für uns ist aber, dass es die Sprache ist die Hytale für ihre Server & Modding API verwendet.
+Java ist eine leistungsstarke, objektorientierte Programmiersprache, die 1995 geschaffen wurde. Sie ist eine der beliebtesten Programmiersprachen der Welt und wird für alles von Handy-Apps bis hin zu Unternehmenssoftware verwendet. Most importantly for us, it's the language Hytale uses for its servers & modding API.
 
 ## Was du lernen wirst
 
diff --git a/content/docs/de-DE/guides/java-basics/02-operators.mdx b/content/docs/de-DE/guides/java-basics/02-operators.mdx
index d9c04d30..f6fc4263 100644
--- a/content/docs/de-DE/guides/java-basics/02-operators.mdx
+++ b/content/docs/de-DE/guides/java-basics/02-operators.mdx
@@ -119,7 +119,7 @@ String greetingWithName = "Hallo, " + name + "!"; // "Hallo, Alice!
 
 ## Vorrang von Operatoren
 
-Innerhalb einer Code-Zeile ist genau festgelegt, welcher Operator zuerst ausgewertet wird. Es ist wie in Mathe: Erst Klammern, dann Wurzeln/Potenzen. Danach gilt Punktrechnung vor Strichrechnung.
+Operator Precedence means which operator gets evaluated first in an line of code. Es ist wie in Mathe: Erst Klammern, dann Wurzeln/Potenzen. Danach gilt Punktrechnung vor Strichrechnung.
 
 ```java
 int result = 10 + 5 * 2; // Das Ergebnis ist 20, nicht 30.
diff --git a/content/docs/de-DE/guides/java-basics/03-control-flow-if.mdx b/content/docs/de-DE/guides/java-basics/03-control-flow-if.mdx
index dd1ca9ed..4cd4e732 100644
--- a/content/docs/de-DE/guides/java-basics/03-control-flow-if.mdx
+++ b/content/docs/de-DE/guides/java-basics/03-control-flow-if.mdx
@@ -7,7 +7,7 @@ Programme müssen Entscheidungen treffen. If-Anweisungen ermöglichen deinem Pro
 
 ## Einfache If-Anweisung
 
-Die einfachste Form überprüft eine Bedingung.
+The simplest form checks one condition:
 
 ```java
 int health = 20;
diff --git a/content/docs/de-DE/guides/java-basics/08-access-modifiers.mdx b/content/docs/de-DE/guides/java-basics/08-access-modifiers.mdx
index af560932..da2bf33b 100644
--- a/content/docs/de-DE/guides/java-basics/08-access-modifiers.mdx
+++ b/content/docs/de-DE/guides/java-basics/08-access-modifiers.mdx
@@ -484,7 +484,7 @@ class Data {
     // Static member:
     // cannot access to non-static variables
     public static void bar() {
-        x = 100; // Error: non-static variable x cannot be renference from a static context
+        x = 100; // Error: non-static variable x cannot be referenced from a static context
         y = 100; // OK
     }
 }
@@ -504,7 +504,7 @@ Data.x = 1000; // Error: cannot access instanced variables in a static context
 
 ### Static Fields
 
-A static field represents a data member owned by the class type rather then the object. Static fields are also stored in a specific memory location that's been shared between all the object instances that are created.
+A static field represents a data member owned by the class type rather than the object. Static fields are also stored in a specific memory location that's been shared between all the object instances that are created.
 
 It is declared as following:
 
diff --git a/content/docs/de-DE/guides/plugin/animated-block-textures.mdx b/content/docs/de-DE/guides/plugin/animated-block-textures.mdx
new file mode 100644
index 00000000..42bfa51f
--- /dev/null
+++ b/content/docs/de-DE/guides/plugin/animated-block-textures.mdx
@@ -0,0 +1,101 @@
+---
+title: Animated Block Textures
+description: Learn how to attach a .blockyanim to a block
+authors:
+  - name: Burkino
+---
+
+import { File, Folder, Files } from 'fumadocs-ui/components/files';
+
+So, you want to make your blocks feel more alive through animations, do you?\
+Now for the most part this is the exact same as [Creating custom blocks](./creating-block).
+![blue fire gif](/assets/guides/blue_fire.gif)
+
+## Prerequisites
+
+This is NOT a guide on animating or texturing or even using BlockBench, why? Because I don't know how to do that.\
+The only thing we will be doing is taking the fire texture, changing the color, and applying it to our new fire block.
+
+## Setup
+
+To start, you're obviously going to want to grab the `Common/VFX/Fire/Fire.png` file. How you do it is up to you, in the Asset Editor you'll need to switch to the Common tab.\
+I'll assume you know how colorize or change the hue of an image, so go ahead and do that now and save it as `Blue_Fire.png`.
+
+The other assets used in this guide are `Common/VFX/Fire/Fire.blockymodel` and `Common/Blocks/Animations/Fire/Fire_Burn.blockyanim` (both renamed to `Blue_Fire`) but since we won't be changing them it's probably fine to leave them. I will reference the `Blue_Fire` versions as a way to point out what should be custom assets.\
+I will also duplicate `Server/Item/Item/Deco/Deco_Fire.json` and call it `Deco_Blue_Fire.json`.
+
+## Applying the changes
+
+The `Deco_Blue_Fire` block is actually just a particle emitter, however we will not be using particles, so lets start by removing them in `Block > Particles`.\
+Next we want to set the Block Model (called `CustomModel` in JSON) to `VFX/Blue_Fire/Blue_Fire.blockymodel` and Block Model Textures (`CustomModelTexture` in JSON) to
+
+```json
+[
+    {
+        "Texture": "VFX/Blue_Fire/Blue_Fire.png",
+        "Weight": 1
+    }
+]
+```
+
+Finally, we will apply the .blockyanim to our model, this is done through the Block Model Animation property (`CustomModelAnimation` in JSON) and the value should be `Blocks/Animations/Blue_Fire/Blue_Fire_Burn.blockyanim`.
+
+## Final Code
+
+With that your new blue fire should be done. Here is the minimal JSON for our blue fire.\
+There is an additional `Looping` and `RequiresAlphaBlending` property that I have not gone over, however I hope it is self-explanatory.
+
+```json
+{
+  "BlockType": {
+    "DrawType": "Model",
+    "CustomModel": "VFX/Blue_Fire/Blue_Fire.blockymodel",
+    "CustomModelAnimation": "Blocks/Animations/Blue_Fire/Blue_Fire_Burn.blockyanim",
+    "CustomModelTexture": [
+      {
+        "Texture": "VFX/Blue_Fire/Blue_Fire.png",
+        "Weight": 1
+      }
+    ],
+    "Looping": true,
+    "RequiresAlphaBlending": false
+  },
+  "PlayerAnimationsId": "Block"
+}
+```
+
+<Files>
+  <Folder name="resources" defaultOpen>
+    <Folder name="Server" defaultOpen>
+      <Folder name="Item" defaultOpen>
+        <Folder name="Items" defaultOpen>
+          <Folder name="Deco" defaultOpen>
+            <File name="Deco_Blue_Fire.json" />
+          </Folder>
+        </Folder>
+      </Folder>
+    </Folder>
+
+    <Folder name="Common" defaultOpen>
+      <Folder name="Blocks" defaultOpen>
+        <Folder name="Animations" defaultOpen>
+          <Folder name="Blue_Fire" defaultOpen>
+            <File name="Blue_Fire_Burn.blockyanim" />
+          </Folder>
+        </Folder>
+      </Folder>
+
+      <Folder name="VFX" defaultOpen>
+        <Folder name="Blue_Fire" defaultOpen>
+          <File name="Blue_Fire.blockymodel" />
+
+          <File name="Blue_Fire.png" />
+        </Folder>
+      </Folder>
+    </Folder>
+  </Folder>
+</Files>
+
+## Next steps
+
+Now that you know how to attach an animation to a block, try adding it to a block state.
diff --git a/content/docs/de-DE/guides/plugin/build-and-test.mdx b/content/docs/de-DE/guides/plugin/build-and-test.mdx
index 0e7fe7eb..f37534c3 100644
--- a/content/docs/de-DE/guides/plugin/build-and-test.mdx
+++ b/content/docs/de-DE/guides/plugin/build-and-test.mdx
@@ -9,18 +9,18 @@ If you followed along with the [Setting Up Your Development Environment](./setti
 
 ## Building Your Mod
 
-In our case, we've **Maven** as the build system. Maven is a powerful build automation tool that manages dependencies, compiles your code, and packages everything into a distributable JAR file.
+In our case, we've **Gradle** as the build system. Gradle is a powerful build automation tool that manages dependencies, compiles your code, and packages everything into a distributable JAR file.
 
-### Understanding Maven
+### Understanding Gradle
 
-Maven uses a `pom.xml` file (Project Object Model) to define your project's configuration, dependencies, and build settings. You can learn more about Maven at the [official Apache Maven website](https://maven.apache.org/).
+Gradle can use a `build.gradle.kts` file (Kotlin DSL) to define your project's configuration, dependencies, and build settings. You can learn more about Gradle at the [official Gradle website](https://gradle.org/).
 
-### Building with Maven
+### Building with Gradle
 
 To build your mod, open a terminal in your project directory and run:
 
 ```bash
-mvn package
+./gradlew build
 ```
 
 This command will:
@@ -29,16 +29,35 @@ This command will:
 2. Run any tests (if present)
 3. Package everything into a JAR file
 
+<Callout type="info">
+  If you are using the plugin template from the [Setting Up Your Development Environment](./setting-up-env) guide, then the build script is already set up for you. It includes paths to your Hytale game library and handles the packaging of your mod, managing hytale dependencies and manifest changes.
+
+  If you have a different path to your Hytale installation, you may receive the following error:
+
+  ```bash
+  FAILURE: Build failed with an exception.
+
+  * What went wrong:
+  Failed to find Hytale at the expected location. Please make sure you have installed the game. The expected location can be changed using the hytale.home_path property. Currently looking in 'C:\Path\To\Hytale'
+  ```
+
+  You can change the path by adding a property to your `gradle.properties` file (if it doesn't exist, create it in the root of your project):
+
+  ```properties
+  hytale.home_path=C:\Correct\Path\To\Hytale
+  ```
+</Callout>
+
 ### Build Output
 
-Once the build completes successfully, your mod will be located in the `target` directory and named:
+Once the build completes successfully, your mod will be located in the `build/libs` directory and named:
 
 ```
-ExamplePlugin-1.0-SNAPSHOT.jar
+ExamplePlugin-1.0.jar
 ```
 
 <Callout type="info">
-  The exact name may vary depending on what you configured in your `pom.xml` file. Check the `artifactId` and `version` fields to see what your JAR will be named.
+  The exact name may vary depending on what you configured in your `build.gradle.kts` and `settings.gradle.kts` file. Check the `rootProject.name` and `version` fields to see what your JAR will be named.
 </Callout>
 
 ## Testing Your Mod
@@ -49,11 +68,11 @@ Now that you've built your mod, it's time to test it in Hytale!
 
 First, you need to find Hytale's mods directory:
 
-1. Press **Win + R** on your keyboard
-2. Type `%appdata%` and press Enter
-3. Navigate to: `Hytale\UserData\Mods`
+1. Go to your Hytale installation directory (The default location is usually in your AppData folder)
+   > On Windows, you can access it by clicking `windows + R` and typing `%appdata%`.
+2. Navigate to: `/UserData/Mods`
 
-The full path should look like:
+The default path would look like:
 
 ```
 C:\Users\YourUsername\AppData\Roaming\Hytale\UserData\Mods
@@ -65,7 +84,7 @@ C:\Users\YourUsername\AppData\Roaming\Hytale\UserData\Mods
 
 ### 2. Copy Your Mod
 
-Copy the `ExamplePlugin-1.0-SNAPSHOT.jar` file from your project's `target` directory into the `Mods` folder you just located.
+Copy the `ExamplePlugin-1.0.jar` file from your project's `build/libs` directory into the `Mods` folder you just located.
 
 ### 3. Launch Hytale and Verify
 
@@ -84,7 +103,7 @@ If your mod doesn't appear in the mods list:
 - Make sure the JAR file is in the correct `Mods` folder
 - Check that your `manifest.json` file is properly configured
 - Look for any error messages in the Hytale logs
-- Verify that you're using the correct version of Java and Maven
+- Verify that you're using the correct version of Java and Gradle
 
 ## Next Steps
 
diff --git a/content/docs/de-DE/guides/plugin/creating-commands.mdx b/content/docs/de-DE/guides/plugin/creating-commands.mdx
index d33597f3..08572f16 100644
--- a/content/docs/de-DE/guides/plugin/creating-commands.mdx
+++ b/content/docs/de-DE/guides/plugin/creating-commands.mdx
@@ -8,6 +8,8 @@ authors:
     url: https://oskar.scot
   - name: jacobwojoski
     url: https://github.com/jacobwojoski
+  - name: Marcel-TO
+    url: https://marcel-to.net
 ---
 
 In this guide, you will learn how to create custom commands for your Hytale mod.
@@ -36,7 +38,7 @@ The most basic command is an `AbstractAsyncCommand`. It has very minimal data av
   `AbstractAsyncCommand` runs on its own background thread. This means its execute is not tied to any world instance and because of this it can not edit any **Stores** or **Refs** without getting the desired world first. To access this data any of the other command types would be preferred and are likely what you will want to use instead.
 </Callout>
 
-The main purpose for a command like this would be for something that can happen everywhere and is not tied to a specific world. For example a `serverRules` command to tell the user thats running the command in chat what the servers rules are nomatter what world they are in.
+The main purpose for a command like this would be for something that can happen everywhere and is not tied to a specific world. For example a `serverRules` command to tell the user that's running the command in chat what the server's rules are no matter what world they are in.
 
 ```java
 // Command that can be run that lists the server rules in chat to the player
@@ -49,7 +51,7 @@ public class ServerRulesCommand extends AbstractAsyncCommand {
     }
 
     // Run the command
-    // conetext - info about who ran the command. Server console?, Some player?
+    // context - info about who ran the command. Server console?, Some player?
     @Override
     protected CompletableFuture<Void> executeAsync(@Nonnull CommandContext context) {
         context.sendMessage(Message.raw("The only rule is there are no rules."));
@@ -134,7 +136,7 @@ Uses a Ray to see what the player is looking at and tries to run the command on
 
 ## Adding Arguments
 
-Arguments are additional fields that the user can input when running a command. The different types of arguments along with small snipits and a large example can be seen below.
+Arguments are additional fields that the user can input when running a command. The different types of arguments along with small snippets and a large example can be seen below.
 
 ### Command Argument Types
 
@@ -163,14 +165,14 @@ this.messageArg = this.withOptionalArg("message", "Message to print while healin
 
 ### Default Arguments
 
-Adding a default argument has two additional arguemnt for the default value and default value description. You need to use `withDefaultArg` method.
+Adding a default argument has two additional argument for the default value and default value description. You need to use `withDefaultArg` method.
 
 ```java
 // args <Command String> <Description> <Default Value> <Desc of default value>
 this.healthArg = this.withDefaultArg("health", "Amount to heal player", ArgTypes.FLOAT, (float)100, "Desc of Default: 100");
 ```
 
-### Flag Arguemnts
+### Flag Arguments
 
 Similar as above but the flags return is either true if it exists or false if it does not. You need to use `withFlagArg` method.
 
@@ -181,20 +183,13 @@ this.debugArg = this.withFlagArg("debug", "Add debug logs");
 
 ### ArgTypes
 
-The following ArgTypes are available (only lists common types):
-
-- `ArgTypes.STRING`
-- `ArgTypes.INTEGER`
-- `ArgTypes.BOOLEAN`
-- `ArgTypes.FLOAT`
-- `ArgTypes.DOUBLE`
-- `ArgTypes.UUID`
+You can find all the available argument types on the [ArgTypes](../../argtypes) page.
 
 ### Example Command Arg Types
 
-Shows all Command arguemnt types with different various input types.
+Shows all Command argument types with different various input types.
 
-**NOTE:** When getting the value of an argument during execute you need to pass the context with `someArg.get(commandContext)`. Where `commandContext` is the first variable in the execute funtion.
+**NOTE:** When getting the value of an argument during execute you need to pass the context with `someArg.get(commandContext)`. Where `commandContext` is the first variable in the execute function.
 
 ```java
 // Example usage: /healplayer --health 50 --message "Feels Good" --debug
@@ -204,7 +199,7 @@ public class HealPlayerCommand extends AbstractTargetPlayerCommand {
     private final FlagArg debugArg;
 
     public HealPlayerCommand() {
-        super("healplayer", "Healing a player for an <input> ammount of HP (default: 100)");
+        super("healplayer", "Healing a player for an <input> amount of HP (default: 100)");
 
         // Abstract TargetPlayerCommand passes the player that ran the command by default and implements
         // the use of `--player <value>` to specify someone else
@@ -213,10 +208,10 @@ public class HealPlayerCommand extends AbstractTargetPlayerCommand {
         this.healthArg = this.withDefaultArg("health", "Amount to heal player", ArgTypes.FLOAT, (float)100, "Desc of Default: 100");
 
         // Or you could do the following making the health value required instead of with a default.
-        //    You would need to change the decleration to RequiredArg<Float>
+        //    You would need to change the declaration to RequiredArg<Float>
         // this.healthArg = this.withRequiredArg("health", "Amount to heal player", ArgTypes.FLOAT);
 
-        // Optional args reguare the user the input `--<key> <value>` so the following would require `--message "Good Luck"`
+// Optional args require the user the input `--<key> <value>` so the following would require `--message "Good Luck"`
         this.messageArg = this.withOptionalArg("message", "Message to print while healing", ArgTypes.STRING);
 
         // No type needed due to being a bool
@@ -230,7 +225,7 @@ public class HealPlayerCommand extends AbstractTargetPlayerCommand {
             commandContext.sendMessage(Message.raw("We are debugging"));
         }
 
-        // Health is stored in a generic stat map to allowing mods/future contect to easily add more stats if desired.
+        // Health is stored in a generic stat map to allowing mods/future content to easily add more stats if desired.
         EntityStatMap stats = store.getComponent(ref, EntityStatMap.getComponentType());
         int healthIdx = DefaultEntityStatTypes.getHealth();
         EntityStatValue health = stats.get(healthIdx);
@@ -252,7 +247,7 @@ public class HealPlayerCommand extends AbstractTargetPlayerCommand {
 
 ## Argument Validators
 
-Argument validators are a way to check the command before the command gets executed. They are added with the `addValidator` method on an argument when calling `withXxxArg`. They provide a nice output to the user when an input value is invalid.
+Argument validators are a way to check the command before the command gets executed. They are added with the `addValidator` method on an argument when calling `withXxxArg`. They provide a nice output to the user when an input value is invalid. There are some common validators provided in the `Validators` class such as `greaterThan`, `lessThan`, and `or`, `max`, `range`, etc.
 
 ```java
 ...
@@ -260,18 +255,59 @@ Argument validators are a way to check the command before the command gets execu
     OptionalArg<Integer> healAmount = withOptionalArg("amount", "Heal Amount", ArgTypes.INTEGER)
         .addValidator(Validators.greaterThan(0))
         .addValidator(Validators.lessThan(1000));
-
-    // Custom check example
-    OptionalArg<Integer> healAmount = withOptionalArg("amount", "Heal Amount", ArgTypes.INTEGER)
-            .addValidator( value -> {
-                if (value != null && value <= 0) {
-                    return ValidationResult.error("ammount argument must be a positive number");
-                }
-                return ValidationResult.success();
-            });
 ...
 ```
 
+### Custom Validators
+
+You can also create custom validators by implementing the `com.hypixel.hytale.codec.validation.Validator` interface. The interfaces forces you to implement the `accept` and `updateSchema` method. The `accept` method takes in the argument value and validates it. If the validation fails, you can use the `fail` method of the `com.hypixel.hytale.codec.validation.ValidationResults` class to return an error message.
+The `updateSchema` method is used to update the schema of the command argument. This is used for commands that have dynamic schemas based on the input value. For example, if you have a command that takes in a player name as an argument, you can use the `updateSchema` method to update the schema to include a list of online players for validation.
+
+Here is an example of a custom validator that checks if a string value is equal to a banned word. In this example, the banned word is "badword". If the input value is "badword", the validator will fail and return an error message.
+
+```java
+import com.hypixel.hytale.codec.schema.SchemaContext;
+import com.hypixel.hytale.codec.schema.config.Schema;
+import com.hypixel.hytale.codec.validation.ValidationResults;
+import com.hypixel.hytale.codec.validation.Validator;
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+
+public class MyCustomValidator implements Validator<String> {
+    @Nonnull
+    private final String value;
+
+    public MyCustomValidator(@Nonnull String value) {
+        this.value = value;
+    }
+
+    @Override
+    public void accept(@Nullable String input, @Nonnull ValidationResults results) {
+        if (this.value.equalsIgnoreCase(input)) {
+            results.fail("The given role has been banned.");
+        }
+    }
+
+    @Override
+    public void updateSchema(SchemaContext context, @Nonnull Schema target) {
+        // This method can be used to update the schema of the command argument. This is useful for commands that have dynamic schemas based on the input value. For example, if you have a command that takes in a player name as an argument, you can use the `updateSchema` method to update the schema to include a list of online players for validation.
+        throw new UnsupportedOperationException("Not implemented yet.");
+    }
+}
+```
+
+After the custom validator is created, you can add it to an argument like the following example. In this example, we add the `MyCustomValidator` to a string argument called "role". If the user inputs "badword" as the role, the command will fail and return the error message defined in the `MyCustomValidator`.
+
+```java
+    ...
+    // Custom validator example
+    String bannedRole = "badword";
+
+    OptionalArg<String> roleArg = withOptionalArg("role", "Role to assign", ArgTypes.STRING)
+        .addValidator(new MyCustomValidator(bannedRole));
+    ...
+```
+
 ---
 
 ## Permissions
@@ -312,7 +348,7 @@ This allows the server to control who has access to specific commands. You add t
 
 If you want variants of the same command without doing argument parsing you can instead use `addUsageVariant(new OtherCommandClass())` in the original commands constructor.
 
-The only difference is in the `OtherCommandClass()` constrcutor you don't pass the command name to the super class.
+The only difference is in the `OtherCommandClass()` constructor you don't pass the command name to the super class.
 
 <Callout type="info">
   You can also use `addAliases("some_alias", "some_other_alias")` as a way to add shorthand or other ways to write the same command.
@@ -387,7 +423,7 @@ public class AdminCommand extends AbstractCommandCollection {
     public AdminCommand () {
         super("admin", "Admin commands");
         addSubCommand(new UserCommandCollection());
-        addSybCommand(new ServerCommandCollection);
+        addSubCommand(new ServerCommandCollection);
     }
 }
 ```
@@ -417,5 +453,5 @@ public class MyPlugin extends JavaPlugin {
 
 ## Video Link
 
-_Special Thanks to [TroubleDev](https://www.youtube.com/@TroubleDEV) for his excelent video guide on all of these features._
+_Special Thanks to [TroubleDev](https://www.youtube.com/@TroubleDEV) for his excellent video guide on all of these features._
 _Video Link: [TroubleDev - Hytale's Command API Explained](https://www.youtube.com/watch?v=KnmhG9MDMgo)_
diff --git a/content/docs/de-DE/guides/plugin/creating-events.mdx b/content/docs/de-DE/guides/plugin/creating-events.mdx
index 95863990..d3f0925d 100644
--- a/content/docs/de-DE/guides/plugin/creating-events.mdx
+++ b/content/docs/de-DE/guides/plugin/creating-events.mdx
@@ -1,6 +1,6 @@
 ---
-title: Creating Events
-description: Learn how to create custom events for your Hytale mod.
+title: Creating Events Listeners
+description: Learn how to create event listeners for your Hytale mod.
 authors:
   - name: Neil Revin
     url: https://itsneil.dev
@@ -10,7 +10,7 @@ authors:
 
 ## Event Class
 
-You can import a Event class and create a function with the Event as a argument. [Click here](../../server/events) to look at all available events.
+You can import an Event class and create a function with the Event as an argument. [Click here](../../server/events) to look at all available events.
 
 Example plugin when a player is ready (joins a server):
 
diff --git a/content/docs/de-DE/guides/plugin/item-registry.mdx b/content/docs/de-DE/guides/plugin/item-registry.mdx
new file mode 100644
index 00000000..9a0fd53a
--- /dev/null
+++ b/content/docs/de-DE/guides/plugin/item-registry.mdx
@@ -0,0 +1,95 @@
+---
+title: Working with the Item Registry
+description: Learn how to access and query the game's item registry to list all items, check if items exist, and retrieve item properties.
+authors:
+  - name: Denis
+---
+
+In this guide, you'll learn how to work with Hytale's Item Registry system. This is useful when you need to programmatically list all available items, validate item IDs, or retrieve item properties at runtime.
+
+## Prerequisites
+
+Before diving in, you should be familiar with:
+
+- [Setting up your development environment](./setting-up-env)
+- [Creating commands](./creating-commands) (optional, for testing)
+
+## Required Imports
+
+To work with the Item Registry, you'll need the following imports:
+
+```java
+import com.hypixel.hytale.assetstore.map.DefaultAssetMap;
+import com.hypixel.hytale.server.core.asset.type.item.config.Item;
+```
+
+## Getting the Item Registry
+
+The Item Registry is accessed through the `Item.getAssetMap()` method, which returns a `DefaultAssetMap<String, Item>` containing all registered items in the game:
+
+```java
+DefaultAssetMap<String, Item> itemMap = Item.getAssetMap();
+```
+
+## Listing All Items
+
+To iterate through all items in the registry, you can get the underlying map and loop through its entries:
+
+```java
+DefaultAssetMap<String, Item> itemMap = Item.getAssetMap();
+var map = itemMap.getAssetMap();
+
+for (var entry : map.entrySet()) {
+    String itemId = String.valueOf(entry.getKey());
+    Item item = entry.getValue();
+    
+    // Do something with the item
+    LOGGER.atInfo().log("Item ID: " + itemId);
+}
+```
+
+You can also get the total count of registered items:
+
+```java
+int totalItems = map.size();
+```
+
+## Checking if an Item Exists
+
+To check if a specific item exists in the registry, use `getAsset()` and verify the result:
+
+```java
+public boolean itemExists(String itemId) {
+    var assetMap = Item.getAssetMap();
+    if (assetMap != null) {
+        Item item = assetMap.getAsset(itemId);
+        return item != null && item != Item.UNKNOWN;
+    }
+    return false;
+}
+```
+
+<Callout type="info">
+  The `Item.UNKNOWN` constant represents an invalid or unrecognized item. Always check for both `null` and `Item.UNKNOWN` when validating items.
+</Callout>
+
+## Accessing Item Properties
+
+Once you have an `Item` instance, you can access various properties:
+
+```java
+var assetMap = Item.getAssetMap();
+Item item = assetMap.getAsset("Soil_Grass");
+
+if (item != null && item != Item.UNKNOWN) {
+    String id = item.getId(); // Soil_Grass
+    int maxStack = item.getMaxStack(); // 100
+    boolean isBlock = item.hasBlockType(); // true
+    boolean isConsumable = item.isConsumable(); // false
+}
+```
+
+## Related Guides
+
+- [Inventory Management](./inventory-management) - Learn how to add and remove items from player inventories
+- [Create Custom Item and Interaction](./item-interaction) - Learn how to create your own custom items
diff --git a/content/docs/de-DE/guides/plugin/permission-management.mdx b/content/docs/de-DE/guides/plugin/permission-management.mdx
index 6b7cfd46..55f06101 100644
--- a/content/docs/de-DE/guides/plugin/permission-management.mdx
+++ b/content/docs/de-DE/guides/plugin/permission-management.mdx
@@ -10,132 +10,569 @@ authors:
     link: https://discord.com/users/292656109939064833
   - name: Ivan
     link: https://discord.com/users/505770451218333717
+  - name: ZenithDevHQ
+    link: https://github.com/ZenithDevHQ
 ---
 
-In this guide, you'll learn how to manage permission nodes and groups in your Hytale plugin.
+In this guide, you'll learn how to manage permission nodes and groups in your Hytale plugin. Permissions control what actions players can perform on your server, from basic commands to advanced administrative functions.
 
-## The `PermissionsModule` class
+## What Are Permissions?
 
-The `PermissionsModule` class is responsible for managing permission nodes and groups in your plugin. It provides methods to check, grant and revoke permissions and groups for players. It allows the following operations
+Permissions are string identifiers that control access to features and commands. When a player tries to perform an action (like using a command), the server checks if they have the required permission.
 
-- Add permissions to user
-- Remove permissions from user
-- Add permissions to group (this also creates the group if it doesn't exist)
-- Remove permissions from group
-- Add user to group
-- Remove user from group
-- List all groups for a user
-- Check if a user has a permission (it checks both user and group permissions for the given player UUID)
+**Example permission nodes:**
 
-With this class you cannot:
+- `hytale.command.gamemode` - Permission to use the gamemode command
+- `hytale.editor.brush.use` - Permission to use brush tools
+- `myplugin.teleport.home` - A custom permission for your plugin
 
-- List all defined groups
-- Remove a group
+Permissions follow a hierarchical naming pattern: `namespace.category.action`
 
-### Adding Permission Nodes
+## Key Concepts
 
-You need a `Set<String>` containing all the permission nodes you want to add, these are added on top of the already existing permission nodes the user may have, it is not a replacement.
+Before diving into code, let's understand the core concepts:
+
+| Concept             | Description                                                                |
+| ------------------- | -------------------------------------------------------------------------- |
+| **Permission Node** | A string like `myplugin.feature.use` that represents a specific permission |
+| **Group**           | A named collection of permissions (e.g., "Admin", "VIP", "Default")        |
+| **Provider**        | The backend that stores and retrieves permissions                          |
+| **Wildcard**        | A pattern like `*` or `myplugin.*` that matches multiple permissions       |
+
+### How Permissions Are Checked
+
+When checking if a player has a permission, Hytale follows this order:
+
+1. **User's direct permissions** - Permissions granted directly to the player
+2. **Group permissions** - Permissions from groups the player belongs to
+3. **Virtual groups** - Game-mode-based permissions (e.g., Creative mode grants builder tools)
+4. **Default value** - Falls back to `false` if no match found
+
+<Callout type="info">
+  The first definitive match wins. If a player has a permission granted at the user level, group permissions won't override it.
+</Callout>
+
+---
+
+## The `PermissionsModule` Class
+
+The `PermissionsModule` class is the central hub for managing permissions. Access it using the singleton pattern:
 
 ```java
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.addUserPermission(playerUUID, permissions);
 ```
 
-### Removing Permission Nodes
+### Available Operations
+
+The module supports these operations:
+
+| Operation                     | Method                                          |
+| ----------------------------- | ----------------------------------------------- |
+| Add permissions to user       | `addUserPermission(uuid, permissions)`          |
+| Remove permissions from user  | `removeUserPermission(uuid, permissions)`       |
+| Add permissions to group      | `addGroupPermission(groupName, permissions)`    |
+| Remove permissions from group | `removeGroupPermission(groupName, permissions)` |
+| Add user to group             | `addUserToGroup(uuid, groupName)`               |
+| Remove user from group        | `removeUserFromGroup(uuid, groupName)`          |
+| Get user's groups             | `getGroupsForUser(uuid)`                        |
+| Check permission              | `hasPermission(uuid, permissionNode)`           |
+
+<Callout type="warning">
+  The module does **not** support:
+
+  - Listing all defined groups
+  - Deleting a group entirely
+
+  Groups are implicitly created when you first add permissions to them.
+</Callout>
+
+---
 
-Same as above, we just use the `removeUserPermission` method instead to remove permission nodes.
+## Checking Permissions
+
+The most common operation is checking if a player has a permission.
+
+### Basic Permission Check
+
+```java
+// Returns true if player has the permission, false otherwise
+boolean canUse = PermissionsModule.get().hasPermission(playerUUID, "myplugin.feature.use");
+
+if (canUse) {
+    // Player has permission, allow the action
+} else {
+    // Player lacks permission, deny or show error
+}
+```
+
+### Permission Check with Default Value
+
+You can specify what to return when no permission is explicitly set:
+
+```java
+// Returns true by default if no explicit permission is found
+boolean canUse = PermissionsModule.get().hasPermission(playerUUID, "myplugin.feature.use", true);
+```
+
+This is useful for features that should be enabled by default but can be revoked.
+
+### Using PermissionHolder Interface
+
+Players and command senders implement `PermissionHolder`, allowing direct checks:
+
+```java
+// In a command or event handler where you have access to the player
+if (player.hasPermission("myplugin.admin.manage")) {
+    // Player has admin permission
+}
+```
+
+---
+
+## Managing User Permissions
+
+### Adding Permissions to a User
+
+Permissions are additive - new permissions are added on top of existing ones, not replaced.
+
+```java
+PermissionsModule perms = PermissionsModule.get();
+
+// Add a single permission
+perms.addUserPermission(playerUUID, Set.of("myplugin.vip.chat"));
+
+// Add multiple permissions at once
+Set<String> newPerms = Set.of(
+    "myplugin.vip.chat",
+    "myplugin.vip.fly",
+    "myplugin.vip.kit"
+);
+perms.addUserPermission(playerUUID, newPerms);
+```
+
+### Removing Permissions from a User
 
 ```java
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.removeUserPermission(playerUUID, permissions);
+
+// Remove specific permissions
+Set<String> toRemove = Set.of("myplugin.vip.fly");
+perms.removeUserPermission(playerUUID, toRemove);
 ```
 
-### Add permissions to group
+---
+
+## Managing Groups
+
+Groups let you assign a collection of permissions to multiple players. This is more manageable than assigning permissions individually.
+
+### Adding Permissions to a Group
+
+If the group doesn't exist, it will be created automatically.
 
 ```java
-String groupName = "testGroup";
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.addGroupPermission(groupName, permissions);
+
+// Create/update the "VIP" group with permissions
+Set<String> vipPerms = Set.of(
+    "myplugin.vip.chat",
+    "myplugin.vip.fly",
+    "myplugin.vip.kit"
+);
+perms.addGroupPermission("VIP", vipPerms);
 ```
 
-### Remove permissions from group
+### Removing Permissions from a Group
 
 ```java
-String groupName = "testGroup";
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.removeGroupPermission(groupName, permissions);
+
+// Remove specific permissions from the group
+Set<String> toRemove = Set.of("myplugin.vip.fly");
+perms.removeGroupPermission("VIP", toRemove);
 ```
 
-### Add user to group
+### Adding a User to a Group
 
 ```java
-String groupName = "testGroup";
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.addUserToGroup(playerUUID, groupName);
+
+// Add player to the VIP group - they now have all VIP permissions
+perms.addUserToGroup(playerUUID, "VIP");
 ```
 
-### Remove user from group
+### Removing a User from a Group
 
 ```java
-String groupName = "testGroup";
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.removeUserFromGroup(playerUUID, groupName);
+
+// Remove player from VIP group
+perms.removeUserFromGroup(playerUUID, "VIP");
 ```
 
-### List all groups for a user
+### Getting a User's Groups
 
 ```java
 PermissionsModule perms = PermissionsModule.get();
-perms.getGroupsForUser(playerUUID);
+
+// Get all groups the player belongs to
+Set<String> groups = perms.getGroupsForUser(playerUUID);
+
+for (String group : groups) {
+    System.out.println("Player is in group: " + group);
+}
 ```
 
-### Check Permission Nodes
+---
+
+## Built-in Groups
+
+Hytale includes two default groups:
+
+| Group     | Default Permissions   | Purpose                           |
+| --------- | --------------------- | --------------------------------- |
+| `OP`      | `*` (all permissions) | Server operators with full access |
+| `Default` | None                  | Base group for all players        |
+
+Players without any explicit group assignment are automatically part of the `Default` group.
 
-To check if a player has a specific permission node, you can use the `hasPermission` method.
+---
+
+## Wildcards
+
+Wildcards let you grant or deny multiple permissions with a single pattern.
+
+### Wildcard Patterns
+
+| Pattern             | Meaning                                          |
+| ------------------- | ------------------------------------------------ |
+| `*`                 | Grants **all** permissions                       |
+| `myplugin.*`        | Grants all permissions starting with `myplugin.` |
+| `-*`                | Denies **all** permissions                       |
+| `-myplugin.admin.*` | Denies all admin permissions in your plugin      |
+
+### Example: Admin Group with Wildcards
 
 ```java
-boolean hasPermission = PermissionsModule.hasPermission(playerUUID, "permission.node");
+// Grant all permissions to admins
+perms.addGroupPermission("Admin", Set.of("*"));
+
+// Grant all plugin permissions to moderators
+perms.addGroupPermission("Moderator", Set.of("myplugin.*"));
+
+// Grant all permissions except admin commands
+perms.addGroupPermission("Helper", Set.of(
+    "*",
+    "-myplugin.admin.*"  // Deny admin permissions
+));
 ```
 
-## Additional: Defining your own provider for permissions and groups
+<Callout type="warning">
+  Negation permissions (starting with `-`) take precedence at each level. Use them carefully to avoid accidentally blocking permissions.
+</Callout>
+
+---
+
+## Built-in Permission Nodes
+
+Hytale provides constants for common permissions in the `HytalePermissions` class:
+
+### Command Permissions
+
+```java
+// Generate permission for a command
+String perm = HytalePermissions.fromCommand("gamemode");
+// Result: "hytale.command.gamemode"
+
+// Generate permission for a subcommand
+String perm = HytalePermissions.fromCommand("gamemode", "creative");
+// Result: "hytale.command.gamemode.creative"
+```
+
+### Common Permission Nodes
+
+| Permission                    | Description                  |
+| ----------------------------- | ---------------------------- |
+| `hytale.command.op.add`       | Add players to OP group      |
+| `hytale.command.op.remove`    | Remove players from OP group |
+| `hytale.editor.brush.use`     | Use brush tools              |
+| `hytale.editor.prefab.use`    | Use prefabs                  |
+| `hytale.editor.selection.use` | Use selection tools          |
+| `hytale.editor.history`       | Undo/redo operations         |
+| `hytale.camera.flycam`        | Use fly camera mode          |
+
+---
+
+## Listening to Permission Events
+
+You can react to permission changes using Hytale's event system.
+
+### Available Events
+
+| Event                                            | Triggered When                   |
+| ------------------------------------------------ | -------------------------------- |
+| `PlayerPermissionChangeEvent.PermissionsAdded`   | Permissions added to a user      |
+| `PlayerPermissionChangeEvent.PermissionsRemoved` | Permissions removed from a user  |
+| `PlayerGroupEvent.Added`                         | User added to a group            |
+| `PlayerGroupEvent.Removed`                       | User removed from a group        |
+| `GroupPermissionChangeEvent.Added`               | Permissions added to a group     |
+| `GroupPermissionChangeEvent.Removed`             | Permissions removed from a group |
 
-The PermissionsModule also enables us to define our own PermissionProvider's, this can be useful for:
+### Example: Reacting to Permission Changes
 
-- Cross server permission systems
-- Implementing features missing in the `HytalePermissionsProvider` like permission expiry
+```java
+public class PermissionListener {
+
+    public static void onPermissionsAdded(PlayerPermissionChangeEvent.PermissionsAdded event) {
+        UUID playerUUID = event.getPlayerUuid();
+        Set<String> added = event.getAddedPermissions();
+
+        System.out.println("Permissions added to " + playerUUID + ": " + added);
 
-To implement our PermissionProvider, first we need to define a provider class that implements PermissionProvider:
+        // Maybe notify the player or update cached data
+    }
+
+    public static void onGroupAdded(PlayerGroupEvent.Added event) {
+        UUID playerUUID = event.getPlayerUuid();
+        String groupName = event.getGroupName();
+
+        System.out.println("Player " + playerUUID + " joined group: " + groupName);
+    }
+}
+```
+
+### Registering the Events
 
 ```java
-public class DatabasePermissionProvider implements PermissionProvider
+public class MyPlugin extends JavaPlugin {
+
+    @Override
+    public void setup() {
+        EventRegistry events = this.getEventRegistry();
+
+        events.registerGlobal(
+            PlayerPermissionChangeEvent.PermissionsAdded.class,
+            PermissionListener::onPermissionsAdded
+        );
+
+        events.registerGlobal(
+            PlayerGroupEvent.Added.class,
+            PermissionListener::onGroupAdded
+        );
+    }
+}
 ```
 
-Then we just implement the required methods using a database implementation.
+---
+
+## Creating a Custom Permission Provider
+
+For advanced use cases, you can create your own permission provider. This is useful for:
+
+- Database-backed permissions (MySQL, MongoDB, etc.)
+- Cross-server permission synchronization
+- Custom features like permission expiry or contexts
+
+### Implementing PermissionProvider
+
+```java
+public class DatabasePermissionProvider implements PermissionProvider {
+
+    @Nonnull
+    @Override
+    public String getName() {
+        return "DatabasePermissionProvider";
+    }
+
+    // User permission methods
+    @Override
+    public void addUserPermissions(@Nonnull UUID uuid, @Nonnull Set<String> permissions) {
+        // Save to your database
+    }
+
+    @Override
+    public void removeUserPermissions(@Nonnull UUID uuid, @Nonnull Set<String> permissions) {
+        // Remove from your database
+    }
+
+    @Override
+    public Set<String> getUserPermissions(@Nonnull UUID uuid) {
+        // Query your database
+        return Set.of();
+    }
+
+    // Group permission methods
+    @Override
+    public void addGroupPermissions(@Nonnull String group, @Nonnull Set<String> permissions) {
+        // Save to your database
+    }
+
+    @Override
+    public void removeGroupPermissions(@Nonnull String group, @Nonnull Set<String> permissions) {
+        // Remove from your database
+    }
+
+    @Override
+    public Set<String> getGroupPermissions(@Nonnull String group) {
+        // Query your database
+        return Set.of();
+    }
+
+    // User-group membership methods
+    @Override
+    public void addUserToGroup(@Nonnull UUID uuid, @Nonnull String group) {
+        // Save to your database
+    }
+
+    @Override
+    public void removeUserFromGroup(@Nonnull UUID uuid, @Nonnull String group) {
+        // Remove from your database
+    }
+
+    @Override
+    public Set<String> getGroupsForUser(@Nonnull UUID uuid) {
+        // Query your database
+        return Set.of("Default");
+    }
+}
+```
 
 <Callout type="warning">
-  Hytale will try to use the first available permissions provider to add/remove gamemode groups (i.e. `Creative`, `Adventure`).
+  Hytale automatically assigns players to game-mode groups (like `Creative` or `Adventure`) using the first available provider.
+
+  If your provider throws an error when the group doesn't exist, the player will be disconnected! Always handle missing groups gracefully.
+</Callout>
+
+### Registering Your Provider
 
-  If your provider throws an error (for instance, if the group does not exist) when the server is preparing the player, the player will be disconnected.
+```java
+public class MyPlugin extends JavaPlugin {
+
+    @Override
+    public void setup() {
+        // Add your provider alongside the default one
+        PermissionsModule.get().addProvider(new DatabasePermissionProvider());
+    }
+}
+```
+
+The `PermissionsModule` aggregates permissions from all registered providers. This means:
+
+- Permission checks query all providers
+- Write operations (add/remove) use the **first** provider
+
+### Replacing the Default Provider
+
+If you want full control, you can remove the default provider:
+
+```java
+public class MyPlugin extends JavaPlugin {
+
+    @Override
+    public void setup() {
+        PermissionsModule perms = PermissionsModule.get();
+
+        // Remove the default provider FIRST
+        perms.removeProvider(perms.getFirstPermissionProvider());
+
+        // Then add your provider
+        perms.addProvider(new DatabasePermissionProvider());
+    }
+}
+```
+
+<Callout type="info">
+  When you remove the default provider, the `/op self` command will stop working since it checks for provider tampering.
 </Callout>
 
-We can then register the provider using the built-in permission module:
+---
+
+## Best Practices
+
+### Permission Naming Conventions
+
+Follow the pattern: `namespace.category.action`
 
 ```java
-PermissionsModule.get().addProvider(new DatabasePermissionProvider());
+// Good - clear hierarchy
+"myplugin.admin.ban"
+"myplugin.user.teleport.home"
+"myplugin.vip.chat.color"
+
+// Bad - unclear structure
+"myplugin_ban"
+"teleport"
+"vipChatColor"
 ```
 
-Please note that the `HytalePermissionsProvider` will still be enabled alongside your provider.
-The `PermissionsModule` will aggregate groups and permissions from all available providers.
+### Use Constants for Permissions
 
-If you want to disable the default `HytalePermissionsProvider`, you can use:
+Define your permissions as constants to avoid typos:
 
 ```java
-// put this **before** you add your provider
-PermissionsModule.get().removeProvider(PermissionsModule.get().getFirstPermissionProvider());
+public final class MyPermissions {
+    public static final String ADMIN_BAN = "myplugin.admin.ban";
+    public static final String ADMIN_KICK = "myplugin.admin.kick";
+    public static final String USER_HOME = "myplugin.user.home";
+    public static final String VIP_FLY = "myplugin.vip.fly";
+}
+
+// Usage
+if (player.hasPermission(MyPermissions.ADMIN_BAN)) {
+    // ...
+}
 ```
+
+### Don't Over-Permission
+
+Only create permissions for actions that genuinely need access control. Not everything needs a permission check.
+
+### Thread Safety
+
+If you create a custom provider, ensure it's thread-safe. Permission checks can occur from multiple threads simultaneously. Use `ReadWriteLock` or `ConcurrentHashMap` for your data structures.
+
+---
+
+## In-Game Commands
+
+Hytale provides built-in commands for managing permissions:
+
+### `/op` Command
+
+| Command               | Description                                                        |
+| --------------------- | ------------------------------------------------------------------ |
+| `/op self`            | Toggle your own OP status (singleplayer or with `--allow-op` flag) |
+| `/op add <player>`    | Add a player to the OP group                                       |
+| `/op remove <player>` | Remove a player from the OP group                                  |
+
+### `/perm` Command
+
+Use `/perm --help` in-game for full usage. Common operations:
+
+| Command                                  | Description                   |
+| ---------------------------------------- | ----------------------------- |
+| `/perm user list <uuid>`                 | List user's permissions       |
+| `/perm user add <uuid> <perm>`           | Add permission to user        |
+| `/perm user remove <uuid> <perm>`        | Remove permission from user   |
+| `/perm user group list <uuid>`           | List user's groups            |
+| `/perm user group add <uuid> <group>`    | Add user to group             |
+| `/perm user group remove <uuid> <group>` | Remove user from group        |
+| `/perm group list <group>`               | List group's permissions      |
+| `/perm group add <group> <perm>`         | Add permission to group       |
+| `/perm group remove <group> <perm>`      | Remove permission from group  |
+| `/perm test <perm>`                      | Test if you have a permission |
+
+---
+
+## Summary
+
+You've learned how to:
+
+- **Check permissions** using `PermissionsModule.hasPermission()`
+- **Manage user permissions** with `addUserPermission()` and `removeUserPermission()`
+- **Work with groups** using `addGroupPermission()`, `addUserToGroup()`, etc.
+- **Use wildcards** like `*` and `myplugin.*` for bulk permissions
+- **Listen to events** for permission changes
+- **Create custom providers** for database-backed permissions
+
+For more advanced permission systems with features like inheritance, expiry, and contexts, we're looking into expanding this guide with advanced permission management techniques in the future.
diff --git a/content/docs/de-DE/guides/plugin/setting-up-env.mdx b/content/docs/de-DE/guides/plugin/setting-up-env.mdx
index d2718098..5be5e9e0 100644
--- a/content/docs/de-DE/guides/plugin/setting-up-env.mdx
+++ b/content/docs/de-DE/guides/plugin/setting-up-env.mdx
@@ -4,6 +4,10 @@ description: Learn how to set up your development environment for modding Hytale
 authors:
   - name: Neil Revin
     link: https://itsneil.dev
+  - name: Marcel-TO
+    url: https://marcel-to.net
+  - name: Ádám Liszkai
+    link: https://adaliszk.dev
 ---
 
 This guide will walk you through setting up a complete development environment for Hytale modding, including all necessary tools and dependencies.
@@ -19,24 +23,73 @@ Before we begin, make sure you have:
 
 ## Required Software
 
-### 1. Java Development Kit (JDK)
+### Integrated Development Environment (IDE)
 
+We recommend IntelliJ IDEA Community Edition for Hytale modding. If you use IntelliJ IDEA, **almost everything is built-in**. You can clone a template, open a new project, and start working right away!
+
+1. Download from [JetBrains website](https://www.jetbrains.com/idea/download/)
+2. Install with default settings
+3. Launch and complete the initial setup wizard
+
+When opening a project, wait for indexing to finish, then start coding.
+Now, IDEA may say "No JDK configured" at the top of the source file you have.
+In that case, you can click Download JDK and choose JetBrains JDK 25.
+
+<Callout type="success">
+  If IDEA opened the project without errors, your environment is ready.
+</Callout>
+
+More details by [JetBrains](https://www.jetbrains.com/help/idea/2026.1/run-for-the-first-time.html)
+help page, where we recommend that you also check the
+[SDK configuration](https://www.jetbrains.com/help/idea/2026.1/sdk.html) guide.
+
+<Callout type="info">
+  We recommened following
+  [TheNullicorn's](https://gist.github.com/TheNullicorn/90a619796c40f20ae1fcf13094c1a57d) guide to ensure
+  you are using the correct `Nonnull` in your projects.
+</Callout>
+
+#### What the IDE Does for You
+
+When opened in IntelliJ IDEA, the project automatically:
+
+- Detects and configures Gradle or Maven
+- Downloads all dependencies
+- Sets up project structure and classpaths
+- Configures run/build tasks
+
+You do **not** need to manually install or configure Maven or Gradle if you stay inside the IDE.
+
+Skip to the [Setting Up Your Workspace](#setting-up-your-workspace).
+
+### Manual Setup: Java Development Kit (JDK)
+
+For any other setup, you will need to install and configure your system to have and load Java.
 Hytale modding requires Java 25 or later. We recommend using OpenJDK.
 
-#### Windows
+#### Windows via Installer
 
 1. Download OpenJDK 25 from [Adoptium](https://adoptium.net/)
 2. Run the installer with default settings
+   - Optionally enable feature `Set or Override JAVA_HOME variable` to resolve version related build issues with your project.
 3. Verify installation by opening Command Prompt and running:
 
+#### Windows via Scoop
+
+1. Install Scoop via PowerShell using [scoop.sh](https://scoop.sh/)
+2. Install OpenJDK 25:
+
 ```bash
-java -version
+scoop bucket add java
+scoop install java/openjdk25
 ```
 
 #### macOS
 
+1. Install Brew via Terminal using [brew.sh](https://brew.sh)
+2. Install JDK via Homebrew:
+
 ```bash
-# Using Homebrew
 brew install openjdk@25
 ```
 
@@ -51,22 +104,41 @@ brew install openjdk@25
 
 #### Linux (Ubuntu/Debian)
 
+1. Install JDK via the built-in package repository:
+
 ```bash
 sudo apt update
 sudo apt install openjdk-25-jdk
 ```
 
-### 2. Integrated Development Environment (IDE)
+### Verify installation:
 
-We recommend IntelliJ IDEA Community Edition for Hytale modding.
+Run the following command to see what version of Java you have:
 
-1. Download from [JetBrains website](https://www.jetbrains.com/idea/download/)
-2. Install with default settings
-3. Launch and complete the initial setup wizard
+```bash
+java -version
+```
+
+### Java Build Tool (Optional)
+
+We recommend using a Gradle Wrapper for managing dependencies and building your Hytale plugins. It provides benefits by eliminating the need for a system-wide Gradle installation and ensuring consistent Gradle versions across different environments. (Alternatively you can use Maven, but this guide focuses on Gradle since it is the default for our plugin template.)
+
+The plugin template in the following sections includes a Gradle Wrapper, so you can skip this step if you plan to use the template.
+
+#### Choosing Gradle (if not using the template)
+
+If you prefer to install Gradle manually, follow these steps:
 
-### 3) Java Build Tool
+1. Visit the official website: https://gradle.org/releases/
+2. Download the newest gradle binary: `gradle-9.3.1-bin.zip` (Binary zip archive)
+3. Unzip it
+4. Add the `gradle-9.3.1/bin/` folder to your PATH
+
+You can now try the command `gradle -version` to verify Gradle is installed correctly. Make sure to do this in a fresh new terminal instead of one you had opened from before!
+
+#### Choosing Maven (if not using the template)
 
-We recommend using Apache Maven for managing dependencies and building your Hytale plugins. (Alternatively you can use Gradle, but this guide focuses on Maven.)
+If you prefer to use Maven instead of Gradle, follow these steps to install Maven:
 
 1. Visit the official website: https://maven.apache.org/download.cgi
 2. Download this file: `apache-maven-3.9.12-bin.zip` (Binary zip archive)
@@ -89,22 +161,61 @@ cd MyFirstMod
 
 If you don't have Git installed, you can download the ZIP file from the repository page and extract it to a folder named `MyFirstMod`.
 
-### 2. Open Plugin in your IDEA
+### 2. Open Plugin in your IDE
 
-1. Open IntelliJ IDEA
+1. Open Your IDE (e.g., IntelliJ IDEA)
 2. Click "Open" and navigate to your `MyFirstMod` directory
-3. IntelliJ will automatically detect it as a Maven project
+3. Most IDEs like IntelliJ will automatically detect it as a Gradle project
 4. Wait for the project to index and dependencies to download
 
-<Callout type="info">
-  We recommened following [this](https://gist.github.com/TheNullicorn/90a619796c40f20ae1fcf13094c1a57d) guide to ensure you are using the correct `Nonnull` in your projects.
-</Callout>
+## Alternate Approach: Hytale Dependency
+
+If you prefer to set up your project from scratch without using the template and importing the hytale dependencies manually, ensure your build configuration includes the Hytale repositories and dependencies:
+
+For Gradle, add the following to your `build.gradle.kts`:
+
+```kotlin
+repositories {
+    mavenCentral()
+    maven {
+        name = "hytale"
+        url = uri("https://maven.hytale.com/release") // Or "hytale-pre-release" for pre-release versions
+    }
+}
+dependencies {
+    // + here means the latest version, but you can hard-wire any known version!
+    implementation("com.hypixel.hytale:Server:+")
+}
+```
+
+For Maven, add the following to your `pom.xml`:
+
+```xml
+<project>
+    <repositories>
+        <repository>
+            <id>hytale-release</id> <!-- Or "hytale-pre-release" for pre-release versions -->
+            <url>https://maven.hytale.com/release</url> <!-- Or "https://maven.hytale.com/pre-release" -->
+        </repository>
+    </repositories>
+
+    <dependencies>
+        <dependency>
+            <groupId>com.hypixel.hytale</groupId>
+            <artifactId>Server</artifactId>
+            <!-- Replace with latest version, Hytale provides jars for the last five releases -->
+            <version>LATEST_VERSION_HERE</version>
+            <scope>provided</scope>
+        </dependency>
+    </dependencies>
+</project>
+```
 
 ## Next Steps
 
 Now that you have your development environment set up with the plugin template:
 
-1. **Customize the template** - Edit the `pom.xml` and `manifest.json` file to change your mod's name and details
+1. **Customize the template** - Edit the `settings.gradle.kts`, `build.gradle.kts` and `manifest.json` file to change your mod's name and details
 2. **Explore the code structure** - Familiarize yourself with the template's organization
 3. **Start modding** - Begin writing your first Hytale plugin!
 
diff --git a/content/docs/de-DE/guides/plugin/spawning-entities.mdx b/content/docs/de-DE/guides/plugin/spawning-entities.mdx
index e12c0aea..15be2fb3 100644
--- a/content/docs/de-DE/guides/plugin/spawning-entities.mdx
+++ b/content/docs/de-DE/guides/plugin/spawning-entities.mdx
@@ -36,7 +36,7 @@ Store<EntityStore> store = world.getEntityStore().getStore();
 
 ## Creating Entities
 
-Once you have the `EntityStore` instance, you can start to create a entity and give it components. Entities are just instances of `Holder<EntityStore>` with several components attached to them.
+Once you have the `EntityStore` instance, you can start to create an entity and give it components. Entities are just instances of `Holder<EntityStore>` with several components attached to them.
 
 <Callout type="warning">
   To interact with the `World` instance, some methods require you to run the code inside the world's execution context.
@@ -118,3 +118,48 @@ Finally, we can add the entity to the world by calling the `addEntity` method on
 ```java
 store.addEntity(holder, AddReason.SPAWN);
 ```
+
+## Making the entity persist
+
+Hytale automatically saves all entities, but the `NetworkId` component (required for players to be able to see the entity) needs to be manually added every time the entity is loaded.
+
+### Using a system
+
+If you have a component that is unique to your entities, this can be done by creating and registering a custom system as follows:
+
+```java
+public class AddNetworkIdToMyEntitySystem extends HolderSystem<EntityStore> {
+    private final ComponentType<EntityStore, MyEntityComponent> myEntityComponentType = MyEntityComponent.getComponentType();
+    private final ComponentType<EntityStore, NetworkId> networkIdComponentType = NetworkId.getComponentType();
+    private final Query<EntityStore> query = Query.and(this.myEntityComponentType, Query.not(this.networkIdComponentType));
+
+    @Override
+    public void onEntityAdd(@NotNull Holder<EntityStore> holder, @NotNull AddReason reason, @NotNull Store<EntityStore> store) {
+        if (!holder.getArchetype().contains(NetworkId.getComponentType())) {
+            holder.addComponent(NetworkId.getComponentType(), new NetworkId(store.getExternalData().takeNextNetworkId()));
+        }
+    }
+
+    @Override
+    public void onEntityRemoved(@NotNull Holder<EntityStore> holder, @NotNull RemoveReason reason, @NotNull Store<EntityStore> store) {}
+
+    @Override
+    public @Nullable Query<EntityStore> getQuery() {
+        return query;
+    }
+}
+```
+
+In your plugin's `setup()` function
+
+```java
+this.getEntityStoreRegistry().registerSystem(new AddNetworkIdToMyEntitySystem())
+```
+
+### Using PropComponent
+
+Alternatively you can add `PropComponent` to your entity. Hytale adds `PropComponent` to entities spawned with the Entity Tool, and such entities automatically get `NetworkId` and `PrefabCopyableComponent` (which makes the entity work with prefabs).
+
+<Callout type="warning">
+  There is no guarantee, that Hytale will not add some other behavior to this component in the future, which may break your entity, so be careful if you decide to rely on it.
+</Callout>
diff --git a/content/docs/de-DE/guides/plugin/store-persistent-data.mdx b/content/docs/de-DE/guides/plugin/store-persistent-data.mdx
new file mode 100644
index 00000000..1071dff3
--- /dev/null
+++ b/content/docs/de-DE/guides/plugin/store-persistent-data.mdx
@@ -0,0 +1,171 @@
+---
+title: Storing Persistent Data on the Player
+description: Learn how to save and load persistent data using Components
+authors:
+  - name: Neil Revin
+    url: https://itsneil.dev/
+  - name: ArcticDev
+    url: https://github.com/ArcticRaven
+  - name: oskarscot
+    url: https://oskar.scot
+  - name: JammingEng
+    url: https://github.com/JammingEnd
+---
+
+Here is how to store persistent data using a custom component on a Player.
+
+## Build your Component Class
+
+Creating a custom component class leverages the Component system made with the ECS architecture in mind. For more information on Components, check out the [ECS Guide](../ecs/hytale-ecs-theory#components).
+
+Start by creating your custom component class. This will be extremely similar to how regular components are created, however we'll setup a custom Codec so the server can translate this data to BSON, or the server's internal json encoder.
+
+<Callout type="info">
+  Each variable you want to store in your component must have its own Codec field defined in the BuilderCodec.
+  For more information on how to create custom Codecs, check out the [ECS Codec Guide](../ecs/hytale-ecs-theory#codec).
+</Callout>
+
+```java
+public class YourPlayerData implements Component<EntityStore> {
+
+    // define some vars!
+    private int someInteger;
+    private String someString;
+    private Map<String, String> someMap;
+
+    public static final BuilderCodec<YourPlayerData> CODEC =
+            BuilderCodec.builder(YourPlayerData.class, YourPlayerData::new)
+            .append(new KeyedCodec<>("SomeInteger", Codec.INTEGER),
+                    (data, value) -> data.someInteger = value, // setter
+                    data -> data.someInteger) // getter
+            .addValidator(Validators.nonNull())
+            .add()
+            .append(new KeyedCodec<>("SomeString", Codec.STRING),
+                    (data, value) -> data.someString = value, // setter
+                    data -> data.someString) // getter
+            .add()
+            .append(new KeyedCodec<>("SomeMap",
+                            new MapCodec<>(Codec.STRING, HashMap::new, false)),
+                    (data, value) -> data.someMap = value, // setter
+                    data -> data.someMap) // getter
+            .add()
+            .build();
+
+
+
+    // Getters and Setters are for the purpose of this example omitted.
+
+    // constructor
+    public YourPlayerData() {
+        this.someInteger = 0;
+        this.someString = "";
+        this.someMap = new HashMap<>();
+    }
+
+    // copy constructor for cloning
+    public YourPlayerData(YourPlayerData clone) {
+        this.someInteger = clone.someInteger;
+        this.someString = clone.someString;
+        this.someMap = clone.someMap;
+    }
+
+    @Nonnull
+    @Override
+    public Component<EntityStore> clone() {
+        return new YourPlayerData(this);
+    }
+}
+```
+
+## Register your Component
+
+Inside your main class's `setup()` method, register your new Component.
+
+```java
+public class YourPlugin extends JavaPlugin {
+
+    private ComponentType<EntityStore, YourPlayerData> yourPlayerDataComponent;
+
+    public YourPlugin(@Nonnull JavaPluginInit init) {
+        super(init);
+    }
+
+    @Override
+    protected void setup(){
+        this.yourPlayerDataComponent = this.getEntityStoreRegistry().registerComponent(
+            YourPlayerData.class,
+            "YourPlayerDataComponent",
+            YourPlayerData.CODEC
+        );
+    }
+
+    public ComponentType<EntityStore, YourPlayerData> getYourPlayerDataComponent() {
+        return this.yourPlayerDataComponent;
+    }
+}
+```
+
+## Using your Component
+
+To use your newly created component, you can add the Component to a player using the `addComponent` method, although this only adds it temporarily, meaning when the player/entity leaves the world, the component is removed. You can use `putComponent` to ensure the component persists between sessions.
+
+```java
+// You will need the Ref and Store to apply components
+private void someEntryMethod(@Nonnull Ref<EntityStore> ref, @Nonnull Store<EntityStore> store)
+{
+       // Any entity will work, for now we will use the player
+      Player player = (Player) store.getComponent(ref, Player.getComponentType());
+
+      // since we're using putComponent, it could be useful to check if it already exists on the player in case we want to update it
+     if(store.getComponent(ref, YourPlugin.instance().getYourPlayerDataComponent()) != null)
+     {
+          // here we implement logic that updates the component
+         var comp = store.getComponent(ref, YourPlugin.instance().getYourPlayerDataComponent())
+         // declare public fields or methods in the component class
+         comp.SomeString = "An Updated Field";
+     } else {
+          // Here we put the component
+          var myCustomComp = new CustomComponent();
+          // declare public fields or methods in the component class
+          myCustomComp.SomeString = "Edited String";
+
+          // putComponent allows you to insert declared objects
+          store.putComponent(ref, YourPlugin.instance().getYourPlayerDataComponent(), myCustomComp);
+     }
+}
+```
+
+## Using your Data
+
+Your component will be stored within the `Store<EntityStore>` when added to the player. In the provided example,
+we'll fetch this data off the player using the `ensureAndGetComponent()` method, which will add the component to
+the player if it does not exist with the default values.
+
+```java
+public class IncompleteCustomCommand extends AbstractPlayerCommand {
+
+    public IncompleteCustomCommand() {
+        super("nope", "don't use this command");
+    }
+
+    @Override
+    protected void execute(
+        @NonNullDecl CommandContext commandContext,
+        @NonNullDecl Store<EntityStore> store,
+        @NonNullDecl Ref<EntityStore> ref,
+        @NonNullDecl PlayerRef playerRef,
+        @NonNullDecl World world
+    ) {
+        YourPlayerData customData = store.ensureAndGetComponent(ref, YourPlugin.instance().getYourPlayerDataComponent());
+        // ensureAndGetComponent adds the component to the ref, with the default values defined inside your component.
+ 		// use your data
+    }
+}
+```
+
+And that's it! Your data will now be saved and loaded automatically with the player.
+
+Using custom components to store persistent data on players is a powerful way to maintain state across sessions.
+By following the steps outlined above, you can easily create, register, and utilize your own data structures within the Hytale ECS framework.
+This approach ensures that your data is seamlessly integrated with the game's existing systems.
+For more information about Hytale's Entity Component System visit the [Hytale ECS Theory](https://hytalemodding.dev/en/docs/guides/ecs/hytale-ecs-theory) guide.
diff --git a/content/docs/de-DE/guides/plugin/teleporting-players.mdx b/content/docs/de-DE/guides/plugin/teleporting-players.mdx
index 57cee77f..32ce0435 100644
--- a/content/docs/de-DE/guides/plugin/teleporting-players.mdx
+++ b/content/docs/de-DE/guides/plugin/teleporting-players.mdx
@@ -1,26 +1,32 @@
 ---
 title: Teleporting the player
 description: Learn how to teleport the player.
+authors:
+  - name: oskarscot
+    url: https://oskar.scot
 ---
 
-To teleport players in Hytale, you will need to get a `World` object so we can safely run the teleport on the world thread. The world thread manages all entity updates, so modifying entities off-thread can crash the server or cause inconsistent state.
-Next, we get the entity store and make a `Teleport` object.
-We add a `Teleport` component to the player’s entity reference in the entity store. This triggers the teleportation logic for that player.
+Teleporting players in Hytale works by simply attaching a `Teleport` component to a player with the desired world and transform.
+You can only trigger teleports from a world where the player is currently present.
+Teleport itself is a component but it also provides factory methods to configure the Teleport. Just as with any entity component, an EntityStore and a Ref to the EntityStore is required
+
+We can create a simple teleport utility like this:
 
 ```java
-public static void teleportPlayer(Player player, int x, int y, int z) {
-        World world = player.getWorld();
-        if (world == null) return;
-        world.execute(() -> {
-            if (player.getReference() == null) return;
-            Store<EntityStore> store = player.getReference().getStore();
-            Teleport teleport = Teleport.createForPlayer(world,
-                new Vector3d(x ,y, z), // Target position
-                new Vector3f(0, 0, 0)  // Target rotation (pitch, yaw, roll)
-            );
+public static void teleportPlayer(Ref<EntityStore> ref, Store<EntityStore> store, World targetWorld, double x, double y, double z) {                                                                                       
+    Transform transform = new Transform(x, y, z);                                                                                                                           
+    Teleport teleport = Teleport.createForPlayer(targetWorld, transform);                                                                                                   
+    store.addComponent(ref, Teleport.getComponentType(), teleport);                                                                                                         
+}  
+```
 
-            store.addComponent(player.getReference(), Teleport.getComponentType(), teleport);
-        });
+A `Transform` is a representation of a position Vector3d and rotation Vector3f which works in the following way:
 
-}
+```java
+Transform transform = new Transform(
+    new Vector3d(x, y, z),      // Position
+    new Rotation(yaw, pitch, 0) // Rotation, last value seems to always be 0
+);
+Teleport teleport = Teleport.createForPlayer(targetWorld, transform);
+store.addComponent(ref, Teleport.getComponentType(), teleport);
 ```
diff --git a/content/docs/de-DE/guides/plugin/tracking-mod-analytics-with-hstats.mdx b/content/docs/de-DE/guides/plugin/tracking-mod-analytics-with-hstats.mdx
new file mode 100644
index 00000000..45c022e0
--- /dev/null
+++ b/content/docs/de-DE/guides/plugin/tracking-mod-analytics-with-hstats.mdx
@@ -0,0 +1,65 @@
+---
+title: Tracking Mod Analytics with HStats
+description: Learn how you can track Analytics for your Hytale Mod for Free using hstats.dev
+authors:
+  - name: Al3x
+    url: https://hstats.dev
+---
+
+In this guide, you will learn how to integrate HStats into your Plugin/Mod which will allow you to track how many Servers are using it along with other stats.
+
+<Callout type="info">
+  HStats is a third-party tool and is not affiliated with HytaleModding or Hypixel Studios
+</Callout>
+
+# Step 1: Register your Mod to HStats
+
+Before you touch any code, you will need to add your mod to the HStats website which will give you a UUID for your mod.
+
+- Create or Login to an Account on https://hstats.dev
+- Navigate to the dashboard page (https://hstats.dev/dashboard)
+- On the left, type in your mod's name and click "Add Mod"
+- Keep note of the UUID generated for later.
+
+# Step 2: Add the HStats Class to Your Project
+
+To keep things simple, HStats uses a single Java class file that handles everything for you.
+
+- Download / Copy the File from the GitHub page (https://github.com/hstats-dev/HStatsExamplePlugin/blob/main/src/main/java/com/al3x/HStats.java)
+- Paste into your Project. You should now have a HStats.java file somewhere in your projects directory.
+- Update the package name from com.al3x to whatever fits your project.
+
+# Step 3: Initialize HStats in your code
+
+You only need to add one line of code to your mod's setup method in your main class to start tracking.
+
+`new HStats("YOUR-MOD-UUID", "1.0.0");`
+
+Replace `YOUR-MOD-UUID` with the Mod UUID we made note of earlier and change the `1.0.0` version to whatever version your mod is currently on.
+
+Your setup method should now look something like this:
+
+```java
+@Override
+protected void setup() {
+  super.setup();
+  new HStats("c34a2b2a-afd8-4d6a-821e-7a63e12c5ea6", "1.0.0");
+}
+```
+
+# Extras
+
+Your done! Your mod should now be listed under the Mods page (https://hstats.dev/mods) as well as under your dashboard.
+
+Servers using your mod should now post updates about every minute to HStats which you can view in the Dashboard.
+
+### Embeds
+
+HStats allows you to generate an Embed Card that you can place on your CurseForge or GitHub page. This is useful for server owners to be able to see how many other servers are using your mod.
+
+- In your dashboard, scroll down to the Embed Card section.
+- Customize the appearance (Light/Dark mode, layout, etc).
+- Copy the generated URL to display your "Active Servers" and "Players Online" live on your mod's description page
+
+Heres an example of what they look like:
+![HStats Example](https://api.hstats.dev/api/embed/d52fa672-6966-47b2-b501-1a11bddebac3/card.svg?theme=light\&layout=compact\&size=md\&show_id=true\&dark=false)
diff --git a/content/docs/de-DE/guides/plugin/world-gen.mdx b/content/docs/de-DE/guides/plugin/world-gen.mdx
index 4c23b0c9..7b193ffd 100644
--- a/content/docs/de-DE/guides/plugin/world-gen.mdx
+++ b/content/docs/de-DE/guides/plugin/world-gen.mdx
@@ -100,7 +100,7 @@ Biome biome = biomeGen.generateBiomeAt(zoneResult, seed, x, z);
 
 ### Zone & Cave Integration
 
-Each zone defines it's own cave patterns:
+Each zone defines its own cave patterns:
 
 ```java
 Zone zone = /* ... */;
diff --git a/content/docs/de-DE/guides/prefabs.mdx b/content/docs/de-DE/guides/prefabs.mdx
index 08404b30..b1a55109 100644
--- a/content/docs/de-DE/guides/prefabs.mdx
+++ b/content/docs/de-DE/guides/prefabs.mdx
@@ -14,7 +14,7 @@ Prefabs are Hytale's way of creating reusable structures.
 There are a few fundamental concepts to understand about prefabs:
 
 - Users interact with prefabs via a prefab editing world.
-- Prefabs the physical structures in the game world, and are saved as JSON files.
+- Prefabs are the physical structures in the game world, and are saved as JSON files.
 
 ## How to Create a Prefab
 
diff --git a/content/docs/de-DE/official-documentation/custom-ui/common-styling.mdx b/content/docs/de-DE/official-documentation/custom-ui/common-styling.mdx
new file mode 100644
index 00000000..c36e3e3a
--- /dev/null
+++ b/content/docs/de-DE/official-documentation/custom-ui/common-styling.mdx
@@ -0,0 +1,50 @@
+---
+title: Common Styling
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# Common Styling
+
+## Common UI Styling Library
+
+This document describes the shared UI components and styles defined in `Common.ui`.
+
+---
+
+### Styles
+
+We are providing some styles that can be re-used in any custom UI that, provide a cohesive UI experience with the core game UI. These styles are available in the `Common.ui` file.
+
+You can find a list of all the styles defined with live examples by running the `/ui-gallery` command ingame.
+
+<Callout type="warning">
+  This command is not available yet, but will be in a future patch.
+</Callout>
+
+![Gallery](/assets/official-documentation/ui/gallery.png)
+
+### Importing
+
+To use these styles in your UI file:
+
+```
+$Common = "Common.ui";
+
+// Then reference styles and components:
+$Common.@TextButton { @Text = "My Button"; }
+$Common.@Container { ... }
+```
+
+<Callout type="info">
+  The `Common.ui` file is at `Common/UI/Custom/Common.ui` within the Hytale pack. If your custom ui document is in a subfolder of `Common/UI/Custom/`, reference it via relative path traversal:
+
+  ```
+  $Common = "../Common.ui";
+  ```
+
+  You can find more info about paths [here](markup#path).
+</Callout>
diff --git a/content/docs/de-DE/official-documentation/custom-ui/index.mdx b/content/docs/de-DE/official-documentation/custom-ui/index.mdx
new file mode 100644
index 00000000..f94c4e88
--- /dev/null
+++ b/content/docs/de-DE/official-documentation/custom-ui/index.mdx
@@ -0,0 +1,125 @@
+---
+title: Custom UI
+icon: LayoutDashboard
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# Custom UI
+
+## What is Custom UI?
+
+Custom UI is Hytale's framework for creating **custom user interfaces** controlled by the game server. Unlike the built-in Client UI (which is part of the game client and cannot be modified), Server UI allows you to create interactive screens and HUD overlays through Java plugins and asset packs.
+
+As a modder, Custom UI gives you the power to:
+
+- **Create custom interactive pages** - Shop interfaces, quest dialogs, server settings menus, admin panels
+- **Add custom HUD overlays** - Quest trackers, status displays, custom health bars, server information
+- **Design with markup** - Use `.ui` files to define reusable UI templates
+- **Handle user interactions** - Respond to button clicks, form submissions, and other events
+- **Localize your UI** - Support multiple languages using the game's translation system
+
+## How Custom UI Fits Into Hytale's UI
+
+Hytale's user interface is divided into two main categories:
+
+### Client UI (Not Moddable)
+
+Built-in interfaces controlled by the C# game client:
+
+- Main menu and settings
+- Character creation
+- Built-in HUD (health, hotbar, chat)
+- Inventory and crafting screens
+- Development tools
+
+**You cannot modify these** - they are part of the core game client.
+
+### In-Game UI (Moddable via Server)
+
+Server-controlled interfaces that you can create and customize:
+
+#### Custom Pages
+
+Full-screen interactive overlays that appear during gameplay:
+
+- Can be dismissed by the player (ESC key)
+- Capture all input (keyboard and mouse)
+- Support loading states while waiting for server responses
+- Perfect for: shops, dialogs, menus, configuration screens
+
+#### Custom HUDs
+
+Persistent overlay elements drawn on top of the game world:
+
+- Display-only (no user interaction)
+- Always visible during gameplay
+- Lightweight and non-intrusive
+- Perfect for: quest objectives, status indicators, server info panels
+
+## Architecture Overview
+
+Server UI uses a **command-based architecture**:
+
+```
+┌─────────────────────┐         ┌──────────────────────┐
+│   Java Server       │         │    C# Client         │
+│   (Your Plugin)     │         │    (Game)            │
+├─────────────────────┤         ├──────────────────────┤
+│                     │         │                      │
+│ InteractiveCustomUI │         │   CustomPage or      │
+│ Page                │         │   CustomHud          │
+│   ↓ build()         ├────────→│     ↓ Apply          │
+│ UICommandBuilder    │         │   Element Tree       │
+│   - append()        │         │     ↓ Layout         │
+│   - set()           │         │   Rendered UI        │
+│   - clear()         │         │                      │
+│                     │         │                      │
+│ ↓ handleDataEvent() │← Events │   User Interaction   │
+│   Process input     │         │   (click, type, etc) │
+│   sendUpdate()      │         │                      │
+└─────────────────────┘         └──────────────────────┘
+```
+
+**The flow:**
+
+1. Your Java code builds UI using `UICommandBuilder`
+2. Commands are sent to the client as data
+3. Client parses `.ui` markup files and creates visual elements
+4. User interacts with the UI
+5. Events are sent back to your Java code
+6. You process events and send updates back
+
+## Key Principles
+
+### Declarative, Not Imperative
+
+You don't create UI objects directly. Instead, you send **commands** that describe what you want:
+
+- "Append this button template to that container"
+- "Set this label's text to 'Hello World'"
+- "Clear all children from this list"
+
+### Asset-Driven
+
+UI structure is defined in `.ui` markup files (assets), not hardcoded in Java. This enables:
+
+- Designers to modify layouts without touching code
+- Reusable UI components
+- Consistent visual language
+
+### Event-Driven
+
+User interactions trigger events that flow back to your server code. You register event bindings and handle them in `handleDataEvent()`.
+
+### Selector-Based
+
+You target specific UI elements using **selectors:**
+
+- `#MyButton` - Element with ID "MyButton"
+- `#List[0]` - First child of element "List"
+- `#List[0] #Title` - Element with ID "Title" in the first child of element "List"
+- `#Label.TextColor` - The TextColor property of element "Label"
diff --git a/content/docs/de-DE/official-documentation/custom-ui/layout.mdx b/content/docs/de-DE/official-documentation/custom-ui/layout.mdx
new file mode 100644
index 00000000..0a24ca09
--- /dev/null
+++ b/content/docs/de-DE/official-documentation/custom-ui/layout.mdx
@@ -0,0 +1,492 @@
+---
+title: Layout
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# Layout
+
+The layout system determines how UI elements are positioned and sized on screen. Understanding layout is crucial for creating well-structured, responsive interfaces.
+
+## Layout Fundamentals
+
+Every UI element has:
+
+- **Container Rectangle** - The space allocated by the parent
+- **Anchor** - How the element positions/sizes itself within the container
+- **Padding** - Inner spacing that affects child layout
+- **LayoutMode** - How the element arranges its children (if it's a container)
+
+```
+┌─────────────────────────────────────┐
+│  Container Rectangle (from parent)  │
+│  ┌───────────────────────────────┐  │
+│  │  Anchored Rectangle           │  │
+│  │  ┌─────────────────────────┐  │  │
+│  │  │ Padding                 │  │  │
+│  │  │  ┌───────────────────┐  │  │  │
+│  │  │  │  Content Area     │  │  │  │
+│  │  │  └───────────────────┘  │  │  │
+│  │  └─────────────────────────┘  │  │
+│  └───────────────────────────────┘  │
+└─────────────────────────────────────┘
+```
+
+## Anchor
+
+`Anchor` controls how an element positions and sizes itself within its container rectangle.
+
+### Fixed Size
+
+```
+Button {
+    Anchor: (Width: 200, Height: 40);
+}
+```
+
+Creates a 200×40 pixel button.
+
+### Positioning
+
+```
+Label {
+    Anchor: (Top: 10, Left: 20, Width: 100, Height: 30);
+}
+```
+
+- **Top**: 10 pixels from container's top edge
+- **Left**: 20 pixels from container's left edge
+- **Width**: 100 pixels wide
+- **Height**: 30 pixels tall
+
+### Anchoring to Edges
+
+```
+Button {
+    Anchor: (Bottom: 10, Right: 10, Width: 100, Height: 30);
+}
+```
+
+Anchors the button to the bottom-right corner, 10 pixels from each edge.
+
+### Stretching
+
+```
+Group {
+    Anchor: (Top: 0, Bottom: 0, Left: 0, Right: 0);
+}
+```
+
+Stretches to fill the entire container (all edges at 0 pixels).
+
+**Shorthand:**
+
+```
+Group {
+    Anchor: (Full: 0);
+}
+```
+
+### Mixed Anchoring
+
+```
+Panel {
+    Anchor: (Top: 10, Bottom: 10, Left: 20, Width: 300);
+}
+```
+
+- Fixed width of 300 pixels
+- Stretches vertically between top and bottom edges
+- 10 pixels from top and bottom
+- 20 pixels from left
+
+## Padding
+
+`Padding` creates inner spacing, affecting where children are positioned.
+
+### Uniform Padding
+
+```
+Group {
+    Padding: (Full: 20);
+}
+```
+
+20 pixels of padding on all sides.
+
+### Directional Padding
+
+```
+Group {
+    Padding: (Top: 10, Bottom: 20, Left: 15, Right: 15);
+}
+```
+
+Different padding per edge.
+
+### Shorthand
+
+```
+// Horizontal and vertical
+Group {
+    Padding: (Horizontal: 20, Vertical: 10);
+}
+
+// Equivalent to:
+// Top: 10, Bottom: 10, Left: 20, Right: 20
+```
+
+### Effect on Children
+
+```
+Group {
+    Anchor: (Width: 200, Height: 100);
+    Padding: (Full: 10);
+
+    Label {
+        Anchor: (Full: 0);
+    }
+}
+```
+
+The label fills the group, but there's a 10-pixel gap on all sides due to padding.
+
+```
+┌──────────────────────┐
+│ Group (200×100)      │
+│  ┌────────────────┐  │
+│  │ Label          │  │ ← 10px padding all around
+│  │                │  │
+│  └────────────────┘  │
+└──────────────────────┘
+```
+
+## LayoutMode
+
+`LayoutMode` determines how a container arranges its children.
+
+### Top (Vertical Stack)
+
+```
+Group {
+    LayoutMode: Top;
+
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+}
+```
+
+Children stack vertically from top to bottom:
+
+```
+┌──────────┐
+│ Button 1 │
+├──────────┤
+│ Button 2 │
+├──────────┤
+│ Button 3 │
+└──────────┘
+
+
+```
+
+Each child's `Anchor.Bottom` adds spacing between elements:
+
+```
+Button { Anchor: (Height: 30, Bottom: 10); }  // 10px gap after this button
+```
+
+### Bottom (Vertical Stack)
+
+```
+Group {
+    LayoutMode: Bottom;
+
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+}
+```
+
+Children stack vertically from top to bottom but aligned to the bottom edge of the parent:
+
+```
+
+
+
+┌──────────┐
+│ Button 1 │
+├──────────┤
+│ Button 2 │
+├──────────┤
+│ Button 3 │
+└──────────┘
+```
+
+### Left (Horizontal Stack)
+
+```
+Group {
+    LayoutMode: Left;
+
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+}
+```
+
+Children arrange horizontally from left to right:
+
+```
+┌────────┬────────┬────────┐
+│ Button │ Button │ Button │
+│   1    │   2    │   3    │
+└────────┴────────┴────────┘
+```
+
+Use `Anchor.Right` for spacing between elements.
+
+### Right (Horizontal Stack)
+
+```
+Group {
+    LayoutMode: Right;
+
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+}
+```
+
+Children arrange horizontally from left to right but aligned to the right side of the parent:
+
+```
+                                                                 ┌────────┬────────┬────────┐
+                                                                 │ Button │ Button │ Button │
+                                                                 │   1    │   2    │   3    │
+                                                                 └────────┴────────┴────────┘
+```
+
+### Center
+
+```
+Group {
+    LayoutMode: Center;
+
+    Group #Dialog {
+        Anchor: (Width: 400, Height: 300);
+    }
+}
+```
+
+Centers the children horizontally.
+
+### Middle
+
+```
+Group {
+    LayoutMode: Middle;
+
+    Group #Dialog {
+        Anchor: (Width: 400, Height: 300);
+    }
+}
+```
+
+Centers the children vertically.
+
+### CenterMiddle (Horizontal Stack, Fully Centered)
+
+```
+Group {
+    LayoutMode: CenterMiddle;
+
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+}
+```
+
+Children stack horizontally from left to right, centered both horizontally and vertically within the parent:
+
+```
+┌────────────────────────────────────────────┐
+│                                            │
+│                                            │
+│         ┌──────┐ ┌──────┐ ┌──────┐         │
+│         │  B1  │ │  B2  │ │  B3  │         │
+│         └──────┘ └──────┘ └──────┘         │
+│                                            │
+│                                            │
+└────────────────────────────────────────────┘
+```
+
+---
+
+### MiddleCenter (Vertical Stack, Fully Centered)
+
+```
+Group {
+    LayoutMode: MiddleCenter;
+
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+}
+```
+
+Children stack vertically from top to bottom, centered both horizontally and vertically within the parent:
+
+```
+┌────────────────────────────────────────────┐
+│                                            │
+│              ┌──────────┐                  │
+│              │ Button 1 │                  │
+│              ├──────────┤                  │
+│              │ Button 2 │                  │
+│              ├──────────┤                  │
+│              │ Button 3 │                  │
+│              └──────────┘                  │
+│                                            │
+└────────────────────────────────────────────┘
+```
+
+---
+
+### Full
+
+```
+Group {
+    LayoutMode: Full;
+
+    Label {
+        Anchor: (Top: 20, Left: 20, Width: 100, Height: 30);
+    }
+}
+```
+
+Children use absolute positioning via their `Anchor` properties.
+
+### TopScrolling
+
+```
+Group {
+    LayoutMode: TopScrolling;
+    ScrollbarStyle: $Common.@DefaultScrollbar;
+
+    // ... many children
+}
+```
+
+Like `Top`, but adds a scrollbar if content exceeds container height.
+
+Or use `BottomScrolling` for bottom-aligned content.
+
+### LeftScrolling
+
+```
+Group {
+    LayoutMode: LeftScrolling;
+    ScrollbarStyle: $Common.@DefaultScrollbar;
+
+    // ... many children
+}
+```
+
+Like `Left`, but adds a scrollbar for horizontal scrolling.
+
+Or use `RightScrolling` for right-aligned content.
+
+### LeftCenterWrap (Wrapping Horizontal Stack, Horizontally Centered)
+
+```
+Group {
+    LayoutMode: LeftCenterWrap;
+
+    Button { Anchor: (Width: 80, Height: 30); }
+    Button { Anchor: (Width: 80, Height: 30); }
+    Button { Anchor: (Width: 80, Height: 30); }
+    Button { Anchor: (Width: 80, Height: 30); }
+    Button { Anchor: (Width: 80, Height: 30); }
+}
+```
+
+Children flow left to right. When there's no more horizontal space, they wrap to the next row. Each row is horizontally centered within the parent:
+
+```
+┌────────────────────────────────────────────┐
+│                                            │
+│       ┌──────┐ ┌──────┐ ┌──────┐           │
+│       │  B1  │ │  B2  │ │  B3  │           │
+│       └──────┘ └──────┘ └──────┘           │
+│            ┌──────┐ ┌──────┐               │
+│            │  B4  │ │  B5  │               │
+│            └──────┘ └──────┘               │
+│                                            │
+└────────────────────────────────────────────┘
+```
+
+## FlexWeight
+
+`FlexWeight` distributes remaining space among children.
+
+```
+Group {
+    LayoutMode: Left;
+    Anchor: (Width: 400);
+
+    Button {
+        Anchor: (Width: 100);
+    }
+
+    Group {
+        FlexWeight: 1;  // Takes all remaining space
+    }
+
+    Button {
+        Anchor: (Width: 100);
+    }
+}
+```
+
+Result:
+
+- First button: 100px
+- Middle group: 200px (400 - 100 - 100 = 200)
+- Last button: 100px
+
+### Multiple FlexWeights
+
+```
+Group {
+    LayoutMode: Left;
+    Anchor: (Width: 600);
+
+    Group { FlexWeight: 1; }
+    Group { FlexWeight: 2; }
+    Group { FlexWeight: 1; }
+}
+```
+
+Remaining space (600px) is split:
+
+- First group: 600 × (1/4) = 150px
+- Second group: 600 × (2/4) = 300px
+- Third group: 600 × (1/4) = 150px
+
+## Visibility
+
+```
+Button #HiddenButton {
+    Visible: false;
+}
+```
+
+**Effect:**
+
+- Element and its children are not displayed
+- Element is **not included in layout** (doesn't take up space)
diff --git a/content/docs/de-DE/official-documentation/custom-ui/markup.mdx b/content/docs/de-DE/official-documentation/custom-ui/markup.mdx
new file mode 100644
index 00000000..564110ed
--- /dev/null
+++ b/content/docs/de-DE/official-documentation/custom-ui/markup.mdx
@@ -0,0 +1,226 @@
+---
+title: Markup
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# Markup
+
+## Markup
+
+An element is the basic building block of a user interface. There are various types of elements with different properties, which are documented below.
+
+Here's what the syntax looks like:
+
+```
+// Basic declaration of an element
+// with its Anchor property set to attach on all sides of its parent
+// with 10 pixels of margin
+Group { Anchor: (Left: 10, Top: 10, Right: 10, Bottom: 10); }
+
+Group { Anchor: (Full: 10); } // More concise version
+
+// Declaration of a Label with a name
+// (can be used to access the element from game code)
+Label #MyLabel {
+  Style: LabelStyle(FontSize: 16); // or just Style: (FontSize: 16), type can be inferred.
+  Text: "Hi! I am text.";
+}
+
+// Declaration of a Group containing 2 children
+// You can use FlexWeight to distribute any left-over space after explicit widths/heights have been subtracted
+Group {
+  LayoutMode: Left;
+  Label { Text: "Child 1"; FlexWeight: 2; }
+  Label { Text: "Child 2"; FlexWeight: 1; }
+}
+```
+
+### Documents
+
+A UI document (_.ui_ file) contains trees of elements. There can be multiple root elements.
+
+### Named Expressions
+
+Named expressions can be declared at any level of a document (including at the root) and will be scoped to that subtree, though they need to be declared at the top of the block.
+
+```
+// Example of named expressions, declared and used with @ prefix
+@Title = "Hytale";
+@ExtraSpacing = 5;
+
+Label {
+  Text: @Title;
+  Style: (LetterSpacing: 2 + @ExtraSpacing);
+}
+```
+
+You can use the spread operator `...` to reuse a named expression while overriding some of its fields:
+
+```
+@MyBaseStyle = LabelStyle(FontSize: 24, LetterSpacing: 2);
+
+Label {
+  Style: (...@MyBaseStyle, FontSize: 36);
+}
+```
+
+You can even layer multiple named expressions like so:
+
+```
+@TitleStyle = LabelStyle(FontSize: 24, HorizontalAlignment: Center);
+@SpacedTextStyle = LabelStyle(LetterSpacing: 2);
+
+Label {
+  Style: (...@BigTextStyle, ...@SpacedTextStyle);
+}
+```
+
+#### Document references
+
+A document can reference another document and access its named expressions.
+
+```
+// Document references are defined with $ prefix
+$Common = "../Common.ui";
+
+TextButton {
+  Style: $Common.@DefaultButtonStyle;
+}
+```
+
+### Templates
+
+You can declare a reusable bit of interface as a named expression and then instantiate it as many times as you want in the tree while customizing it.
+
+You can override local named expressions as well as insert additional children at any point in the template tree. However, local named expressions must be defined at the very top of the block, before properties and child elements.
+
+```
+// This is the template
+@Row = Group {
+  Anchor: (Height: 50);
+  Label #Label { Anchor: (Left: 0, Width: 100); Text: @LabelText; }
+  Group #Content { Anchor: (Left: 100); }
+};
+
+// Here we'll be using it twice in the document tree
+Group #Rows {
+  LayoutMode: TopScrolling;
+
+  @Row #MyFirstRow {
+    @LabelText = "First row";
+    #Content { TextInput {} }
+  }
+
+  @Row #MySecondRow {
+    @LabelText = "Second row";
+  }
+}
+```
+
+### Property Types
+
+#### Basic Types
+
+- **Boolean**
+  - `Visible: false;`
+  - `Visible: true;`
+- **Int**
+  - `Height: 20;`
+- **Float, Double, Decimal**
+  - `Min: 0.2;`
+- **String**
+  - `Text: "Hi!";`
+- **Char**
+  - `PasswordChar: "*";`
+  - _Note: The syntax is the same as a string, however a value of this type cannot contain more than one character!_
+- **Color**
+  - `Background: #ffffff;`&#x20;
+- **Objects**
+  - `Style: (Background: #ffffff)`
+- **Array**&#x20;
+  - `TextSpans: [(Text: "Hi", IsBold: true)]`
+
+#### Translations
+
+Translation keys can be referenced anywhere in markup where you can provide a string, and they are then converted to a string when an element gets instantiated.
+
+**Example:**
+
+```
+Label {
+  Text: %ui.general.cancel;
+}
+```
+
+#### Colors
+
+A color literal can be written as follows:
+
+- `#rrggbb`: 6-digit hexadecimal representation for red, green, blue (fully opaque)
+- `#rrggbb(a.a)`: 6-digit hexadecimal representation for red, green, blue with alpha between 0 and 1
+- `#rrggbbaa`: 8-digit hexadecimal representation for red, green, blue and alpha
+
+```
+Group {
+  Background: #000000(0.3);
+}
+```
+
+<Callout>
+  The `#rrggbb(a.a)` format is prefered over the `#rrggbbaa` format for
+  readability reasons.
+</Callout>
+
+#### Font Name
+
+Font names can be referenced directly by their string ID. Internally this is using a custom type called `UIFontName`, however strings will be converted automatically to this type in markup.
+
+```
+Label {
+  Text: "Hi";
+  Style: (FontName: "Secondary");
+}
+```
+
+**Available Font Names**
+
+- _Default_ - This is the default font that is used for most text and is always used unless a different option has been specified
+- _Secondary_ - This font is mostly used for headlines or elements that are supposed to stick out
+- _Mono_ - This is only used for development; For things such as profiling or error overlays.
+
+#### Path
+
+We can reference other UI assets with the `UIPath` type. Similar to `UIFontName`_,_ Strings are automatically converted to a `UIPath`. Paths are always relative to the file where they have been declared in. Looking up _MyButton.png_ in _Menu/MyAwesomeMenu.ui_ will result in _Menu/MyButton.png_. If you want to reference a file that is in a parent folder you can go back one directory by writing two dots (_../MyButton.png_).
+
+The markup syntax of a `UIPath` is the same as a String. (e.g. `Path: "Test.png"`)
+
+Here are some more examples:
+
+| UIPath             | .ui File                              | Resulting Path    |
+| ------------------ | ------------------------------------- | ----------------- |
+| MyButton.png       | Menu/MyAwesomeMenu.ui                 | Menu/MyButton.png |
+| ../MyButton.png    | Menu/MyAwesomeMenu.ui                 | MyButton.png      |
+| ../../MyButton.png | Menu/Popup/Templates/MyAwesomeMenu.ui | Menu/MyButton.png |
+
+#### Objects
+
+Objects contain a set of properties. In this example we are assigning an Anchor object to the _Anchor_ property:
+
+```
+Group {
+  Anchor: (
+   Height: 10,
+   Width: 20
+ );
+}
+```
+
+You can find all objects that can be used in markup [here](type-documentation#elements).
+
+## Visual Studio Code Extension
+
+There is an official extension for Visual Studio Code which adds syntax highlighting for .ui files. You can find it [here](https://marketplace.visualstudio.com/items?itemName=HypixelStudiosCanadaInc.vscode-hytaleui).
diff --git a/content/docs/de-DE/official-documentation/custom-ui/type-documentation/index.mdx b/content/docs/de-DE/official-documentation/custom-ui/type-documentation/index.mdx
new file mode 100644
index 00000000..69cea406
--- /dev/null
+++ b/content/docs/de-DE/official-documentation/custom-ui/type-documentation/index.mdx
@@ -0,0 +1,127 @@
+---
+title: Type Documentation
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# Type Documentation
+
+This is a generated list of UI elements accessible by markup. More information about the User Interface framework can be found in the main documentation.
+
+## Elements
+
+- [ActionButton](type-documentation/elements/actionbutton)
+- [AssetImage](type-documentation/elements/assetimage)
+- [BackButton](type-documentation/elements/backbutton)
+- [BlockSelector](type-documentation/elements/blockselector)
+- [Button](type-documentation/elements/button)
+- [CharacterPreviewComponent](type-documentation/elements/characterpreviewcomponent)
+- [CheckBox](type-documentation/elements/checkbox)
+- [CheckBoxContainer](type-documentation/elements/checkboxcontainer)
+- [CircularProgressBar](type-documentation/elements/circularprogressbar)
+- [CodeEditor](type-documentation/elements/codeeditor)
+- [ColorOptionGrid](type-documentation/elements/coloroptiongrid)
+- [ColorPicker](type-documentation/lements/colorpicker)
+- [ColorPickerDropdownBox](type-documentation/elements/colorpickerdropdownbox)
+- [CompactTextField](type-documentation/elements/compacttextfield)
+- [DropdownBox](type-documentation/elements/dropdownbox)
+- [DropdownEntry](type-documentation/elements/dropdownentry)
+- [DynamicPane](type-documentation/elements/dynamicpane)
+- [DynamicPaneContainer](type-documentation/elements/dynamicpanecontainer)
+- [FloatSlider](type-documentation/elements/floatslider)
+- [FloatSliderNumberField](type-documentation/elements/floatslidernumberfield)
+- [Group](type-documentation/elements/group)
+- [HotkeyLabel](type-documentation/elements/hotkeylabel)
+- [ItemGrid](type-documentation/elements/itemgrid)
+- [ItemIcon](type-documentation/elements/itemicon)
+- [ItemPreviewComponent](type-documentation/elements/itempreviewcomponent)
+- [ItemSlot](type-documentation/elements/itemslot)
+- [ItemSlotButton](type-documentation/elements/itemslotbutton)
+- [Label](type-documentation/elements/label)
+- [LabeledCheckBox](type-documentation/elements/labeledcheckbox)
+- [MenuItem](type-documentation/elements/menuitem)
+- [MultilineTextField](type-documentation/elements/multilinetextfield)
+- [NumberField](type-documentation/elements/numberfield)
+- [Panel](type-documentation/elements/panel)
+- [ProgressBar](type-documentation/elements/progressbar)
+- [ReorderableList](type-documentation/elements/reorderablelist)
+- [ReorderableListGrip](type-documentation/elements/reorderablelistgrip)
+- [SceneBlur](type-documentation/elements/sceneblur)
+- [Slider](type-documentation/elements/slider)
+- [SliderNumberField](type-documentation/elements/slidernumberfield)
+- [Sprite](type-documentation/elements/sprite)
+- [TabButton](type-documentation/elements/tabbutton)
+- [TabNavigation](type-documentation/elements/tabnavigation)
+- [TextButton](type-documentation/elements/textbutton)
+- [TextField](type-documentation/elements/textfield)
+- [TimerLabel](type-documentation/elements/timerlabel)
+- [ToggleButton](type-documentation/elements/togglebutton)
+
+## Property Types
+
+- [Anchor](type-documentation/property-types/anchor)
+- [BlockSelectorStyle](type-documentation/property-types/blockselectorstyle)
+- [ButtonSounds](type-documentation/property-types/buttonsounds)
+- [ButtonStyle](type-documentation/property-types/buttonstyle)
+- [ButtonStyleState](type-documentation/property-types/buttonstylestate)
+- [CheckBoxStyle](type-documentation/property-types/checkboxstyle)
+- [CheckBoxStyleState](type-documentation/property-types/checkboxstylestate)
+- [ClientItemStack](type-documentation/property-types/clientitemstack)
+- [ColorOptionGridStyle](type-documentation/property-types/coloroptiongridstyle)
+- [ColorPickerDropdownBoxStateBackground](type-documentation/property-types/colorpickerdropdownboxstatebackground)
+- [ColorPickerDropdownBoxStyle](type-documentation/property-types/colorpickerdropdownboxstyle)
+- [ColorPickerStyle](type-documentation/property-types/colorpickerstyle)
+- [DropdownBoxSearchInputStyle](type-documentation/property-types/dropdownboxsearchinputstyle)
+- [DropdownBoxSounds](type-documentation/property-types/dropdownboxsounds)
+- [DropdownBoxStyle](type-documentation/property-types/dropdownboxstyle)
+- [InputFieldButtonStyle](type-documentation/property-types/inputfieldbuttonstyle)
+- [InputFieldDecorationStyle](type-documentation/property-types/inputfielddecorationstyle)
+- [InputFieldDecorationStyleState](type-documentation/property-types/inputfielddecorationstylestate)
+- [InputFieldIcon](type-documentation/property-types/inputfieldicon)
+- [InputFieldStyle](type-documentation/property-types/inputfieldstyle)
+- [ItemGridSlot](type-documentation/property-types/itemgridslot)
+- [ItemGridStyle](type-documentation/property-types/itemgridstyle)
+- [LabeledCheckBoxStyle](type-documentation/property-types/labeledcheckboxstyle)
+- [LabeledCheckBoxStyleState](type-documentation/property-types/labeledcheckboxstylestate)
+- [LabelSpan](type-documentation/property-types/labelspan)
+- [LabelStyle](type-documentation/property-types/labelstyle)
+- [NumberFieldFormat](type-documentation/property-types/numberfieldformat)
+- [Padding](type-documentation/property-types/padding)
+- [PatchStyle](type-documentation/property-types/patchstyle)
+- [PopupStyle](type-documentation/property-types/popupstyle)
+- [ScrollbarStyle](type-documentation/property-types/scrollbarstyle)
+- [SliderStyle](type-documentation/property-types/sliderstyle)
+- [SoundStyle](type-documentation/property-types/soundstyle)
+- [SpriteFrame](type-documentation/property-types/spriteframe)
+- [SubMenuItemStyle](type-documentation/property-types/submenuitemstyle)
+- [SubMenuItemStyleState](type-documentation/property-types/submenuitemstylestate)
+- [Tab](type-documentation/property-types/tab)
+- [TabNavigationStyle](type-documentation/property-types/tabnavigationstyle)
+- [TabStyle](type-documentation/property-types/tabstyle)
+- [TabStyleState](type-documentation/property-types/tabstylestate)
+- [TextButtonStyle](type-documentation/property-types/textbuttonstyle)
+- [TextButtonStyleState](type-documentation/property-types/textbuttonstylestate)
+- [TextTooltipStyle](type-documentation/property-types/texttooltipstyle)
+- [ToggleButtonStyle](type-documentation/property-types/togglebuttonstyle)
+- [ToggleButtonStyleState](type-documentation/property-types/togglebuttonstylestate)
+
+## Enums
+
+- [ActionButtonAlignment](type-documentation/enums/actionbuttonalignment)
+- [CodeEditorLanguage](type-documentation/enums/codeeditorlanguage)
+- [ColorFormat](type-documentation/enums/colorformat)
+- [DropdownBoxAlign](type-documentation/enums/dropdownboxalign)
+- [InputFieldButtonSide](type-documentation/enums/inputfieldbuttonside)
+- [InputFieldIconSide](type-documentation/enums/inputfieldiconside)
+- [ItemGridInfoDisplayMode](type-documentation/enums/itemgridinfodisplaymode)
+- [LabelAlignment](type-documentation/enums/labelalignment)
+- [LayoutMode](type-documentation/enums/layoutmode)
+- [MouseWheelScrollBehaviourType](type-documentation/enums/mousewheelscrollbehaviourtype)
+- [ProgressBarAlignment](type-documentation/enums/progressbaralignment)
+- [ProgressBarDirection](type-documentation/enums/progressbardirection)
+- [ResizeType](type-documentation/enums/resizetype)
+- [TimerDirection](type-documentation/enums/timerdirection)
+- [TooltipAlignment](type-documentation/enums/tooltipalignment)
diff --git a/content/docs/de-DE/official-documentation/npc/2-getting-started-with-templates.mdx b/content/docs/de-DE/official-documentation/npc/2-getting-started-with-templates.mdx
index 91081ca1..99d078e0 100644
--- a/content/docs/de-DE/official-documentation/npc/2-getting-started-with-templates.mdx
+++ b/content/docs/de-DE/official-documentation/npc/2-getting-started-with-templates.mdx
@@ -9,7 +9,7 @@ authors:
 
 There are no hard and fast rules for making a start on a template. I like to duplicate **BlankTemplate** and start from there because it already provides the basic structure of the file.
 
-This leaves me with the following template (`Template_Goblin_Ogre.json`): (note: the file could be looking different in the current version of the game)
+This leaves me with the following template (`Template_Goblin_Ogre.json`): (**note: the file could be looking different in the current version of the game**)
 
 ```json
 {
@@ -33,7 +33,7 @@ This leaves me with the following template (`Template_Goblin_Ogre.json`): (note:
     }
   },
   "Appearance": { "Compute": "Appearance" },
-  "DropList": { "Compute": "Droplist" },
+  "DropList": { "Compute": "DropList" },
   "MaxHealth": { "Compute": "MaxHealth" },
   "MotionControllerList": [
     {
@@ -65,10 +65,10 @@ And the following variant (`Goblin_Ogre.json`) next to the template. There's a t
   "Type": "Variant",
   "Reference": "Template_Goblin_Ogre",
   "Modify": {
-    "Appearance": "Goblin_Ogre",
+    "Appearance": "Goblin",
     "MaxHealth": 124
   }
 }
 ```
 
-Our artists have defined the `Goblin_Ogre` appearance already so I'm going to use that.
+Our artists have not yet finished animations for the `Goblin_Ogre`, for that sake of the tutorial I am going to use appearance `Goblin`, because it offers a more complete set of animations that we will need.
diff --git a/content/docs/de-DE/official-documentation/worldgen/pack-tutorial/asset-packs.mdx b/content/docs/de-DE/official-documentation/worldgen/pack-tutorial/asset-packs.mdx
index 38809fad..dcf1f3b9 100644
--- a/content/docs/de-DE/official-documentation/worldgen/pack-tutorial/asset-packs.mdx
+++ b/content/docs/de-DE/official-documentation/worldgen/pack-tutorial/asset-packs.mdx
@@ -9,13 +9,13 @@ authors:
 
 <OfficialDocumentationNotice />
 
-# How to modify Hytale
+# How to modify Hytale?
 
-## What's an Asset Pack
+## What's an Asset Pack?
 
-Hytales gameplay is driven by assets in the game that can be modified by creators. Asset Packs are our solution to let you override or add features to the base game with your own work. These can in the form of zip files of folders, which contain a custom set of assets. This is not the only way for a creator to change Hytale but this is the most accessible form.;
+Hytales gameplay is driven by assets in the game that can be modified by creators. Asset Packs are our solution to let you override or add features to the base game with your own work. These can be the form of zip files of folders, which contain a custom set of assets. This is not the only way for a creator to change Hytale but this is the most accessible form.;
 
-### How do I make an Asset Pack
+### How do I make an Asset Pack?
 
 <video controls className="my-6 aspect-video w-full rounded-lg border">
   <source src="https://cdn.internal.hytalemodding.dev/guides/official/how-to-asset-pack.mp4" type="video/mp4" />
@@ -48,7 +48,7 @@ An asset pack is typically a zip or folder, with a `manifest.json` inside. This
 }
 ```
 
-### Where are they stored
+### Where are they stored?
 
 Asset Packs are stored with other mods in the Mods folder.
 
@@ -76,7 +76,7 @@ C:\Users\<user>\AppData\Roaming\Hytale\UserData\Saves\New World 5\mods
 
 When you have Asset Packs or Mods installed, these will appear in the New World menu under the Options menu.;
 
-### How do I change an existing asset
+### How do I change an existing asset?
 
 <video controls className="my-6 aspect-video w-full rounded-lg border">
   <source src="https://cdn.internal.hytalemodding.dev/guides/official/how-to-asset.mp4" type="video/mp4" />
diff --git a/content/docs/de-DE/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx b/content/docs/de-DE/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx
index 44528376..24e628b5 100644
--- a/content/docs/de-DE/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx
+++ b/content/docs/de-DE/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx
@@ -106,7 +106,7 @@ If a BaseHeight is provided, the TopY and BottomY values are relative to the Bas
 
 Applies a Material Provider slot on a set of horizontal stripes of blocks of varying thickness and position. Below is an example image of basalt stripes into a stone cliff.
 
-{/* ![](https://540086904-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F7KAmBkOg6d13nZCkf9ku%2Fuploads%2FbcxO9LpArn8gPCaBwFg5%2Funknown.png?alt=media&token=1c72b67a-8253-4d03-8c64-1ad5f6830050) */}
+![Example of basalt stripes](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/basalt-stripes-example.png)
 
 #### Parameters:
 
diff --git a/content/docs/de-DE/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx b/content/docs/de-DE/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx
index 5e34acd4..a4418473 100644
--- a/content/docs/de-DE/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx
+++ b/content/docs/de-DE/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx
@@ -294,7 +294,7 @@ Combines all the positions into a single Positioins field.
 
 ---
 
-### SimpleHoritontal
+### SimpleHorizontal
 
 Keeps only the positions that are within the provided range.
 
diff --git a/content/docs/de-DE/official-documentation/worldgen/worldgen-tutorial/README.mdx b/content/docs/de-DE/official-documentation/worldgen/worldgen-tutorial/README.mdx
new file mode 100644
index 00000000..5f66d245
--- /dev/null
+++ b/content/docs/de-DE/official-documentation/worldgen/worldgen-tutorial/README.mdx
@@ -0,0 +1,166 @@
+---
+title: How to edit and create Biomes
+description: Explores where world generation assets can be found and how to edit them.
+---
+
+### Where are the Assets
+
+World generation assets are kept in the HytaleGenerator directory within the assets.
+
+```
+/Server/HytaleGenerator/
+```
+
+<div className="flex flex-row rounded-lg border p-4">
+  <div className="flex-1/2 border-r pr-4">
+    ```
+    /Biomes
+    ```
+
+    Biome assets, with content configurations.
+  </div>
+
+  <div className="flex-1/2 pl-4">
+    ```
+    /WorldStructure
+    ```
+
+    Generator files that define which biomes spawn together.
+  </div>
+</div>
+
+<div className="flex flex-row rounded-lg border p-4">
+  <div className="flex-1/2 border-r pr-4">
+    ```
+    /Density
+    ```
+
+    Density assets that can be referenced by any other assets.
+  </div>
+
+  <div className="flex-1/2 pl-4">
+    ```
+    /Assignments
+    ```
+
+    Prop assets that can be referenced by any Biome assets.
+  </div>
+</div>
+
+***
+
+An example of this structure can be found bellow, packed in an asset pack with the instance configuration.
+
+[https://drive.google.com/file/d/1sIz_CluANIIe3n8vNiOi-4PQdeqCO0qY/view?usp=drive_link](https://drive.google.com/file/d/1sIz_CluANIIe3n8vNiOi-4PQdeqCO0qY/view?usp=drive_link)
+
+<Callout>
+  Ensure you place your asset pack in the correct directory, under Mods.
+</Callout>
+
+### How to visit our worlds
+
+https://drive.google.com/file/d/1BJurxyj-taE-PXWm04bk7Dl6X7ZHTH92/view?usp=sharing
+
+#### Requirements
+
+- You must be an **Operator** in the world.
+  - To do this, run <mark style="color:$danger;">`/op self`</mark>
+- You must be in **Creative mode**.
+  - Press the <mark style="color:$danger;">`O`</mark> key, O for Orange.&#x20;
+
+The generation assets define a set of generators but on their own you cannot visit these. Currently you require an Instance with a generator that will allow you to visit your work.
+
+```
+/Server/Instances/
+```
+
+Instances are separate worlds that players can join using the `/instances` command. Each instance has an `Instance.bson` configuration asset that specifies which generator to use, among other worldly settings.
+
+```json
+{
+  "WorldGen": {
+    "Type": "HytaleGenerator",
+    "WorldStructure": "Basic",
+    "playerSpawn" : {
+      "X" : 123,
+      "Y" : 480,
+      "Z" : 10000,
+      "Pitch" : 0,
+      "Yaw" : 0,
+      "Roll" : 0
+    }
+  }
+}
+```
+
+<Callout>
+  You can create custom instances for different world structures and biomes as you need them.
+</Callout>
+
+### How to edit Biomes
+
+<video>
+  <source src="https://cdn.internal.hytalemodding.dev/guides/official/How-to-edit-Biomes.mp4" type="video/mp4" />
+</video>
+
+We currently use the Hytale Node Editor when editing world generation assets. This can be accessed while in-game from the Content Creation menu when pressing B. The node editor is then found under the asset editor dropdown on the upper left.&#x20;
+
+![Node Editor 1](/assets/official-documentation/worldgen/worldgen-tutorial/biomes/node-editor-1.png)
+
+Once you have the Hytale Node Editor open, through the file menu you can open Biomes by navigating to the Biomes directory and selecting one from your pack.&#x20;
+
+```
+/Server/HytaleGenerator/Biomes/
+```
+
+### Biome Asset Structure
+
+Every Biome has a root Biome node, this node splits into 5 structures. This is covered briefly but more information on each field can be found on the World Generation Concepts page.
+
+![Node Editor 2](/assets/official-documentation/worldgen/worldgen-tutorial/biomes/node-editor-2.png)
+
+<Callout>
+  Each biome is for the most part self contained, meaning it has control over what appears with the biome. The only exception to this are Base Heights.
+</Callout>
+
+<Tabs>
+  <Tab value="Terrain">
+    Mathematical function nodes that calculate the physical shape of the Biome's terrain.
+  </Tab>
+
+  <Tab value="Materials">
+    Logical nodes that determine what materials (blocks) make up a Biome's terrain.
+  </Tab>
+
+  <Tab value="Props">
+    Function nodes that add objects like prefabs and decorations to the terrain.
+  </Tab>
+
+  <Tab value="Environments">
+    Logical nodes that determine the environment asset at a given coordinate within the biome. This asset determines things like weather, NPC spawns, and sounds.
+  </Tab>
+
+  <Tab value="Tints">
+    Logical function nodes that determine a colour code that can be used by certain blocks in the world. Typically this will be grasses and soils.
+  </Tab>
+</Tabs>
+
+### How to preview your work
+
+[https://drive.google.com/file/d/1mNcHn9LhFnWDF0DzWFH6_YllmKAUvUry/view?t=6](https://drive.google.com/file/d/1mNcHn9LhFnWDF0DzWFH6_YllmKAUvUry/view?t=6)
+
+Once you are in an Instance world with the Hytale Generator active you will only be able to see your work by generating new chunks. There are a few ways to do this.
+
+The viewport command selects an area around the Player that will live reload as you make changes to the generator.&#x20;
+
+```
+/viewport --radius 5 
+```
+
+You can also create a new world to show your changes.&#x20;
+
+```
+/instances spawn <instance> 
+```
+
+The last option is to simply fly south, new chunks will generate with the changes made.
diff --git a/content/docs/de-DE/quick-start.mdx b/content/docs/de-DE/quick-start.mdx
index 5c7047a7..50ab3cb3 100644
--- a/content/docs/de-DE/quick-start.mdx
+++ b/content/docs/de-DE/quick-start.mdx
@@ -9,3 +9,8 @@ Welcome to the Hytale modding documentation! Here you'll find everything you nee
 * [Setting up your dev environment](./guides/plugin/setting-up-env)
 * [Entity Component System (ECS)](./guides/ecs/entity-component-system)
 * [Publishing your mod](./publishing)
+
+### Useful Links
+
+* [Kaupenjoe's Modding Videos](https://www.youtube.com/@ModdingByKaupenjoe)
+* [TroubleDEV's Modding Videos](https://www.youtube.com/@TroubleDEV)
diff --git a/content/docs/de-DE/server/argtypes.mdx b/content/docs/de-DE/server/argtypes.mdx
new file mode 100644
index 00000000..e54a442e
--- /dev/null
+++ b/content/docs/de-DE/server/argtypes.mdx
@@ -0,0 +1,61 @@
+---
+title: ArgTypes
+description: Available ArgTypes
+icon: List
+full: true
+authors:
+  - name: Valeena
+---
+
+| Name                        | Target Class                           | Description                                                                                                                               |   |
+| :-------------------------- | :------------------------------------- | :---------------------------------------------------------------------------------------------------------------------------------------- | - |
+| Boolean                     | java.lang.Boolean                      | A 'true' or 'false' input                                                                                                                 |   |
+| Integer                     | java.lang.Integer                      | A whole number                                                                                                                            |   |
+| String                      | java.lang.String                       | Words, text, numbers, letters. To input more than one word at a time, you may need to wrap it with double quotes (`"my fancy sentence"`). |   |
+| Float                       | java.lang.Float                        | A floating-pointer number                                                                                                                 |   |
+| Double                      | java.lang.Double                       | A decimal number                                                                                                                          |   |
+| UUID                        | java.util.UUID                         | A UUID (Universally Unique IDentifier)                                                                                                    |   |
+| Player_UUID                 | java.util.UUID                         | A UUID or an online player username                                                                                                       |   |
+| Game_Profile_Lookup_Async   | ProfileServiceClient.PublicGameProfile | A player UUID or username. If not found locally, performs a remote lookup via the Profile Service.                                        |   |
+| Relative_Double_Coord       | Coord                                  | An x, y, or z coordinate as a decimal, optionally relative by specifying a tilde (~) in front of the number                               |   |
+| Relative_Int_Coord          | IntCoord                               | An x, y, or z coordinate as a whole number, optionally relative by specifying a tilde (~) in front of the number                          |   |
+| Relative_Integer            | RelativeInteger                        | A tilde to mark an integer relative to a base                                                                                             |   |
+| Relative_Float              | RelativeFloat                          | A tilde to mark a float relative to a base                                                                                                |   |
+| Player_Ref                  | PlayerRef                              | A UUID or an online player's username                                                                                                     |   |
+| World                       | World                                  | A world folder name                                                                                                                       |   |
+| Model_Asset                 | ModelAsset                             | A reference to an Asset of type Model                                                                                                     |   |
+| Weather_Asset               | Weather                                | A reference to an Asset of type Weather                                                                                                   |   |
+| Interaction_Asset           | Interaction                            | A reference to an Asset of type Interaction                                                                                               |   |
+| Root_Interaction_Asset      | RootInteraction                        | A reference to an Asset of type Root Interaction                                                                                          |   |
+| Effect_Asset                | EntityEffect                           | A refernece to an Asset of type EntityEffect                                                                                              |   |
+| Environment_Asset           | Environment                            | A reference to an Asset of type Environment                                                                                               |   |
+| Item_Asset                  | Item                                   | A reference to an Asset of type Item                                                                                                      |   |
+| Block_Type_Asset            | BlockType                              | A reference to an Asset of type BlockType                                                                                                 |   |
+| Particle_System             | ParticleSystem                         | A reference to an Asset of type ParticleSystem                                                                                            |   |
+| Hitbox_Collision_Config     | HitboxCollisionConfig                  | A reference to an Asset of type HitboxCollisionConfig                                                                                     |   |
+| Repulsion_Config            | RepulsionConfig                        | A reference to an Asset of type RepulsionConfig                                                                                           |   |
+| Sound_Event_Asset           | SoundEvent                             | A reference to an Asset of type SoundEvent                                                                                                |   |
+| Ambiance_Fx_Asset           | AmbianceFX                             | A reference to an Asset of type AmbianceFX                                                                                                |   |
+| Sound_Category              | SoundCategory                          | A sound category (sfx, music, ambient, ui)                                                                                                |   |
+| Entity_ID                   | `ArgWrapper<EntityWrappedArg, UUID>`   | A UUID representing an entity id                                                                                                          |   |
+| Integer_Comparison_Operator | IntegerComparisonOperator              | A mathematical sign for integer comparison                                                                                                |   |
+| Integer_Operation           | IntegerOperation                       | A mathematical sign for performing an operation                                                                                           |   |
+| Int_Range                   | `Pair<Integer, Integer>`               | Two integers representing a minimum and maximum of a range                                                                                |   |
+| Relative_Int_Range          | RelativeIntRange                       | Two integers representing a minimum and maximum of a range                                                                                |   |
+| Vector2I                    | Vector2i                               | Two integers, generally corresponding to x/z axis                                                                                         |   |
+| Vector3I                    | Vector3i                               | Three integers, generally corresponding to x/y/z axis                                                                                     |   |
+| Relative_Vector3I           | RelativeVector3i                       | Three optionally relative integers, generally corresponding to x/y/z axis                                                                 |   |
+| Relative_Block_Position     | RelativeIntPosition                    | A position with three integer coordinates, representing a block's location in world space.                                                |   |
+| Relative_Position           | Relative                               | A position with three decimal coordinates, representing a location in world space.                                                        |   |
+| Relative_Chunk_Position     | RealtiveChunkPosition                  | A position with two integer coordinates (x, z), representing a chunk's location.                                                          |   |
+| Rotation                    | Vector3f                               | A rotation with three coordinates, representing the pitch, yaw, and roll respectively                                                     |   |
+| Block_Type_Key              | String                                 | A block type                                                                                                                              |   |
+| Block_ID                    | Integer                                | A block type, converted to an int id                                                                                                      |   |
+| Color                       | Integer                                | A color value in hex format, hex integer, or decimal integer                                                                              |   |
+| Weighted_Block_Type         | `Pair<Integer, String>`                | A weight corresponding to a blocktype                                                                                                     |   |
+| Weighted_Block_Entry        | String                                 | A block with optional weight prefix                                                                                                       |   |
+| Block_Pattern               | BlockPattern                           | A list of blocks with optional weights                                                                                                    |   |
+| Individual_Block_Mask       | BlockMask                              | Create a block mask using symbols and block names                                                                                         |   |
+| Block_Mask                  | BlockMask                              | A tick rate value (e.g., 30tps, 33ms, or 30)                                                                                              |   |
+| Tick_Rate                   | Integer                                | A list of block masks that combine together                                                                                               |   |
+| Game_Mode                   | GameMode                               | GameMode                                                                                                                                  |   |
diff --git a/content/docs/de-DE/server/interaction-reference.mdx b/content/docs/de-DE/server/interaction-reference.mdx
new file mode 100644
index 00000000..6c0d01b3
--- /dev/null
+++ b/content/docs/de-DE/server/interaction-reference.mdx
@@ -0,0 +1,1586 @@
+---
+title: Interactions
+description: A list of most Interaction types provided by Hypixel, along with the meaning of their fields, and how they fit together.
+icon: List
+authors:
+  - name: Stephen Baynham
+    url: https://github.com/cannibalvox
+---
+
+### The Interaction Base Type
+
+All interactions of every type below are inherited from Interaction and have these fields.
+
+**Interaction Fields**
+
+| Field Name                | Type                                                                 | Required? | Notes                                                                                                                                                                                                                       |
+| ------------------------- | -------------------------------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| ViewDistance              | `Double`<br />(Default: 96.0)                                        | **No**    | Distance in blocks at which other players can see the effects from this interaction.                                                                                                                                        |
+| Effects                   | `InteractionEffects`                                                 | **No**    | Sound, animations, and particle effects that should trigger when this interaction begins executing.                                                                                                                         |
+| HorizontalSpeedMultiplier | `Float`<br />(Default: 1.0)                                          | **No**    | Multiplier applied to the User entity's movement speed while this interaction is executing                                                                                                                                  |
+| RunTime                   | `Float`                                                              | **No**    | If provided, this interaction will continue executing for at least this long before the interaction chain moves onto the next interaction.                                                                                  |
+| CancelOnItemChange        | `Boolean`<br />(Default: true)                                       | **No**    | If true, this interaction will be cancelled if the User entity's held item changes during execution. This can happen either due to the selected hotbar slot changing or the contents of the item's inventory slot changing. |
+| Rules                     | `InteractionRules`                                                   | **Yes**   | If provided, adds additional limitations and cancellation conditions to this interaction.                                                                                                                                   |
+| Settings                  | `Map`<br />(Key Type: `GameMode`, Value Type: `InteractionSettings`) | **No**    | If provided, adds additional per-GameMode settings to the interaction.                                                                                                                                                      |
+| Camera                    | `InteractionCameraSettings`                                          | **No**    | Arrays of camera motion keyframes for cutscenes and reveals.                                                                                                                                                                |
+
+**GameMode Values**
+
+- `Creative`: The game is currently in Creative Mode
+- `Adventure`: The game is currently in Adventure Mode
+
+**InteractionEffects Fields**
+
+| Field Name               | Type                                              | Required? | Notes                                                                                                                                                 |
+| ------------------------ | ------------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Particles                | `Array`<br />(Element Type: `ModelParticle`)      | **No**    | Particle systems to activate when this interaction begins if the player is in third-person mode.                                                      |
+| FirstPersonParticles     | `Array`<br />(Element Type: `ModelParticle`)      | **No**    | Particle systems to activate when this interaction begins if the player is in first-person mode.                                                      |
+| WorldSoundEventId        | `Asset`<br />(Asset Type: `SoundEvent`)           | **No**    | A sound to play in the world at the User entity's location when this interaction begins.<br />**The SoundEvent must be single-channel (mono) sound.** |
+| LocalSoundEventId        | `Asset`<br />(Asset Type: `SoundEvent`)           | **No**    | A 2D sound to play for the User entity when this interaction begins. Ignored if the User entity is not a player.                                      |
+| Trails                   | `Array`<br />(Element Type: `ModelTrail`)         | **No**    | Trail effects to activate on the User entity when this interaction begins.                                                                            |
+| WaitForAnimationToFinish | `Boolean`<br />(Default: false)                   | **No**    | If true, this interaction will continue executing for at least the length of any animations in this InteractionEffects object.                        |
+| ItemPlayerAnimationsId   | `Asset`<br />(Asset Type: `ItemPlayerAnimations`) | **No**    | If provided, the User entity will use this ItemPlayerAnimations set while this interaction is executing.                                              |
+| ItemAnimationId          | `String`                                          | **No**    | Id of an animation to trigger when this interaction begins executing.<br />**This animation id is not validated on server start.**                    |
+| ClearAnimationOnFinish   | `Boolean`<br />(Default: false)                   | **No**    | If true, animations triggered by this interaction will be halted when the interaction completes.                                                      |
+| ClearSoundEventOnFinish  | `Boolean`<br />(Default: false)                   | **No**    | If true, sounds triggered by this interaction will be halted when the interaction completes.                                                          |
+| CameraEffect             | `Asset`<br />(Asset Type: `CameraEffect` )        | **No**    | If provided, the CameraEffect will be applied while this interaction is executing.                                                                    |
+| MovementEffects          | `MovementEffects`                                 | **No**    | If provided, apply the movement effects to the User entity while this interaction is executing.                                                       |
+| StartDelay               | `Float`<br />(Default: 0.0f)                      | **No**    | The interaction will wait this many seconds before triggering the effects in this object.                                                             |
+
+**InteractionRules Fields**
+
+| Field Name          | Type                                                                                                | Required? | Notes                                                                                                                                                                                                                                     |
+| ------------------- | --------------------------------------------------------------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| BlockedBy           | `Array`<br />(Element Type: `InteractionType`)<br />(Default: Based on the chain's InteractionType) | **No**    | If provided, this RootInteraction cannot be executed while interaction chains of the provided types are executing.<br />**This field only functions for rules attached to a RootInteraction. It has no effect on an Interaction.**        |
+| Blocking            | `Array`<br />(Element Type: `InteractionType`)                                                      | **No**    | If provided, interaction chains with the specified InteractionTypes cannot be executed while this interaction is executing.                                                                                                               |
+| InterruptedBy       | `Array`<br />(Element Type: `InteractionType`)                                                      | **No**    | If provided, interaction chains with the specified InteractionTypes will cancel this interaction chain when they execute.<br />**This field only functions for rules attached to a RootInteraction. It has no effect on an Interaction.** |
+| Interrupting        | `Array`<br />(Element Type: `InteractionType`)                                                      | **No**    | If provided, interaction chains with the specified InteractionTypes will be canceled when this interaction begins.                                                                                                                        |
+| BlockedByBypass     | `String`                                                                                            | **No**    | If provided, this RootInteraction cannot be blocked by interaction chains whose RootInteraction has this value as an asset tag.                                                                                                           |
+| BlockingBypass      | `String`                                                                                            | **No**    | If provided, this interaction will not block RootInteractions that have the this value as an asset tag.                                                                                                                                   |
+| InterruptedByBypass | `String`                                                                                            | **No**    | If provided, this RootInteraction cannot be canceled by RootInteractions that have this value as an asset tag.                                                                                                                            |
+| InterruptingBypass  | `String`                                                                                            | **No**    | If provided, this interaction will not cancel interaction chains whose RootInteraction has this value as an asset tag.                                                                                                                    |
+
+**InteractionType Values**
+
+- `Primary`
+- `Secondary`
+- `Ability1`
+- `Ability2`
+- `Ability3`
+- `Use`
+- `Pick`
+- `Pickup`
+- `CollisionEnter`
+- `CollisionLeave`
+- `Collision`
+- `EntityStatEffect`
+- `SwapTo`
+- `SwapFrom`
+- `Death`
+- `Wielding`
+- `ProjectileSpawn`
+- `ProjectileHit`
+- `ProjectileMiss`
+- `ProjectileBounce`
+- `Held`
+- `HeldOffhand`
+- `Equipped`
+- `Dodge`
+- `GameModeSwap`
+
+**InteractionSettings Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                        |
+| ---------------- | ------------------------------- | --------- | -------------------------------------------------------------------------------------------- |
+| AllowSkipOnClick | `Boolean`<br />(Default: false) | **No**    | If true, the user will be able to skip this interaction by clicking shortly after it starts. |
+
+**InteractionCameraSettings Fields**
+
+| Field Name  | Type                                             | Required? | Notes                                                                                                                                                           |
+| ----------- | ------------------------------------------------ | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| FirstPerson | `Array`<br />(Element Type: `InteractionCamera`) | **No**    | A list of camera keyframes to be played if the player is in first-person.<br />**The time of each keyframe must be after the keyframe before it in the array.** |
+| ThirdPerson | `Array`<br />(Element Type: `InteractionCamera`) | **No**    | A list of camera keyframes to be played if the player is in third-person.<br />**The time of each keyframe must be after the keyframe before it in the array.** |
+
+**InteractionCamera Fields**
+
+| Field Name | Type                         | Required? | Notes                                                                                                                                       |
+| ---------- | ---------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------- |
+| Time       | `Float`<br />(Default: 0.1f) | **No**    | How long after the interaction begins executing that the camera should arrive at this keyframe.<br />**Cannot be less than or equal to 0.** |
+| Position   | `Vector3`                    | **Yes**   | Where the camera should be located when it arrives at this keyframe.                                                                        |
+| Rotation   | `Direction`                  | **Yes**   | Where the camera should be pointing when it arrives at this keyframe.                                                                       |
+
+### SimpleInteraction
+
+Most interaction types below are inherited from SimpleInteraction and have these
+fields.  If a type does not have these fields, the documentation will mention it.
+
+The purpose of SimpleInteraction is to facilitate Interaction chaining by taking different paths
+based on whether the Interaction succeeded or failed.  The circumstances under which
+a given Interaction fails are generally type-specific (and described in the documentation
+below), but all interactions will be marked failed if they are cancelled via one of the
+many, many mechanisms for doing so.
+
+It is valid to create an interaction asset of type "Simple", which can be valuable when you want to use the
+interaction fields with no additional functionality.
+
+**SimpleInteraction Fields**
+
+| Field Name | Type                                     | Required? | Notes                                                                                          |
+| ---------- | ---------------------------------------- | --------- | ---------------------------------------------------------------------------------------------- |
+| Next       | `Asset`<br />(Asset Type: `Interaction`) | **No**    | After this Interaction has finished, "Next" will be executed if this Interaction did not fail. |
+| Failed     | `Asset`<br />(Asset Type: `Interaction`) | **No**    | After this Interaction has finished, "Failed" will be executed if this Interaction failed.     |
+
+## Flow Control
+
+These are interaction types used to control the flow of an interaction chain and allow interactions
+to be composed into more complex behaviors.  These interaction types generally do not pertain to
+the game and instead pertain to the interaction system itself.
+
+### Condition
+
+This interaction will fail if one of the fields is provided but does not match the current state.
+
+**Condition Fields**
+
+| Field Name       | Type       | Required? | Notes                                                                                                                                                                                    |
+| ---------------- | ---------- | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| RequiredGameMode | `GameMode` | **No**    | If provided, the interaction will fail if the current GameMode does not match the provided value.                                                                                        |
+| Jumping          | `Boolean`  | **No**    | If provided, the interaction will fail if the player's Jumping state does not match the provided value. (i.e. if True, the player must be jumping, if False, the player must not be)     |
+| Swimming         | `Boolean`  | **No**    | If provided, the interaction will fail if the player's Swimming state does not match the provided value. (i.e. if True, the player must be swimming, if False, the player must not be)   |
+| Crouching        | `Boolean`  | **No**    | If provided, the interaction will fail if the player's Crouching state does not match the provided value. (i.e. if True, the player must be crouching, if False, the player must not be) |
+| Running          | `Boolean`  | **No**    | If provided, the interaction will fail if the player's Running state does not match the provided value. (i.e. if True, the player must be running, if False, the player must not be)     |
+| Flying           | `Boolean`  | **No**    | If provided, the interaction will fail if the player's Flying state does not match the provided value. (i.e. if True, the player must be flying, if False, the player must not be)       |
+
+**GameMode Values**
+
+- `Creative`: The game is currently in Creative Mode
+- `Adventure`: The game is currently in Adventure Mode
+
+### FirstClick
+
+This interaction does not inherit from SimpleInteraction and therefore has no Next or Failed fields.
+
+This interaction has two fields that each contain a reference to an Interaction: Click and Hold.  If the root interaction
+of the chain was initiated by a client button/key press (or simulated NPC input) and the input was a tap, then
+the Click interaction is run. if it was a longer press, then the Hold interaction is run.
+
+As a minor implementation detail, this interaction is internally marked as failed when the Hold path is followed.
+This generally shouldn't matter.  If the interaction was not initiated by a key press at all, the Click path will be followed,
+but it seems risky to rely on that behavior.
+
+**FirstClick Fields**
+
+| Field Name | Type                                     | Required? | Notes                                                                                                                                                    |
+| ---------- | ---------------------------------------- | --------- | -------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Click      | `Asset`<br />(Asset Type: `Interaction`) | **No**    | If provided and the root interaction of the chain was initiated by button/key press, this interaction is executed next if the press was a quick tap.     |
+| Hold       | `Asset`<br />(Asset Type: `Interaction`) | **No**    | If provided and the root interaction of the chain was initiated by a button/key press, this interaction is executed next if the press was a longer hold. |
+
+### Interrupt
+
+This interaction can be used to cancel one or more running interaction chains on an entity and **all forked interaction
+chains those chains have spawned that are still currently running**.  All interaction chains canceled in this manner will be marked as
+Failed, which may have additional implications if the canceled chains are themselves forked from
+other chains that are still running.
+
+**Interrupt Fields**
+
+| Field Name     | Type                                           | Required? | Notes                                                                                                                                                                                               |
+| -------------- | ---------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Entity         | `InteractionTarget`<br />(Default: User)       | **Yes**   | The entity that is the owner of the target interaction chains.  This field can indicate the Owner, User, or Target of this interaction chain.                                                       |
+| InterruptTypes | `Array`<br />(Element Type: `InteractionType`) | **No**    | A set of InteractionTypes that are to be interrupted. Only interactions of these types are affected. If null, all types will be interrupted.<br />**(Note: An empty set will interrupt NO TYPES.)** |
+| RequiredTag    | `String`                                       | **No**    | An asset tag that, if provided, the RootInteraction of the interaction chain must have in order to be canceled.                                                                                     |
+| ExcludedTag    | `String`                                       | **No**    | An asset tag that, if provided, the RootInteraction of the interaction chain must not have in order to be canceled.                                                                                 |
+
+**InteractionTarget Values**
+
+- `User` - The user of this interaction chain. The entity whose actions caused this interaction chain to be executed. This is usually the same as the Owner.
+- `Owner` - The owner of this interaction chain. The entity upon whom this interaction chain is executing.
+- `Target` - The entity target of this interaction chain, if any.  This value is mutable (and can therefore come from many places) but most commonly, it is an entity the User was targeting when this interaction chain began executing.
+
+**InteractionType Values**
+
+- `Primary`
+- `Secondary`
+- `Ability1`
+- `Ability2`
+- `Ability3`
+- `Use`
+- `Pick`
+- `Pickup`
+- `CollisionEnter`
+- `CollisionLeave`
+- `Collision`
+- `EntityStatEffect`
+- `SwapTo`
+- `SwapFrom`
+- `Death`
+- `Wielding`
+- `ProjectileSpawn`
+- `ProjectileHit`
+- `ProjectileMiss`
+- `ProjectileBounce`
+- `Held`
+- `HeldOffhand`
+- `Equipped`
+- `Dodge`
+- `GameModeSwap`
+
+### Parallel
+
+This interaction does not inherit from SimpleInteraction and therefore has no Next or Failed fields.
+
+This interaction has a field `Interactions` that is an array of RootInteraction assets. The list must contain at least
+two RootInteractions.  This interaction will fork all of its children except for the first into their
+own interaction chains and immediately complete. After this interaction completes, this interaction chain will
+execute the first RootInteraction in the `Interactions` list.
+
+This interaction does not have any failure conditions and is indifferent to the fate of the forked interaction chains.
+
+**Parallel Fields**
+
+| Field Name   | Type                                                | Required? | Notes                                                         |
+| ------------ | --------------------------------------------------- | --------- | ------------------------------------------------------------- |
+| Interactions | `AssetArray`<br />(Element Type: `RootInteraction`) | **Yes**   | An array of RootInteractions that will be forked or executed. |
+
+### Repeat
+
+This interaction has a field `ForkInteractions` that is an asset of type RootInteraction. This interaction will fork that
+RootInteraction into its own interaction chain and then wait for it to complete. If the RootInteraction fails, this
+interaction will complete immediately and be marked failed. Otherwise, the RootInteraction will be forked and run again,
+up to a specified total number of times.
+
+**Repeat Fields**
+
+| Field Name       | Type                                                                                   | Required? | Notes                                                                                                                                                                                                              |
+| ---------------- | -------------------------------------------------------------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| ForkInteractions | `Asset`<br />(Asset Type: `RootInteraction`)                                           | **Yes**   | A RootInteraction that will be forked.                                                                                                                                                                             |
+| Repeat           | `Integer`<br />(Default: 1)<br />**Must be -1 or a positive integer. 0 is not valid.** | **No**    | The total number of times to fork ForkInteractions. If -1 is provided, ForkInteractions will continue being forked and executed indefinitely, until this interaction is cancelled or until ForkInteractions fails. |
+
+### Replace
+
+This interaction does not inherit from SimpleInteraction and therefore has no Next or Failed fields.
+
+This interaction uses the InteractionVars system that is avaiable for items. InteractionVars are RootInteractions that
+can be attached to an Item asset with a name.
+
+This interaction specifies a var name, and if this interaction chain was executed through
+an item and that item has an InteractionVar of the same name, then this interaction will immediately execute
+the RootInteraction on the var.  Otherwise, it will execute the default RootInteraction specified in this interaction.
+If no default is specified, then this interaction will be marked as failed.
+
+**Replace Fields**
+
+| Field Name   | Type                                         | Required? | Notes                                                                                                                                                                                                           |
+| ------------ | -------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Var          | `String`                                     | **Yes**   | The name of the InteractionVar to execute.                                                                                                                                                                      |
+| DefaultValue | `Asset`<br />(Asset Type: `RootInteraction`) | **No**    | The RootInteraction to execute if the owning item does not have an InteractionVar by the specified name. If not provided, the interaction will be marked as failed instead.                                     |
+| DefaultOk    | `Boolean`<br />(Default: false)              | **No**    | If false, then an angry message will be printed to the server logs if the owning item does not have an InteractionVar by the specified name.  The functioning of this interaction will be otherwise unaffected. |
+
+### RunRootInteraction
+
+This interaction immediately executes the provided RootInteraction as part of this interaction chain. This interaction
+does not have any failure conditions.
+
+**RunRootInteraction Fields**
+
+| Field Name      | Type                                         | Required? | Notes                           |
+| --------------- | -------------------------------------------- | --------- | ------------------------------- |
+| RootInteraction | `Asset`<br />(Asset Type: `RootInteraction`) | **Yes**   | The RootInteraction to execute. |
+
+### Selector
+
+This interaction will execute a Selector to find entities and/or blocks (depending on the Selector) and fork off an
+interaction chain for each located entity or block. This interaction will not wait for those interaction chains
+to complete and is indifferent to their fate. The forked interaction chains will use the located entity/block as
+their target entity/target block. Each entity or block will only fork one interaction chain over the life of this
+interaction.  The Selector is guaranteed to run once for each execution of this interaction, but some Selectors
+are intended to be run over a period of time and sweep across an area to locate targets. In order to use those Selectors
+properly, you will need to extend the execution time of this interaction using `RunTime` or `WaitForAnimationToFinish`.
+The Selector will be executed repeatedly over the lifetime of the interaction.
+
+If the Selector is configured to locate entities, you can add additional sets of entity matching rules. If a located entity
+matches one of the rules, the matching RootInteraction will be forked instead of the standard `HitEntity` RootInteraction.
+
+Entities located by the Selector will be ignored if they do not have a NetworkId, if they are dead, or if they are invulnerable.
+The only exception to this rule is that players in Creative Mode that are marked to receive hits will not be ignored.
+
+This interaction's failure conditions are configurable via the `FailOn` field. You can configure this interaction to never
+fail, to fail if the Selector does not locate any blocks before this interaction finishes executing, to fail if the
+Selector does not locate any entities before this interaction finishes executing, or to fail in either case.
+
+**Selector Fields**
+
+| Field Name     | Type                                         | Required? | Notes                                                                                                                                                                                                                                     |
+| -------------- | -------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Selector       | `Selector`                                   | **Yes**   | The Selector is executed at least once and may be executed repeatedly to locate blocks and/or entities in an area.                                                                                                                        |
+| HitEntity      | `Asset`<br />(Asset Type: `RootInteraction`) | **No**    | If included and the `Selector` locates an entity that does not match any `HitEntityRules`, this RootInteraction will be forked into a new interaction chain with the located entity as the target entity.                                 |
+| HitEntityRules | `Array`<br />(Element Type: `HitEntity`)     | **No**    | If included, these rules will be matched against any entity located by the `Selector`. If an entity matches a set of rules, the RootInteraction associated with the rules will be forked instead of the standard `HitEntity` interaction. |
+| HitBlock       | `Asset`<br />(Asset Type: `RootInteraction`) | **No**    | If included and the `Selector` locates a block, this RootInteraction will be forked into a new interaction chain with the located block as the block target.                                                                              |
+| FailOn         | `FailOnType`<br />(Default: `Neither`)       | **No**    | Defines under what circumstances this interaction will fail.  It can be marked to fail when it completes without locating any blocks, it can be marked to fail when it completes without locating any entities, both, or neither.         |
+| IgnoreOwner    | `Boolean`<br />(Default: true)               | **No**    | If true, the Selector will not locate the User entity of this interaction.                                                                                                                                                                |
+
+**HitEntity Fields**
+
+| Field Name | Type                                         | Required? | Notes                                                                                                 |
+| ---------- | -------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------- |
+| Matchers   | `Array`<br />(Element Type: `EntityMatcher`) | **Yes**   | A set of rules that an entity must match. An entity must successful match all rules to be considered. |
+| Next       | `Asset`<br />(Asset Type: `RootInteraction`) | **Yes**   | The RootInteraction to fork if an entity matches all rules.                                           |
+
+**EntityMatcher Fields**
+
+| Field Name | Type                            | Required? | Notes                                                                                                     |
+| ---------- | ------------------------------- | --------- | --------------------------------------------------------------------------------------------------------- |
+| Type       | `String`                        | **Yes**   | If provided, specifies a type of EntityMatcher to use. Each matcher type may come with additional fields. |
+| Invert     | `Boolean`<br />(Default: false) | **No**    | If true, an entity must fail this rule for it to be marked as succeeded.                                  |
+
+**EntityMatcher Type: Player**
+
+This EntityMatcher will succesfully match the entity only if they are a player.
+
+**EntityMatcher Type: Vulnerable**
+
+This Entitymatcher will successfully match the entity only if they are not marked as invulnerable.
+
+**FailOnType Values**
+
+- `Neither`
+- `Entity`
+- `Block`
+- `Either`
+
+### Serial
+
+This interaction does not inherit from SimpleInteraction and therefore has no Next or Failed fields.
+
+This interaction has a field `Interactions` which is a list of Interaction assets. This interaction immediately
+completes and the interaction chain continues by executing the interactions in the list one at a time. This
+interaction does not have any failure conditions.
+
+**Serial Fields**
+
+| Field Name   | Type                                            | Required? | Notes                                      |
+| ------------ | ----------------------------------------------- | --------- | ------------------------------------------ |
+| Interactions | `AssetArray`<br />(Element Type: `Interaction`) | **Yes**   | An array of Interaction assets to execute. |
+
+## Cooldowns
+
+RootInteractions interface with a complex cooldown system that can be used for a variety of purposes. Aside from simply
+adding an important aspect of resource management to your game design, cooldowns can be used to ensure that click-activated
+interaction chains don't repeatedly spam if the player holds down the input.
+
+By default, every RootInteraction has a cooldown timer that is keyed to the RootInteraction name, and by default, it
+will launch a cooldown of 0.35 seconds when activated by client input.  Otherwise, no cooldown will be activated.  However,
+by configuring your RootInteraction, you can change the key for the cooldown (so that multiple RootInteractions can share
+a single cooldown), set the cooldown timer to whatever you like, and configure multiple charges that can build up over time
+to allow the entity to activate the RootInteraction multiple times before being forced to pause.
+
+One important concept to keep in mind is the difference between **cooldown** and **charge time**.  The cooldown, if any,
+is activated each time a RootInteraction triggers, even if the player has more available charges. If the RootInteraction
+is configured to use charges, then they will gradually build up over time. In order for a RootInteraction to be activated,
+the cooldown (if any) must be expired, and the RootInteraction must have at least one charge (if it has been
+configured to use charges).
+
+Bear in mind that the entire Cooldown configuration is shared between different RootInteractions with the same cooldown id.
+If you activate an ability with 5 charges and a short cooldown and then another ability with a much longer cooldown and no
+charges, the second ability will use the cooldown properties of the first ability until/unless the first ability finishes
+charging and is cleared from the system.  You should generally only have multiple RootInteractions share a cooldown id
+if they have the same configuration.
+
+The interactions below interact with the cooldown system to allow you to manipulate cooldowns via the interaction system. By
+using these interactions, you can have several interaction chains with different cooldown configurations share cooldowns
+that are checked and activated as part of the interaction chain itself, or have some components of an interaction change
+use a second cooldown separate from the main one.
+
+### CooldownCondition
+
+**CooldownCondition Fields**
+
+This interaction will fail if the specified cooldown id is on cooldown for the User entity.  This interaction will only
+function for players- the interaction will always succeed for NPCs.  In order for this interaction to succeed, the
+cooldown, if any, must have expired and at least one charge, if any, must have filled.
+
+| Field Name | Type     | Required? | Notes                     |
+| ---------- | -------- | --------- | ------------------------- |
+| Id         | `String` | **Yes**   | The cooldown id to check. |
+
+### IncrementCooldown
+
+**IncrementCooldown Fields**
+
+This interaction will modify a cooldown that is currently active on the User entity, allowing charges and remaining
+cooldown to be modified.
+Despite its name, this interaction can be used to reduce a cooldown as well as increase it. If the cooldown is not
+currently active, this interaction will have no effect. The interaction has no special failure conditions.
+
+| Field Name        | Type                        | Required? | Notes                                                                                                                                                                                                                                                                                     |
+| ----------------- | --------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Id                | `String`                    | **No**    | If provided, the cooldown id of the cooldown to be manipulated. If not provided, the cooldown id of the current chain's RootInteraction will be used.                                                                                                                                     |
+| Time              | `Float`<br />(Default: 0.0) | **No**    | The amount to increase the remaining cooldown by. Can be negative. The remaining cooldown time will not be reduced below zero or increased above the maximum cooldown time.                                                                                                               |
+| ChargeTime        | `Float`<br />(Default: 0.0) | **No**    | The amount to increase the remaining time until the next charge is filled by. Can be negative. The remaining charge time cannot be reduced below zero or increased above the maximum cooldown time. **This will not work on abilities that have a maximum of 1 charge, for some reason.** |
+| Charge            | `Integer`<br />(Default: 0) | **No**    | The amount to increase the number of charges by. Can be negative. The number of charges cannot be reduced below 0 or increased above the maximum.                                                                                                                                         |
+| InterruptRecharge | `Boolean`(Default: false)   | **No**    | If true and `Charge` is not 0, will reset the remaining time to the next charge to the maximum value after changing the charge count.                                                                                                                                                     |
+
+### ResetCooldown
+
+This interaction will trigger a cooldown on the User entity with a specified configuration. The charges will be refilled
+but the cooldown will be immediately triggered.  The mechanisms for deciding on the configuration are a little bit complicated.
+You may specify a cooldown configuration via the `Cooldown` field. If you do not include an `Id` field, then the
+interaction chain's RootInteraction will be used for any field not specified in the configuration. If there is an active
+cooldown under the specified `Id` (or under the RootInteraction's cooldown id if none is specified) then the fields
+from that active cooldown will overwrite data in the RootInteraction's cooldown, but not data in your `Cooldown` field.
+
+**ResetCooldown Fields**
+
+| Field Name | Type                  | Required? | Notes                                                        |
+| ---------- | --------------------- | --------- | ------------------------------------------------------------ |
+| Cooldown   | `InteractionCooldown` | **No**    | A cooldown configuration to use for the new, reset cooldown. |
+
+**InteractionCooldown Fields**
+
+| Field Name        | Type                                 | Required? | Notes                                                                                                                                                                                                 |
+| ----------------- | ------------------------------------ | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Id                | `String`                             | **No**    | The cooldown id to use for this cooldown. If not provided, the RootInteraction's cooldown id will be used, if any.                                                                                    |
+| Cooldown          | `Float`<br />(Default: 0.0)          | **No**    | The duration of the cooldown, in seconds.                                                                                                                                                             |
+| Charges           | `Array`<br />(Element Type: `Float`) | **No**    | If provided, a list of how many charges this cooldown can build, and how long each charge takes to build, in seconds.                                                                                 |
+| InterruptRecharge | `Boolean`<br />(Default: false)      | **No**    | If true, the charge time will be reset when the number of charges changes.                                                                                                                            |
+| ClickBypass       | `Boolean`<br />(Default: false)      | **No**    | If true, RootInteractions keyed to this cooldown can still be activated when it is on cooldown provided that the RootInteraction was triggered by a distinct key or mouse button press on the client. |
+
+### TriggerCooldown
+
+This interaction is similar to ResetCooldown, except instead of refilling the cooldown's charges, one charge will be deducted
+as normal.
+
+**TriggerCooldown Fields**
+
+| Field Name | Type                  | Required? | Notes                                                        |
+| ---------- | --------------------- | --------- | ------------------------------------------------------------ |
+| Cooldown   | `InteractionCooldown` | **No**    | A cooldown configuration to use for the new, reset cooldown. |
+
+**InteractionCooldown Fields**
+
+| Field Name        | Type                                 | Required? | Notes                                                                                                                                                                                                 |
+| ----------------- | ------------------------------------ | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Id                | `String`                             | **No**    | The cooldown id to use for this cooldown. If not provided, the RootInteraction's cooldown id will be used, if any.                                                                                    |
+| Cooldown          | `Float`<br />(Default: 0.0)          | **No**    | The duration of the cooldown, in seconds.                                                                                                                                                             |
+| Charges           | `Array`<br />(Element Type: `Float`) | **No**    | If provided, a list of how many charges this cooldown can build, and how long each charge takes to build, in seconds.                                                                                 |
+| InterruptRecharge | `Boolean`<br />(Default: false)      | **No**    | If true, the charge time will be reset when the number of charges changes.                                                                                                                            |
+| ClickBypass       | `Boolean`<br />(Default: false)      | **No**    | If true, RootInteractions keyed to this cooldown can still be activated when it is on cooldown provided that the RootInteraction was triggered by a distinct key or mouse button press on the client. |
+
+## Combo Chains
+
+Hytale additionally comes with a rich "combo chaining" system, which allows several inputs in a row to result in different
+attacks and special moves.  Rather than being attached to the RootInteraction like the cooldown system, these are
+primarily driven by the `Chaining` interaction.
+
+### Chaining
+
+This interaction does not inherit from SimpleInteraction and therefore has no Failed field. Its Next field works differently
+from most interaction types.
+
+Chaining is a type of flow control interaction- each time a Chaining interaction with the same `ChainId` is called, a single
+interaction in the `Next` list is chosen and the others are ignored. The first time the `ChainId` is used, the first
+interaction in the list is chosen, the next time the second, etc. Once the end of the list is reached, the first
+interaction will be chosen again.
+
+Bear in mind: the progress through the Next list is based on the **ChainId**, not the interaction!  That means that two
+different Chaining interactions can share a single combo chain. You could have a pair of daggers that attacks with
+the left when the left mouse button is clicked and with the right when the right mouse button is clicked.  You could give
+both interaction chains a Chaining interaction with the same `ChainId` and three `Next` entries that do a light-light-heavy
+combo.  Each specific hit would occur with either the left or the right knife based on which button you clicked, but
+the combo would be otherwise identical regardless of which you chose.
+
+The Chaining interaction also has a concept called "flags".  It is possible to attach named flags to a `ChainId` by using
+the ChainFlag interaction.  Then, you specify the flag name in Chaining's `Flags` field. If a Flag is active when the
+Chaining interaction is run, the Flag's interaction will be run instead of the appropriate interaction in `Next`.
+Bear in mind: the entity's progress through the `Next` list still advances, the resulting `Next` interaction is just not
+run.  Only one flag can be active at a time.
+
+Lastly, it is possible to cancel the entity's progress through the combo chain and reset them to the first interaction in
+the list. This can be done with the CancelChain interaction, but it will also happen automatically if the player does
+not trigger an interaction with the ChainId for the specified ChainingAllowance.  When either of these happen, all flags will be
+canceled as well.
+
+All of these effects are triggered on the User entity only. Non-players can use the chaining system, but Flags do not currently
+work for non-players.  This interaction has no special failure conditions.
+
+**Chaining Fields**
+
+| Field Name        | Type                                                       | Required? | Notes                                                                                                                                                                                                                       |
+| ----------------- | ---------------------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| ChainId           | `String`                                                   | **No**    | If provided, acts as a key that multiple Chaining interactions can use to share combo chain progress and flags. If not provided, a unique ChainId will be generated for this interaction.                                   |
+| ChainingAllowance | `Double`<br />(Default: 0.0)                               | **No**    | If, at the time this interaction is triggered, it has been this long in seconds since the last time a Chaining interaction with the same ChainId was executed, all state for this ChainId will be cleared before execution. |
+| Next              | `AssetArray`<br />(Element Type: `Interaction`)            | **Yes**   | A list of interactions to cycle between each time this interaction is run.                                                                                                                                                  |
+| Flags             | `Map`<br />(Key Type: `String`, Value Type: `Interaction`) | **No**    | A map of flag names to interactions to run if the flag is active when this interaction executes.                                                                                                                            |
+
+### CancelChain
+
+This interaction resets all progress and flag data on the User entity for the provided `ChainId`.  The next time a Chaining
+interaction is called for the provided `ChainId`, it will begin at the first interaction in the `Next` list. This
+interaction has no special failure conditions.
+
+**CancelChain Fields**
+
+| Field Name | Type     | Required? | Notes                                 |
+| ---------- | -------- | --------- | ------------------------------------- |
+| ChainId    | `String` | **Yes**   | A ChainId whose data should be reset. |
+
+### ChainFlag
+
+This interaction activates a flag on the User entity for the provided `ChainId`, which can be used to change behavior the
+next time a Chaining interaction with this `ChainId` is run. This will overwrite any flag that has
+already been raised. This interaction will have no effect for non-players. This interaction has no special failure
+conditions.
+
+| Field Name | Type     | Required? | Notes                                        |
+| ---------- | -------- | --------- | -------------------------------------------- |
+| ChainId    | `String` | **Yes**   | A ChainId on whom the flag should be raised. |
+| Flag       | `String` | **Yes**   | The name of the flag to raise.               |
+
+## Charging
+
+A unique flow-control interaction that is frequently used is the Charging interaction.  It is a flow-control interaction
+that delays while the input button used to trigger the interaction chain is held.  When it is released (or the interaction
+is forced to end), the interaction chain can continue with a different interaction based on how long the input was held
+for.
+
+These interactions are all related by either being the Charging interaction, or other interaction types that inherit the
+Charging interaction's behavior.
+
+### Charging
+
+This interaction does not inherit from SimpleInteraction and therefore its Next field works different from most interactions.
+This interaction adds its own Failed field which works the same way that SimpleInteraction's does.
+
+This interaction only works properly when its interaction chain was triggered by a client key or button press (or
+NPC-simulated equivalent). This interaction will continue executing for as long as the key or button press is held (with
+some exceptions, covered below) by the User entity.  Like other interactions, it has a `Next` field indicating which interaction to execute
+after this one, but the field is a map from `Float` values to `Interaction` assets. When this interaction ends, either
+due to the input being released or the charge duration completing, this interaction will determine the largest `Float` key that is less
+than the amount of time in seconds that the interaction was executing for.  The Interaction mapped to that key will be
+executed next.
+
+The interaction includes some cancellation conditions that are specific to this interaction. For instance, the interaction
+has a `CancelOnOtherClick` field that matches the field on RootInteraction. If it is active on this interaction but not
+the RootInteraction, then clicking while charging will cancel this interaction (and execute the `Failed` interaction rather
+than any of the `Next` interactions) but otherwise continue the interaction chain.
+
+Another valuable feature Charging has is the `Forks` field.  For input-triggered interactions that are triggered while the
+Charging interaction is executing, you can add an entry for the relevant InteractionType to this field and instead of
+triggering the usual interaction chain based on held item, targeted block, etc. the RootInteraction specified in the
+`Forks` field will be triggered.  This can unlock rich attack modes and behaviors. For instance, having a shield bash attack
+triggered off left click while blocking, or a special attack that triggers when both mouse buttons are pressed at the
+same time.
+
+There are two modes of operation for the Charging interaction. One is to have the ability charge for as long
+as the input is held and only end execution when the entity releases the input.  Bows in the main Hytale game work
+that way.  That is accomplished by setting `AllowIndefiniteHold` to true.  Another mode of operation is to have the
+interaction complete execution when the execution time has surpassed the largest key value in the `Next` field and
+immediately begin executing the Interaction mapped to that key.  Food in the main Hytale game work like this.  It
+is accomplished by setting `AllowIndefiniteHold` to false.
+
+One pitfall to be careful of when setting `AllowIndefiniteHold` to false is the way it interacts with cooldowns.\
+Normally, input-initiated interaction chains start a 0.35s cooldown on the triggered RootInteraction that prevents
+holding the mouse button from immediately spamming a new interaction when the first one completes.  However, if the
+duration of a Charging interaction is longer than 0.35s, then the cooldown will have already completed when the
+interaction chain finishes, which will often result in a new execution beginning immediately before the player can
+stop pressing the mouse button.  One solution for this problem is to add a `Simple` interaction to the end of your
+interaction chain with a `RunTime` of 0.35s to simulate the cooldown.  Alternatively, you can add a longer cooldown
+(the maximum duration of your Charging interaction plus 0.35s) to the RootInteraction. However, the longer cooldown is
+not always desirable, as the interaction may have ended prematurely, resulting in an unusually long lockout between
+executions.
+
+**Charging Fields**
+
+| Field Name                         | Type                                                                    | Required? | Notes                                                                                                                                                                                                                                                                                                                                                                                       |
+| ---------------------------------- | ----------------------------------------------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| FailOnDamage                       | `Boolean`<br />(Default: false)                                         | **No**    | If true, this interaction will fail and end immediately if the User entity takes any damage while it is executing.                                                                                                                                                                                                                                                                          |
+| CancelOnOtherClick                 | `Boolean`<br />(Default: true)                                          | **No**    | If true, this interaction will fail and end immediately if the User entity sends another button or key press while it is executing.                                                                                                                                                                                                                                                         |
+| Forks                              | `Map`<br />(Key Type: `InteractionType`, Value Type: `RootInteraction`) | **No**    | A map of InteractionType to RootInteraction. If entity input triggers the InteractionType while this interaction is executing, the mapped RootInteraction will be forked into its own interaction chain. This will happen instead of the usual handling for that InteractionType.  This fork will occur even if `CancelOnOtherClick` is set to true.                                        |
+| Failed                             | `Asset`<br />(Asset Type: `Interaction`)                                | **No**    | After this Interaction has finished, "Failed" will be executed if this Interaction failed.                                                                                                                                                                                                                                                                                                  |
+| AllowIndefiniteHold                | `Boolean`<br />(Default: false)                                         | **No**    | If true, this interaction will continue executing for as long as the User entity continues to hold the input. If false, execution will end as soon as the execution time in seconds reaches the largest key value in the `Next` map.                                                                                                                                                        |
+| DisplayProgress                    | `Boolean`<br />(Default: true)                                          | **No**    | If true, players executing this interaction will see a progress bar will be displayed below their cursor indicating how close to reaching the highest key value in `Next` they are.                                                                                                                                                                                                         |
+| Next                               | `Map`<br />(Key Type: `Float`, Value Type: `Interaction`)               | **No**    | A map from `Float` to `Interaction`.  When this interaction successfully finishes executing (either because the input was released or because the maximum duration was reached), this interaction will find the `Float` value with the largest duration in seconds that is less than the amount of time this interaction executed for. That key's mapped Interaction will then be executed. |
+| MouseSensitivityAdjustmentTarget   | `Float`<br />(Default: 1.0)                                             | **No**    | While charging, this mouse sensitivity multiplier will gradually be applied.                                                                                                                                                                                                                                                                                                                |
+| MouseSensitivityAdjustmentDuration | `Float`<br />(Default: 1.0)                                             | **No**    | Duration in seconds. After this many seconds, `MouseSensitivityAdjustmentTarget` will be fully applied to the mouse sensitivity.                                                                                                                                                                                                                                                            |
+| Delay                              | `ChargingDelay`                                                         | **No**    | Settings that allow charging progress to be pushed back when the User entity takes damage.                                                                                                                                                                                                                                                                                                  |
+
+**ChargingDelay Fields**
+
+| Field Name    | Type                        | Required? | Notes                                                                                                                                                                                                                                                                     |
+| ------------- | --------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| MinHealth     | `Float`<br />(Default: 0.0) | **No**    | Damage taken as a percentage of entity health (0.0-1.0). If a hit deals less than this much damage, no pushback will be applied.  If a hit deals exactly this much damage, `MinDelay` seconds worth of pushback will be applied.                                          |
+| MaxHealth     | `Float`<br />(Default: 0.0) | **No**    | Damage taken as a percentage of entity health (0.0-1.0). If a hit deals at least this much damage, `MaxDelay` seconds worth of pushback will be applied.                                                                                                                  |
+| MinDelay      | `Float`<br />(Default: 0)   | **No**    | The amount of pushback, in seconds, to apply if the entity takes a hit that deals `MinHealth` damage. The amount of pushback applied by a hit is a gradiant between `MinDelay` and `MaxDelay` based on the amount of damage between `MinHealth` and `MaxHealth`.          |
+| MaxDelay      | `Float`<br />(Default: 0)   | **No**    | The amount of pushback, in seconds, to apply if the entity takes a hit that deals at least `MaxHealth` damage. The amount of pushback applied by a hit is a gradiant between `MinDelay` and `MaxDelay` based on the amount of damage between `MinHealth` and `MaxHealth`. |
+| MaxTotalDelay | `Float`<br />(Deault: 0)    | **No**    | The maximum amount of pushback the entity can receive over the course of a single charge, regardless of how many times they are hit.                                                                                                                                      |
+
+**InteractionType Values**
+
+- `Primary`
+- `Secondary`
+- `Ability1`
+- `Ability2`
+- `Ability3`
+- `Use`
+- `Pick`
+- `Pickup`
+- `CollisionEnter`
+- `CollisionLeave`
+- `Collision`
+- `EntityStatEffect`
+- `SwapTo`
+- `SwapFrom`
+- `Death`
+- `Wielding`
+- `ProjectileSpawn`
+- `ProjectileHit`
+- `ProjectileMiss`
+- `ProjectileBounce`
+- `Held`
+- `HeldOffhand`
+- `Equipped`
+- `Dodge`
+- `GameModeSwap`
+
+### Wielding
+
+This interaction is inherited from Charging rather than SimpleInteraction.  However, its `Failed` and `Next` fields function
+identically to SimpleInteraction.  It does not inherit all fields from Charging, so be sure to pay close attention to
+the field list below.
+
+This interaction drives most blocking behavior in the game. While this interaction is executing, attacks made against
+the Owner entity will (conditionally) trigger effects defined in this interaction.  Unlike the Charging interaction,
+this interaction can always execute indefinitely and will only end when it fails or when the input is released.
+
+One option available in Wielding is `AngledWielding`, which allows damage and knockback modifiers to only be applied
+depending on the direction the attack against the Owner entity is coming from.  The AngledWielding type has a
+field `Angle` which determines which direction the protection points relative to the player (0 is the player's
+front), and `AngleDistance` which determines how wide the cone of protection extends around the player.  Block effects
+from this interaction (such as `BlockedEffects`, `BlockedInteractions`, and `StaminaCost`) will only apply if
+the DamageCause matches `DamageModifiers` OR if the DamageCause matches `AngledWielding.DamageModifiers` and
+the source of the damage matches `Angle` and `AngleDistance`.  It is possible for damage and knockback multipliers
+specified on both this interaction's modifier fields and `AngledWielding`'s modifier fields to stack, if both
+have entries for the same DamageCause.
+
+This interaction will only have an effect on damage taken by one of the DamageCause entries in `DamageModifiers` or
+`AngledWielding.DamageModifiers`.  If a DamageCause is in `DamageModifiers`, then the block effect will be triggered
+and the damage modifier applied regardless of what direction the Owner entity is attacked from.  If a DamageCause is in
+`AngledWielding.DamageModifiers`, then the damage modifier is only applied if the
+
+\*\* Wielding Fields\*\*
+
+| Field Name          | Type                                                                    | Required? | Notes                                                                                                                                                                                                                                                                                                                                                                                                      |
+| ------------------- | ----------------------------------------------------------------------- | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| FailOnDamage        | `Boolean`<br />(Default: false)                                         | **No**    | If true, this interaction will fail and end immediately if the User entity takes any damage while it is executing.                                                                                                                                                                                                                                                                                         |
+| CancelOnOtherClick  | `Boolean`<br />(Default: true)                                          | **No**    | If true, this interaction will fail and end immediately if the User entity sends another button or key press while it is executing.                                                                                                                                                                                                                                                                        |
+| Forks               | `Map`<br />(Key Type: `InteractionType`, Value Type: `RootInteraction`) | **No**    | A map of InteractionType to RootInteraction. If entity input triggers the InteractionType while this interaction is executing, the mapped RootInteraction will be forked into its own interaction chain. This will happen instead of the usual handling for that InteractionType.  This fork will occur even if `CancelOnOtherClick` is set to true (after which this interaction chain will be canceled). |
+| Next                | `Asset`<br />(Asset Type: `Interaction`)                                | **No**    | After this interaction has finished, "Next" will be executed if this interaction did not fail.                                                                                                                                                                                                                                                                                                             |
+| Failed              | `Asset`<br />(Asset Type: `Interaction`)                                | **No**    | After this interaction has finished, "Failed" will be executed if this interaction failed.                                                                                                                                                                                                                                                                                                                 |
+| DamageModifiers     | `Map`<br />(Key Type: `DamageCause`, Value Type: `Float`)               | **No**    | A map from DamageCause to Float, where the Float is multiplied against any damage received from the mapped DamageCause while this interaction is executing.                                                                                                                                                                                                                                                |
+| KnockbackModifiers  | `Map`<br />(Key Type: `DamageCause`, Value Type: `Float`)               | **No**    | A map from DamageCause to Float, where the Float is multiplied against any knockback force received from the mapped DamageCause while this interaction is executing.                                                                                                                                                                                                                                       |
+| AngledWielding      | `AngledWielding`                                                        | **No**    | Configuration to only trigger block effects from certain angles.                                                                                                                                                                                                                                                                                                                                           |
+| StaminaCost         | `StaminaCost`                                                           | **No**    | If the Owner entity receives damage that matches `DamageModifiers` or `AngledWielding` while this interaction is executing, then the entity's stamina will be deducted according to this configuration.                                                                                                                                                                                                    |
+| BlockedEffects      | `DamageEffects`                                                         | **No**    | If the Owner entity receives damage that matches `DamageModifiers` or `AngledWielding` while this interaction is executing, then these effects will be applied to the instance of damage.                                                                                                                                                                                                                  |
+| BlockedInteractions | `Asset`<br />(Asset Type: `RootInteraction`)                            | **No**    | If the Owner entity receives damage that matches `DamageModifiers` or `AngledWielding` while this interaction is executing, then this RootInteraction will be launched as a brand new interaction chain with the Owner entity as both Owner and User, and the attacker as the Target entity.  This new interaction chain is, notably, brand new, **not** forked from the current one.                      |
+
+**AngledWielding Fields**
+
+| Field Name         | Type                                                      | Required? | Notes                                                                                                                                                                                                            |
+| ------------------ | --------------------------------------------------------- | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Angle              | `Float`<br />(Default: 0.0)                               | **No**    | Angle in degrees relative to the Owner entity where the angled protection is centered. 0.0 means pointed towards the front of the Owner entity.                                                                  |
+| AngleDistance      | `Float`<br />(Default: 0.0)                               | **No**    | Angle in degrees indicating how wide the cone of protection is.                                                                                                                                                  |
+| DamageModifiers    | `Map`<br />(Key Type: `DamageCause`, Value Type: `Float`) | **No**    | A map from DamageCause to Float, where the Float is multiplied against any damage received from the mapped DamageCause received from within the cone of protection while this interaction is executing.          |
+| KnockbackModifiers | `Map`<br />(Key Type: `DamageCause`, Value Type: `Float`) | **No**    | A map from DamageCause to Float, where the Float is multiplied against any knockback force received from the mapped DamageCause received from within the cone of protection while this interaction is executing. |
+
+**StaminaCost Fields**
+
+| Field Name | Type                                             | Required? | Notes                                                                                                                                                                                                                                                |
+| ---------- | ------------------------------------------------ | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| CostType   | `CostType`<br />(Default: `MaxHealthPercentage`) | **No**    | How to calculate stamina consumed by blocking from the raw pre-block damage. If `Damage`, then the stamina consumed will be `rawDamage / Value`. If `MaxHealthPercentage`, then the stamina consumed will be `rawDamage / (EntityMaxHealth * Value)` |
+| Value      | `Float`<br />(Default: 0.04)                     | **No**    | The value to use in the `CostType` formula.                                                                                                                                                                                                          |
+
+**DamageEffects Fields**
+
+| Field Name             | Type                                         | Required? | Notes                                                                           |
+| ---------------------- | -------------------------------------------- | --------- | ------------------------------------------------------------------------------- |
+| ModelParticles         | `Array`<br />(Element Type: `ModelParticle`) | **No**    | Particle systems to trigger in the first-person view.                           |
+| WorldParticles         | `Array`<br />(Element Type: `WorldParticle`) | **No**    | Particle systems to trigger in the third-person view.                           |
+| LocalSoundEventId      | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | 2D sound to play locally to the attacking entity if they are a player.          |
+| WorldSoundEventId      | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | Sound to play in the world at the Owner entity's location.                      |
+| PlayerSoundEventId     | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | 2D sound to play locally to the Owner entity if they are a player.              |
+| ViewDistance           | `Double`<br />(Default: 75.0)                | **No**    | Distance at which these effects should play for other players.                  |
+| Knockback              | `Knockback`                                  | **No**    | The properties of the knockback that will be applied.                           |
+| CameraEffect           | `Asset`<br />(Asset Type: `CameraEffect`)    | **No**    | CameraEffect to briefly apply locally to the Owner entity if they are a player. |
+| StaminaDrainMultiplier | `Float`<br />(Default: 1.0)                  | **No**    | This multiplier is applied to the `StaminaCost`, if any.                        |
+
+**Knockback Fields**
+
+| Field Name     | Type                                       | Required? | Notes                                                                                                                      |
+| -------------- | ------------------------------------------ | --------- | -------------------------------------------------------------------------------------------------------------------------- |
+| Type           | `String`                                   | **No**    | If provided, specifies a type of knockback to use. Each knockback type may come with additional fields.                    |
+| Force          | `Double`<br />(Default: 0.0)               | **No**    | The amount of force to apply to the Owner entity.                                                                          |
+| Duration       | `Double`<br />(Default: 0.0)               | **No**    | If 0.0, apply the force as a single impulse.  If more, continuously apply the force over a period of time.                 |
+| VelocityType   | `ChangeVelocityType`<br />(Default: `Add`) | **No**    | How to apply the force, either adding it to the entity's current velocity, or setting the velocity to the knockback force. |
+| VelocityConfig | `VelocityConfig`                           | **No**    | Characteristics of friction as the Owner entity is thrown by this knockback.                                               |
+
+**Knockback Type: Force**
+
+Apply the calculated knockback force along the provided direction.
+
+| Field Name | Type                         | Required? | Notes                                                                                |
+| ---------- | ---------------------------- | --------- | ------------------------------------------------------------------------------------ |
+| Direction  | `Vector3`<br />(Default: Up) | **No**    | Which direction the player should be flung, relative to the direction of the attack. |
+
+**Knockback Type: Point**
+
+Apply the calculated knockback force laterally along the XZ plane, plus provided Y velocity.
+
+| Field Name | Type                        | Required? | Notes                                                                                                   |
+| ---------- | --------------------------- | --------- | ------------------------------------------------------------------------------------------------------- |
+| OffsetX    | `Integer`<br />(Default: 0) | **No**    | Offset the source position of the knockback left or right perpendicular to the direction of the attack. |
+| OffsetZ    | `Integer`<br />(Default: 0) | **No**    | Offset the source position of the knockback, forward or backward along the directon of the attack.      |
+| RotateY    | `Integer`<br />(Default: 0) | **No**    | Rotate the knockback direction around the Y axis, where 0 is the default attack direction.              |
+| VelocityY  | `Float`<br />(Default: 0.0) | **No**    | Add vertical velocity to the knockback force after the direction and force has been calculated.         |
+
+**Knockback Type: Directional**
+
+Apply the calculated knockback force along the attack direction, removing any vertical component and replacing it with a provided Y velocity.
+
+| Field Name | Type                      | Required? | Notes                                                                                                                                            |
+| ---------- | ------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------ |
+| RelativeX  | `Float`<br />(Default: 0) | **No**    | Apply additional force left or right perpendicular to the direction of the attack. The additional force is multiplied by the knockback strength. |
+| RelativeZ  | `Float`<br />(Default: 0) | **No**    | Apply additional force forward or backward along the attack direction. The additional force is multiplied by the knockback strength.             |
+| VelocityY  | `Float`<br />(Default: 0) | **No**    | Replace the vertical velocity of the knockback with this value.  This value is not multiplied by knockback strength.                             |
+
+**VelocityConfig Fields**
+
+| Field Name          | Type                                              | Required? | Notes                                                                                                                                                                                           |
+| ------------------- | ------------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| GroundResistance    | `Float`<br />(Default: 0.82)                      | **No**    | The minimum amount of friction applied when the entity is in contact with the ground.  1.0 = no friction, 0.0 = total friction                                                                  |
+| GroundResistanceMax | `Float`<br />(Default: 0.0)                       | **No**    | The maximum amount of friction applied when the entity is in contact with the ground.  1.0 = no friction, 0.0 = total friction                                                                  |
+| AirResistance       | `Float`<br />(Default: 0.96)                      | **No**    | The minimum amount of friction applied when the entity is in the air. 1.0 = no friction, 0.0 = total friction                                                                                   |
+| AirResistanceMax    | `Float`<br />(Default: 0.0)                       | **No**    | The maximum amount of friction applied when the entity is in the air. 1.0 = no friction, 0.0 = total friction                                                                                   |
+| Threshold           | `Float`<br />(Default: 1.0)                       | **No**    | The speed at which the maximum amount of friction will be applied to the entity. The amount of friction applied will increase from minimum to maximum as the entity moves from 0 to this speed. |
+| Style               | `VelocityThresholdStyle`<br />(Default: `Linear`) | **No**    | The curve that friction follows as the entity's speed increases toward the `Threshold`.                                                                                                         |
+
+**CostType Values**
+
+- `MaxHealthPercentage`
+- `Damage`
+
+**ChangeVelocityType Values**
+
+- `Add`
+- `Set`
+
+**VelocityThresholdStyle Values**
+
+- `Linear`
+- `Exp`
+
+## Blocks
+
+These are interaction types meant to reason about and modify blocks in the world.  The most important concept unique
+to these interactions is the Block Target.  Like the Entity Target, it is mutable and can come from many places.
+However, for interaction chains initiated by the client, the block target will initially be the block that the player's cursor was
+over, if any.
+
+Additionally, for interaction chains initiated by the client, the client will send along which face of the block is targeted,
+which is used by a few block-related interactions.
+It is left up to each interaction type that cares about block faces as to how to handle this behavior for simulated input
+(i.e. NPCs initiating chains that are normally initated by the client).  At the time of this writing, all block-related
+interactions choose the top face where relevant in simulated input.
+
+### BlockCondition
+
+This interaction has a field `Matchers` which specifies certain conditions, such as block type, state, etc.  This
+interaction fails if the current target block does not match all of them.
+
+**BlockCondition Fields**
+
+| Field Name       | Type                                        | Required? | Notes                                                                                                                                                                                                                                                                                                                                   |
+| ---------------- | ------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false)             | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction.                                                                                                                                                                                                       |
+| Matchers         | `Array`<br />(Element Type: `BlockMatcher`) | **Yes**   | A list of conditions that the target block must match or this condition will fail.<br />**Note: This field is technically not required but there is a bug that makes it dangerous to not provide at the time of this writing.**<br />**Note: If no conditions are added to this array, the interaction will fail, counterintuitively.** |
+
+**BlockMatcher Fields**
+
+| Field Name | Type                       | Required? | Notes                                                                          |
+| ---------- | -------------------------- | --------- | ------------------------------------------------------------------------------ |
+| Block      | `BlockIdMatcher`           | **No**    | If provided, requires the block itself match some set of conditions.           |
+| Face       | `BlockFace`                | **No**    | If provided and not 'None', requires a specific block face be targeted.        |
+| StaticFace | `Boolean` (Default: false) | **No**    | If false, the face condition will be adjusted by the block's current rotation. |
+
+**BlockFace Values**
+
+- `Up`
+- `Down`
+- `North`
+- `South`
+- `East`
+- `West`
+- `None`
+
+**BlockIdMatcher Fields**
+
+| Field Name | Type                                   | Required? | Notes                                                                      |
+| ---------- | -------------------------------------- | --------- | -------------------------------------------------------------------------- |
+| Id         | `Asset`<br />(Asset Type: `BlockType`) | **No**    | If provided, the block must match the specified `BlockType`.               |
+| State      | `String`                               | **No**    | If provided, the block's current state must match the provided state name. |
+| Tag        | `String`                               | **No**    | If provided, the block type's asset tags must contain the provided tag.    |
+
+### DestroyCondition
+
+This interaction fails if the current User entity cannot destroy the current target blcok.
+
+**DestroyCondition Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+
+### PlacementCountCondition
+
+This interaction accepts the name of a BlockType that has the TrackedPlacement BlockEntity. The interaction will fail if the number of
+blocks of the provided BlockType in the world do not match the provided condition.
+
+**PlacementCountCondition Fields**
+
+| Field Name | Type                           | Required? | Notes                                                                                                                                                                                                                                                           |
+| ---------- | ------------------------------ | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Block      | `String`                       | **Yes**   | The BlockType to examine. The number of instances of the BlockType in the world will be compared to Value.<br />**Note: The specified BlockType must have the TrackedPlacement BlockEntity. Otherwise, the number of blocks in the world will always be zero.** |
+| Value      | `Integer`<br />(Default: 0)    | **No**    | The value to compare the number of blocks in the world with.                                                                                                                                                                                                    |
+| LessThan   | \`Boolean<br />(Default: true) | **No**    | If true, the interaction will fail if the number of blocks in the world is greater than or equal to Value. If false, the interaction will fail if the number of blocks in the world is less than or equal to Value.                                             |
+
+### BreakBlock
+
+This interaction attempts to break the target block while acting as the User entity. The User entity must be a player. It
+is not guaranteed to work, depending on world settings and the User entity's current state, it may not work.  If it
+fails, it will fail the interaction under some circumstances, but not others.
+
+**Note: In particular, if `Harvest`=false and the player is in Survival mode, the player will simply execute a damage operation
+against the block. Even when the Tool field is specified, the player's currently-held item can impact the results in unintuitive
+ways.**
+
+This interaction will fail if there is no block target, if `Harvest`=true and the
+block is not harvestable, or if the world settings prevent the Harvest/Break operation.
+It will generally not fail otherwise, even if the block was not broken or damaged.
+The block will generally break every time if `Harvest`=true or the player is in
+Creative mode.
+
+**BreakBlock Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                                                                                                                                                                                                  |
+| ---------------- | ------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction.                                                                                                                                                                      |
+| Harvest          | `Boolean` (Default: false)      | **No**    | If true, harvest the block and deposit the drops in the player's inventory. This operation will generally always succeed.  If false, this interaction will effectively perform whatever action would have occurred if the player had left-clicked the block.                                           |
+| Tool             | `String`                        | **No**    | If `Harvest`=true, the player is in Survival mode, and this field is provided, then the break operation will be performed as though with this tool type.<br />**This field mostly doesn't work.  Your held item will be used for most block damage calculations regardless of this field's contents.** |
+| MatchTool        | `Boolean` (Default: false)      | **No**    | If true, `Harvest`=true, the player is in Survival mode, and `Tool` is provided, block breaking will be prevented unless `Tool` is a valid gathering tool for the target block. The interaction will not be failed, even if block breaking is prevented in this manner.                                |
+
+### ChangeBlock
+
+This interaction requires a mapping from one or more current BlockTypes to one or more target BlockTypes.  If the
+target block is one of the key BlockTypes, then it will be changed to the mapped target BlockType.  If the current
+BlockType of the target block does not appear as a key in the Changes field, then this interaction fails.
+
+**ChangeBlock Fields**
+
+| Field Name        | Type                                                        | Required? | Notes                                                                                                                             |
+| ----------------- | ----------------------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget  | `Boolean`<br />(Default: false)                             | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+| Changes           | `Map`<br />(Key Type: `BlockType`, Value Type: `BlockType`) | **No**    | A list of potential block type changes, with each entry having a current and new BlockType id.                                    |
+| WorldSoundEventId | `Asset`<br />(Asset Type: `SoundEvent`)                     | **No**    | If provided, this SoundEvent is played in the world at the position of the block if the block successfully changes.               |
+| RequireNotBroken  | `Boolean`<br />(Default: false)                             | **No**    | If true, this interaction will fail if the player's held item is broken (durability 0), and the block change will not take place. |
+
+### ChangeState
+
+This interaction requires a mapping from one or more current block state names to one or more state names. If the
+target block is in one of the key block states, then it will be changed to the mapped target blocks tate. If the
+current block state of the target block does nto appear as a key in the Changes field, then this interaction fails.
+
+All blocks start out with a null state by default.  This null state can be referenced by the key "default" and the block
+can be returned to that state with the value "default".
+
+**ChangeState Fields**
+
+| Field Name       | Type                                                  | Required? | Notes                                                                                                                                          |
+| ---------------- | ----------------------------------------------------- | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false)                       | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction.              |
+| Changes          | `Map`<br />(Key Type: `String`, Value Type: `String`) | **No**    | A list of potential block state changes, with each entry having a current and new state name.                                                  |
+| UpdateBlockState | `Boolean`<br />(Default: false)                       | **No**    | If true, performs a full refresh of the block's BlockEntity component and notifies nearby players as though a full block type change occurred. |
+
+### CycleBlockGroup
+
+This interaction will attempt to change the target block to the next block type in one of the BlockGroups it belongs to.
+If the block type belongs to multiple BlockGroups, which one is used is effectively arbitrary. The User entity must be
+a player. If the block cannot be changed for any reason (entity not a player, no block target, block does not belong
+to a BlockGroup, etc.). If the block is the only entry in the BlockGroup, this interaction will succeed and the block
+will be considered changed despite nothing happening.  Unlike most other block-changing interactions, this one will
+fail if the world settings prevent players from breaking blocks.
+
+**This interaction always reduces the player's held item's durability by a single 'hit' worth of damage if the block
+changes. There is no way to prevent it. The block type will change and the interaction will succeed even if the player's
+held item is broken, however.**
+
+**CycleBlockGroup Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+
+### DestroyBlock
+
+This interaction destroys the target block without dropping anything.  It will successfully destroy the block if the
+target block exists and this interaction has no failure conditions.
+
+**This interaction has no additional fields.**
+
+### PickBlock
+
+This interaction is effectively equivalent to using the middle mouse button in creative mode. In survival mode, the
+block's item will be moved to the user's current active hotbar slot if it is in the player's inventory.  This
+interaction is performed entirely on the client and cannot be performed by non-players.  It is unclear if this
+interaction has failure conditions.
+
+**PickBlock Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+
+### PlaceBlock
+
+This interaction is effectively identical to a right clicking while holding a block in their hand, with some
+additional options. For one, it can be executed with any LivingEntity as the User entity. For another, it has some
+useful fields.  For the most part, though, it follows the same behaviors and rules as any ordinary block placement
+by a player.
+
+It's not clear under what circumstances this interaction can fail. The server will not fail the interaction under any
+special circumstances (including when there is no target block, or when `BlockTypeToPlace` is not provided and the
+LivingEntity is not holding a block). However, the client is very involved with the function of this interaction and
+its behavior is unknown.
+
+**PlaceBlock Fields**
+
+| Field Name         | Type                                   | Required? | Notes                                                                                                                                                                                                                                                                                                                                                           |
+| ------------------ | -------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| BlockTypeToPlace   | `Asset`<br />(Asset Type: `BlockType`) | **No**    | If provided, the block placed by this interaction will be the specified BlockType. If not provided, the User entity's held item will be used, instead, if it is a block.                                                                                                                                                                                        |
+| RemoveItemInHand   | `Boolean`<br />(Default: True)         | **No**    | If true and the User entity is not a player in Creative mode, the item in the player's hand must match the block being placed and one quantity will be removed for each block placed. If the item does not match, the block cannot be placed.  If false, the player's hand item is ignored entirely.\*\*                                                        |
+| AllowDragPlacement | `Boolean`<br />(Default: True)         | **No**    | If true and the interaction was triggered on the client by a player, then the player can hold the input that was used to activate this interaction chain and move the mouse around in order to execute this interaction repeatedly and place several blocks. The interaction chain will not move onto the next interaction until the player releases the input. |
+
+### RunOnBlockTypes
+
+This interaction retrieves all blocks within a provided radius of the User entity. For each block that matches any of
+the provided BlockSets, a new interaction chain will be forked that uses the matching block as the target block.
+This interaction will continue executing until all forked interaction chains have completed.  The interaction will fail if no
+blocks within the radius match the provided BlockSets or if all of the forked interaction chains fail.
+
+**RunOnBlockTypes Fields**
+
+| Field Name   | Type                                         | Required?        | Notes                                                                                                                                                                                                                                                                                      |
+| ------------ | -------------------------------------------- | ---------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| Range        | `Integer`                                    | **Yes**          | The spherical radius around the User entity to search for blocks. Must be at least 1.                                                                                                                                                                                                      |
+| BlockSets    | `AssetArray`<br />(Element Type: `BlockSet`) | **No**           | A list of BlockSets to match nearby blocks again. Only blocks that match any of the BlockSets will have interaction chains forked for them.                                                                                                                                                |
+| MaxCount     | `Integer`                                    | **Yes**          | The maximum number of blocks that will be located with the search. Further blocks will be ignored. If there are more matching blocks within the radius than this number, the specific set of blocks that will be found is completely arbitrary and may change from execution to execution. |
+| Interactions | `Asset`<br />(Asset Type: `RootInteraction`) | **No, but yes.** | The RootInteraction that will be forked for each matching block.  This interaction will not fail to validate if it is missing, but every execution of this interaction will fail.                                                                                                          |
+
+### UseBlock
+
+If the target block has an interaction for this interaction chain's interaction type, execute it immediately as part of
+this interaction chain. The execution will be wrapped in UseBlockEvent.Pre and UseBlockEvent.Post events, and cancellations
+of the UserBlockEvent.Pre event are respected. The User entity is considered the triggering entity for both events.
+
+If the target block does not have an interaction for this interaction chain's interaction type, this interaction fails.
+
+**This interaction has no additional fields.**
+
+## Items
+
+These are interactions intended to interface with an entity's inventory. There is no concept of an "item target",
+unfortunately, so these generally either interact with the entity's held item or the entity's inventory at a high level.
+
+### AddItem
+
+Adds a specified quantity of a specified item to the User entity's inventory, preferring to add it to the
+entity's hotbar where possible. This interaction will have no effect on User entities that are not LivingEntities.
+This interaction has no failure states.
+
+**Note: This interaction has a bug in its field validators that will cause interactions that reference items declared
+in the same mod to fail validation on startup.  Additionally, this interaction has a bug that will cause it to
+fail and have no effect if the User entity has no block target. Use ModifyInventory instead.**
+
+**AddItem Fields**
+
+| Field Name       | Type                              | Required? | Notes                                                                                                                             |
+| ---------------- | --------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false)   | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+| ItemId           | `Asset`<br />(Asset Type: `Item`) | **Yes**   | The item id of the item to add to the player's inventory.                                                                         |
+| Quantity         | `Integer`<br />(Default: 0)       | **No**    | The quantity of the item to add to the player's inventory.                                                                        |
+
+### CheckUniqueItemUsage
+
+This interaction will check whether it has run once for the User entity with their currently-held item before. If it hasn't,
+it will succeed. If it has, it will fail. It will also fail if the User entity is not a player. The interaction will record
+the item id of the User entity's currently-held item on success, ensuring it cannot be successfully run with that player
+and item id combination again.
+
+**This interaction has no additional fields.**
+
+### ChangeActiveSlot
+
+This interaction does not inherit from SimpleInteraction and therefore has no Next or Failed fields.  The `CancelOnItemChange`
+field is ignored for this interaction and is always treated as false. This interaction will set the User entity's currently-
+active hotbar slot to the specified slot index. If none is specified, the interaction chain's target slot will be used,
+if any. Otherwise, slot 0 will be used.  If a slot is specified and it is already active, then this interaction will
+have no effect, but if no slot is specified and the interaction chain's target slot is already active, the logic in
+the next paragraph will still be executed. This interaction will also have no effect if the User entity is not a
+LivingEntity.
+
+Once the slot has changed, a new SwapTo interaction chain will be forked off for the selected slot.
+If a target slot was specified, then the interaction chain's current target slot will be set to the specified slot, as will
+the forked SwapTo interaction chain. If this interaction chain was initiated by a player swapping an item into or out of
+an occupied active hotbar slot, then the swap will be executed after the slot is changed and before the SwapTo
+interaction is forked. Not running this interaction in the resulting SwapFrom interaction chain is a way for the server
+to cancel players performing these sorts of swap interactions. The default behavior for these swap interactions is that
+the SwapFrom interaction chain will be initiated with the currently-active-slot as the target slot. As a result, the
+target slot will usually not change when this interaction runs, it merely exists as a signal for the server to continue the
+item swap.
+
+**ChangeActiveSlot Fields**
+
+| Field Name | Type      | Required? | Notes                                                                                                                                                                                                     |
+| ---------- | --------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| TargetSlot | `Integer` | **No**    | If not provided, indicates the slot the player's active hotbar slot should be changed to.  Otherwise, the interaction chain's target slot will be used (which is usually the already-active hotbar slot). |
+
+### EquipItem
+
+This interaction will equip the User entity's currently-held item into the appropriate armor slot, if it is armor. The
+interaction will fail if the item is armor but it cannot be equipped for some reason. The interaction will succeed but
+take no action if the User entity cannot equip armor or if the item is not armor.
+
+**This interaction has no additional fields.**
+
+### IncreaseBackpackCapacity
+
+This interaction will increase the User entity's backpack size by the provided amount.  **It will additionally remove one
+quantity from the player's currently-held item. There is no way to prevent this.**  This interaction will have no effect
+if the User entity is not a player.  This interaction has no special failure conditions, even if the User entity
+is not a player, or the player is not currently holding an item.
+
+| Field Name | Type                        | Required? | Notes                                                                                   |
+| ---------- | --------------------------- | --------- | --------------------------------------------------------------------------------------- |
+| Capacity   | `Integer`<br />(Default: 1) | **No**    | The additional backpack capacity to add to the player. **Must be between 1 and 32767.** |
+
+### ModifyInventory
+
+This interaction attempts to perform one or more inventory-modifying actions against the User entity. The User entity must
+be a player. If they are not, no actions will be performed, but the interaction will not fail. Any item removals performed
+by this interaction, either as a result of `ItemToRemove` or `AdjustHeldItemQuantity`, are both atomic (meaning the entire
+quantity must be removed, or none) and required (meaning that the interaction will fail and no further actions taken if
+the removal fails for any reason).  Item additions performed by this interaction, either as a result of `ItemToAdd` or
+`AdjustHeldItemQuantity` will drop excess items on the ground near the player if necesary and continue on.
+
+This interaction first executes the item removal in `ItemToRemove`, if any, then adjusts the held item as specified by
+`AdjustHeldItemQuantity`, if provided, then executes the item addition in `ItemToAdd`, if any, and then finally executes
+the damage/healing of the held item in `AdjustHeldItemDurability`, if provided.
+
+**ModifyDurability Fields**
+
+| Field Name               | Type                            | Required? | Notes                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
+| ------------------------ | ------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| RequiredGameMode         | `GameMode`                      | **No**    | If provided, only execute the inventory-modifying actions if the player is in the provided GameMode. The interaction will not fail if the GameMode doesn't match.                                                                                                                                                                                                                                                                                                                                                                               |
+| ItemToRemove             | `ItemStack`                     | **No**    | If provided, a matching item will be removed in the provided quantity. If there is no matching item in the player inventory in the required quantity, then the interaction will fail and further actions will not be executed.                                                                                                                                                                                                                                                                                                                  |
+| AdjustHeldItemQuantity   | `Integer`<br />(Default: 0)     | **No**    | The player's held item, if any, will have its quantity will be modified by the provided amount- subtracted from if this number is negative or added to if this item is positive.  If the player has no held item, then this field will have no effect regardless of its value and the interaction will NOT fail.  If the player's inventory does not have sufficient quantity of items to support the removal, this interaction will fail and further actions will not be executed. Excess items will be dropped on the ground near the player. |
+| ItemToAdd                | `ItemStack`                     | **No**    | If provided, the ItemStack will be added to the player's inventory. Excess items will be dropped on the ground near the player.                                                                                                                                                                                                                                                                                                                                                                                                                 |
+| AdjustHeldItemDurability | `Double`<br />(Default: 0.0)    | **No**    | The player's held item, if any, will have its durability adjusted by the specified amount.  The durability cannot go below 0 or raise above the item's maximum durability. Invalid durability values in this field will not cause the interaction to fail. Neither will it fail if the player has no held item.                                                                                                                                                                                                                                 |
+| BrokenItem               | `String`                        | **No**    | This field should contain an ItemId, but it is not validated by the server on startup, so be careful.  This field can have the value of "Empty" to specify no item, or an empty hand. If specified and the `AdjustHeldItemDurability` operation reduces the player's held item to 0 durability, the player's held item is changed to this ItemId. If the inventory replacement fails, this interaction will fail.                                                                                                                               |
+| NotifyOnBreak            | `Boolean`<br />(Default: false) | **No**    | If true and the `AdjustHeldItemDurability` operation reduces the player's held item to 0 durability, this interaction will perform the usual audiovisual feedback of a broken tool. It will play the usual tool breaking sound and send the player a text message in chat that their item has broken.                                                                                                                                                                                                                                           |
+| NotifyOnBreakMessage     | `String`                        | **No**    | If provided, and `NotifyOnBreak` is true, when the player is notified of a broken tool by this interaction, the message sent to their chat will instead be the translation key specified by this field. The translation key supports the templating parameter `{itemName}`. See the translation key `server.general.repair.itemBroken_Hoe` for an example.                                                                                                                                                                                      |
+
+**GameMode Values**
+
+- `Creative`: The game is currently in Creative Mode
+- `Adventure`: The game is currently in Adventure Mode
+
+**ItemStack Fields**
+
+| Field Name                   | Type                              | Required? | Notes                                                                                |
+| ---------------------------- | --------------------------------- | --------- | ------------------------------------------------------------------------------------ |
+| Id                           | `Asset`<br />(Asset Type: `Item`) | **Yes**   | The id of the Item asset this stack contains.                                        |
+| Quantity                     | `Integer`<br />(Default: 1)       | **No**    | The number of items in this stack.<br />**Must be greater than 0.**                  |
+| Durability                   | `Double`<br />(Default: 0.0)      | **No**    | The durability of the item stack.<br />**Cannot be negative.**                       |
+| MaxDurability                | `Double`<br />(Default: 0.0)      | **No**    | The maximum durability of the item this stack contains.<br />**Cannot be negative.** |
+| Metadata                     | `Bson Document`                   | **No**    | If provided, applies the bson to the item stack metadata.                            |
+| OverrideDroppedItemAnimation | `Boolean`\*(Default: false)       | **No**    | ???                                                                                  |
+
+### PickupItem
+
+This interaction will attempt to pick up the User entity's current target entity and add it to their inventory. It will
+fail if the User entity is not a player, if they do not have a target entity, or if the target entity is not an item
+located in the world.  It will not fail if the player simply cannot pick up the item.
+
+**This interaction has no additional fields.**
+
+### RefillContainer
+
+This interaction will fail if the User entity is not a player. The interaction will draw a ray from the player's head
+down their look direction until the edge of the player's held item's interaction range or until the first solid block.
+The nearest fluid block of a type listed in this interaction's `States` map will result in the one of the player's
+currently-held items being converted to the fluid's related item state.  If the `States` map indicates a durability
+for the new item state, then the converted item will use that durability. If the item is already in the fluid's related
+item state, then this interaction will fail if the player's held item is already at maximum durability (unless the
+`States` map indicates a durability value greater than the item's maximum, in which case the interaction will succeed
+but the item will not change).  Otherwise, the durability listed for the fluid in the `States` map will be added to the
+item's current durability.
+
+If the interaction has not failed by this point, the fluid block in the world may be transformed to a different type if one is listed
+in the `States` map.
+
+If any part of this process does not proceed for any reason (for instance, if the player is not holding an item),
+then this interaction will fail.
+
+**RefillContainer Fields**
+
+| Field Name | Type                                                       | Required? | Notes                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| ---------- | ---------------------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| States     | `Map`<br />(Key Type: `String`, Value Type: `RefillState`) | **Yes**   | A map from item state names to `RefillState` objects, which contain information such as acceptable fluid block types, durability increases, and what fluid type to convert the targeted fluid block to after refill, if any. If the player targets a fluid block that matches one of the fluid types in the `RefillState`, the item will be converted to the keyed item state and the `RefillState` will be used to decide what happens next. |
+
+**RefillState Fields**
+
+| Field Name     | Type                                  | Required? | Notes                                                                                                                                                                                                                                                                                                                           |
+| -------------- | ------------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| AllowedFluids  | `Array`<br />(Element Type: `String`) | **Yes**   | If any of these fluids are targeted by the player, the player's held item will be converted to the keyed item state and `Durability` and `TransformFluid` will be used.                                                                                                                                                         |
+| Durability     | `Double`<br />(Default: -1.0)         | **No**    | If the player's held item changes item states, this value is the new item's durability, unless it is negative, in which case the item will begin at full durability. If the player's held item is already in the item state, and the item is not already at full durability, this value will be added to the item's durability. |
+| TransformFluid | `String`                              | **No**    | If provided, this field is a fluid id that the targeted fluid block should be transformed to if the player's held item is successfully updated.                                                                                                                                                                                 |
+
+## Entities
+
+### DamageEntity
+
+This interaction does not inherit from SimpleInteraction, but adds its own Next and Failed fields that
+work similarly.
+
+This interaction will cause the User entity to damage the Target entity.  It has the capability to apply different
+damage based on the direction of the attack or what body part was targeted by the User entity, with each possibility
+providing different damage calculations, effects, and Next interaction. If multiple entires match the attack, `TargetedDamage`
+(body part damage) takes highest priority, then the first matching `AngledDamage` in the list, then the default
+damage in the base interaction fields.  It is possible for elements of these different damage priorities to be taken peacemeal if higher-priority
+damage fields do not overwrite lower-priority damage fields. For instance,
+damage calculation could be taken from `TargetedDamage`, the damage effects could be taken from the first matching
+`AngledDamage`, and the Next interaction coming from the default damage field.
+
+If all damage dealt by this interaction is cancelled, then this interaction will fail, and the `Failed` interaction
+will be executed next in the chain. If any damage dealt by this interaction is blocked, then this interaction will
+succeed, but the `Blocked` interaction wil lbe executed next in the chain. Otherwise, the highest-precedent matching
+`Next` interaction that you provide will be executed.  For instance, if you provide `Next` interactions for all
+`TargetedDamage` and `AngledDamage` entries, and one in the interaction's `Next` field, then a headshot could result
+in a unique `Next` interaction being executed, even if there is a matching `AngledDamage` entry. However, if you leave
+the `Next` interaction out of your `TargetedDamage` entries, a special `Next` interaction for backstabs could be
+executed.  Otherwise, the `Next` field in the root of the interaction will be executed instead.
+
+DamageEntity has an unusual relationship with `RunTime`. This interaction always ends immediately after its first tick,
+regardless of the status of `RunTime` or `WaitForAnimationToFinish`.  However, if damage dealt by this interaction is
+calculated as `DamageCalculatorType` `Dps`, then the `RunTime` will be used to determine the precise amount of damage to
+deal. If `RunTime` is 0, then no damage will be dealt.
+
+**DamageEntity Fields**
+
+| Field Name       | Type                                                          | Required?                                                                                                                    | Notes                                                                                                                                                                                                                                                                                                                                                                         |
+| ---------------- | ------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| DamageCalculator | `DamageCalculator`                                            | **No**                                                                                                                       | If provided, describes the damage amounts and types to apply to the Target entity.                                                                                                                                                                                                                                                                                            |
+| DamageEffects    | `DamageEffects`                                               | **No**                                                                                                                       | If provided, describes particles, sounds, knockback, etc. to apply to the target entity on damage.                                                                                                                                                                                                                                                                            |
+| Next             | `Asset`<br />(Asset Type: `Interaction`)                      | **No**  After this interaction has finished, "Next" will be executed if damage was dealt to the target and none was blocked. |                                                                                                                                                                                                                                                                                                                                                                               |
+| AngledDamage     | `Array`<br />(Element Type: `AngledDamage`)                   | **No**                                                                                                                       | If provided, allows alternative `DamageCalculator`, `DamageEffects`, and `Next` entries for attacks that approach the target from certain angles.                                                                                                                                                                                                                             |
+| TargetedDamage   | `Map`<br />(Key Type: `String`, Value Type: `TargetedDamage`) | **Yes**                                                                                                                      | This field must be provided, but is not required to have any entries.  This is a map from body part names to `TargetedDamage` values. Hypixel only uses one body part name: `Head`, and it is not clear whether there are others.  If provided, allows alternative `DamageCalculator`, `DamageEffects`, and `Next` entries for attacks that damage specific enemy body parts. |
+| EntityStatsOnHit | `Array`<br />(Element Type: `EntityStatOnHit`)                | **No**                                                                                                                       | If provided, allows this attack to reduce enemy stats other than health.  Each individual damage application dealt by the same ability will apply stat reductions, at diminishing returns. All damage dealt in interaction chains forked by a Selector interaction will share the number of hits across all targets.                                                          |
+| Failed           | `Asset`<br />(Asset Type: `Interaction`)                      | **No**                                                                                                                       | After this interaction has finished, "Failed" will be executed if no damage hits were applied to the player, or if all damage hits were cancelled.                                                                                                                                                                                                                            |
+| Blocked          | `Asset`<br />(Asset Type: `Interaction`)                      | **No**                                                                                                                       | After this interaction has finished, "Blocked" will be executed if any damage hits were blocked by the target.                                                                                                                                                                                                                                                                |
+
+**DamageCalculator Fields**
+
+| Field Name                | Type                                                      | Required? | Notes                                                                                                                                                                                                                                                 |
+| ------------------------- | --------------------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Type                      | `DamageCalculatorType`<br />(Default: Absolute)           | **No**    | Whether the damage being applied is `Absolute` or \`Dps'.                                                                                                                                                                                             |
+| Class                     | `DamageClass`<br />(Default: Unknown)                     | **No**    | The type of attack producing the damage. Some weapon systems apply equipment modifiers based on this value.                                                                                                                                           |
+| BaseDamage                | `Map`<br />(Key Type: `DamageCause`, Value Type: `Float`) | **No**    | A set of DamageCauses and how much base damage is dealt for each.                                                                                                                                                                                     |
+| SequentialModifierStep    | `Float`<br />(Default: 0.0)                               | **No**    | Value between 0.0-1.0. Each additional hit from a single ability will have its damage reduced by this much as a percentage. All damage dealt in interaction chains forked by a Selector interaction will share the number of hits across all targets. |
+| SequentialModifierMinimum | `Float`<br />(Default: 0.0)                               | **No**    | Value between 0.0-1.0. `SequentialModifierStep` cannot reduce damage below this percentage regardless of the number of hits.                                                                                                                          |
+| RandomPercentageModifier  | `Float`<br />(Default: 0.0)                               | **No**    | A random value between +/- this amount multiplied by the base damage will be added to the base damage.                                                                                                                                                |
+
+**DamageEffects Fields**
+
+| Field Name             | Type                                         | Required? | Notes                                                                                   |
+| ---------------------- | -------------------------------------------- | --------- | --------------------------------------------------------------------------------------- |
+| ModelParticles         | `Array`<br />(Element Type: `ModelParticle`) | **No**    | Particle systems to trigger in the first-person view.                                   |
+| WorldParticles         | `Array`<br />(Element Type: `WorldParticle`) | **No**    | Particle systems to trigger in the third-person view.                                   |
+| LocalSoundEventId      | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | 2D sound to play locally to the attacking entity if they are a player.                  |
+| WorldSoundEventId      | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | Sound to play in the world at the Target entity's location.                             |
+| PlayerSoundEventId     | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | 2D sound to play locally to the Target entity if they are a player.                     |
+| ViewDistance           | `Double`<br />(Default: 75.0)                | **No**    | Distance at which these effects should play for other players.                          |
+| Knockback              | `Knockback`                                  | **No**    | The properties of the knockback that will be applied.                                   |
+| CameraEffect           | `Asset`<br />(Asset Type: `CameraEffect`)    | **No**    | CameraEffect to briefly apply locally to the Target entity if they are a player.        |
+| StaminaDrainMultiplier | `Float`<br />(Default: 1.0)                  | **No**    | This multiplier is applied to the stamina cost incurred by the target blocking, if any. |
+
+**AngledDamage Fields**
+
+| Field Name       | Type                                     | Required? | Notes                                                                                                                                                                                                     |
+| ---------------- | ---------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| AngleDistance    | `Float`<br />(Default: 0)                | **No**    | The width in degrees of the matching arc around the Target entity. If the attack against the Target originates from within the arc, then the properties below will be applied to the attack, if provided. |
+| Angle            | `Float`<br />(Default: 0.0)              | **No**    | The angle in degrees around the Target entity at which the matching arc is centered.                                                                                                                      |
+| DamageCalculator | `DamageCalculator`                       | **No**    | If provided and the attack against the Target entity originates from within the provided arc, this DamageCalculator will override the interaction's `DamageCalculator` field.                             |
+| DamageEffects    | `DamageEffects`                          | **No**    | If provided and the attack against the Target entity originates from within the provided arc, this DamageEffects will override the interaction's `DamageEffects` field.                                   |
+| Next             | `Asset`<br />(Asset Type: `Interaction`) | **No**    | If provided and the attack against the Target entity originates from within the provided arc, this Interaction will override the interaction's `Next` field.                                              |
+
+**TargetedDamage Fields**
+
+| Field Name       | Type                                     | Required? | Notes                                                                                                                                                                                            |
+| ---------------- | ---------------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| DamageCalculator | `DamageCalculator`                       | **No**    | If provided and this TargetedDamage was matched, this DamageCalculator will override the interaction's `DamageCalculator` field and the `DamageCalculator` field of any matching `AngledDamage`. |
+| DamageEffects    | `DamageEffects`                          | **No**    | If provided and this TargetedDamage was matched, this DamageEffects will override the interaction's `DamageEffects` field and the `DamageEffects` field of any matching `AngledDamage`.          |
+| Next             | `Asset`<br />(Asset Type: `Interaction`) | **No**    | If provided and this TargetedDamage was matched, this Interaction will override the interaction's `Next` field and the `Next` field of any matching `AngledDamage`.                              |
+
+**EntityStatOnHit Fields**
+
+| Field Name                  | Type                                                                       | Required? | Notes                                                                                                                                                                                                                                                                                        |
+| --------------------------- | -------------------------------------------------------------------------- | --------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| EntityStatId                | `Asset`<br />(AssetType: `EntityStatType`)                                 | **Yes**   | Which entity stat to affect.                                                                                                                                                                                                                                                                 |
+| Amount                      | `Float`<br />(Default: 0.0)                                                | **No**    | How much of the stat to apply for each damage application. Use negative numbers to reduce stats.                                                                                                                                                                                             |
+| MultipliersPerEntitiesHit   | `Array`<br />(Element Type: `Float`, Default: `[1.0, 0.6, 0.4, 0.2, 0.1]`) | **No**    | The diminishing returns curve to be applied for multiple damage applications by the same ability. Each hit's stat impact will be multiplied by the next value in the list.  If there are more hits than array elements, subsequent hits will be multiplied by `MultiplierPerExtraEntityHit`. |
+| MultiplierPerExtraEntityHit | `Float`<br />(Default: 0.05)                                               | **No**    | If an ability carries out more damage applications than there are elements in the `MultipliersPerEntitiesHit` array, then subsequent stat values will be multiplied by this number.                                                                                                          |
+
+**Knockback Fields**
+
+| Field Name     | Type                                       | Required? | Notes                                                                                                                      |
+| -------------- | ------------------------------------------ | --------- | -------------------------------------------------------------------------------------------------------------------------- |
+| Type           | `String`                                   | **No**    | If provided, specifies a type of knockback to use. Each Target type may come with additional fields.                       |
+| Force          | `Double`<br />(Default: 0.0)               | **No**    | The amount of force to apply to the Owner entity.                                                                          |
+| Duration       | `Double`<br />(Default: 0.0)               | **No**    | If 0.0, apply the force as a single impulse.  If more, continuously apply the force over a period of time.                 |
+| VelocityType   | `ChangeVelocityType`<br />(Default: `Add`) | **No**    | How to apply the force, either adding it to the entity's current velocity, or setting the velocity to the knockback force. |
+| VelocityConfig | `VelocityConfig`                           | **No**    | Characteristics of friction as the Owner entity is thrown by this knockback.                                               |
+
+**Knockback Type: Force**
+
+Apply the calculated knockback force along the provided direction.
+
+| Field Name | Type                         | Required? | Notes                                                                                |
+| ---------- | ---------------------------- | --------- | ------------------------------------------------------------------------------------ |
+| Direction  | `Vector3`<br />(Default: Up) | **No**    | Which direction the entity should be flung, relative to the direction of the attack. |
+
+**Knockback Type: Point**
+
+Apply the calculated knockback force laterally along the XZ plane, plus provided Y velocity.
+
+| Field Name | Type                        | Required? | Notes                                                                                                   |
+| ---------- | --------------------------- | --------- | ------------------------------------------------------------------------------------------------------- |
+| OffsetX    | `Integer`<br />(Default: 0) | **No**    | Offset the source position of the knockback left or right perpendicular to the direction of the attack. |
+| OffsetZ    | `Integer`<br />(Default: 0) | **No**    | Offset the source position of the knockback, forward or backward along the directon of the attack.      |
+| RotateY    | `Integer`<br />(Default: 0) | **No**    | Rotate the knockback direction around the Y axis, where 0 is the default attack direction.              |
+| VelocityY  | `Float`<br />(Default: 0.0) | **No**    | Add vertical velocity to the knockback force after the direction and force has been calculated.         |
+
+**Knockback Type: Directional**
+
+Apply the calculated knockback force along the attack direction, removing any vertical component and replacing it with a provided Y velocity.
+
+| Field Name | Type                      | Required? | Notes                                                                                                                                            |
+| ---------- | ------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------ |
+| RelativeX  | `Float`<br />(Default: 0) | **No**    | Apply additional force left or right perpendicular to the direction of the attack. The additional force is multiplied by the knockback strength. |
+| RelativeZ  | `Float`<br />(Default: 0) | **No**    | Apply additional force forward or backward along the attack direction. The additional force is multiplied by the knockback strength.             |
+| VelocityY  | `Float`<br />(Default: 0) | **No**    | Replace the vertical velocity of the knockback with this value.  This value is not multiplied by knockback strength.                             |
+
+**VelocityConfig Fields**
+
+| Field Name          | Type                                              | Required? | Notes                                                                                                                                                                                           |
+| ------------------- | ------------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| GroundResistance    | `Float`<br />(Default: 0.82)                      | **No**    | The minimum amount of friction applied when the entity is in contact with the ground.  1.0 = no friction, 0.0 = total friction                                                                  |
+| GroundResistanceMax | `Float`<br />(Default: 0.0)                       | **No**    | The maximum amount of friction applied when the entity is in contact with the ground.  1.0 = no friction, 0.0 = total friction                                                                  |
+| AirResistance       | `Float`<br />(Default: 0.96)                      | **No**    | The minimum amount of friction applied when the entity is in the air. 1.0 = no friction, 0.0 = total friction                                                                                   |
+| AirResistanceMax    | `Float`<br />(Default: 0.0)                       | **No**    | The maximum amount of friction applied when the entity is in the air. 1.0 = no friction, 0.0 = total friction                                                                                   |
+| Threshold           | `Float`<br />(Default: 1.0)                       | **No**    | The speed at which the maximum amount of friction will be applied to the entity. The amount of friction applied will increase from minimum to maximum as the entity moves from 0 to this speed. |
+| Style               | `VelocityThresholdStyle`<br />(Default: `Linear`) | **No**    | The curve that friction follows as the entity's speed increases toward the `Threshold`.                                                                                                         |
+
+**DamageCalculatorType Values**
+
+- `Absolute`
+- `Dps`
+
+**DamageClass Values**
+
+- `Unknown`
+- `Light`
+- `Charged`
+- `Signature`
+
+**ChangeVelocityType Values**
+
+- `Add`
+- `Set`
+
+**VelocityThresholdStyle Values**
+
+- `Linear`
+- `Exp`
+
+### LaunchProjectile
+
+This is just a worse version of Projectile and is slated to be removed.  Use Projectile.
+
+### Projectile
+
+This interaction will spawn a new projectile at the User entity's eye position that will travel in its look direction.
+
+| Field Name | Type                                          | Required? | Notes                                                  |
+| ---------- | --------------------------------------------- | --------- | ------------------------------------------------------ |
+| Config     | `Asset`<br />(Asset Type: `ProjectileConfig`) | **No**    | Configuration describing the projectile to be spawned. |
+
+### RemoveEntity
+
+Despawns the specified entity from the world. This interaction will have no effect if the specified entity is a player. This
+interaction has no special failure conditions.
+
+| Field Name | Type                                     | Required? | Notes                  |
+| ---------- | ---------------------------------------- | --------- | ---------------------- |
+| Entity     | `InteractionTarget`<br />(Default: User) | **No**    | The entity to despawn. |
+
+**InteractionTarget Values**
+
+- `User` - The user of this interaction chain. The entity whose actions caused this interaction chain to be executed. This is usually the same as the Owner.
+- `Owner` - The owner of this interaction chain. The entity upon whom this interaction chain is executing.
+- `Target` - The entity target of this interaction chain, if any.  This value is mutable (and can therefore come from many places) but most commonly, it is an entity the User was targeting when this interaction chain began executing.
+
+### SendMessage
+
+This interaction sends a message to the Owner entity if that entity can receive messages.  Otherwise, the message
+is written to the server logs.  If the entity is a player, the message will appear in the player's chat window.
+
+\*\*SendMessage
+
+| Field Name | Type     | Required? | Notes                                                                                                                 |
+| ---------- | -------- | --------- | --------------------------------------------------------------------------------------------------------------------- |
+| Message    | `String` | **No**    | A text message to be sent to the Owner entity.  If this field is not provided, `Key` is used instead.                 |
+| Key        | `String` | **No**    | A translation key for a message to be sent to the Owner entity. If `Message` is provided, then this field is ignored. |
+
+### UseEntity
+
+This interaction is not in use by Hypixel and has some unusual qualities that mean it probably won't do what you want it
+to.  Do not use it.
+
+This interaction will retrieve the entity currently targeted by the client (NOT the interaction chain's current Target
+entity) and execute that entity's RootInteraction for this interaction chain's current interaction type. The
+RootInteraction will be executed as part of this current interaction chain. None of the properties of this interaction
+chain will be modified.
+
+This interaction will fail if the client is not currently targeting an entity, or if no interaction for the current
+interaction type exists on the entity.
+
+## Stats
+
+Hytale's resource system has been written about fairly extensively.  You can use these interactions to modify stats in
+response to actions or use stats as a cost for abilities.
+
+### ChangeStat
+
+This interaction applies a set of raw stat changes to the User entity. It has no special failure conditions.
+
+| Field Name    | Type                                                         | Required? | Notes                                                                                                                                                                                                                      |
+| ------------- | ------------------------------------------------------------ | --------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| StatModifiers | `Map`<br />(Key Type: `EntityStatType`, Value Type: `Float`) | **Yes**   | A set of stats to modify and what value to apply to them.                                                                                                                                                                  |
+| ValueType     | `ValueType`<br />(Default: Absolute)                         | **No**    | Whether the values in the `StatModifiers` map represent flat values to apply to the stat total, or percentages (0.0-100.0). Percentage values are percentage of the difference between the maximum and minimum stat value. |
+| Behaviour     | `ChangeStatBehavior`<br />(Default: Add)                     | **No**    | Whether the values in the `StatModifiers` map represent deltas to add into the User entity's current stat values, or fixed values to set the entity's stats to.                                                            |
+
+**ValueType Values**
+
+- `Absolute`
+- `Percent`
+
+**ChangeStatBehaviour Values**
+
+- `Add`
+- `Set`
+
+### ChangeStatWithModifier
+
+This interaction is like ChangeStat, except an armor stat modifier can be chosen which will apply bonuses and penalties
+to a stat from the User entity's equipped armor before it is applied.
+
+| Field Name            | Type                                                         | Required? | Notes                                                                                                                                                                                                                      |
+| --------------------- | ------------------------------------------------------------ | --------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| StatModifiers         | `Map`<br />(Key Type: `EntityStatType`, Value Type: `Float`) | **Yes**   | A set of stats to modify and what value to apply to them.                                                                                                                                                                  |
+| ValueType             | `ValueType`<br />(Default: Absolute)                         | **No**    | Whether the values in the `StatModifiers` map represent flat values to apply to the stat total, or percentages (0.0-100.0). Percentage values are percentage of the difference between the maximum and minimum stat value. |
+| Behaviour             | `ChangeStatBehavior`<br />(Default: Add)                     | **No**    | Whether the values in the `StatModifiers` map represent deltas to add into the User entity's current stat values, or fixed values to set the entity's stats to.                                                            |
+| InteractionModifierId | `InteractionModifierId`                                      | **Yes**   | The armor interaction modifier to apply bonuses and penalties for.                                                                                                                                                         |
+
+**ValueType Values**
+
+- `Absolute`
+- `Percent`
+
+**ChangeStatBehaviour Values**
+
+- `Add`
+- `Set`
+
+**InteractionModifierId Values**
+
+- `Dodge`
+
+### StatsCondition
+
+This interaction will fail if the User entity cannot afford the specified stats costs, or if it does not have the
+requested stats.
+
+| Field Name | Type                                                         | Required? | Notes                                                                                                                                                                                    |
+| ---------- | ------------------------------------------------------------ | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Costs      | `Map`<br />(Key Type:` EntityStatType`, Value Type: `Float`) | **Yes**   | A set of costs that the User entity needs to be able to afford for this interaction to succeed.                                                                                          |
+| ValueType  | `ValueType`<br />(Default: Absolute)                         | **No**    | Whether the values in the `Costs` map represetn flat values or percentages (0.0-100.0).  Percentage values are percentage of the difference between the maximum and minimum value.       |
+| LessThan   | `Boolean`<br />(Default: false)                              | **No**    | If true, this interaction will fail unless the User entity's current stat values are at or **below** the specified levels.  If false, they must be at or **above** the specified levels. |
+| Lenient    | `Boolean`<br />(Default: false)                              | **No**    | If true and `LessThan` is true, and a player's minimum stat value is below zero, then the player can afford a stat cost if the current value of a stat if above 0.                       |
+
+**ValueType Values**
+
+- `Absolute`
+- `Percent`
+
+### StatsConditionWithModifier
+
+This interaction is like StatsCondition, except an armor stat modifier can be chosen which will apply bonuses and penalties
+to a stat's cost from the User entity's equipped armor before it is compared.
+
+| Field Name            | Type                                                         | Required? | Notes                                                                                                                                                                                    |
+| --------------------- | ------------------------------------------------------------ | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Costs                 | `Map`<br />(Key Type:` EntityStatType`, Value Type: `Float`) | **Yes**   | A set of costs that the User entity needs to be able to afford for this interaction to succeed.                                                                                          |
+| ValueType             | `ValueType`<br />(Default: Absolute)                         | **No**    | Whether the values in the `Costs` map represetn flat values or percentages (0.0-100.0).  Percentage values are percentage of the difference between the maximum and minimum value.       |
+| LessThan              | `Boolean`<br />(Default: false)                              | **No**    | If true, this interaction will fail unless the User entity's current stat values are at or **below** the specified levels.  If false, they must be at or **above** the specified levels. |
+| Lenient               | `Boolean`<br />(Default: false)                              | **No**    | If true and `LessThan` is true, and a player's minimum stat value is below zero, then the player can afford a stat cost if the current value of a stat if above 0.                       |
+| InteractionModifierId | `InteractionModifierId`                                      | **Yes**   | The armor interaction modifier to apply bonuses and penalties for.                                                                                                                       |
+
+**ValueType Values**
+
+- `Absolute`
+- `Percent`
+
+**InteractionModifierId Values**
+
+- `Dodge`
+
+## EntityEffects
+
+EntityEffects are buff or debuff effects that can be applied to a LivingEntity.  These can have a variety of effects from
+movement speed changes to periodic damage.
+
+### EffectCondition
+
+This interaction will fail if the specified entity's EntityEffects do not match the provided conditions.
+
+**EffectCondition Fields**
+
+| Field Name      | Type                                             | Required? | Notes                                                                                                                                                                                                             |
+| --------------- | ------------------------------------------------ | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Entity          | `InteractionTarget`<br />(Default: User)         | **Yes**   | The entity to examine for EntityEffects. This field can indicate the Owner, User, or Target of this interaction chain.                                                                                            |
+| Match           | `Match`<br />(Default: All)                      | **No**    | If `All`, then this interaction will fail if any EntityEffect in the `EntityEffectIds` is not on the specified entity. If `None`, then this interaction will fail if any EntityEffect IS on the specified entity. |
+| EntityEffectIds | `AssetArray`<br />(Element Type: `EntityEffect`) | **Yes**   | The set of EntityEffects to check against the specified entity and `Match`.                                                                                                                                       |
+
+**InteractionTarget Values**
+
+- `User` - The user of this interaction chain. The entity whose actions caused this interaction chain to be executed. This is usually the same as the Owner.
+- `Owner` - The owner of this interaction chain. The entity upon whom this interaction chain is executing.
+- `Target` - The entity target of this interaction chain, if any.  This value is mutable (and can therefore come from many places) but most commonly, it is an entity the User was targeting when this interaction chain began executing.
+
+**Match Values**
+
+- `All` - All EntityEffects must be on the specified entity for this interaction to succeed.
+- `None` - None of the EntityEffects must be on the specified entity for this interaction to succeed.
+
+### ApplyEffect
+
+This interaction will apply the specified EntityEffect to the specified Entity.  It has no special failure conditions.
+
+**ApplyEffect Fields**
+
+| Field Name | Type                                      | Required? | Notes                                                                                                                  |
+| ---------- | ----------------------------------------- | --------- | ---------------------------------------------------------------------------------------------------------------------- |
+| Entity     | `InteractionTarget`<br />(Default: User)  | **Yes**   | The entity to apply the EntityEffect to. This field can indicate the Owner, User, or Target of this interaction chain. |
+| EffectId   | `Asset`<br />(Asset Type: `EntityEffect`) | **Yes**   | The effect to apply.                                                                                                   |
+
+**InteractionTarget Values**
+
+- `User` - The user of this interaction chain. The entity whose actions caused this interaction chain to be executed. This is usually the same as the Owner.
+- `Owner` - The owner of this interaction chain. The entity upon whom this interaction chain is executing.
+- `Target` - The entity target of this interaction chain, if any.  This value is mutable (and can therefore come from many places) but most commonly, it is an entity the User was targeting when this interaction chain began executing.
+
+### ClearEntityEffect
+
+This interaction will remove the specified EntityEffect from the specified Entity. It has no special failure conditions.
+It will not fail if the Entity does not have the EntityEffect.
+
+**ClearEntityEffect Fields**
+
+| Field Name | Type                                      | Required? | Notes                                                                                                                     |
+| ---------- | ----------------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------- |
+| Entity     | `InteractionTarget`<br />(Default: User)  | **Yes**   | The entity to remove the EntityEffect from. This field can indicate the Owner, User, or Target of this interaction chain. |
+| EffectId   | `Asset`<br />(Asset Type: `EntityEffect`) | **Yes**   | The effect to remove.                                                                                                     |
+
+**InteractionTarget Values**
+
+- `User` - The user of this interaction chain. The entity whose actions caused this interaction chain to be executed. This is usually the same as the Owner.
+- `Owner` - The owner of this interaction chain. The entity upon whom this interaction chain is executing.
+- `Target` - The entity target of this interaction chain, if any.  This value is mutable (and can therefore come from many places) but most commonly, it is an entity the User was targeting when this interaction chain began executing.
+
+## Farming
+
+These are interaction types built to support the in-game farming system in Hytale. They are mostly block-related interactions
+with a few exceptions.
+
+### ChangeFarmingStage
+
+If the target block is a farming block, this interaction will attempt to modify the current farming stage in one of
+three ways.  The interaction can optionally specify which StageSet to use for the new stage. If it is not specified,
+the current StageSet will be used. If any part of the the process of changing the growth stage fails, this interaction
+will fail, with the one exception that attempting to set the stage to the crop's existing stage will have no effect but
+still succeed.
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                                                                                                                                                                          |
+| ---------------- | ------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction.                                                                                                                                              |
+| StageSet         | `String`                        | **No**    | If provided, set the block's current stage to one in the provided StageSet. Otherwise, use the crop's current StageSet.                                                                                                                                                        |
+| Increase         | `Integer`                       | **No**    | If provided, increase the current stage by the specified amount. If the specified stage does not exist, the block will be set to the closest extant stage.                                                                                                                     |
+| Decrease         | `Integer`                       | **No**    | If provided and `Increase` is not provided, decrease the current stage by the specified amount. If the specified stage does not exist, the block will be set to the closest extant stage.                                                                                      |
+| Stage            | `Integer`<br />(Default: -1)    | **No**    | If provided and `Increase`/`Decrease` are not provided, set the current stage to the specified stage. If this value is less than 0, set the current stage to the final growth stage. If the specified stage does not exist, the block will be set to the closest extant stage. |
+
+### FertilizeSoil
+
+If the target block is unfertilized tilled soil or a farming block on top of unfertilized tilled soil, fertilizes the soil.
+The interaction will fail otherwise.
+
+**FertilizeSoil Fields**
+
+| Field Name       | Type                                  | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false)       | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+| RefreshModifiers | `Array`<br />(Element Type: `String`) | **No**    | Does nothing.                                                                                                                     |
+
+### HarvestCrop
+
+This interaction will attempt to execute the harvest action on the current block target and add the crop's drops to the User entity's
+inventory.  The block will either be destroyed or set to its post-harvest growth stage, depending on the farming
+configuration of the block.  This will happen (and the player will receive the full harvest drops) regardless of the
+block's current growth stage. This interaction has no special failure conditions, even if the block target isn't a
+farming block or gathering isn't permitted in the current world, but nothing will occur in those cases.
+
+**HarvestCrop Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+
+### UseWateringCan
+
+If the target block is tilled soil or a farming block on top of tilled soil, waters the soil for the specified duration.
+The interaction will fail otherwise.
+
+**UseWateringCan Fields**
+
+| Field Name       | Type                                  | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false)       | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+| Duration         | `Integer`<br />(Default: 0)           | **No**    | The duration in seconds to water the soil for.                                                                                    |
+| RefreshModifiers | `Array`<br />(Element Type: `String`) | **No**    | Does nothing.                                                                                                                     |
diff --git a/content/docs/es-ES/contributing/pr-guidelines.mdx b/content/docs/es-ES/contributing/pr-guidelines.mdx
index e64ff3f1..bde4fe94 100644
--- a/content/docs/es-ES/contributing/pr-guidelines.mdx
+++ b/content/docs/es-ES/contributing/pr-guidelines.mdx
@@ -19,6 +19,8 @@ Para garantizar un proceso de revisión fluido y eficiente, tanto los colaborado
 4. **Calidad del Código**
    - Asegúrate de que tu código siga los estándares de codificación y buenas prácticas del proyecto.
    - Incluye comentarios cuando sea necesario para explicar lógica compleja.
+   - Always test your changes locally before submitting the PR to catch any issues early.
+   - Format your code using `bun format` to maintain consistency across the codebase.
 5. **Prueba**
    - Prueba tus cambios a fondo antes de enviar el PR.
    - Si aplica, incluye pruebas unitarias o pruebas de integración para verificar tus cambios.
diff --git a/content/docs/es-ES/contributing/translate.mdx b/content/docs/es-ES/contributing/translate.mdx
new file mode 100644
index 00000000..c62ffdde
--- /dev/null
+++ b/content/docs/es-ES/contributing/translate.mdx
@@ -0,0 +1,74 @@
+---
+title: Translate
+description: How to translate HytaleModding to your language
+---
+
+# Translating HytaleModding
+
+HytaleModding is translated with the help of the community using **Crowdin**. If you want to help translate or improve existing translations, this is the right place.
+
+## Steps to Translate
+
+All translations are managed **via Crowdin**.
+
+1. Visit [our Crowdin project](https://crowdin.com/project/hytalemodding) and log in if required.
+2. Click on your language.
+3. Click on the file/article you wish to translate. We recommend starting with Official Documentation, and then Server Plugin Documentation.
+4. Start translating!
+5. Approved translations will appear on the website.
+
+### Video Guide
+
+<iframe src="https://www.youtube.com/embed/NHiG1rDRgks" allowFullScreen />
+
+## How to discuss
+
+You can always report issues or discuss specific topics directly on Crowdin, but we recommend using Discord instead of the Crowdin comment system to keep everything organized in one place.
+
+1. Join [our Discord](https://discord.gg/hytalemodding)
+2. Open `#translations` channel. Here you can discuss or ask questions that are not related to a specific language.
+3. If you want to join a thread, you are required to run `/translator <your-language>` command here. The bot will add you to the thread for your language.
+
+## Translation Guidelines
+
+- You need to be confident in what you are translating. You should be able to read the text you just translated and understand the meaning of it very easily.
+- It should use the simplest form of language possible. Use English words if the translation is unknown to the majority in your country.
+- Use your imagination, trust yourself. Feel free to change any context as you wish as long as it can still get the same point across and is understandable.
+- These guidelines are more important than language-specific guidelines, but less important than Hytale terminology and rules.
+
+## What not to translate
+
+We request you all to not translate these specific sections of the website:
+
+### Callout types
+
+Callouts are the boxes that contain important information. We request you to not translate the types as they only work in English.
+
+**Example:**
+
+```mdx
+<Callout type="warning" title="Translate this title!">
+Translate the text inside the callout!
+</Callout>
+```
+
+In this example, please don't translate the word warning, the rest you can translate.
+
+### Icons
+
+Icon names must not be translated.
+They are technical identifiers mapped directly to existing icons. Translating them will break the icon rendering.
+
+```mdx
+icon: Globe
+```
+
+---
+
+{/* 
+For translators who will edit this page:
+
+- You are required to translate the Guidelines as they change.
+- General guidelines should be translated but not edited.
+- Learn how to use Markdown from writing_guides.mdx
+*/}
diff --git a/content/docs/es-ES/established-information/server/content-categories/art-assets.mdx b/content/docs/es-ES/established-information/server/content-categories/art-assets.mdx
index 3210abab..b83d26d5 100644
--- a/content/docs/es-ES/established-information/server/content-categories/art-assets.mdx
+++ b/content/docs/es-ES/established-information/server/content-categories/art-assets.mdx
@@ -14,7 +14,7 @@ Hytale provee soporte integral para modelado 3D y creación de texturas, con her
 Hytale usa **Blockbench** como herramienta principal para modelado 3D y animaciones:
 
 * **Soporte oficial**: Usado para "crear modelos, texturas y animaciones de Hytale"
-* ***Plugin* especial**: Hytale tendrá un *plugin* dedicado para Blockbench, que se lanzará lo antes posible
+* **Special plugin**: Hytale has a dedicated [Blockbench Plugin](https://www.blockbench.net/plugins/hytale_plugin).
 * **Compatibilidad directa**: El *plugin* permitirá "crear modelos, texturas y animaciones compatibles con Hytale directamente en Blockbench"
 * **Reemplaza herramientas antiguas**: Sustituye por completo el antiguo Hytale Model Maker para brindar un mejor soporte a los flujos de trabajo creativos ya establecidos en la comunidad.
 * **Funciones de seguridad**: Solo permite agregar elementos compatibles con el motor, por lo que no hay que preocuparse por romper nada.
diff --git a/content/docs/es-ES/guides/ecs/block-components.mdx b/content/docs/es-ES/guides/ecs/block-components.mdx
new file mode 100644
index 00000000..ca68b38a
--- /dev/null
+++ b/content/docs/es-ES/guides/ecs/block-components.mdx
@@ -0,0 +1,247 @@
+---
+title: Block Components
+description: Learn how to use the block components.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+  - name: oskarscot
+    link: https://oskar.scot
+---
+
+# Overview
+
+In this guide, you'll learn how to use block components to create a ticking block.
+
+<Callout>
+  For a more complete reference, you may also want to review FarmingSystems.Ticking, as much of the underlying logic is based on its implementation.
+</Callout>
+
+## Steps
+
+### 1. ExampleBlock - holds block behavior
+
+```java
+public class ExampleBlock implements Component<ChunkStore> {
+
+    public static final BuilderCodec CODEC = BuilderCodec.builder(ExampleBlock.class, ExampleBlock::new).build();
+
+    // Components usually require a copy constructor as well but since we don't actually hold any data in this component this is not neccessary
+    public ExampleBlock() { }
+
+    public static ComponentType getComponentType() {
+        return ExamplePlugin.get().getExampleBlockComponentType();
+    }
+
+    @Nullable
+    public Component<ChunkStore> clone() {
+        return new ExampleBlock();
+    }
+}
+```
+
+ExampleBlock is a custom component that stores the behavior and data for your ticking block. Here, it simply places an Ice Block at x + 1 relative to its current position when it ticks.
+
+---
+
+### 2. ExampleInitializer - marks blocks as ticking when placed
+
+```java
+public class ExampleInitializer extends RefSystem {
+
+    @Override
+    public void onEntityAdded(@Nonnull Ref ref, @Nonnull AddReason reason, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+        BlockModule.BlockStateInfo info = (BlockModule.BlockStateInfo) commandBuffer.getComponent(ref, BlockModule.BlockStateInfo.getComponentType());
+        if (info == null) return;
+
+        ExampleBlock generator = (ExampleBlock) commandBuffer.getComponent(ref, ExamplePlugin.get().getExampleBlockComponentType());
+        if (generator != null) {
+            int x = ChunkUtil.xFromBlockInColumn(info.getIndex());
+            int y = ChunkUtil.yFromBlockInColumn(info.getIndex());
+            int z = ChunkUtil.zFromBlockInColumn(info.getIndex());
+
+            WorldChunk worldChunk = (WorldChunk) commandBuffer.getComponent(info.getChunkRef(), WorldChunk.getComponentType());
+            if (worldChunk != null) {
+				worldChunk.setTicking(x, y, z, true);
+            }
+        }
+    }
+
+    @Override
+    public void onEntityRemove(@Nonnull Ref ref, @Nonnull RemoveReason reason, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+    }
+
+    @Override
+    public Query getQuery() {
+        return Query.and(BlockModule.BlockStateInfo.getComponentType(), ExamplePlugin.get().getExampleBlockComponentType());
+    }
+}
+```
+
+ExampleInitializer is a RefSystem that reacts when block entities with the ExampleBlock component are added or removed. This is crucial for marking blocks as ticking when they're first placed.
+
+**Key Points:**
+
+- Tells the game that this block should tick, allowing `ExampleSystem` to process it.
+
+```java
+worldChunk.setTicking(x, y, z, true);
+```
+
+---
+
+### 3. ExampleSystem - handles ticking
+
+```java
+public class ExampleSystem extends EntityTickingSystem {
+
+    public void tick(float dt, int index, @Nonnull ArchetypeChunk archetypeChunk, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+        BlockSection blocks = (BlockSection) archetypeChunk.getComponent(index, BlockSection.getComponentType());
+
+        assert blocks != null;
+
+        if (blocks.getTickingBlocksCountCopy() != 0) {
+            ChunkSection section = (ChunkSection) archetypeChunk.getComponent(index, ChunkSection.getComponentType());
+
+            assert section != null;
+
+            BlockComponentChunk blockComponentChunk = (BlockComponentChunk) commandBuffer.getComponent(section.getChunkColumnReference(), BlockComponentChunk.getComponentType());
+
+            assert blockComponentChunk != null;
+
+            blocks.forEachTicking(blockComponentChunk, commandBuffer, section.getY(), (blockComponentChunk1, commandBuffer1, localX, localY, localZ, blockId) -> {
+                Ref<ChunkStore> blockRef = blockComponentChunk.getEntityReference(ChunkUtil.indexBlockInColumn(localX, localY, localZ));
+                if (blockRef == null) {
+                    return BlockTickStrategy.IGNORED;
+                } else {
+                    ExampleBlock exampleBlock = (ExampleBlock) commandBuffer1.getComponent(blockRef, ExampleBlock.getComponentType());
+                    if (exampleBlock != null) {
+                        WorldChunk worldChunk = (WorldChunk) commandBuffer.getComponent(section.getChunkColumnReference(), WorldChunk.getComponentType());
+                        World world = worldChunk.getWorld();
+
+                        int globalX = localX + (worldChunk.getX() * 32);
+                        int globalZ = localZ + (worldChunk.getZ() * 32);
+
+                        // We need to execute setBlock on the world thread as you cannot call store functions from a system
+                        // This is because of the architecture of the server, depending on your needs you can also use the CommandBuffer
+                        world.execute(() -> {
+                            world.setBlock(globalX + 1, localY, globalZ, "Rock_Ice");
+                        });
+
+                        return BlockTickStrategy.CONTINUE;
+
+                    } else {
+                        return BlockTickStrategy.IGNORED;
+                    }
+                }
+            });
+        }
+    }
+
+    @Nullable
+    public Query getQuery() {
+        return Query.and(BlockSection.getComponentType(), ChunkSection.getComponentType());;
+    }
+}
+```
+
+ExampleSystem is an EntityTickingSystem that runs every tick to execute the logic for all ticking blocks with the ExampleBlock component.
+
+**Key Points:**
+
+- **Get the block component**
+
+```java
+ExampleBlock exampleBlock = (ExampleBlock) commandBuffer.getComponent(blockRef, ExampleBlock.getComponentType());
+```
+
+- **Convert local chunk coordinates to world coordinates**
+
+```java
+int globalX = localX + (worldChunk.getX() * 32);
+int globalZ = localZ + (worldChunk.getZ() * 32);
+```
+
+- **Run the block logic**
+
+```java
+exampleBlock.runBlockAction(globalX, localY, globalZ, worldChunk.getWorld());
+```
+
+- **Keep the block ticking in the next tick**
+
+```java
+return BlockTickStrategy.CONTINUE;
+```
+
+---
+
+### 4. ExamplePlugin - registers components and systems
+
+```java
+public class ExamplePlugin extends JavaPlugin {
+    protected static ExamplePlugin instance;
+    private static final HytaleLogger LOGGER = HytaleLogger.forEnclosingClass();
+    private ComponentType exampleBlockComponentType;
+
+    public static ExamplePlugin get() {
+        return instance;
+    }
+
+    public ExamplePlugin(@Nonnull JavaPluginInit init) {
+        super(init);
+        LOGGER.atInfo().log("Hello from " + this.getName() + " version " + this.getManifest().getVersion().toString());
+    }
+
+    @Override
+    protected void setup() {
+        instance = this;
+        LOGGER.atInfo().log("Setting up plugin " + this.getName());
+        this.exampleBlockComponentType = this.getChunkStoreRegistry().registerComponent(ExampleBlock.class, "ExampleBlock", ExampleBlock.CODEC);
+    }
+	
+	@Override
+	protected void start() {
+		this.getChunkStoreRegistry().registerSystem(new ExampleSystem());
+		this.getChunkStoreRegistry().registerSystem(new ExampleInitializer());
+	}
+
+    public ComponentType getExampleBlockComponentType() {
+        return this.exampleBlockComponentType;
+    }
+}
+```
+
+---
+
+### 5. Configure In-Game
+
+![block-component-1](/assets/guides/block-component-1.png)
+
+![block-component-2](/assets/guides/block-component-2.png)
+
+With this logic, the block will now continuously place an Ice Block at the coordinates x + 1 relative to its current position every time it ticks.
+
+---
+
+## Common Issues
+
+### NullPointerException on Startup
+
+**Error message:**
+
+```java
+java.lang.NullPointerException: Cannot invoke "com.hypixel.hytale.component.query.Query.validateRegistry(com.hypixel.hytale.component.ComponentRegistry)" because "query" is null
+```
+
+**Cause:**
+This error occurs when your module is loaded **before** the required Hytale modules.
+
+**Fix:**
+Add `EntityModule` and `BlockModule` as dependencies in your `manifest.json` to ensure proper load order.
+
+```json
+"Dependencies": {
+  "Hytale:EntityModule": "*",
+  "Hytale:BlockModule": "*"
+}
+```
diff --git a/content/docs/es-ES/guides/ecs/hytale-ecs-theory.mdx b/content/docs/es-ES/guides/ecs/hytale-ecs-theory.mdx
index 20c3a94d..52d8b1f5 100644
--- a/content/docs/es-ES/guides/ecs/hytale-ecs-theory.mdx
+++ b/content/docs/es-ES/guides/ecs/hytale-ecs-theory.mdx
@@ -29,7 +29,7 @@ for now this is the basic understanding for the `ChunkStore`. You can use it to
 
 ## Holder
 
-A Holder is essentially a blueprint for an entity. Before an entity exists in the Store (and thus in the world), is exists as a `Holder`. It collects and holds all the necessary components (data). You can compare it analogous to shopping cart. You grab all components you need and once you have everything, check out at the store which will take your cart and create a valid entity ID and hand you back a receipt (a Ref).
+A Holder is essentially a blueprint for an entity. Before an entity exists in the Store (and thus in the world), it exists as a `Holder`. It collects and holds all the necessary components (data). You can compare it analogous to shopping cart. You grab all components you need and once you have everything, check out at the store which will take your cart and create a valid entity ID and hand you back a receipt (a Ref).
 
 Let's take a look at an example: initializing players. In `Universe`, the `addPlayer` method demonstrates it perfectly.
 When a player connects, we don't immediately throw them into the ECS. We first construct their data in a Holder.
@@ -167,7 +167,7 @@ MyComponent comp = commandBuffer.getComponent(ref, componentType);
 
 Codecs handle serialization and deserialization of components. Hytale uses them to save and load entity data to and from disk as well as sending component data over the network. When creating a custom component, you must also create a corresponding Codec.
 
-There are mutliple Codec types already implemented in the default Codec Interface:
+There are multiple Codec types already implemented in the default Codec Interface:
 
 - Codec.STRING
 - Codec.BOOLEAN
@@ -215,7 +215,7 @@ This might seem tedious at first but it ensures that your component can be corre
   KeyedCodec<Integer> exampleInt = new KeyedCodec<Integer>("ExampleIntIdForCodec", Codec.INTEGER);
   ```
 
-- **Setter Function**: This is a lambda function that takes an instance of your component and returns the value of the field you want to serialize. For example, if you have a field called `myCustomField` in your custom component, your getter function would look like this:
+- **Setter Function**: This is a lambda function that takes an instance of your component + the value to set and sets the field value on the component. For example, if you have a field called `myCustomField` in your custom component, your setter function would look like this:
   ```java
   (data, value) -> data.myCustomField = value
   ```
@@ -276,7 +276,7 @@ public class PoisonComponent implements Component<EntityStore> {
 
 You can also add validators to your Codec fields to ensure that the data being serialized/deserialized meets certain criteria. For example, if you want to ensure that the `damagePerTick` field is always non-negative or the poison name is never null, you can add a validator like this:
 
-````java
+```java
 .append(
     new KeyedCodec<Float>("DamagePerTick", Codec.FLOAT),
     (data, value) -> data.damagePerTick = value,
@@ -292,14 +292,15 @@ You can also add validators to your Codec fields to ensure that the data being s
 )
 .addValidator(Validators.nonNull())
 .add()
+```
 
 ### Complex Codec Examples
 
-If you want to have a map inside your component, you can use the MapCodec class to build a KeyedCoded for it. Here's an example of how to create a Codec for a Map field:
+If you want to have a map inside your component, you can use the MapCodec class to build a KeyedCodec for it. Here's an example of how to create a Codec for a Map field:
 
 ```java
 var damagePerTick = new KeyedCodec<>("DamagePerTick", new MapCodec<>(Codec.FLOAT, HashMap<String, Float>::new));
-````
+```
 
 <Callout type="info">
   This also works with custom Objects as long as you have a Codec defined for the Object type.
diff --git a/content/docs/es-ES/guides/java-basics/00-introduction.mdx b/content/docs/es-ES/guides/java-basics/00-introduction.mdx
index 6f9e975f..94bb7736 100644
--- a/content/docs/es-ES/guides/java-basics/00-introduction.mdx
+++ b/content/docs/es-ES/guides/java-basics/00-introduction.mdx
@@ -7,7 +7,7 @@ description: Una guía de principiantes para entender los fundamentos de la prog
 
 ## ¿Qué es Java?
 
-Java es un lenguaje de programación potente y orientado a objetos creado en 1995. Es uno de los más populares en el mundo y se utiliza para todo, desde aplicaciones móviles hasta programas empresariales. Y lo más importante para nosotros, es el lenguaje que utiliza Hytale para sus servidores y su API de *modding*.
+Java es un lenguaje de programación potente y orientado a objetos creado en 1995. Es uno de los más populares en el mundo y se utiliza para todo, desde aplicaciones móviles hasta programas empresariales. Most importantly for us, it's the language Hytale uses for its servers & modding API.
 
 ## Qué vas a aprender
 
diff --git a/content/docs/es-ES/guides/java-basics/02-operators.mdx b/content/docs/es-ES/guides/java-basics/02-operators.mdx
index 1bc7a265..1ca10848 100644
--- a/content/docs/es-ES/guides/java-basics/02-operators.mdx
+++ b/content/docs/es-ES/guides/java-basics/02-operators.mdx
@@ -120,7 +120,7 @@ String greetingWithName = "Hello, " + name + "!"; // "Hello, Alice!"
 
 ## Operator Precedence
 
-Operator Precendence means which operator gets evaluated first in an line of code. Think of it like BODMAS/PEMDAS in math!
+Operator Precedence means which operator gets evaluated first in an line of code. Think of it like BODMAS/PEMDAS in math!
 
 ```java
 int result = 10 + 5 * 2; // result is 20, not 30
diff --git a/content/docs/es-ES/guides/java-basics/03-control-flow-if.mdx b/content/docs/es-ES/guides/java-basics/03-control-flow-if.mdx
index b9d6c479..af2d1c22 100644
--- a/content/docs/es-ES/guides/java-basics/03-control-flow-if.mdx
+++ b/content/docs/es-ES/guides/java-basics/03-control-flow-if.mdx
@@ -7,7 +7,7 @@ Programs need to make decisions. If statements let your code choose different pa
 
 ## Basic If Statement
 
-The simplest form checks one condition;
+The simplest form checks one condition:
 
 ```java
 int health = 20;
diff --git a/content/docs/es-ES/guides/java-basics/08-access-modifiers.mdx b/content/docs/es-ES/guides/java-basics/08-access-modifiers.mdx
index af560932..da2bf33b 100644
--- a/content/docs/es-ES/guides/java-basics/08-access-modifiers.mdx
+++ b/content/docs/es-ES/guides/java-basics/08-access-modifiers.mdx
@@ -484,7 +484,7 @@ class Data {
     // Static member:
     // cannot access to non-static variables
     public static void bar() {
-        x = 100; // Error: non-static variable x cannot be renference from a static context
+        x = 100; // Error: non-static variable x cannot be referenced from a static context
         y = 100; // OK
     }
 }
@@ -504,7 +504,7 @@ Data.x = 1000; // Error: cannot access instanced variables in a static context
 
 ### Static Fields
 
-A static field represents a data member owned by the class type rather then the object. Static fields are also stored in a specific memory location that's been shared between all the object instances that are created.
+A static field represents a data member owned by the class type rather than the object. Static fields are also stored in a specific memory location that's been shared between all the object instances that are created.
 
 It is declared as following:
 
diff --git a/content/docs/es-ES/guides/plugin/animated-block-textures.mdx b/content/docs/es-ES/guides/plugin/animated-block-textures.mdx
new file mode 100644
index 00000000..42bfa51f
--- /dev/null
+++ b/content/docs/es-ES/guides/plugin/animated-block-textures.mdx
@@ -0,0 +1,101 @@
+---
+title: Animated Block Textures
+description: Learn how to attach a .blockyanim to a block
+authors:
+  - name: Burkino
+---
+
+import { File, Folder, Files } from 'fumadocs-ui/components/files';
+
+So, you want to make your blocks feel more alive through animations, do you?\
+Now for the most part this is the exact same as [Creating custom blocks](./creating-block).
+![blue fire gif](/assets/guides/blue_fire.gif)
+
+## Prerequisites
+
+This is NOT a guide on animating or texturing or even using BlockBench, why? Because I don't know how to do that.\
+The only thing we will be doing is taking the fire texture, changing the color, and applying it to our new fire block.
+
+## Setup
+
+To start, you're obviously going to want to grab the `Common/VFX/Fire/Fire.png` file. How you do it is up to you, in the Asset Editor you'll need to switch to the Common tab.\
+I'll assume you know how colorize or change the hue of an image, so go ahead and do that now and save it as `Blue_Fire.png`.
+
+The other assets used in this guide are `Common/VFX/Fire/Fire.blockymodel` and `Common/Blocks/Animations/Fire/Fire_Burn.blockyanim` (both renamed to `Blue_Fire`) but since we won't be changing them it's probably fine to leave them. I will reference the `Blue_Fire` versions as a way to point out what should be custom assets.\
+I will also duplicate `Server/Item/Item/Deco/Deco_Fire.json` and call it `Deco_Blue_Fire.json`.
+
+## Applying the changes
+
+The `Deco_Blue_Fire` block is actually just a particle emitter, however we will not be using particles, so lets start by removing them in `Block > Particles`.\
+Next we want to set the Block Model (called `CustomModel` in JSON) to `VFX/Blue_Fire/Blue_Fire.blockymodel` and Block Model Textures (`CustomModelTexture` in JSON) to
+
+```json
+[
+    {
+        "Texture": "VFX/Blue_Fire/Blue_Fire.png",
+        "Weight": 1
+    }
+]
+```
+
+Finally, we will apply the .blockyanim to our model, this is done through the Block Model Animation property (`CustomModelAnimation` in JSON) and the value should be `Blocks/Animations/Blue_Fire/Blue_Fire_Burn.blockyanim`.
+
+## Final Code
+
+With that your new blue fire should be done. Here is the minimal JSON for our blue fire.\
+There is an additional `Looping` and `RequiresAlphaBlending` property that I have not gone over, however I hope it is self-explanatory.
+
+```json
+{
+  "BlockType": {
+    "DrawType": "Model",
+    "CustomModel": "VFX/Blue_Fire/Blue_Fire.blockymodel",
+    "CustomModelAnimation": "Blocks/Animations/Blue_Fire/Blue_Fire_Burn.blockyanim",
+    "CustomModelTexture": [
+      {
+        "Texture": "VFX/Blue_Fire/Blue_Fire.png",
+        "Weight": 1
+      }
+    ],
+    "Looping": true,
+    "RequiresAlphaBlending": false
+  },
+  "PlayerAnimationsId": "Block"
+}
+```
+
+<Files>
+  <Folder name="resources" defaultOpen>
+    <Folder name="Server" defaultOpen>
+      <Folder name="Item" defaultOpen>
+        <Folder name="Items" defaultOpen>
+          <Folder name="Deco" defaultOpen>
+            <File name="Deco_Blue_Fire.json" />
+          </Folder>
+        </Folder>
+      </Folder>
+    </Folder>
+
+    <Folder name="Common" defaultOpen>
+      <Folder name="Blocks" defaultOpen>
+        <Folder name="Animations" defaultOpen>
+          <Folder name="Blue_Fire" defaultOpen>
+            <File name="Blue_Fire_Burn.blockyanim" />
+          </Folder>
+        </Folder>
+      </Folder>
+
+      <Folder name="VFX" defaultOpen>
+        <Folder name="Blue_Fire" defaultOpen>
+          <File name="Blue_Fire.blockymodel" />
+
+          <File name="Blue_Fire.png" />
+        </Folder>
+      </Folder>
+    </Folder>
+  </Folder>
+</Files>
+
+## Next steps
+
+Now that you know how to attach an animation to a block, try adding it to a block state.
diff --git a/content/docs/es-ES/guides/plugin/build-and-test.mdx b/content/docs/es-ES/guides/plugin/build-and-test.mdx
index 0e7fe7eb..f37534c3 100644
--- a/content/docs/es-ES/guides/plugin/build-and-test.mdx
+++ b/content/docs/es-ES/guides/plugin/build-and-test.mdx
@@ -9,18 +9,18 @@ If you followed along with the [Setting Up Your Development Environment](./setti
 
 ## Building Your Mod
 
-In our case, we've **Maven** as the build system. Maven is a powerful build automation tool that manages dependencies, compiles your code, and packages everything into a distributable JAR file.
+In our case, we've **Gradle** as the build system. Gradle is a powerful build automation tool that manages dependencies, compiles your code, and packages everything into a distributable JAR file.
 
-### Understanding Maven
+### Understanding Gradle
 
-Maven uses a `pom.xml` file (Project Object Model) to define your project's configuration, dependencies, and build settings. You can learn more about Maven at the [official Apache Maven website](https://maven.apache.org/).
+Gradle can use a `build.gradle.kts` file (Kotlin DSL) to define your project's configuration, dependencies, and build settings. You can learn more about Gradle at the [official Gradle website](https://gradle.org/).
 
-### Building with Maven
+### Building with Gradle
 
 To build your mod, open a terminal in your project directory and run:
 
 ```bash
-mvn package
+./gradlew build
 ```
 
 This command will:
@@ -29,16 +29,35 @@ This command will:
 2. Run any tests (if present)
 3. Package everything into a JAR file
 
+<Callout type="info">
+  If you are using the plugin template from the [Setting Up Your Development Environment](./setting-up-env) guide, then the build script is already set up for you. It includes paths to your Hytale game library and handles the packaging of your mod, managing hytale dependencies and manifest changes.
+
+  If you have a different path to your Hytale installation, you may receive the following error:
+
+  ```bash
+  FAILURE: Build failed with an exception.
+
+  * What went wrong:
+  Failed to find Hytale at the expected location. Please make sure you have installed the game. The expected location can be changed using the hytale.home_path property. Currently looking in 'C:\Path\To\Hytale'
+  ```
+
+  You can change the path by adding a property to your `gradle.properties` file (if it doesn't exist, create it in the root of your project):
+
+  ```properties
+  hytale.home_path=C:\Correct\Path\To\Hytale
+  ```
+</Callout>
+
 ### Build Output
 
-Once the build completes successfully, your mod will be located in the `target` directory and named:
+Once the build completes successfully, your mod will be located in the `build/libs` directory and named:
 
 ```
-ExamplePlugin-1.0-SNAPSHOT.jar
+ExamplePlugin-1.0.jar
 ```
 
 <Callout type="info">
-  The exact name may vary depending on what you configured in your `pom.xml` file. Check the `artifactId` and `version` fields to see what your JAR will be named.
+  The exact name may vary depending on what you configured in your `build.gradle.kts` and `settings.gradle.kts` file. Check the `rootProject.name` and `version` fields to see what your JAR will be named.
 </Callout>
 
 ## Testing Your Mod
@@ -49,11 +68,11 @@ Now that you've built your mod, it's time to test it in Hytale!
 
 First, you need to find Hytale's mods directory:
 
-1. Press **Win + R** on your keyboard
-2. Type `%appdata%` and press Enter
-3. Navigate to: `Hytale\UserData\Mods`
+1. Go to your Hytale installation directory (The default location is usually in your AppData folder)
+   > On Windows, you can access it by clicking `windows + R` and typing `%appdata%`.
+2. Navigate to: `/UserData/Mods`
 
-The full path should look like:
+The default path would look like:
 
 ```
 C:\Users\YourUsername\AppData\Roaming\Hytale\UserData\Mods
@@ -65,7 +84,7 @@ C:\Users\YourUsername\AppData\Roaming\Hytale\UserData\Mods
 
 ### 2. Copy Your Mod
 
-Copy the `ExamplePlugin-1.0-SNAPSHOT.jar` file from your project's `target` directory into the `Mods` folder you just located.
+Copy the `ExamplePlugin-1.0.jar` file from your project's `build/libs` directory into the `Mods` folder you just located.
 
 ### 3. Launch Hytale and Verify
 
@@ -84,7 +103,7 @@ If your mod doesn't appear in the mods list:
 - Make sure the JAR file is in the correct `Mods` folder
 - Check that your `manifest.json` file is properly configured
 - Look for any error messages in the Hytale logs
-- Verify that you're using the correct version of Java and Maven
+- Verify that you're using the correct version of Java and Gradle
 
 ## Next Steps
 
diff --git a/content/docs/es-ES/guides/plugin/creating-commands.mdx b/content/docs/es-ES/guides/plugin/creating-commands.mdx
index d33597f3..08572f16 100644
--- a/content/docs/es-ES/guides/plugin/creating-commands.mdx
+++ b/content/docs/es-ES/guides/plugin/creating-commands.mdx
@@ -8,6 +8,8 @@ authors:
     url: https://oskar.scot
   - name: jacobwojoski
     url: https://github.com/jacobwojoski
+  - name: Marcel-TO
+    url: https://marcel-to.net
 ---
 
 In this guide, you will learn how to create custom commands for your Hytale mod.
@@ -36,7 +38,7 @@ The most basic command is an `AbstractAsyncCommand`. It has very minimal data av
   `AbstractAsyncCommand` runs on its own background thread. This means its execute is not tied to any world instance and because of this it can not edit any **Stores** or **Refs** without getting the desired world first. To access this data any of the other command types would be preferred and are likely what you will want to use instead.
 </Callout>
 
-The main purpose for a command like this would be for something that can happen everywhere and is not tied to a specific world. For example a `serverRules` command to tell the user thats running the command in chat what the servers rules are nomatter what world they are in.
+The main purpose for a command like this would be for something that can happen everywhere and is not tied to a specific world. For example a `serverRules` command to tell the user that's running the command in chat what the server's rules are no matter what world they are in.
 
 ```java
 // Command that can be run that lists the server rules in chat to the player
@@ -49,7 +51,7 @@ public class ServerRulesCommand extends AbstractAsyncCommand {
     }
 
     // Run the command
-    // conetext - info about who ran the command. Server console?, Some player?
+    // context - info about who ran the command. Server console?, Some player?
     @Override
     protected CompletableFuture<Void> executeAsync(@Nonnull CommandContext context) {
         context.sendMessage(Message.raw("The only rule is there are no rules."));
@@ -134,7 +136,7 @@ Uses a Ray to see what the player is looking at and tries to run the command on
 
 ## Adding Arguments
 
-Arguments are additional fields that the user can input when running a command. The different types of arguments along with small snipits and a large example can be seen below.
+Arguments are additional fields that the user can input when running a command. The different types of arguments along with small snippets and a large example can be seen below.
 
 ### Command Argument Types
 
@@ -163,14 +165,14 @@ this.messageArg = this.withOptionalArg("message", "Message to print while healin
 
 ### Default Arguments
 
-Adding a default argument has two additional arguemnt for the default value and default value description. You need to use `withDefaultArg` method.
+Adding a default argument has two additional argument for the default value and default value description. You need to use `withDefaultArg` method.
 
 ```java
 // args <Command String> <Description> <Default Value> <Desc of default value>
 this.healthArg = this.withDefaultArg("health", "Amount to heal player", ArgTypes.FLOAT, (float)100, "Desc of Default: 100");
 ```
 
-### Flag Arguemnts
+### Flag Arguments
 
 Similar as above but the flags return is either true if it exists or false if it does not. You need to use `withFlagArg` method.
 
@@ -181,20 +183,13 @@ this.debugArg = this.withFlagArg("debug", "Add debug logs");
 
 ### ArgTypes
 
-The following ArgTypes are available (only lists common types):
-
-- `ArgTypes.STRING`
-- `ArgTypes.INTEGER`
-- `ArgTypes.BOOLEAN`
-- `ArgTypes.FLOAT`
-- `ArgTypes.DOUBLE`
-- `ArgTypes.UUID`
+You can find all the available argument types on the [ArgTypes](../../argtypes) page.
 
 ### Example Command Arg Types
 
-Shows all Command arguemnt types with different various input types.
+Shows all Command argument types with different various input types.
 
-**NOTE:** When getting the value of an argument during execute you need to pass the context with `someArg.get(commandContext)`. Where `commandContext` is the first variable in the execute funtion.
+**NOTE:** When getting the value of an argument during execute you need to pass the context with `someArg.get(commandContext)`. Where `commandContext` is the first variable in the execute function.
 
 ```java
 // Example usage: /healplayer --health 50 --message "Feels Good" --debug
@@ -204,7 +199,7 @@ public class HealPlayerCommand extends AbstractTargetPlayerCommand {
     private final FlagArg debugArg;
 
     public HealPlayerCommand() {
-        super("healplayer", "Healing a player for an <input> ammount of HP (default: 100)");
+        super("healplayer", "Healing a player for an <input> amount of HP (default: 100)");
 
         // Abstract TargetPlayerCommand passes the player that ran the command by default and implements
         // the use of `--player <value>` to specify someone else
@@ -213,10 +208,10 @@ public class HealPlayerCommand extends AbstractTargetPlayerCommand {
         this.healthArg = this.withDefaultArg("health", "Amount to heal player", ArgTypes.FLOAT, (float)100, "Desc of Default: 100");
 
         // Or you could do the following making the health value required instead of with a default.
-        //    You would need to change the decleration to RequiredArg<Float>
+        //    You would need to change the declaration to RequiredArg<Float>
         // this.healthArg = this.withRequiredArg("health", "Amount to heal player", ArgTypes.FLOAT);
 
-        // Optional args reguare the user the input `--<key> <value>` so the following would require `--message "Good Luck"`
+// Optional args require the user the input `--<key> <value>` so the following would require `--message "Good Luck"`
         this.messageArg = this.withOptionalArg("message", "Message to print while healing", ArgTypes.STRING);
 
         // No type needed due to being a bool
@@ -230,7 +225,7 @@ public class HealPlayerCommand extends AbstractTargetPlayerCommand {
             commandContext.sendMessage(Message.raw("We are debugging"));
         }
 
-        // Health is stored in a generic stat map to allowing mods/future contect to easily add more stats if desired.
+        // Health is stored in a generic stat map to allowing mods/future content to easily add more stats if desired.
         EntityStatMap stats = store.getComponent(ref, EntityStatMap.getComponentType());
         int healthIdx = DefaultEntityStatTypes.getHealth();
         EntityStatValue health = stats.get(healthIdx);
@@ -252,7 +247,7 @@ public class HealPlayerCommand extends AbstractTargetPlayerCommand {
 
 ## Argument Validators
 
-Argument validators are a way to check the command before the command gets executed. They are added with the `addValidator` method on an argument when calling `withXxxArg`. They provide a nice output to the user when an input value is invalid.
+Argument validators are a way to check the command before the command gets executed. They are added with the `addValidator` method on an argument when calling `withXxxArg`. They provide a nice output to the user when an input value is invalid. There are some common validators provided in the `Validators` class such as `greaterThan`, `lessThan`, and `or`, `max`, `range`, etc.
 
 ```java
 ...
@@ -260,18 +255,59 @@ Argument validators are a way to check the command before the command gets execu
     OptionalArg<Integer> healAmount = withOptionalArg("amount", "Heal Amount", ArgTypes.INTEGER)
         .addValidator(Validators.greaterThan(0))
         .addValidator(Validators.lessThan(1000));
-
-    // Custom check example
-    OptionalArg<Integer> healAmount = withOptionalArg("amount", "Heal Amount", ArgTypes.INTEGER)
-            .addValidator( value -> {
-                if (value != null && value <= 0) {
-                    return ValidationResult.error("ammount argument must be a positive number");
-                }
-                return ValidationResult.success();
-            });
 ...
 ```
 
+### Custom Validators
+
+You can also create custom validators by implementing the `com.hypixel.hytale.codec.validation.Validator` interface. The interfaces forces you to implement the `accept` and `updateSchema` method. The `accept` method takes in the argument value and validates it. If the validation fails, you can use the `fail` method of the `com.hypixel.hytale.codec.validation.ValidationResults` class to return an error message.
+The `updateSchema` method is used to update the schema of the command argument. This is used for commands that have dynamic schemas based on the input value. For example, if you have a command that takes in a player name as an argument, you can use the `updateSchema` method to update the schema to include a list of online players for validation.
+
+Here is an example of a custom validator that checks if a string value is equal to a banned word. In this example, the banned word is "badword". If the input value is "badword", the validator will fail and return an error message.
+
+```java
+import com.hypixel.hytale.codec.schema.SchemaContext;
+import com.hypixel.hytale.codec.schema.config.Schema;
+import com.hypixel.hytale.codec.validation.ValidationResults;
+import com.hypixel.hytale.codec.validation.Validator;
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+
+public class MyCustomValidator implements Validator<String> {
+    @Nonnull
+    private final String value;
+
+    public MyCustomValidator(@Nonnull String value) {
+        this.value = value;
+    }
+
+    @Override
+    public void accept(@Nullable String input, @Nonnull ValidationResults results) {
+        if (this.value.equalsIgnoreCase(input)) {
+            results.fail("The given role has been banned.");
+        }
+    }
+
+    @Override
+    public void updateSchema(SchemaContext context, @Nonnull Schema target) {
+        // This method can be used to update the schema of the command argument. This is useful for commands that have dynamic schemas based on the input value. For example, if you have a command that takes in a player name as an argument, you can use the `updateSchema` method to update the schema to include a list of online players for validation.
+        throw new UnsupportedOperationException("Not implemented yet.");
+    }
+}
+```
+
+After the custom validator is created, you can add it to an argument like the following example. In this example, we add the `MyCustomValidator` to a string argument called "role". If the user inputs "badword" as the role, the command will fail and return the error message defined in the `MyCustomValidator`.
+
+```java
+    ...
+    // Custom validator example
+    String bannedRole = "badword";
+
+    OptionalArg<String> roleArg = withOptionalArg("role", "Role to assign", ArgTypes.STRING)
+        .addValidator(new MyCustomValidator(bannedRole));
+    ...
+```
+
 ---
 
 ## Permissions
@@ -312,7 +348,7 @@ This allows the server to control who has access to specific commands. You add t
 
 If you want variants of the same command without doing argument parsing you can instead use `addUsageVariant(new OtherCommandClass())` in the original commands constructor.
 
-The only difference is in the `OtherCommandClass()` constrcutor you don't pass the command name to the super class.
+The only difference is in the `OtherCommandClass()` constructor you don't pass the command name to the super class.
 
 <Callout type="info">
   You can also use `addAliases("some_alias", "some_other_alias")` as a way to add shorthand or other ways to write the same command.
@@ -387,7 +423,7 @@ public class AdminCommand extends AbstractCommandCollection {
     public AdminCommand () {
         super("admin", "Admin commands");
         addSubCommand(new UserCommandCollection());
-        addSybCommand(new ServerCommandCollection);
+        addSubCommand(new ServerCommandCollection);
     }
 }
 ```
@@ -417,5 +453,5 @@ public class MyPlugin extends JavaPlugin {
 
 ## Video Link
 
-_Special Thanks to [TroubleDev](https://www.youtube.com/@TroubleDEV) for his excelent video guide on all of these features._
+_Special Thanks to [TroubleDev](https://www.youtube.com/@TroubleDEV) for his excellent video guide on all of these features._
 _Video Link: [TroubleDev - Hytale's Command API Explained](https://www.youtube.com/watch?v=KnmhG9MDMgo)_
diff --git a/content/docs/es-ES/guides/plugin/creating-events.mdx b/content/docs/es-ES/guides/plugin/creating-events.mdx
index 95863990..d3f0925d 100644
--- a/content/docs/es-ES/guides/plugin/creating-events.mdx
+++ b/content/docs/es-ES/guides/plugin/creating-events.mdx
@@ -1,6 +1,6 @@
 ---
-title: Creating Events
-description: Learn how to create custom events for your Hytale mod.
+title: Creating Events Listeners
+description: Learn how to create event listeners for your Hytale mod.
 authors:
   - name: Neil Revin
     url: https://itsneil.dev
@@ -10,7 +10,7 @@ authors:
 
 ## Event Class
 
-You can import a Event class and create a function with the Event as a argument. [Click here](../../server/events) to look at all available events.
+You can import an Event class and create a function with the Event as an argument. [Click here](../../server/events) to look at all available events.
 
 Example plugin when a player is ready (joins a server):
 
diff --git a/content/docs/es-ES/guides/plugin/item-registry.mdx b/content/docs/es-ES/guides/plugin/item-registry.mdx
new file mode 100644
index 00000000..9a0fd53a
--- /dev/null
+++ b/content/docs/es-ES/guides/plugin/item-registry.mdx
@@ -0,0 +1,95 @@
+---
+title: Working with the Item Registry
+description: Learn how to access and query the game's item registry to list all items, check if items exist, and retrieve item properties.
+authors:
+  - name: Denis
+---
+
+In this guide, you'll learn how to work with Hytale's Item Registry system. This is useful when you need to programmatically list all available items, validate item IDs, or retrieve item properties at runtime.
+
+## Prerequisites
+
+Before diving in, you should be familiar with:
+
+- [Setting up your development environment](./setting-up-env)
+- [Creating commands](./creating-commands) (optional, for testing)
+
+## Required Imports
+
+To work with the Item Registry, you'll need the following imports:
+
+```java
+import com.hypixel.hytale.assetstore.map.DefaultAssetMap;
+import com.hypixel.hytale.server.core.asset.type.item.config.Item;
+```
+
+## Getting the Item Registry
+
+The Item Registry is accessed through the `Item.getAssetMap()` method, which returns a `DefaultAssetMap<String, Item>` containing all registered items in the game:
+
+```java
+DefaultAssetMap<String, Item> itemMap = Item.getAssetMap();
+```
+
+## Listing All Items
+
+To iterate through all items in the registry, you can get the underlying map and loop through its entries:
+
+```java
+DefaultAssetMap<String, Item> itemMap = Item.getAssetMap();
+var map = itemMap.getAssetMap();
+
+for (var entry : map.entrySet()) {
+    String itemId = String.valueOf(entry.getKey());
+    Item item = entry.getValue();
+    
+    // Do something with the item
+    LOGGER.atInfo().log("Item ID: " + itemId);
+}
+```
+
+You can also get the total count of registered items:
+
+```java
+int totalItems = map.size();
+```
+
+## Checking if an Item Exists
+
+To check if a specific item exists in the registry, use `getAsset()` and verify the result:
+
+```java
+public boolean itemExists(String itemId) {
+    var assetMap = Item.getAssetMap();
+    if (assetMap != null) {
+        Item item = assetMap.getAsset(itemId);
+        return item != null && item != Item.UNKNOWN;
+    }
+    return false;
+}
+```
+
+<Callout type="info">
+  The `Item.UNKNOWN` constant represents an invalid or unrecognized item. Always check for both `null` and `Item.UNKNOWN` when validating items.
+</Callout>
+
+## Accessing Item Properties
+
+Once you have an `Item` instance, you can access various properties:
+
+```java
+var assetMap = Item.getAssetMap();
+Item item = assetMap.getAsset("Soil_Grass");
+
+if (item != null && item != Item.UNKNOWN) {
+    String id = item.getId(); // Soil_Grass
+    int maxStack = item.getMaxStack(); // 100
+    boolean isBlock = item.hasBlockType(); // true
+    boolean isConsumable = item.isConsumable(); // false
+}
+```
+
+## Related Guides
+
+- [Inventory Management](./inventory-management) - Learn how to add and remove items from player inventories
+- [Create Custom Item and Interaction](./item-interaction) - Learn how to create your own custom items
diff --git a/content/docs/es-ES/guides/plugin/permission-management.mdx b/content/docs/es-ES/guides/plugin/permission-management.mdx
index 6b7cfd46..55f06101 100644
--- a/content/docs/es-ES/guides/plugin/permission-management.mdx
+++ b/content/docs/es-ES/guides/plugin/permission-management.mdx
@@ -10,132 +10,569 @@ authors:
     link: https://discord.com/users/292656109939064833
   - name: Ivan
     link: https://discord.com/users/505770451218333717
+  - name: ZenithDevHQ
+    link: https://github.com/ZenithDevHQ
 ---
 
-In this guide, you'll learn how to manage permission nodes and groups in your Hytale plugin.
+In this guide, you'll learn how to manage permission nodes and groups in your Hytale plugin. Permissions control what actions players can perform on your server, from basic commands to advanced administrative functions.
 
-## The `PermissionsModule` class
+## What Are Permissions?
 
-The `PermissionsModule` class is responsible for managing permission nodes and groups in your plugin. It provides methods to check, grant and revoke permissions and groups for players. It allows the following operations
+Permissions are string identifiers that control access to features and commands. When a player tries to perform an action (like using a command), the server checks if they have the required permission.
 
-- Add permissions to user
-- Remove permissions from user
-- Add permissions to group (this also creates the group if it doesn't exist)
-- Remove permissions from group
-- Add user to group
-- Remove user from group
-- List all groups for a user
-- Check if a user has a permission (it checks both user and group permissions for the given player UUID)
+**Example permission nodes:**
 
-With this class you cannot:
+- `hytale.command.gamemode` - Permission to use the gamemode command
+- `hytale.editor.brush.use` - Permission to use brush tools
+- `myplugin.teleport.home` - A custom permission for your plugin
 
-- List all defined groups
-- Remove a group
+Permissions follow a hierarchical naming pattern: `namespace.category.action`
 
-### Adding Permission Nodes
+## Key Concepts
 
-You need a `Set<String>` containing all the permission nodes you want to add, these are added on top of the already existing permission nodes the user may have, it is not a replacement.
+Before diving into code, let's understand the core concepts:
+
+| Concept             | Description                                                                |
+| ------------------- | -------------------------------------------------------------------------- |
+| **Permission Node** | A string like `myplugin.feature.use` that represents a specific permission |
+| **Group**           | A named collection of permissions (e.g., "Admin", "VIP", "Default")        |
+| **Provider**        | The backend that stores and retrieves permissions                          |
+| **Wildcard**        | A pattern like `*` or `myplugin.*` that matches multiple permissions       |
+
+### How Permissions Are Checked
+
+When checking if a player has a permission, Hytale follows this order:
+
+1. **User's direct permissions** - Permissions granted directly to the player
+2. **Group permissions** - Permissions from groups the player belongs to
+3. **Virtual groups** - Game-mode-based permissions (e.g., Creative mode grants builder tools)
+4. **Default value** - Falls back to `false` if no match found
+
+<Callout type="info">
+  The first definitive match wins. If a player has a permission granted at the user level, group permissions won't override it.
+</Callout>
+
+---
+
+## The `PermissionsModule` Class
+
+The `PermissionsModule` class is the central hub for managing permissions. Access it using the singleton pattern:
 
 ```java
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.addUserPermission(playerUUID, permissions);
 ```
 
-### Removing Permission Nodes
+### Available Operations
+
+The module supports these operations:
+
+| Operation                     | Method                                          |
+| ----------------------------- | ----------------------------------------------- |
+| Add permissions to user       | `addUserPermission(uuid, permissions)`          |
+| Remove permissions from user  | `removeUserPermission(uuid, permissions)`       |
+| Add permissions to group      | `addGroupPermission(groupName, permissions)`    |
+| Remove permissions from group | `removeGroupPermission(groupName, permissions)` |
+| Add user to group             | `addUserToGroup(uuid, groupName)`               |
+| Remove user from group        | `removeUserFromGroup(uuid, groupName)`          |
+| Get user's groups             | `getGroupsForUser(uuid)`                        |
+| Check permission              | `hasPermission(uuid, permissionNode)`           |
+
+<Callout type="warning">
+  The module does **not** support:
+
+  - Listing all defined groups
+  - Deleting a group entirely
+
+  Groups are implicitly created when you first add permissions to them.
+</Callout>
+
+---
 
-Same as above, we just use the `removeUserPermission` method instead to remove permission nodes.
+## Checking Permissions
+
+The most common operation is checking if a player has a permission.
+
+### Basic Permission Check
+
+```java
+// Returns true if player has the permission, false otherwise
+boolean canUse = PermissionsModule.get().hasPermission(playerUUID, "myplugin.feature.use");
+
+if (canUse) {
+    // Player has permission, allow the action
+} else {
+    // Player lacks permission, deny or show error
+}
+```
+
+### Permission Check with Default Value
+
+You can specify what to return when no permission is explicitly set:
+
+```java
+// Returns true by default if no explicit permission is found
+boolean canUse = PermissionsModule.get().hasPermission(playerUUID, "myplugin.feature.use", true);
+```
+
+This is useful for features that should be enabled by default but can be revoked.
+
+### Using PermissionHolder Interface
+
+Players and command senders implement `PermissionHolder`, allowing direct checks:
+
+```java
+// In a command or event handler where you have access to the player
+if (player.hasPermission("myplugin.admin.manage")) {
+    // Player has admin permission
+}
+```
+
+---
+
+## Managing User Permissions
+
+### Adding Permissions to a User
+
+Permissions are additive - new permissions are added on top of existing ones, not replaced.
+
+```java
+PermissionsModule perms = PermissionsModule.get();
+
+// Add a single permission
+perms.addUserPermission(playerUUID, Set.of("myplugin.vip.chat"));
+
+// Add multiple permissions at once
+Set<String> newPerms = Set.of(
+    "myplugin.vip.chat",
+    "myplugin.vip.fly",
+    "myplugin.vip.kit"
+);
+perms.addUserPermission(playerUUID, newPerms);
+```
+
+### Removing Permissions from a User
 
 ```java
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.removeUserPermission(playerUUID, permissions);
+
+// Remove specific permissions
+Set<String> toRemove = Set.of("myplugin.vip.fly");
+perms.removeUserPermission(playerUUID, toRemove);
 ```
 
-### Add permissions to group
+---
+
+## Managing Groups
+
+Groups let you assign a collection of permissions to multiple players. This is more manageable than assigning permissions individually.
+
+### Adding Permissions to a Group
+
+If the group doesn't exist, it will be created automatically.
 
 ```java
-String groupName = "testGroup";
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.addGroupPermission(groupName, permissions);
+
+// Create/update the "VIP" group with permissions
+Set<String> vipPerms = Set.of(
+    "myplugin.vip.chat",
+    "myplugin.vip.fly",
+    "myplugin.vip.kit"
+);
+perms.addGroupPermission("VIP", vipPerms);
 ```
 
-### Remove permissions from group
+### Removing Permissions from a Group
 
 ```java
-String groupName = "testGroup";
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.removeGroupPermission(groupName, permissions);
+
+// Remove specific permissions from the group
+Set<String> toRemove = Set.of("myplugin.vip.fly");
+perms.removeGroupPermission("VIP", toRemove);
 ```
 
-### Add user to group
+### Adding a User to a Group
 
 ```java
-String groupName = "testGroup";
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.addUserToGroup(playerUUID, groupName);
+
+// Add player to the VIP group - they now have all VIP permissions
+perms.addUserToGroup(playerUUID, "VIP");
 ```
 
-### Remove user from group
+### Removing a User from a Group
 
 ```java
-String groupName = "testGroup";
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.removeUserFromGroup(playerUUID, groupName);
+
+// Remove player from VIP group
+perms.removeUserFromGroup(playerUUID, "VIP");
 ```
 
-### List all groups for a user
+### Getting a User's Groups
 
 ```java
 PermissionsModule perms = PermissionsModule.get();
-perms.getGroupsForUser(playerUUID);
+
+// Get all groups the player belongs to
+Set<String> groups = perms.getGroupsForUser(playerUUID);
+
+for (String group : groups) {
+    System.out.println("Player is in group: " + group);
+}
 ```
 
-### Check Permission Nodes
+---
+
+## Built-in Groups
+
+Hytale includes two default groups:
+
+| Group     | Default Permissions   | Purpose                           |
+| --------- | --------------------- | --------------------------------- |
+| `OP`      | `*` (all permissions) | Server operators with full access |
+| `Default` | None                  | Base group for all players        |
+
+Players without any explicit group assignment are automatically part of the `Default` group.
 
-To check if a player has a specific permission node, you can use the `hasPermission` method.
+---
+
+## Wildcards
+
+Wildcards let you grant or deny multiple permissions with a single pattern.
+
+### Wildcard Patterns
+
+| Pattern             | Meaning                                          |
+| ------------------- | ------------------------------------------------ |
+| `*`                 | Grants **all** permissions                       |
+| `myplugin.*`        | Grants all permissions starting with `myplugin.` |
+| `-*`                | Denies **all** permissions                       |
+| `-myplugin.admin.*` | Denies all admin permissions in your plugin      |
+
+### Example: Admin Group with Wildcards
 
 ```java
-boolean hasPermission = PermissionsModule.hasPermission(playerUUID, "permission.node");
+// Grant all permissions to admins
+perms.addGroupPermission("Admin", Set.of("*"));
+
+// Grant all plugin permissions to moderators
+perms.addGroupPermission("Moderator", Set.of("myplugin.*"));
+
+// Grant all permissions except admin commands
+perms.addGroupPermission("Helper", Set.of(
+    "*",
+    "-myplugin.admin.*"  // Deny admin permissions
+));
 ```
 
-## Additional: Defining your own provider for permissions and groups
+<Callout type="warning">
+  Negation permissions (starting with `-`) take precedence at each level. Use them carefully to avoid accidentally blocking permissions.
+</Callout>
+
+---
+
+## Built-in Permission Nodes
+
+Hytale provides constants for common permissions in the `HytalePermissions` class:
+
+### Command Permissions
+
+```java
+// Generate permission for a command
+String perm = HytalePermissions.fromCommand("gamemode");
+// Result: "hytale.command.gamemode"
+
+// Generate permission for a subcommand
+String perm = HytalePermissions.fromCommand("gamemode", "creative");
+// Result: "hytale.command.gamemode.creative"
+```
+
+### Common Permission Nodes
+
+| Permission                    | Description                  |
+| ----------------------------- | ---------------------------- |
+| `hytale.command.op.add`       | Add players to OP group      |
+| `hytale.command.op.remove`    | Remove players from OP group |
+| `hytale.editor.brush.use`     | Use brush tools              |
+| `hytale.editor.prefab.use`    | Use prefabs                  |
+| `hytale.editor.selection.use` | Use selection tools          |
+| `hytale.editor.history`       | Undo/redo operations         |
+| `hytale.camera.flycam`        | Use fly camera mode          |
+
+---
+
+## Listening to Permission Events
+
+You can react to permission changes using Hytale's event system.
+
+### Available Events
+
+| Event                                            | Triggered When                   |
+| ------------------------------------------------ | -------------------------------- |
+| `PlayerPermissionChangeEvent.PermissionsAdded`   | Permissions added to a user      |
+| `PlayerPermissionChangeEvent.PermissionsRemoved` | Permissions removed from a user  |
+| `PlayerGroupEvent.Added`                         | User added to a group            |
+| `PlayerGroupEvent.Removed`                       | User removed from a group        |
+| `GroupPermissionChangeEvent.Added`               | Permissions added to a group     |
+| `GroupPermissionChangeEvent.Removed`             | Permissions removed from a group |
 
-The PermissionsModule also enables us to define our own PermissionProvider's, this can be useful for:
+### Example: Reacting to Permission Changes
 
-- Cross server permission systems
-- Implementing features missing in the `HytalePermissionsProvider` like permission expiry
+```java
+public class PermissionListener {
+
+    public static void onPermissionsAdded(PlayerPermissionChangeEvent.PermissionsAdded event) {
+        UUID playerUUID = event.getPlayerUuid();
+        Set<String> added = event.getAddedPermissions();
+
+        System.out.println("Permissions added to " + playerUUID + ": " + added);
 
-To implement our PermissionProvider, first we need to define a provider class that implements PermissionProvider:
+        // Maybe notify the player or update cached data
+    }
+
+    public static void onGroupAdded(PlayerGroupEvent.Added event) {
+        UUID playerUUID = event.getPlayerUuid();
+        String groupName = event.getGroupName();
+
+        System.out.println("Player " + playerUUID + " joined group: " + groupName);
+    }
+}
+```
+
+### Registering the Events
 
 ```java
-public class DatabasePermissionProvider implements PermissionProvider
+public class MyPlugin extends JavaPlugin {
+
+    @Override
+    public void setup() {
+        EventRegistry events = this.getEventRegistry();
+
+        events.registerGlobal(
+            PlayerPermissionChangeEvent.PermissionsAdded.class,
+            PermissionListener::onPermissionsAdded
+        );
+
+        events.registerGlobal(
+            PlayerGroupEvent.Added.class,
+            PermissionListener::onGroupAdded
+        );
+    }
+}
 ```
 
-Then we just implement the required methods using a database implementation.
+---
+
+## Creating a Custom Permission Provider
+
+For advanced use cases, you can create your own permission provider. This is useful for:
+
+- Database-backed permissions (MySQL, MongoDB, etc.)
+- Cross-server permission synchronization
+- Custom features like permission expiry or contexts
+
+### Implementing PermissionProvider
+
+```java
+public class DatabasePermissionProvider implements PermissionProvider {
+
+    @Nonnull
+    @Override
+    public String getName() {
+        return "DatabasePermissionProvider";
+    }
+
+    // User permission methods
+    @Override
+    public void addUserPermissions(@Nonnull UUID uuid, @Nonnull Set<String> permissions) {
+        // Save to your database
+    }
+
+    @Override
+    public void removeUserPermissions(@Nonnull UUID uuid, @Nonnull Set<String> permissions) {
+        // Remove from your database
+    }
+
+    @Override
+    public Set<String> getUserPermissions(@Nonnull UUID uuid) {
+        // Query your database
+        return Set.of();
+    }
+
+    // Group permission methods
+    @Override
+    public void addGroupPermissions(@Nonnull String group, @Nonnull Set<String> permissions) {
+        // Save to your database
+    }
+
+    @Override
+    public void removeGroupPermissions(@Nonnull String group, @Nonnull Set<String> permissions) {
+        // Remove from your database
+    }
+
+    @Override
+    public Set<String> getGroupPermissions(@Nonnull String group) {
+        // Query your database
+        return Set.of();
+    }
+
+    // User-group membership methods
+    @Override
+    public void addUserToGroup(@Nonnull UUID uuid, @Nonnull String group) {
+        // Save to your database
+    }
+
+    @Override
+    public void removeUserFromGroup(@Nonnull UUID uuid, @Nonnull String group) {
+        // Remove from your database
+    }
+
+    @Override
+    public Set<String> getGroupsForUser(@Nonnull UUID uuid) {
+        // Query your database
+        return Set.of("Default");
+    }
+}
+```
 
 <Callout type="warning">
-  Hytale will try to use the first available permissions provider to add/remove gamemode groups (i.e. `Creative`, `Adventure`).
+  Hytale automatically assigns players to game-mode groups (like `Creative` or `Adventure`) using the first available provider.
+
+  If your provider throws an error when the group doesn't exist, the player will be disconnected! Always handle missing groups gracefully.
+</Callout>
+
+### Registering Your Provider
 
-  If your provider throws an error (for instance, if the group does not exist) when the server is preparing the player, the player will be disconnected.
+```java
+public class MyPlugin extends JavaPlugin {
+
+    @Override
+    public void setup() {
+        // Add your provider alongside the default one
+        PermissionsModule.get().addProvider(new DatabasePermissionProvider());
+    }
+}
+```
+
+The `PermissionsModule` aggregates permissions from all registered providers. This means:
+
+- Permission checks query all providers
+- Write operations (add/remove) use the **first** provider
+
+### Replacing the Default Provider
+
+If you want full control, you can remove the default provider:
+
+```java
+public class MyPlugin extends JavaPlugin {
+
+    @Override
+    public void setup() {
+        PermissionsModule perms = PermissionsModule.get();
+
+        // Remove the default provider FIRST
+        perms.removeProvider(perms.getFirstPermissionProvider());
+
+        // Then add your provider
+        perms.addProvider(new DatabasePermissionProvider());
+    }
+}
+```
+
+<Callout type="info">
+  When you remove the default provider, the `/op self` command will stop working since it checks for provider tampering.
 </Callout>
 
-We can then register the provider using the built-in permission module:
+---
+
+## Best Practices
+
+### Permission Naming Conventions
+
+Follow the pattern: `namespace.category.action`
 
 ```java
-PermissionsModule.get().addProvider(new DatabasePermissionProvider());
+// Good - clear hierarchy
+"myplugin.admin.ban"
+"myplugin.user.teleport.home"
+"myplugin.vip.chat.color"
+
+// Bad - unclear structure
+"myplugin_ban"
+"teleport"
+"vipChatColor"
 ```
 
-Please note that the `HytalePermissionsProvider` will still be enabled alongside your provider.
-The `PermissionsModule` will aggregate groups and permissions from all available providers.
+### Use Constants for Permissions
 
-If you want to disable the default `HytalePermissionsProvider`, you can use:
+Define your permissions as constants to avoid typos:
 
 ```java
-// put this **before** you add your provider
-PermissionsModule.get().removeProvider(PermissionsModule.get().getFirstPermissionProvider());
+public final class MyPermissions {
+    public static final String ADMIN_BAN = "myplugin.admin.ban";
+    public static final String ADMIN_KICK = "myplugin.admin.kick";
+    public static final String USER_HOME = "myplugin.user.home";
+    public static final String VIP_FLY = "myplugin.vip.fly";
+}
+
+// Usage
+if (player.hasPermission(MyPermissions.ADMIN_BAN)) {
+    // ...
+}
 ```
+
+### Don't Over-Permission
+
+Only create permissions for actions that genuinely need access control. Not everything needs a permission check.
+
+### Thread Safety
+
+If you create a custom provider, ensure it's thread-safe. Permission checks can occur from multiple threads simultaneously. Use `ReadWriteLock` or `ConcurrentHashMap` for your data structures.
+
+---
+
+## In-Game Commands
+
+Hytale provides built-in commands for managing permissions:
+
+### `/op` Command
+
+| Command               | Description                                                        |
+| --------------------- | ------------------------------------------------------------------ |
+| `/op self`            | Toggle your own OP status (singleplayer or with `--allow-op` flag) |
+| `/op add <player>`    | Add a player to the OP group                                       |
+| `/op remove <player>` | Remove a player from the OP group                                  |
+
+### `/perm` Command
+
+Use `/perm --help` in-game for full usage. Common operations:
+
+| Command                                  | Description                   |
+| ---------------------------------------- | ----------------------------- |
+| `/perm user list <uuid>`                 | List user's permissions       |
+| `/perm user add <uuid> <perm>`           | Add permission to user        |
+| `/perm user remove <uuid> <perm>`        | Remove permission from user   |
+| `/perm user group list <uuid>`           | List user's groups            |
+| `/perm user group add <uuid> <group>`    | Add user to group             |
+| `/perm user group remove <uuid> <group>` | Remove user from group        |
+| `/perm group list <group>`               | List group's permissions      |
+| `/perm group add <group> <perm>`         | Add permission to group       |
+| `/perm group remove <group> <perm>`      | Remove permission from group  |
+| `/perm test <perm>`                      | Test if you have a permission |
+
+---
+
+## Summary
+
+You've learned how to:
+
+- **Check permissions** using `PermissionsModule.hasPermission()`
+- **Manage user permissions** with `addUserPermission()` and `removeUserPermission()`
+- **Work with groups** using `addGroupPermission()`, `addUserToGroup()`, etc.
+- **Use wildcards** like `*` and `myplugin.*` for bulk permissions
+- **Listen to events** for permission changes
+- **Create custom providers** for database-backed permissions
+
+For more advanced permission systems with features like inheritance, expiry, and contexts, we're looking into expanding this guide with advanced permission management techniques in the future.
diff --git a/content/docs/es-ES/guides/plugin/setting-up-env.mdx b/content/docs/es-ES/guides/plugin/setting-up-env.mdx
index d2718098..5be5e9e0 100644
--- a/content/docs/es-ES/guides/plugin/setting-up-env.mdx
+++ b/content/docs/es-ES/guides/plugin/setting-up-env.mdx
@@ -4,6 +4,10 @@ description: Learn how to set up your development environment for modding Hytale
 authors:
   - name: Neil Revin
     link: https://itsneil.dev
+  - name: Marcel-TO
+    url: https://marcel-to.net
+  - name: Ádám Liszkai
+    link: https://adaliszk.dev
 ---
 
 This guide will walk you through setting up a complete development environment for Hytale modding, including all necessary tools and dependencies.
@@ -19,24 +23,73 @@ Before we begin, make sure you have:
 
 ## Required Software
 
-### 1. Java Development Kit (JDK)
+### Integrated Development Environment (IDE)
 
+We recommend IntelliJ IDEA Community Edition for Hytale modding. If you use IntelliJ IDEA, **almost everything is built-in**. You can clone a template, open a new project, and start working right away!
+
+1. Download from [JetBrains website](https://www.jetbrains.com/idea/download/)
+2. Install with default settings
+3. Launch and complete the initial setup wizard
+
+When opening a project, wait for indexing to finish, then start coding.
+Now, IDEA may say "No JDK configured" at the top of the source file you have.
+In that case, you can click Download JDK and choose JetBrains JDK 25.
+
+<Callout type="success">
+  If IDEA opened the project without errors, your environment is ready.
+</Callout>
+
+More details by [JetBrains](https://www.jetbrains.com/help/idea/2026.1/run-for-the-first-time.html)
+help page, where we recommend that you also check the
+[SDK configuration](https://www.jetbrains.com/help/idea/2026.1/sdk.html) guide.
+
+<Callout type="info">
+  We recommened following
+  [TheNullicorn's](https://gist.github.com/TheNullicorn/90a619796c40f20ae1fcf13094c1a57d) guide to ensure
+  you are using the correct `Nonnull` in your projects.
+</Callout>
+
+#### What the IDE Does for You
+
+When opened in IntelliJ IDEA, the project automatically:
+
+- Detects and configures Gradle or Maven
+- Downloads all dependencies
+- Sets up project structure and classpaths
+- Configures run/build tasks
+
+You do **not** need to manually install or configure Maven or Gradle if you stay inside the IDE.
+
+Skip to the [Setting Up Your Workspace](#setting-up-your-workspace).
+
+### Manual Setup: Java Development Kit (JDK)
+
+For any other setup, you will need to install and configure your system to have and load Java.
 Hytale modding requires Java 25 or later. We recommend using OpenJDK.
 
-#### Windows
+#### Windows via Installer
 
 1. Download OpenJDK 25 from [Adoptium](https://adoptium.net/)
 2. Run the installer with default settings
+   - Optionally enable feature `Set or Override JAVA_HOME variable` to resolve version related build issues with your project.
 3. Verify installation by opening Command Prompt and running:
 
+#### Windows via Scoop
+
+1. Install Scoop via PowerShell using [scoop.sh](https://scoop.sh/)
+2. Install OpenJDK 25:
+
 ```bash
-java -version
+scoop bucket add java
+scoop install java/openjdk25
 ```
 
 #### macOS
 
+1. Install Brew via Terminal using [brew.sh](https://brew.sh)
+2. Install JDK via Homebrew:
+
 ```bash
-# Using Homebrew
 brew install openjdk@25
 ```
 
@@ -51,22 +104,41 @@ brew install openjdk@25
 
 #### Linux (Ubuntu/Debian)
 
+1. Install JDK via the built-in package repository:
+
 ```bash
 sudo apt update
 sudo apt install openjdk-25-jdk
 ```
 
-### 2. Integrated Development Environment (IDE)
+### Verify installation:
 
-We recommend IntelliJ IDEA Community Edition for Hytale modding.
+Run the following command to see what version of Java you have:
 
-1. Download from [JetBrains website](https://www.jetbrains.com/idea/download/)
-2. Install with default settings
-3. Launch and complete the initial setup wizard
+```bash
+java -version
+```
+
+### Java Build Tool (Optional)
+
+We recommend using a Gradle Wrapper for managing dependencies and building your Hytale plugins. It provides benefits by eliminating the need for a system-wide Gradle installation and ensuring consistent Gradle versions across different environments. (Alternatively you can use Maven, but this guide focuses on Gradle since it is the default for our plugin template.)
+
+The plugin template in the following sections includes a Gradle Wrapper, so you can skip this step if you plan to use the template.
+
+#### Choosing Gradle (if not using the template)
+
+If you prefer to install Gradle manually, follow these steps:
 
-### 3) Java Build Tool
+1. Visit the official website: https://gradle.org/releases/
+2. Download the newest gradle binary: `gradle-9.3.1-bin.zip` (Binary zip archive)
+3. Unzip it
+4. Add the `gradle-9.3.1/bin/` folder to your PATH
+
+You can now try the command `gradle -version` to verify Gradle is installed correctly. Make sure to do this in a fresh new terminal instead of one you had opened from before!
+
+#### Choosing Maven (if not using the template)
 
-We recommend using Apache Maven for managing dependencies and building your Hytale plugins. (Alternatively you can use Gradle, but this guide focuses on Maven.)
+If you prefer to use Maven instead of Gradle, follow these steps to install Maven:
 
 1. Visit the official website: https://maven.apache.org/download.cgi
 2. Download this file: `apache-maven-3.9.12-bin.zip` (Binary zip archive)
@@ -89,22 +161,61 @@ cd MyFirstMod
 
 If you don't have Git installed, you can download the ZIP file from the repository page and extract it to a folder named `MyFirstMod`.
 
-### 2. Open Plugin in your IDEA
+### 2. Open Plugin in your IDE
 
-1. Open IntelliJ IDEA
+1. Open Your IDE (e.g., IntelliJ IDEA)
 2. Click "Open" and navigate to your `MyFirstMod` directory
-3. IntelliJ will automatically detect it as a Maven project
+3. Most IDEs like IntelliJ will automatically detect it as a Gradle project
 4. Wait for the project to index and dependencies to download
 
-<Callout type="info">
-  We recommened following [this](https://gist.github.com/TheNullicorn/90a619796c40f20ae1fcf13094c1a57d) guide to ensure you are using the correct `Nonnull` in your projects.
-</Callout>
+## Alternate Approach: Hytale Dependency
+
+If you prefer to set up your project from scratch without using the template and importing the hytale dependencies manually, ensure your build configuration includes the Hytale repositories and dependencies:
+
+For Gradle, add the following to your `build.gradle.kts`:
+
+```kotlin
+repositories {
+    mavenCentral()
+    maven {
+        name = "hytale"
+        url = uri("https://maven.hytale.com/release") // Or "hytale-pre-release" for pre-release versions
+    }
+}
+dependencies {
+    // + here means the latest version, but you can hard-wire any known version!
+    implementation("com.hypixel.hytale:Server:+")
+}
+```
+
+For Maven, add the following to your `pom.xml`:
+
+```xml
+<project>
+    <repositories>
+        <repository>
+            <id>hytale-release</id> <!-- Or "hytale-pre-release" for pre-release versions -->
+            <url>https://maven.hytale.com/release</url> <!-- Or "https://maven.hytale.com/pre-release" -->
+        </repository>
+    </repositories>
+
+    <dependencies>
+        <dependency>
+            <groupId>com.hypixel.hytale</groupId>
+            <artifactId>Server</artifactId>
+            <!-- Replace with latest version, Hytale provides jars for the last five releases -->
+            <version>LATEST_VERSION_HERE</version>
+            <scope>provided</scope>
+        </dependency>
+    </dependencies>
+</project>
+```
 
 ## Next Steps
 
 Now that you have your development environment set up with the plugin template:
 
-1. **Customize the template** - Edit the `pom.xml` and `manifest.json` file to change your mod's name and details
+1. **Customize the template** - Edit the `settings.gradle.kts`, `build.gradle.kts` and `manifest.json` file to change your mod's name and details
 2. **Explore the code structure** - Familiarize yourself with the template's organization
 3. **Start modding** - Begin writing your first Hytale plugin!
 
diff --git a/content/docs/es-ES/guides/plugin/spawning-entities.mdx b/content/docs/es-ES/guides/plugin/spawning-entities.mdx
index e12c0aea..15be2fb3 100644
--- a/content/docs/es-ES/guides/plugin/spawning-entities.mdx
+++ b/content/docs/es-ES/guides/plugin/spawning-entities.mdx
@@ -36,7 +36,7 @@ Store<EntityStore> store = world.getEntityStore().getStore();
 
 ## Creating Entities
 
-Once you have the `EntityStore` instance, you can start to create a entity and give it components. Entities are just instances of `Holder<EntityStore>` with several components attached to them.
+Once you have the `EntityStore` instance, you can start to create an entity and give it components. Entities are just instances of `Holder<EntityStore>` with several components attached to them.
 
 <Callout type="warning">
   To interact with the `World` instance, some methods require you to run the code inside the world's execution context.
@@ -118,3 +118,48 @@ Finally, we can add the entity to the world by calling the `addEntity` method on
 ```java
 store.addEntity(holder, AddReason.SPAWN);
 ```
+
+## Making the entity persist
+
+Hytale automatically saves all entities, but the `NetworkId` component (required for players to be able to see the entity) needs to be manually added every time the entity is loaded.
+
+### Using a system
+
+If you have a component that is unique to your entities, this can be done by creating and registering a custom system as follows:
+
+```java
+public class AddNetworkIdToMyEntitySystem extends HolderSystem<EntityStore> {
+    private final ComponentType<EntityStore, MyEntityComponent> myEntityComponentType = MyEntityComponent.getComponentType();
+    private final ComponentType<EntityStore, NetworkId> networkIdComponentType = NetworkId.getComponentType();
+    private final Query<EntityStore> query = Query.and(this.myEntityComponentType, Query.not(this.networkIdComponentType));
+
+    @Override
+    public void onEntityAdd(@NotNull Holder<EntityStore> holder, @NotNull AddReason reason, @NotNull Store<EntityStore> store) {
+        if (!holder.getArchetype().contains(NetworkId.getComponentType())) {
+            holder.addComponent(NetworkId.getComponentType(), new NetworkId(store.getExternalData().takeNextNetworkId()));
+        }
+    }
+
+    @Override
+    public void onEntityRemoved(@NotNull Holder<EntityStore> holder, @NotNull RemoveReason reason, @NotNull Store<EntityStore> store) {}
+
+    @Override
+    public @Nullable Query<EntityStore> getQuery() {
+        return query;
+    }
+}
+```
+
+In your plugin's `setup()` function
+
+```java
+this.getEntityStoreRegistry().registerSystem(new AddNetworkIdToMyEntitySystem())
+```
+
+### Using PropComponent
+
+Alternatively you can add `PropComponent` to your entity. Hytale adds `PropComponent` to entities spawned with the Entity Tool, and such entities automatically get `NetworkId` and `PrefabCopyableComponent` (which makes the entity work with prefabs).
+
+<Callout type="warning">
+  There is no guarantee, that Hytale will not add some other behavior to this component in the future, which may break your entity, so be careful if you decide to rely on it.
+</Callout>
diff --git a/content/docs/es-ES/guides/plugin/store-persistent-data.mdx b/content/docs/es-ES/guides/plugin/store-persistent-data.mdx
new file mode 100644
index 00000000..1071dff3
--- /dev/null
+++ b/content/docs/es-ES/guides/plugin/store-persistent-data.mdx
@@ -0,0 +1,171 @@
+---
+title: Storing Persistent Data on the Player
+description: Learn how to save and load persistent data using Components
+authors:
+  - name: Neil Revin
+    url: https://itsneil.dev/
+  - name: ArcticDev
+    url: https://github.com/ArcticRaven
+  - name: oskarscot
+    url: https://oskar.scot
+  - name: JammingEng
+    url: https://github.com/JammingEnd
+---
+
+Here is how to store persistent data using a custom component on a Player.
+
+## Build your Component Class
+
+Creating a custom component class leverages the Component system made with the ECS architecture in mind. For more information on Components, check out the [ECS Guide](../ecs/hytale-ecs-theory#components).
+
+Start by creating your custom component class. This will be extremely similar to how regular components are created, however we'll setup a custom Codec so the server can translate this data to BSON, or the server's internal json encoder.
+
+<Callout type="info">
+  Each variable you want to store in your component must have its own Codec field defined in the BuilderCodec.
+  For more information on how to create custom Codecs, check out the [ECS Codec Guide](../ecs/hytale-ecs-theory#codec).
+</Callout>
+
+```java
+public class YourPlayerData implements Component<EntityStore> {
+
+    // define some vars!
+    private int someInteger;
+    private String someString;
+    private Map<String, String> someMap;
+
+    public static final BuilderCodec<YourPlayerData> CODEC =
+            BuilderCodec.builder(YourPlayerData.class, YourPlayerData::new)
+            .append(new KeyedCodec<>("SomeInteger", Codec.INTEGER),
+                    (data, value) -> data.someInteger = value, // setter
+                    data -> data.someInteger) // getter
+            .addValidator(Validators.nonNull())
+            .add()
+            .append(new KeyedCodec<>("SomeString", Codec.STRING),
+                    (data, value) -> data.someString = value, // setter
+                    data -> data.someString) // getter
+            .add()
+            .append(new KeyedCodec<>("SomeMap",
+                            new MapCodec<>(Codec.STRING, HashMap::new, false)),
+                    (data, value) -> data.someMap = value, // setter
+                    data -> data.someMap) // getter
+            .add()
+            .build();
+
+
+
+    // Getters and Setters are for the purpose of this example omitted.
+
+    // constructor
+    public YourPlayerData() {
+        this.someInteger = 0;
+        this.someString = "";
+        this.someMap = new HashMap<>();
+    }
+
+    // copy constructor for cloning
+    public YourPlayerData(YourPlayerData clone) {
+        this.someInteger = clone.someInteger;
+        this.someString = clone.someString;
+        this.someMap = clone.someMap;
+    }
+
+    @Nonnull
+    @Override
+    public Component<EntityStore> clone() {
+        return new YourPlayerData(this);
+    }
+}
+```
+
+## Register your Component
+
+Inside your main class's `setup()` method, register your new Component.
+
+```java
+public class YourPlugin extends JavaPlugin {
+
+    private ComponentType<EntityStore, YourPlayerData> yourPlayerDataComponent;
+
+    public YourPlugin(@Nonnull JavaPluginInit init) {
+        super(init);
+    }
+
+    @Override
+    protected void setup(){
+        this.yourPlayerDataComponent = this.getEntityStoreRegistry().registerComponent(
+            YourPlayerData.class,
+            "YourPlayerDataComponent",
+            YourPlayerData.CODEC
+        );
+    }
+
+    public ComponentType<EntityStore, YourPlayerData> getYourPlayerDataComponent() {
+        return this.yourPlayerDataComponent;
+    }
+}
+```
+
+## Using your Component
+
+To use your newly created component, you can add the Component to a player using the `addComponent` method, although this only adds it temporarily, meaning when the player/entity leaves the world, the component is removed. You can use `putComponent` to ensure the component persists between sessions.
+
+```java
+// You will need the Ref and Store to apply components
+private void someEntryMethod(@Nonnull Ref<EntityStore> ref, @Nonnull Store<EntityStore> store)
+{
+       // Any entity will work, for now we will use the player
+      Player player = (Player) store.getComponent(ref, Player.getComponentType());
+
+      // since we're using putComponent, it could be useful to check if it already exists on the player in case we want to update it
+     if(store.getComponent(ref, YourPlugin.instance().getYourPlayerDataComponent()) != null)
+     {
+          // here we implement logic that updates the component
+         var comp = store.getComponent(ref, YourPlugin.instance().getYourPlayerDataComponent())
+         // declare public fields or methods in the component class
+         comp.SomeString = "An Updated Field";
+     } else {
+          // Here we put the component
+          var myCustomComp = new CustomComponent();
+          // declare public fields or methods in the component class
+          myCustomComp.SomeString = "Edited String";
+
+          // putComponent allows you to insert declared objects
+          store.putComponent(ref, YourPlugin.instance().getYourPlayerDataComponent(), myCustomComp);
+     }
+}
+```
+
+## Using your Data
+
+Your component will be stored within the `Store<EntityStore>` when added to the player. In the provided example,
+we'll fetch this data off the player using the `ensureAndGetComponent()` method, which will add the component to
+the player if it does not exist with the default values.
+
+```java
+public class IncompleteCustomCommand extends AbstractPlayerCommand {
+
+    public IncompleteCustomCommand() {
+        super("nope", "don't use this command");
+    }
+
+    @Override
+    protected void execute(
+        @NonNullDecl CommandContext commandContext,
+        @NonNullDecl Store<EntityStore> store,
+        @NonNullDecl Ref<EntityStore> ref,
+        @NonNullDecl PlayerRef playerRef,
+        @NonNullDecl World world
+    ) {
+        YourPlayerData customData = store.ensureAndGetComponent(ref, YourPlugin.instance().getYourPlayerDataComponent());
+        // ensureAndGetComponent adds the component to the ref, with the default values defined inside your component.
+ 		// use your data
+    }
+}
+```
+
+And that's it! Your data will now be saved and loaded automatically with the player.
+
+Using custom components to store persistent data on players is a powerful way to maintain state across sessions.
+By following the steps outlined above, you can easily create, register, and utilize your own data structures within the Hytale ECS framework.
+This approach ensures that your data is seamlessly integrated with the game's existing systems.
+For more information about Hytale's Entity Component System visit the [Hytale ECS Theory](https://hytalemodding.dev/en/docs/guides/ecs/hytale-ecs-theory) guide.
diff --git a/content/docs/es-ES/guides/plugin/teleporting-players.mdx b/content/docs/es-ES/guides/plugin/teleporting-players.mdx
index 57cee77f..32ce0435 100644
--- a/content/docs/es-ES/guides/plugin/teleporting-players.mdx
+++ b/content/docs/es-ES/guides/plugin/teleporting-players.mdx
@@ -1,26 +1,32 @@
 ---
 title: Teleporting the player
 description: Learn how to teleport the player.
+authors:
+  - name: oskarscot
+    url: https://oskar.scot
 ---
 
-To teleport players in Hytale, you will need to get a `World` object so we can safely run the teleport on the world thread. The world thread manages all entity updates, so modifying entities off-thread can crash the server or cause inconsistent state.
-Next, we get the entity store and make a `Teleport` object.
-We add a `Teleport` component to the player’s entity reference in the entity store. This triggers the teleportation logic for that player.
+Teleporting players in Hytale works by simply attaching a `Teleport` component to a player with the desired world and transform.
+You can only trigger teleports from a world where the player is currently present.
+Teleport itself is a component but it also provides factory methods to configure the Teleport. Just as with any entity component, an EntityStore and a Ref to the EntityStore is required
+
+We can create a simple teleport utility like this:
 
 ```java
-public static void teleportPlayer(Player player, int x, int y, int z) {
-        World world = player.getWorld();
-        if (world == null) return;
-        world.execute(() -> {
-            if (player.getReference() == null) return;
-            Store<EntityStore> store = player.getReference().getStore();
-            Teleport teleport = Teleport.createForPlayer(world,
-                new Vector3d(x ,y, z), // Target position
-                new Vector3f(0, 0, 0)  // Target rotation (pitch, yaw, roll)
-            );
+public static void teleportPlayer(Ref<EntityStore> ref, Store<EntityStore> store, World targetWorld, double x, double y, double z) {                                                                                       
+    Transform transform = new Transform(x, y, z);                                                                                                                           
+    Teleport teleport = Teleport.createForPlayer(targetWorld, transform);                                                                                                   
+    store.addComponent(ref, Teleport.getComponentType(), teleport);                                                                                                         
+}  
+```
 
-            store.addComponent(player.getReference(), Teleport.getComponentType(), teleport);
-        });
+A `Transform` is a representation of a position Vector3d and rotation Vector3f which works in the following way:
 
-}
+```java
+Transform transform = new Transform(
+    new Vector3d(x, y, z),      // Position
+    new Rotation(yaw, pitch, 0) // Rotation, last value seems to always be 0
+);
+Teleport teleport = Teleport.createForPlayer(targetWorld, transform);
+store.addComponent(ref, Teleport.getComponentType(), teleport);
 ```
diff --git a/content/docs/es-ES/guides/plugin/tracking-mod-analytics-with-hstats.mdx b/content/docs/es-ES/guides/plugin/tracking-mod-analytics-with-hstats.mdx
new file mode 100644
index 00000000..45c022e0
--- /dev/null
+++ b/content/docs/es-ES/guides/plugin/tracking-mod-analytics-with-hstats.mdx
@@ -0,0 +1,65 @@
+---
+title: Tracking Mod Analytics with HStats
+description: Learn how you can track Analytics for your Hytale Mod for Free using hstats.dev
+authors:
+  - name: Al3x
+    url: https://hstats.dev
+---
+
+In this guide, you will learn how to integrate HStats into your Plugin/Mod which will allow you to track how many Servers are using it along with other stats.
+
+<Callout type="info">
+  HStats is a third-party tool and is not affiliated with HytaleModding or Hypixel Studios
+</Callout>
+
+# Step 1: Register your Mod to HStats
+
+Before you touch any code, you will need to add your mod to the HStats website which will give you a UUID for your mod.
+
+- Create or Login to an Account on https://hstats.dev
+- Navigate to the dashboard page (https://hstats.dev/dashboard)
+- On the left, type in your mod's name and click "Add Mod"
+- Keep note of the UUID generated for later.
+
+# Step 2: Add the HStats Class to Your Project
+
+To keep things simple, HStats uses a single Java class file that handles everything for you.
+
+- Download / Copy the File from the GitHub page (https://github.com/hstats-dev/HStatsExamplePlugin/blob/main/src/main/java/com/al3x/HStats.java)
+- Paste into your Project. You should now have a HStats.java file somewhere in your projects directory.
+- Update the package name from com.al3x to whatever fits your project.
+
+# Step 3: Initialize HStats in your code
+
+You only need to add one line of code to your mod's setup method in your main class to start tracking.
+
+`new HStats("YOUR-MOD-UUID", "1.0.0");`
+
+Replace `YOUR-MOD-UUID` with the Mod UUID we made note of earlier and change the `1.0.0` version to whatever version your mod is currently on.
+
+Your setup method should now look something like this:
+
+```java
+@Override
+protected void setup() {
+  super.setup();
+  new HStats("c34a2b2a-afd8-4d6a-821e-7a63e12c5ea6", "1.0.0");
+}
+```
+
+# Extras
+
+Your done! Your mod should now be listed under the Mods page (https://hstats.dev/mods) as well as under your dashboard.
+
+Servers using your mod should now post updates about every minute to HStats which you can view in the Dashboard.
+
+### Embeds
+
+HStats allows you to generate an Embed Card that you can place on your CurseForge or GitHub page. This is useful for server owners to be able to see how many other servers are using your mod.
+
+- In your dashboard, scroll down to the Embed Card section.
+- Customize the appearance (Light/Dark mode, layout, etc).
+- Copy the generated URL to display your "Active Servers" and "Players Online" live on your mod's description page
+
+Heres an example of what they look like:
+![HStats Example](https://api.hstats.dev/api/embed/d52fa672-6966-47b2-b501-1a11bddebac3/card.svg?theme=light\&layout=compact\&size=md\&show_id=true\&dark=false)
diff --git a/content/docs/es-ES/guides/plugin/world-gen.mdx b/content/docs/es-ES/guides/plugin/world-gen.mdx
index 4c23b0c9..7b193ffd 100644
--- a/content/docs/es-ES/guides/plugin/world-gen.mdx
+++ b/content/docs/es-ES/guides/plugin/world-gen.mdx
@@ -100,7 +100,7 @@ Biome biome = biomeGen.generateBiomeAt(zoneResult, seed, x, z);
 
 ### Zone & Cave Integration
 
-Each zone defines it's own cave patterns:
+Each zone defines its own cave patterns:
 
 ```java
 Zone zone = /* ... */;
diff --git a/content/docs/es-ES/guides/prefabs.mdx b/content/docs/es-ES/guides/prefabs.mdx
index 08404b30..b1a55109 100644
--- a/content/docs/es-ES/guides/prefabs.mdx
+++ b/content/docs/es-ES/guides/prefabs.mdx
@@ -14,7 +14,7 @@ Prefabs are Hytale's way of creating reusable structures.
 There are a few fundamental concepts to understand about prefabs:
 
 - Users interact with prefabs via a prefab editing world.
-- Prefabs the physical structures in the game world, and are saved as JSON files.
+- Prefabs are the physical structures in the game world, and are saved as JSON files.
 
 ## How to Create a Prefab
 
diff --git a/content/docs/es-ES/official-documentation/custom-ui/common-styling.mdx b/content/docs/es-ES/official-documentation/custom-ui/common-styling.mdx
new file mode 100644
index 00000000..c36e3e3a
--- /dev/null
+++ b/content/docs/es-ES/official-documentation/custom-ui/common-styling.mdx
@@ -0,0 +1,50 @@
+---
+title: Common Styling
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# Common Styling
+
+## Common UI Styling Library
+
+This document describes the shared UI components and styles defined in `Common.ui`.
+
+---
+
+### Styles
+
+We are providing some styles that can be re-used in any custom UI that, provide a cohesive UI experience with the core game UI. These styles are available in the `Common.ui` file.
+
+You can find a list of all the styles defined with live examples by running the `/ui-gallery` command ingame.
+
+<Callout type="warning">
+  This command is not available yet, but will be in a future patch.
+</Callout>
+
+![Gallery](/assets/official-documentation/ui/gallery.png)
+
+### Importing
+
+To use these styles in your UI file:
+
+```
+$Common = "Common.ui";
+
+// Then reference styles and components:
+$Common.@TextButton { @Text = "My Button"; }
+$Common.@Container { ... }
+```
+
+<Callout type="info">
+  The `Common.ui` file is at `Common/UI/Custom/Common.ui` within the Hytale pack. If your custom ui document is in a subfolder of `Common/UI/Custom/`, reference it via relative path traversal:
+
+  ```
+  $Common = "../Common.ui";
+  ```
+
+  You can find more info about paths [here](markup#path).
+</Callout>
diff --git a/content/docs/es-ES/official-documentation/custom-ui/index.mdx b/content/docs/es-ES/official-documentation/custom-ui/index.mdx
new file mode 100644
index 00000000..f94c4e88
--- /dev/null
+++ b/content/docs/es-ES/official-documentation/custom-ui/index.mdx
@@ -0,0 +1,125 @@
+---
+title: Custom UI
+icon: LayoutDashboard
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# Custom UI
+
+## What is Custom UI?
+
+Custom UI is Hytale's framework for creating **custom user interfaces** controlled by the game server. Unlike the built-in Client UI (which is part of the game client and cannot be modified), Server UI allows you to create interactive screens and HUD overlays through Java plugins and asset packs.
+
+As a modder, Custom UI gives you the power to:
+
+- **Create custom interactive pages** - Shop interfaces, quest dialogs, server settings menus, admin panels
+- **Add custom HUD overlays** - Quest trackers, status displays, custom health bars, server information
+- **Design with markup** - Use `.ui` files to define reusable UI templates
+- **Handle user interactions** - Respond to button clicks, form submissions, and other events
+- **Localize your UI** - Support multiple languages using the game's translation system
+
+## How Custom UI Fits Into Hytale's UI
+
+Hytale's user interface is divided into two main categories:
+
+### Client UI (Not Moddable)
+
+Built-in interfaces controlled by the C# game client:
+
+- Main menu and settings
+- Character creation
+- Built-in HUD (health, hotbar, chat)
+- Inventory and crafting screens
+- Development tools
+
+**You cannot modify these** - they are part of the core game client.
+
+### In-Game UI (Moddable via Server)
+
+Server-controlled interfaces that you can create and customize:
+
+#### Custom Pages
+
+Full-screen interactive overlays that appear during gameplay:
+
+- Can be dismissed by the player (ESC key)
+- Capture all input (keyboard and mouse)
+- Support loading states while waiting for server responses
+- Perfect for: shops, dialogs, menus, configuration screens
+
+#### Custom HUDs
+
+Persistent overlay elements drawn on top of the game world:
+
+- Display-only (no user interaction)
+- Always visible during gameplay
+- Lightweight and non-intrusive
+- Perfect for: quest objectives, status indicators, server info panels
+
+## Architecture Overview
+
+Server UI uses a **command-based architecture**:
+
+```
+┌─────────────────────┐         ┌──────────────────────┐
+│   Java Server       │         │    C# Client         │
+│   (Your Plugin)     │         │    (Game)            │
+├─────────────────────┤         ├──────────────────────┤
+│                     │         │                      │
+│ InteractiveCustomUI │         │   CustomPage or      │
+│ Page                │         │   CustomHud          │
+│   ↓ build()         ├────────→│     ↓ Apply          │
+│ UICommandBuilder    │         │   Element Tree       │
+│   - append()        │         │     ↓ Layout         │
+│   - set()           │         │   Rendered UI        │
+│   - clear()         │         │                      │
+│                     │         │                      │
+│ ↓ handleDataEvent() │← Events │   User Interaction   │
+│   Process input     │         │   (click, type, etc) │
+│   sendUpdate()      │         │                      │
+└─────────────────────┘         └──────────────────────┘
+```
+
+**The flow:**
+
+1. Your Java code builds UI using `UICommandBuilder`
+2. Commands are sent to the client as data
+3. Client parses `.ui` markup files and creates visual elements
+4. User interacts with the UI
+5. Events are sent back to your Java code
+6. You process events and send updates back
+
+## Key Principles
+
+### Declarative, Not Imperative
+
+You don't create UI objects directly. Instead, you send **commands** that describe what you want:
+
+- "Append this button template to that container"
+- "Set this label's text to 'Hello World'"
+- "Clear all children from this list"
+
+### Asset-Driven
+
+UI structure is defined in `.ui` markup files (assets), not hardcoded in Java. This enables:
+
+- Designers to modify layouts without touching code
+- Reusable UI components
+- Consistent visual language
+
+### Event-Driven
+
+User interactions trigger events that flow back to your server code. You register event bindings and handle them in `handleDataEvent()`.
+
+### Selector-Based
+
+You target specific UI elements using **selectors:**
+
+- `#MyButton` - Element with ID "MyButton"
+- `#List[0]` - First child of element "List"
+- `#List[0] #Title` - Element with ID "Title" in the first child of element "List"
+- `#Label.TextColor` - The TextColor property of element "Label"
diff --git a/content/docs/es-ES/official-documentation/custom-ui/layout.mdx b/content/docs/es-ES/official-documentation/custom-ui/layout.mdx
new file mode 100644
index 00000000..0a24ca09
--- /dev/null
+++ b/content/docs/es-ES/official-documentation/custom-ui/layout.mdx
@@ -0,0 +1,492 @@
+---
+title: Layout
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# Layout
+
+The layout system determines how UI elements are positioned and sized on screen. Understanding layout is crucial for creating well-structured, responsive interfaces.
+
+## Layout Fundamentals
+
+Every UI element has:
+
+- **Container Rectangle** - The space allocated by the parent
+- **Anchor** - How the element positions/sizes itself within the container
+- **Padding** - Inner spacing that affects child layout
+- **LayoutMode** - How the element arranges its children (if it's a container)
+
+```
+┌─────────────────────────────────────┐
+│  Container Rectangle (from parent)  │
+│  ┌───────────────────────────────┐  │
+│  │  Anchored Rectangle           │  │
+│  │  ┌─────────────────────────┐  │  │
+│  │  │ Padding                 │  │  │
+│  │  │  ┌───────────────────┐  │  │  │
+│  │  │  │  Content Area     │  │  │  │
+│  │  │  └───────────────────┘  │  │  │
+│  │  └─────────────────────────┘  │  │
+│  └───────────────────────────────┘  │
+└─────────────────────────────────────┘
+```
+
+## Anchor
+
+`Anchor` controls how an element positions and sizes itself within its container rectangle.
+
+### Fixed Size
+
+```
+Button {
+    Anchor: (Width: 200, Height: 40);
+}
+```
+
+Creates a 200×40 pixel button.
+
+### Positioning
+
+```
+Label {
+    Anchor: (Top: 10, Left: 20, Width: 100, Height: 30);
+}
+```
+
+- **Top**: 10 pixels from container's top edge
+- **Left**: 20 pixels from container's left edge
+- **Width**: 100 pixels wide
+- **Height**: 30 pixels tall
+
+### Anchoring to Edges
+
+```
+Button {
+    Anchor: (Bottom: 10, Right: 10, Width: 100, Height: 30);
+}
+```
+
+Anchors the button to the bottom-right corner, 10 pixels from each edge.
+
+### Stretching
+
+```
+Group {
+    Anchor: (Top: 0, Bottom: 0, Left: 0, Right: 0);
+}
+```
+
+Stretches to fill the entire container (all edges at 0 pixels).
+
+**Shorthand:**
+
+```
+Group {
+    Anchor: (Full: 0);
+}
+```
+
+### Mixed Anchoring
+
+```
+Panel {
+    Anchor: (Top: 10, Bottom: 10, Left: 20, Width: 300);
+}
+```
+
+- Fixed width of 300 pixels
+- Stretches vertically between top and bottom edges
+- 10 pixels from top and bottom
+- 20 pixels from left
+
+## Padding
+
+`Padding` creates inner spacing, affecting where children are positioned.
+
+### Uniform Padding
+
+```
+Group {
+    Padding: (Full: 20);
+}
+```
+
+20 pixels of padding on all sides.
+
+### Directional Padding
+
+```
+Group {
+    Padding: (Top: 10, Bottom: 20, Left: 15, Right: 15);
+}
+```
+
+Different padding per edge.
+
+### Shorthand
+
+```
+// Horizontal and vertical
+Group {
+    Padding: (Horizontal: 20, Vertical: 10);
+}
+
+// Equivalent to:
+// Top: 10, Bottom: 10, Left: 20, Right: 20
+```
+
+### Effect on Children
+
+```
+Group {
+    Anchor: (Width: 200, Height: 100);
+    Padding: (Full: 10);
+
+    Label {
+        Anchor: (Full: 0);
+    }
+}
+```
+
+The label fills the group, but there's a 10-pixel gap on all sides due to padding.
+
+```
+┌──────────────────────┐
+│ Group (200×100)      │
+│  ┌────────────────┐  │
+│  │ Label          │  │ ← 10px padding all around
+│  │                │  │
+│  └────────────────┘  │
+└──────────────────────┘
+```
+
+## LayoutMode
+
+`LayoutMode` determines how a container arranges its children.
+
+### Top (Vertical Stack)
+
+```
+Group {
+    LayoutMode: Top;
+
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+}
+```
+
+Children stack vertically from top to bottom:
+
+```
+┌──────────┐
+│ Button 1 │
+├──────────┤
+│ Button 2 │
+├──────────┤
+│ Button 3 │
+└──────────┘
+
+
+```
+
+Each child's `Anchor.Bottom` adds spacing between elements:
+
+```
+Button { Anchor: (Height: 30, Bottom: 10); }  // 10px gap after this button
+```
+
+### Bottom (Vertical Stack)
+
+```
+Group {
+    LayoutMode: Bottom;
+
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+}
+```
+
+Children stack vertically from top to bottom but aligned to the bottom edge of the parent:
+
+```
+
+
+
+┌──────────┐
+│ Button 1 │
+├──────────┤
+│ Button 2 │
+├──────────┤
+│ Button 3 │
+└──────────┘
+```
+
+### Left (Horizontal Stack)
+
+```
+Group {
+    LayoutMode: Left;
+
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+}
+```
+
+Children arrange horizontally from left to right:
+
+```
+┌────────┬────────┬────────┐
+│ Button │ Button │ Button │
+│   1    │   2    │   3    │
+└────────┴────────┴────────┘
+```
+
+Use `Anchor.Right` for spacing between elements.
+
+### Right (Horizontal Stack)
+
+```
+Group {
+    LayoutMode: Right;
+
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+}
+```
+
+Children arrange horizontally from left to right but aligned to the right side of the parent:
+
+```
+                                                                 ┌────────┬────────┬────────┐
+                                                                 │ Button │ Button │ Button │
+                                                                 │   1    │   2    │   3    │
+                                                                 └────────┴────────┴────────┘
+```
+
+### Center
+
+```
+Group {
+    LayoutMode: Center;
+
+    Group #Dialog {
+        Anchor: (Width: 400, Height: 300);
+    }
+}
+```
+
+Centers the children horizontally.
+
+### Middle
+
+```
+Group {
+    LayoutMode: Middle;
+
+    Group #Dialog {
+        Anchor: (Width: 400, Height: 300);
+    }
+}
+```
+
+Centers the children vertically.
+
+### CenterMiddle (Horizontal Stack, Fully Centered)
+
+```
+Group {
+    LayoutMode: CenterMiddle;
+
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+}
+```
+
+Children stack horizontally from left to right, centered both horizontally and vertically within the parent:
+
+```
+┌────────────────────────────────────────────┐
+│                                            │
+│                                            │
+│         ┌──────┐ ┌──────┐ ┌──────┐         │
+│         │  B1  │ │  B2  │ │  B3  │         │
+│         └──────┘ └──────┘ └──────┘         │
+│                                            │
+│                                            │
+└────────────────────────────────────────────┘
+```
+
+---
+
+### MiddleCenter (Vertical Stack, Fully Centered)
+
+```
+Group {
+    LayoutMode: MiddleCenter;
+
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+}
+```
+
+Children stack vertically from top to bottom, centered both horizontally and vertically within the parent:
+
+```
+┌────────────────────────────────────────────┐
+│                                            │
+│              ┌──────────┐                  │
+│              │ Button 1 │                  │
+│              ├──────────┤                  │
+│              │ Button 2 │                  │
+│              ├──────────┤                  │
+│              │ Button 3 │                  │
+│              └──────────┘                  │
+│                                            │
+└────────────────────────────────────────────┘
+```
+
+---
+
+### Full
+
+```
+Group {
+    LayoutMode: Full;
+
+    Label {
+        Anchor: (Top: 20, Left: 20, Width: 100, Height: 30);
+    }
+}
+```
+
+Children use absolute positioning via their `Anchor` properties.
+
+### TopScrolling
+
+```
+Group {
+    LayoutMode: TopScrolling;
+    ScrollbarStyle: $Common.@DefaultScrollbar;
+
+    // ... many children
+}
+```
+
+Like `Top`, but adds a scrollbar if content exceeds container height.
+
+Or use `BottomScrolling` for bottom-aligned content.
+
+### LeftScrolling
+
+```
+Group {
+    LayoutMode: LeftScrolling;
+    ScrollbarStyle: $Common.@DefaultScrollbar;
+
+    // ... many children
+}
+```
+
+Like `Left`, but adds a scrollbar for horizontal scrolling.
+
+Or use `RightScrolling` for right-aligned content.
+
+### LeftCenterWrap (Wrapping Horizontal Stack, Horizontally Centered)
+
+```
+Group {
+    LayoutMode: LeftCenterWrap;
+
+    Button { Anchor: (Width: 80, Height: 30); }
+    Button { Anchor: (Width: 80, Height: 30); }
+    Button { Anchor: (Width: 80, Height: 30); }
+    Button { Anchor: (Width: 80, Height: 30); }
+    Button { Anchor: (Width: 80, Height: 30); }
+}
+```
+
+Children flow left to right. When there's no more horizontal space, they wrap to the next row. Each row is horizontally centered within the parent:
+
+```
+┌────────────────────────────────────────────┐
+│                                            │
+│       ┌──────┐ ┌──────┐ ┌──────┐           │
+│       │  B1  │ │  B2  │ │  B3  │           │
+│       └──────┘ └──────┘ └──────┘           │
+│            ┌──────┐ ┌──────┐               │
+│            │  B4  │ │  B5  │               │
+│            └──────┘ └──────┘               │
+│                                            │
+└────────────────────────────────────────────┘
+```
+
+## FlexWeight
+
+`FlexWeight` distributes remaining space among children.
+
+```
+Group {
+    LayoutMode: Left;
+    Anchor: (Width: 400);
+
+    Button {
+        Anchor: (Width: 100);
+    }
+
+    Group {
+        FlexWeight: 1;  // Takes all remaining space
+    }
+
+    Button {
+        Anchor: (Width: 100);
+    }
+}
+```
+
+Result:
+
+- First button: 100px
+- Middle group: 200px (400 - 100 - 100 = 200)
+- Last button: 100px
+
+### Multiple FlexWeights
+
+```
+Group {
+    LayoutMode: Left;
+    Anchor: (Width: 600);
+
+    Group { FlexWeight: 1; }
+    Group { FlexWeight: 2; }
+    Group { FlexWeight: 1; }
+}
+```
+
+Remaining space (600px) is split:
+
+- First group: 600 × (1/4) = 150px
+- Second group: 600 × (2/4) = 300px
+- Third group: 600 × (1/4) = 150px
+
+## Visibility
+
+```
+Button #HiddenButton {
+    Visible: false;
+}
+```
+
+**Effect:**
+
+- Element and its children are not displayed
+- Element is **not included in layout** (doesn't take up space)
diff --git a/content/docs/es-ES/official-documentation/custom-ui/markup.mdx b/content/docs/es-ES/official-documentation/custom-ui/markup.mdx
new file mode 100644
index 00000000..564110ed
--- /dev/null
+++ b/content/docs/es-ES/official-documentation/custom-ui/markup.mdx
@@ -0,0 +1,226 @@
+---
+title: Markup
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# Markup
+
+## Markup
+
+An element is the basic building block of a user interface. There are various types of elements with different properties, which are documented below.
+
+Here's what the syntax looks like:
+
+```
+// Basic declaration of an element
+// with its Anchor property set to attach on all sides of its parent
+// with 10 pixels of margin
+Group { Anchor: (Left: 10, Top: 10, Right: 10, Bottom: 10); }
+
+Group { Anchor: (Full: 10); } // More concise version
+
+// Declaration of a Label with a name
+// (can be used to access the element from game code)
+Label #MyLabel {
+  Style: LabelStyle(FontSize: 16); // or just Style: (FontSize: 16), type can be inferred.
+  Text: "Hi! I am text.";
+}
+
+// Declaration of a Group containing 2 children
+// You can use FlexWeight to distribute any left-over space after explicit widths/heights have been subtracted
+Group {
+  LayoutMode: Left;
+  Label { Text: "Child 1"; FlexWeight: 2; }
+  Label { Text: "Child 2"; FlexWeight: 1; }
+}
+```
+
+### Documents
+
+A UI document (_.ui_ file) contains trees of elements. There can be multiple root elements.
+
+### Named Expressions
+
+Named expressions can be declared at any level of a document (including at the root) and will be scoped to that subtree, though they need to be declared at the top of the block.
+
+```
+// Example of named expressions, declared and used with @ prefix
+@Title = "Hytale";
+@ExtraSpacing = 5;
+
+Label {
+  Text: @Title;
+  Style: (LetterSpacing: 2 + @ExtraSpacing);
+}
+```
+
+You can use the spread operator `...` to reuse a named expression while overriding some of its fields:
+
+```
+@MyBaseStyle = LabelStyle(FontSize: 24, LetterSpacing: 2);
+
+Label {
+  Style: (...@MyBaseStyle, FontSize: 36);
+}
+```
+
+You can even layer multiple named expressions like so:
+
+```
+@TitleStyle = LabelStyle(FontSize: 24, HorizontalAlignment: Center);
+@SpacedTextStyle = LabelStyle(LetterSpacing: 2);
+
+Label {
+  Style: (...@BigTextStyle, ...@SpacedTextStyle);
+}
+```
+
+#### Document references
+
+A document can reference another document and access its named expressions.
+
+```
+// Document references are defined with $ prefix
+$Common = "../Common.ui";
+
+TextButton {
+  Style: $Common.@DefaultButtonStyle;
+}
+```
+
+### Templates
+
+You can declare a reusable bit of interface as a named expression and then instantiate it as many times as you want in the tree while customizing it.
+
+You can override local named expressions as well as insert additional children at any point in the template tree. However, local named expressions must be defined at the very top of the block, before properties and child elements.
+
+```
+// This is the template
+@Row = Group {
+  Anchor: (Height: 50);
+  Label #Label { Anchor: (Left: 0, Width: 100); Text: @LabelText; }
+  Group #Content { Anchor: (Left: 100); }
+};
+
+// Here we'll be using it twice in the document tree
+Group #Rows {
+  LayoutMode: TopScrolling;
+
+  @Row #MyFirstRow {
+    @LabelText = "First row";
+    #Content { TextInput {} }
+  }
+
+  @Row #MySecondRow {
+    @LabelText = "Second row";
+  }
+}
+```
+
+### Property Types
+
+#### Basic Types
+
+- **Boolean**
+  - `Visible: false;`
+  - `Visible: true;`
+- **Int**
+  - `Height: 20;`
+- **Float, Double, Decimal**
+  - `Min: 0.2;`
+- **String**
+  - `Text: "Hi!";`
+- **Char**
+  - `PasswordChar: "*";`
+  - _Note: The syntax is the same as a string, however a value of this type cannot contain more than one character!_
+- **Color**
+  - `Background: #ffffff;`&#x20;
+- **Objects**
+  - `Style: (Background: #ffffff)`
+- **Array**&#x20;
+  - `TextSpans: [(Text: "Hi", IsBold: true)]`
+
+#### Translations
+
+Translation keys can be referenced anywhere in markup where you can provide a string, and they are then converted to a string when an element gets instantiated.
+
+**Example:**
+
+```
+Label {
+  Text: %ui.general.cancel;
+}
+```
+
+#### Colors
+
+A color literal can be written as follows:
+
+- `#rrggbb`: 6-digit hexadecimal representation for red, green, blue (fully opaque)
+- `#rrggbb(a.a)`: 6-digit hexadecimal representation for red, green, blue with alpha between 0 and 1
+- `#rrggbbaa`: 8-digit hexadecimal representation for red, green, blue and alpha
+
+```
+Group {
+  Background: #000000(0.3);
+}
+```
+
+<Callout>
+  The `#rrggbb(a.a)` format is prefered over the `#rrggbbaa` format for
+  readability reasons.
+</Callout>
+
+#### Font Name
+
+Font names can be referenced directly by their string ID. Internally this is using a custom type called `UIFontName`, however strings will be converted automatically to this type in markup.
+
+```
+Label {
+  Text: "Hi";
+  Style: (FontName: "Secondary");
+}
+```
+
+**Available Font Names**
+
+- _Default_ - This is the default font that is used for most text and is always used unless a different option has been specified
+- _Secondary_ - This font is mostly used for headlines or elements that are supposed to stick out
+- _Mono_ - This is only used for development; For things such as profiling or error overlays.
+
+#### Path
+
+We can reference other UI assets with the `UIPath` type. Similar to `UIFontName`_,_ Strings are automatically converted to a `UIPath`. Paths are always relative to the file where they have been declared in. Looking up _MyButton.png_ in _Menu/MyAwesomeMenu.ui_ will result in _Menu/MyButton.png_. If you want to reference a file that is in a parent folder you can go back one directory by writing two dots (_../MyButton.png_).
+
+The markup syntax of a `UIPath` is the same as a String. (e.g. `Path: "Test.png"`)
+
+Here are some more examples:
+
+| UIPath             | .ui File                              | Resulting Path    |
+| ------------------ | ------------------------------------- | ----------------- |
+| MyButton.png       | Menu/MyAwesomeMenu.ui                 | Menu/MyButton.png |
+| ../MyButton.png    | Menu/MyAwesomeMenu.ui                 | MyButton.png      |
+| ../../MyButton.png | Menu/Popup/Templates/MyAwesomeMenu.ui | Menu/MyButton.png |
+
+#### Objects
+
+Objects contain a set of properties. In this example we are assigning an Anchor object to the _Anchor_ property:
+
+```
+Group {
+  Anchor: (
+   Height: 10,
+   Width: 20
+ );
+}
+```
+
+You can find all objects that can be used in markup [here](type-documentation#elements).
+
+## Visual Studio Code Extension
+
+There is an official extension for Visual Studio Code which adds syntax highlighting for .ui files. You can find it [here](https://marketplace.visualstudio.com/items?itemName=HypixelStudiosCanadaInc.vscode-hytaleui).
diff --git a/content/docs/es-ES/official-documentation/custom-ui/type-documentation/index.mdx b/content/docs/es-ES/official-documentation/custom-ui/type-documentation/index.mdx
new file mode 100644
index 00000000..69cea406
--- /dev/null
+++ b/content/docs/es-ES/official-documentation/custom-ui/type-documentation/index.mdx
@@ -0,0 +1,127 @@
+---
+title: Type Documentation
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# Type Documentation
+
+This is a generated list of UI elements accessible by markup. More information about the User Interface framework can be found in the main documentation.
+
+## Elements
+
+- [ActionButton](type-documentation/elements/actionbutton)
+- [AssetImage](type-documentation/elements/assetimage)
+- [BackButton](type-documentation/elements/backbutton)
+- [BlockSelector](type-documentation/elements/blockselector)
+- [Button](type-documentation/elements/button)
+- [CharacterPreviewComponent](type-documentation/elements/characterpreviewcomponent)
+- [CheckBox](type-documentation/elements/checkbox)
+- [CheckBoxContainer](type-documentation/elements/checkboxcontainer)
+- [CircularProgressBar](type-documentation/elements/circularprogressbar)
+- [CodeEditor](type-documentation/elements/codeeditor)
+- [ColorOptionGrid](type-documentation/elements/coloroptiongrid)
+- [ColorPicker](type-documentation/lements/colorpicker)
+- [ColorPickerDropdownBox](type-documentation/elements/colorpickerdropdownbox)
+- [CompactTextField](type-documentation/elements/compacttextfield)
+- [DropdownBox](type-documentation/elements/dropdownbox)
+- [DropdownEntry](type-documentation/elements/dropdownentry)
+- [DynamicPane](type-documentation/elements/dynamicpane)
+- [DynamicPaneContainer](type-documentation/elements/dynamicpanecontainer)
+- [FloatSlider](type-documentation/elements/floatslider)
+- [FloatSliderNumberField](type-documentation/elements/floatslidernumberfield)
+- [Group](type-documentation/elements/group)
+- [HotkeyLabel](type-documentation/elements/hotkeylabel)
+- [ItemGrid](type-documentation/elements/itemgrid)
+- [ItemIcon](type-documentation/elements/itemicon)
+- [ItemPreviewComponent](type-documentation/elements/itempreviewcomponent)
+- [ItemSlot](type-documentation/elements/itemslot)
+- [ItemSlotButton](type-documentation/elements/itemslotbutton)
+- [Label](type-documentation/elements/label)
+- [LabeledCheckBox](type-documentation/elements/labeledcheckbox)
+- [MenuItem](type-documentation/elements/menuitem)
+- [MultilineTextField](type-documentation/elements/multilinetextfield)
+- [NumberField](type-documentation/elements/numberfield)
+- [Panel](type-documentation/elements/panel)
+- [ProgressBar](type-documentation/elements/progressbar)
+- [ReorderableList](type-documentation/elements/reorderablelist)
+- [ReorderableListGrip](type-documentation/elements/reorderablelistgrip)
+- [SceneBlur](type-documentation/elements/sceneblur)
+- [Slider](type-documentation/elements/slider)
+- [SliderNumberField](type-documentation/elements/slidernumberfield)
+- [Sprite](type-documentation/elements/sprite)
+- [TabButton](type-documentation/elements/tabbutton)
+- [TabNavigation](type-documentation/elements/tabnavigation)
+- [TextButton](type-documentation/elements/textbutton)
+- [TextField](type-documentation/elements/textfield)
+- [TimerLabel](type-documentation/elements/timerlabel)
+- [ToggleButton](type-documentation/elements/togglebutton)
+
+## Property Types
+
+- [Anchor](type-documentation/property-types/anchor)
+- [BlockSelectorStyle](type-documentation/property-types/blockselectorstyle)
+- [ButtonSounds](type-documentation/property-types/buttonsounds)
+- [ButtonStyle](type-documentation/property-types/buttonstyle)
+- [ButtonStyleState](type-documentation/property-types/buttonstylestate)
+- [CheckBoxStyle](type-documentation/property-types/checkboxstyle)
+- [CheckBoxStyleState](type-documentation/property-types/checkboxstylestate)
+- [ClientItemStack](type-documentation/property-types/clientitemstack)
+- [ColorOptionGridStyle](type-documentation/property-types/coloroptiongridstyle)
+- [ColorPickerDropdownBoxStateBackground](type-documentation/property-types/colorpickerdropdownboxstatebackground)
+- [ColorPickerDropdownBoxStyle](type-documentation/property-types/colorpickerdropdownboxstyle)
+- [ColorPickerStyle](type-documentation/property-types/colorpickerstyle)
+- [DropdownBoxSearchInputStyle](type-documentation/property-types/dropdownboxsearchinputstyle)
+- [DropdownBoxSounds](type-documentation/property-types/dropdownboxsounds)
+- [DropdownBoxStyle](type-documentation/property-types/dropdownboxstyle)
+- [InputFieldButtonStyle](type-documentation/property-types/inputfieldbuttonstyle)
+- [InputFieldDecorationStyle](type-documentation/property-types/inputfielddecorationstyle)
+- [InputFieldDecorationStyleState](type-documentation/property-types/inputfielddecorationstylestate)
+- [InputFieldIcon](type-documentation/property-types/inputfieldicon)
+- [InputFieldStyle](type-documentation/property-types/inputfieldstyle)
+- [ItemGridSlot](type-documentation/property-types/itemgridslot)
+- [ItemGridStyle](type-documentation/property-types/itemgridstyle)
+- [LabeledCheckBoxStyle](type-documentation/property-types/labeledcheckboxstyle)
+- [LabeledCheckBoxStyleState](type-documentation/property-types/labeledcheckboxstylestate)
+- [LabelSpan](type-documentation/property-types/labelspan)
+- [LabelStyle](type-documentation/property-types/labelstyle)
+- [NumberFieldFormat](type-documentation/property-types/numberfieldformat)
+- [Padding](type-documentation/property-types/padding)
+- [PatchStyle](type-documentation/property-types/patchstyle)
+- [PopupStyle](type-documentation/property-types/popupstyle)
+- [ScrollbarStyle](type-documentation/property-types/scrollbarstyle)
+- [SliderStyle](type-documentation/property-types/sliderstyle)
+- [SoundStyle](type-documentation/property-types/soundstyle)
+- [SpriteFrame](type-documentation/property-types/spriteframe)
+- [SubMenuItemStyle](type-documentation/property-types/submenuitemstyle)
+- [SubMenuItemStyleState](type-documentation/property-types/submenuitemstylestate)
+- [Tab](type-documentation/property-types/tab)
+- [TabNavigationStyle](type-documentation/property-types/tabnavigationstyle)
+- [TabStyle](type-documentation/property-types/tabstyle)
+- [TabStyleState](type-documentation/property-types/tabstylestate)
+- [TextButtonStyle](type-documentation/property-types/textbuttonstyle)
+- [TextButtonStyleState](type-documentation/property-types/textbuttonstylestate)
+- [TextTooltipStyle](type-documentation/property-types/texttooltipstyle)
+- [ToggleButtonStyle](type-documentation/property-types/togglebuttonstyle)
+- [ToggleButtonStyleState](type-documentation/property-types/togglebuttonstylestate)
+
+## Enums
+
+- [ActionButtonAlignment](type-documentation/enums/actionbuttonalignment)
+- [CodeEditorLanguage](type-documentation/enums/codeeditorlanguage)
+- [ColorFormat](type-documentation/enums/colorformat)
+- [DropdownBoxAlign](type-documentation/enums/dropdownboxalign)
+- [InputFieldButtonSide](type-documentation/enums/inputfieldbuttonside)
+- [InputFieldIconSide](type-documentation/enums/inputfieldiconside)
+- [ItemGridInfoDisplayMode](type-documentation/enums/itemgridinfodisplaymode)
+- [LabelAlignment](type-documentation/enums/labelalignment)
+- [LayoutMode](type-documentation/enums/layoutmode)
+- [MouseWheelScrollBehaviourType](type-documentation/enums/mousewheelscrollbehaviourtype)
+- [ProgressBarAlignment](type-documentation/enums/progressbaralignment)
+- [ProgressBarDirection](type-documentation/enums/progressbardirection)
+- [ResizeType](type-documentation/enums/resizetype)
+- [TimerDirection](type-documentation/enums/timerdirection)
+- [TooltipAlignment](type-documentation/enums/tooltipalignment)
diff --git a/content/docs/es-ES/official-documentation/npc/2-getting-started-with-templates.mdx b/content/docs/es-ES/official-documentation/npc/2-getting-started-with-templates.mdx
index 91081ca1..99d078e0 100644
--- a/content/docs/es-ES/official-documentation/npc/2-getting-started-with-templates.mdx
+++ b/content/docs/es-ES/official-documentation/npc/2-getting-started-with-templates.mdx
@@ -9,7 +9,7 @@ authors:
 
 There are no hard and fast rules for making a start on a template. I like to duplicate **BlankTemplate** and start from there because it already provides the basic structure of the file.
 
-This leaves me with the following template (`Template_Goblin_Ogre.json`): (note: the file could be looking different in the current version of the game)
+This leaves me with the following template (`Template_Goblin_Ogre.json`): (**note: the file could be looking different in the current version of the game**)
 
 ```json
 {
@@ -33,7 +33,7 @@ This leaves me with the following template (`Template_Goblin_Ogre.json`): (note:
     }
   },
   "Appearance": { "Compute": "Appearance" },
-  "DropList": { "Compute": "Droplist" },
+  "DropList": { "Compute": "DropList" },
   "MaxHealth": { "Compute": "MaxHealth" },
   "MotionControllerList": [
     {
@@ -65,10 +65,10 @@ And the following variant (`Goblin_Ogre.json`) next to the template. There's a t
   "Type": "Variant",
   "Reference": "Template_Goblin_Ogre",
   "Modify": {
-    "Appearance": "Goblin_Ogre",
+    "Appearance": "Goblin",
     "MaxHealth": 124
   }
 }
 ```
 
-Our artists have defined the `Goblin_Ogre` appearance already so I'm going to use that.
+Our artists have not yet finished animations for the `Goblin_Ogre`, for that sake of the tutorial I am going to use appearance `Goblin`, because it offers a more complete set of animations that we will need.
diff --git a/content/docs/es-ES/official-documentation/worldgen/pack-tutorial/asset-packs.mdx b/content/docs/es-ES/official-documentation/worldgen/pack-tutorial/asset-packs.mdx
index 38809fad..dcf1f3b9 100644
--- a/content/docs/es-ES/official-documentation/worldgen/pack-tutorial/asset-packs.mdx
+++ b/content/docs/es-ES/official-documentation/worldgen/pack-tutorial/asset-packs.mdx
@@ -9,13 +9,13 @@ authors:
 
 <OfficialDocumentationNotice />
 
-# How to modify Hytale
+# How to modify Hytale?
 
-## What's an Asset Pack
+## What's an Asset Pack?
 
-Hytales gameplay is driven by assets in the game that can be modified by creators. Asset Packs are our solution to let you override or add features to the base game with your own work. These can in the form of zip files of folders, which contain a custom set of assets. This is not the only way for a creator to change Hytale but this is the most accessible form.;
+Hytales gameplay is driven by assets in the game that can be modified by creators. Asset Packs are our solution to let you override or add features to the base game with your own work. These can be the form of zip files of folders, which contain a custom set of assets. This is not the only way for a creator to change Hytale but this is the most accessible form.;
 
-### How do I make an Asset Pack
+### How do I make an Asset Pack?
 
 <video controls className="my-6 aspect-video w-full rounded-lg border">
   <source src="https://cdn.internal.hytalemodding.dev/guides/official/how-to-asset-pack.mp4" type="video/mp4" />
@@ -48,7 +48,7 @@ An asset pack is typically a zip or folder, with a `manifest.json` inside. This
 }
 ```
 
-### Where are they stored
+### Where are they stored?
 
 Asset Packs are stored with other mods in the Mods folder.
 
@@ -76,7 +76,7 @@ C:\Users\<user>\AppData\Roaming\Hytale\UserData\Saves\New World 5\mods
 
 When you have Asset Packs or Mods installed, these will appear in the New World menu under the Options menu.;
 
-### How do I change an existing asset
+### How do I change an existing asset?
 
 <video controls className="my-6 aspect-video w-full rounded-lg border">
   <source src="https://cdn.internal.hytalemodding.dev/guides/official/how-to-asset.mp4" type="video/mp4" />
diff --git a/content/docs/es-ES/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx b/content/docs/es-ES/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx
index 44528376..24e628b5 100644
--- a/content/docs/es-ES/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx
+++ b/content/docs/es-ES/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx
@@ -106,7 +106,7 @@ If a BaseHeight is provided, the TopY and BottomY values are relative to the Bas
 
 Applies a Material Provider slot on a set of horizontal stripes of blocks of varying thickness and position. Below is an example image of basalt stripes into a stone cliff.
 
-{/* ![](https://540086904-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F7KAmBkOg6d13nZCkf9ku%2Fuploads%2FbcxO9LpArn8gPCaBwFg5%2Funknown.png?alt=media&token=1c72b67a-8253-4d03-8c64-1ad5f6830050) */}
+![Example of basalt stripes](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/basalt-stripes-example.png)
 
 #### Parameters:
 
diff --git a/content/docs/es-ES/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx b/content/docs/es-ES/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx
index 5e34acd4..a4418473 100644
--- a/content/docs/es-ES/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx
+++ b/content/docs/es-ES/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx
@@ -294,7 +294,7 @@ Combines all the positions into a single Positioins field.
 
 ---
 
-### SimpleHoritontal
+### SimpleHorizontal
 
 Keeps only the positions that are within the provided range.
 
diff --git a/content/docs/es-ES/official-documentation/worldgen/worldgen-tutorial/README.mdx b/content/docs/es-ES/official-documentation/worldgen/worldgen-tutorial/README.mdx
new file mode 100644
index 00000000..5f66d245
--- /dev/null
+++ b/content/docs/es-ES/official-documentation/worldgen/worldgen-tutorial/README.mdx
@@ -0,0 +1,166 @@
+---
+title: How to edit and create Biomes
+description: Explores where world generation assets can be found and how to edit them.
+---
+
+### Where are the Assets
+
+World generation assets are kept in the HytaleGenerator directory within the assets.
+
+```
+/Server/HytaleGenerator/
+```
+
+<div className="flex flex-row rounded-lg border p-4">
+  <div className="flex-1/2 border-r pr-4">
+    ```
+    /Biomes
+    ```
+
+    Biome assets, with content configurations.
+  </div>
+
+  <div className="flex-1/2 pl-4">
+    ```
+    /WorldStructure
+    ```
+
+    Generator files that define which biomes spawn together.
+  </div>
+</div>
+
+<div className="flex flex-row rounded-lg border p-4">
+  <div className="flex-1/2 border-r pr-4">
+    ```
+    /Density
+    ```
+
+    Density assets that can be referenced by any other assets.
+  </div>
+
+  <div className="flex-1/2 pl-4">
+    ```
+    /Assignments
+    ```
+
+    Prop assets that can be referenced by any Biome assets.
+  </div>
+</div>
+
+***
+
+An example of this structure can be found bellow, packed in an asset pack with the instance configuration.
+
+[https://drive.google.com/file/d/1sIz_CluANIIe3n8vNiOi-4PQdeqCO0qY/view?usp=drive_link](https://drive.google.com/file/d/1sIz_CluANIIe3n8vNiOi-4PQdeqCO0qY/view?usp=drive_link)
+
+<Callout>
+  Ensure you place your asset pack in the correct directory, under Mods.
+</Callout>
+
+### How to visit our worlds
+
+https://drive.google.com/file/d/1BJurxyj-taE-PXWm04bk7Dl6X7ZHTH92/view?usp=sharing
+
+#### Requirements
+
+- You must be an **Operator** in the world.
+  - To do this, run <mark style="color:$danger;">`/op self`</mark>
+- You must be in **Creative mode**.
+  - Press the <mark style="color:$danger;">`O`</mark> key, O for Orange.&#x20;
+
+The generation assets define a set of generators but on their own you cannot visit these. Currently you require an Instance with a generator that will allow you to visit your work.
+
+```
+/Server/Instances/
+```
+
+Instances are separate worlds that players can join using the `/instances` command. Each instance has an `Instance.bson` configuration asset that specifies which generator to use, among other worldly settings.
+
+```json
+{
+  "WorldGen": {
+    "Type": "HytaleGenerator",
+    "WorldStructure": "Basic",
+    "playerSpawn" : {
+      "X" : 123,
+      "Y" : 480,
+      "Z" : 10000,
+      "Pitch" : 0,
+      "Yaw" : 0,
+      "Roll" : 0
+    }
+  }
+}
+```
+
+<Callout>
+  You can create custom instances for different world structures and biomes as you need them.
+</Callout>
+
+### How to edit Biomes
+
+<video>
+  <source src="https://cdn.internal.hytalemodding.dev/guides/official/How-to-edit-Biomes.mp4" type="video/mp4" />
+</video>
+
+We currently use the Hytale Node Editor when editing world generation assets. This can be accessed while in-game from the Content Creation menu when pressing B. The node editor is then found under the asset editor dropdown on the upper left.&#x20;
+
+![Node Editor 1](/assets/official-documentation/worldgen/worldgen-tutorial/biomes/node-editor-1.png)
+
+Once you have the Hytale Node Editor open, through the file menu you can open Biomes by navigating to the Biomes directory and selecting one from your pack.&#x20;
+
+```
+/Server/HytaleGenerator/Biomes/
+```
+
+### Biome Asset Structure
+
+Every Biome has a root Biome node, this node splits into 5 structures. This is covered briefly but more information on each field can be found on the World Generation Concepts page.
+
+![Node Editor 2](/assets/official-documentation/worldgen/worldgen-tutorial/biomes/node-editor-2.png)
+
+<Callout>
+  Each biome is for the most part self contained, meaning it has control over what appears with the biome. The only exception to this are Base Heights.
+</Callout>
+
+<Tabs>
+  <Tab value="Terrain">
+    Mathematical function nodes that calculate the physical shape of the Biome's terrain.
+  </Tab>
+
+  <Tab value="Materials">
+    Logical nodes that determine what materials (blocks) make up a Biome's terrain.
+  </Tab>
+
+  <Tab value="Props">
+    Function nodes that add objects like prefabs and decorations to the terrain.
+  </Tab>
+
+  <Tab value="Environments">
+    Logical nodes that determine the environment asset at a given coordinate within the biome. This asset determines things like weather, NPC spawns, and sounds.
+  </Tab>
+
+  <Tab value="Tints">
+    Logical function nodes that determine a colour code that can be used by certain blocks in the world. Typically this will be grasses and soils.
+  </Tab>
+</Tabs>
+
+### How to preview your work
+
+[https://drive.google.com/file/d/1mNcHn9LhFnWDF0DzWFH6_YllmKAUvUry/view?t=6](https://drive.google.com/file/d/1mNcHn9LhFnWDF0DzWFH6_YllmKAUvUry/view?t=6)
+
+Once you are in an Instance world with the Hytale Generator active you will only be able to see your work by generating new chunks. There are a few ways to do this.
+
+The viewport command selects an area around the Player that will live reload as you make changes to the generator.&#x20;
+
+```
+/viewport --radius 5 
+```
+
+You can also create a new world to show your changes.&#x20;
+
+```
+/instances spawn <instance> 
+```
+
+The last option is to simply fly south, new chunks will generate with the changes made.
diff --git a/content/docs/es-ES/quick-start.mdx b/content/docs/es-ES/quick-start.mdx
index 653644f4..249d803a 100644
--- a/content/docs/es-ES/quick-start.mdx
+++ b/content/docs/es-ES/quick-start.mdx
@@ -9,3 +9,8 @@ Welcome to the Hytale modding documentation! Here you'll find everything you nee
 * [Setting up your dev environment](./guides/plugin/setting-up-env)
 * [Entity Component System (ECS)](./guides/ecs/entity-component-system)
 * [Publishing your mod](./publishing)
+
+### Useful Links
+
+* [Kaupenjoe's Modding Videos](https://www.youtube.com/@ModdingByKaupenjoe)
+* [TroubleDEV's Modding Videos](https://www.youtube.com/@TroubleDEV)
diff --git a/content/docs/es-ES/server/argtypes.mdx b/content/docs/es-ES/server/argtypes.mdx
new file mode 100644
index 00000000..e54a442e
--- /dev/null
+++ b/content/docs/es-ES/server/argtypes.mdx
@@ -0,0 +1,61 @@
+---
+title: ArgTypes
+description: Available ArgTypes
+icon: List
+full: true
+authors:
+  - name: Valeena
+---
+
+| Name                        | Target Class                           | Description                                                                                                                               |   |
+| :-------------------------- | :------------------------------------- | :---------------------------------------------------------------------------------------------------------------------------------------- | - |
+| Boolean                     | java.lang.Boolean                      | A 'true' or 'false' input                                                                                                                 |   |
+| Integer                     | java.lang.Integer                      | A whole number                                                                                                                            |   |
+| String                      | java.lang.String                       | Words, text, numbers, letters. To input more than one word at a time, you may need to wrap it with double quotes (`"my fancy sentence"`). |   |
+| Float                       | java.lang.Float                        | A floating-pointer number                                                                                                                 |   |
+| Double                      | java.lang.Double                       | A decimal number                                                                                                                          |   |
+| UUID                        | java.util.UUID                         | A UUID (Universally Unique IDentifier)                                                                                                    |   |
+| Player_UUID                 | java.util.UUID                         | A UUID or an online player username                                                                                                       |   |
+| Game_Profile_Lookup_Async   | ProfileServiceClient.PublicGameProfile | A player UUID or username. If not found locally, performs a remote lookup via the Profile Service.                                        |   |
+| Relative_Double_Coord       | Coord                                  | An x, y, or z coordinate as a decimal, optionally relative by specifying a tilde (~) in front of the number                               |   |
+| Relative_Int_Coord          | IntCoord                               | An x, y, or z coordinate as a whole number, optionally relative by specifying a tilde (~) in front of the number                          |   |
+| Relative_Integer            | RelativeInteger                        | A tilde to mark an integer relative to a base                                                                                             |   |
+| Relative_Float              | RelativeFloat                          | A tilde to mark a float relative to a base                                                                                                |   |
+| Player_Ref                  | PlayerRef                              | A UUID or an online player's username                                                                                                     |   |
+| World                       | World                                  | A world folder name                                                                                                                       |   |
+| Model_Asset                 | ModelAsset                             | A reference to an Asset of type Model                                                                                                     |   |
+| Weather_Asset               | Weather                                | A reference to an Asset of type Weather                                                                                                   |   |
+| Interaction_Asset           | Interaction                            | A reference to an Asset of type Interaction                                                                                               |   |
+| Root_Interaction_Asset      | RootInteraction                        | A reference to an Asset of type Root Interaction                                                                                          |   |
+| Effect_Asset                | EntityEffect                           | A refernece to an Asset of type EntityEffect                                                                                              |   |
+| Environment_Asset           | Environment                            | A reference to an Asset of type Environment                                                                                               |   |
+| Item_Asset                  | Item                                   | A reference to an Asset of type Item                                                                                                      |   |
+| Block_Type_Asset            | BlockType                              | A reference to an Asset of type BlockType                                                                                                 |   |
+| Particle_System             | ParticleSystem                         | A reference to an Asset of type ParticleSystem                                                                                            |   |
+| Hitbox_Collision_Config     | HitboxCollisionConfig                  | A reference to an Asset of type HitboxCollisionConfig                                                                                     |   |
+| Repulsion_Config            | RepulsionConfig                        | A reference to an Asset of type RepulsionConfig                                                                                           |   |
+| Sound_Event_Asset           | SoundEvent                             | A reference to an Asset of type SoundEvent                                                                                                |   |
+| Ambiance_Fx_Asset           | AmbianceFX                             | A reference to an Asset of type AmbianceFX                                                                                                |   |
+| Sound_Category              | SoundCategory                          | A sound category (sfx, music, ambient, ui)                                                                                                |   |
+| Entity_ID                   | `ArgWrapper<EntityWrappedArg, UUID>`   | A UUID representing an entity id                                                                                                          |   |
+| Integer_Comparison_Operator | IntegerComparisonOperator              | A mathematical sign for integer comparison                                                                                                |   |
+| Integer_Operation           | IntegerOperation                       | A mathematical sign for performing an operation                                                                                           |   |
+| Int_Range                   | `Pair<Integer, Integer>`               | Two integers representing a minimum and maximum of a range                                                                                |   |
+| Relative_Int_Range          | RelativeIntRange                       | Two integers representing a minimum and maximum of a range                                                                                |   |
+| Vector2I                    | Vector2i                               | Two integers, generally corresponding to x/z axis                                                                                         |   |
+| Vector3I                    | Vector3i                               | Three integers, generally corresponding to x/y/z axis                                                                                     |   |
+| Relative_Vector3I           | RelativeVector3i                       | Three optionally relative integers, generally corresponding to x/y/z axis                                                                 |   |
+| Relative_Block_Position     | RelativeIntPosition                    | A position with three integer coordinates, representing a block's location in world space.                                                |   |
+| Relative_Position           | Relative                               | A position with three decimal coordinates, representing a location in world space.                                                        |   |
+| Relative_Chunk_Position     | RealtiveChunkPosition                  | A position with two integer coordinates (x, z), representing a chunk's location.                                                          |   |
+| Rotation                    | Vector3f                               | A rotation with three coordinates, representing the pitch, yaw, and roll respectively                                                     |   |
+| Block_Type_Key              | String                                 | A block type                                                                                                                              |   |
+| Block_ID                    | Integer                                | A block type, converted to an int id                                                                                                      |   |
+| Color                       | Integer                                | A color value in hex format, hex integer, or decimal integer                                                                              |   |
+| Weighted_Block_Type         | `Pair<Integer, String>`                | A weight corresponding to a blocktype                                                                                                     |   |
+| Weighted_Block_Entry        | String                                 | A block with optional weight prefix                                                                                                       |   |
+| Block_Pattern               | BlockPattern                           | A list of blocks with optional weights                                                                                                    |   |
+| Individual_Block_Mask       | BlockMask                              | Create a block mask using symbols and block names                                                                                         |   |
+| Block_Mask                  | BlockMask                              | A tick rate value (e.g., 30tps, 33ms, or 30)                                                                                              |   |
+| Tick_Rate                   | Integer                                | A list of block masks that combine together                                                                                               |   |
+| Game_Mode                   | GameMode                               | GameMode                                                                                                                                  |   |
diff --git a/content/docs/es-ES/server/interaction-reference.mdx b/content/docs/es-ES/server/interaction-reference.mdx
new file mode 100644
index 00000000..6c0d01b3
--- /dev/null
+++ b/content/docs/es-ES/server/interaction-reference.mdx
@@ -0,0 +1,1586 @@
+---
+title: Interactions
+description: A list of most Interaction types provided by Hypixel, along with the meaning of their fields, and how they fit together.
+icon: List
+authors:
+  - name: Stephen Baynham
+    url: https://github.com/cannibalvox
+---
+
+### The Interaction Base Type
+
+All interactions of every type below are inherited from Interaction and have these fields.
+
+**Interaction Fields**
+
+| Field Name                | Type                                                                 | Required? | Notes                                                                                                                                                                                                                       |
+| ------------------------- | -------------------------------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| ViewDistance              | `Double`<br />(Default: 96.0)                                        | **No**    | Distance in blocks at which other players can see the effects from this interaction.                                                                                                                                        |
+| Effects                   | `InteractionEffects`                                                 | **No**    | Sound, animations, and particle effects that should trigger when this interaction begins executing.                                                                                                                         |
+| HorizontalSpeedMultiplier | `Float`<br />(Default: 1.0)                                          | **No**    | Multiplier applied to the User entity's movement speed while this interaction is executing                                                                                                                                  |
+| RunTime                   | `Float`                                                              | **No**    | If provided, this interaction will continue executing for at least this long before the interaction chain moves onto the next interaction.                                                                                  |
+| CancelOnItemChange        | `Boolean`<br />(Default: true)                                       | **No**    | If true, this interaction will be cancelled if the User entity's held item changes during execution. This can happen either due to the selected hotbar slot changing or the contents of the item's inventory slot changing. |
+| Rules                     | `InteractionRules`                                                   | **Yes**   | If provided, adds additional limitations and cancellation conditions to this interaction.                                                                                                                                   |
+| Settings                  | `Map`<br />(Key Type: `GameMode`, Value Type: `InteractionSettings`) | **No**    | If provided, adds additional per-GameMode settings to the interaction.                                                                                                                                                      |
+| Camera                    | `InteractionCameraSettings`                                          | **No**    | Arrays of camera motion keyframes for cutscenes and reveals.                                                                                                                                                                |
+
+**GameMode Values**
+
+- `Creative`: The game is currently in Creative Mode
+- `Adventure`: The game is currently in Adventure Mode
+
+**InteractionEffects Fields**
+
+| Field Name               | Type                                              | Required? | Notes                                                                                                                                                 |
+| ------------------------ | ------------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Particles                | `Array`<br />(Element Type: `ModelParticle`)      | **No**    | Particle systems to activate when this interaction begins if the player is in third-person mode.                                                      |
+| FirstPersonParticles     | `Array`<br />(Element Type: `ModelParticle`)      | **No**    | Particle systems to activate when this interaction begins if the player is in first-person mode.                                                      |
+| WorldSoundEventId        | `Asset`<br />(Asset Type: `SoundEvent`)           | **No**    | A sound to play in the world at the User entity's location when this interaction begins.<br />**The SoundEvent must be single-channel (mono) sound.** |
+| LocalSoundEventId        | `Asset`<br />(Asset Type: `SoundEvent`)           | **No**    | A 2D sound to play for the User entity when this interaction begins. Ignored if the User entity is not a player.                                      |
+| Trails                   | `Array`<br />(Element Type: `ModelTrail`)         | **No**    | Trail effects to activate on the User entity when this interaction begins.                                                                            |
+| WaitForAnimationToFinish | `Boolean`<br />(Default: false)                   | **No**    | If true, this interaction will continue executing for at least the length of any animations in this InteractionEffects object.                        |
+| ItemPlayerAnimationsId   | `Asset`<br />(Asset Type: `ItemPlayerAnimations`) | **No**    | If provided, the User entity will use this ItemPlayerAnimations set while this interaction is executing.                                              |
+| ItemAnimationId          | `String`                                          | **No**    | Id of an animation to trigger when this interaction begins executing.<br />**This animation id is not validated on server start.**                    |
+| ClearAnimationOnFinish   | `Boolean`<br />(Default: false)                   | **No**    | If true, animations triggered by this interaction will be halted when the interaction completes.                                                      |
+| ClearSoundEventOnFinish  | `Boolean`<br />(Default: false)                   | **No**    | If true, sounds triggered by this interaction will be halted when the interaction completes.                                                          |
+| CameraEffect             | `Asset`<br />(Asset Type: `CameraEffect` )        | **No**    | If provided, the CameraEffect will be applied while this interaction is executing.                                                                    |
+| MovementEffects          | `MovementEffects`                                 | **No**    | If provided, apply the movement effects to the User entity while this interaction is executing.                                                       |
+| StartDelay               | `Float`<br />(Default: 0.0f)                      | **No**    | The interaction will wait this many seconds before triggering the effects in this object.                                                             |
+
+**InteractionRules Fields**
+
+| Field Name          | Type                                                                                                | Required? | Notes                                                                                                                                                                                                                                     |
+| ------------------- | --------------------------------------------------------------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| BlockedBy           | `Array`<br />(Element Type: `InteractionType`)<br />(Default: Based on the chain's InteractionType) | **No**    | If provided, this RootInteraction cannot be executed while interaction chains of the provided types are executing.<br />**This field only functions for rules attached to a RootInteraction. It has no effect on an Interaction.**        |
+| Blocking            | `Array`<br />(Element Type: `InteractionType`)                                                      | **No**    | If provided, interaction chains with the specified InteractionTypes cannot be executed while this interaction is executing.                                                                                                               |
+| InterruptedBy       | `Array`<br />(Element Type: `InteractionType`)                                                      | **No**    | If provided, interaction chains with the specified InteractionTypes will cancel this interaction chain when they execute.<br />**This field only functions for rules attached to a RootInteraction. It has no effect on an Interaction.** |
+| Interrupting        | `Array`<br />(Element Type: `InteractionType`)                                                      | **No**    | If provided, interaction chains with the specified InteractionTypes will be canceled when this interaction begins.                                                                                                                        |
+| BlockedByBypass     | `String`                                                                                            | **No**    | If provided, this RootInteraction cannot be blocked by interaction chains whose RootInteraction has this value as an asset tag.                                                                                                           |
+| BlockingBypass      | `String`                                                                                            | **No**    | If provided, this interaction will not block RootInteractions that have the this value as an asset tag.                                                                                                                                   |
+| InterruptedByBypass | `String`                                                                                            | **No**    | If provided, this RootInteraction cannot be canceled by RootInteractions that have this value as an asset tag.                                                                                                                            |
+| InterruptingBypass  | `String`                                                                                            | **No**    | If provided, this interaction will not cancel interaction chains whose RootInteraction has this value as an asset tag.                                                                                                                    |
+
+**InteractionType Values**
+
+- `Primary`
+- `Secondary`
+- `Ability1`
+- `Ability2`
+- `Ability3`
+- `Use`
+- `Pick`
+- `Pickup`
+- `CollisionEnter`
+- `CollisionLeave`
+- `Collision`
+- `EntityStatEffect`
+- `SwapTo`
+- `SwapFrom`
+- `Death`
+- `Wielding`
+- `ProjectileSpawn`
+- `ProjectileHit`
+- `ProjectileMiss`
+- `ProjectileBounce`
+- `Held`
+- `HeldOffhand`
+- `Equipped`
+- `Dodge`
+- `GameModeSwap`
+
+**InteractionSettings Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                        |
+| ---------------- | ------------------------------- | --------- | -------------------------------------------------------------------------------------------- |
+| AllowSkipOnClick | `Boolean`<br />(Default: false) | **No**    | If true, the user will be able to skip this interaction by clicking shortly after it starts. |
+
+**InteractionCameraSettings Fields**
+
+| Field Name  | Type                                             | Required? | Notes                                                                                                                                                           |
+| ----------- | ------------------------------------------------ | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| FirstPerson | `Array`<br />(Element Type: `InteractionCamera`) | **No**    | A list of camera keyframes to be played if the player is in first-person.<br />**The time of each keyframe must be after the keyframe before it in the array.** |
+| ThirdPerson | `Array`<br />(Element Type: `InteractionCamera`) | **No**    | A list of camera keyframes to be played if the player is in third-person.<br />**The time of each keyframe must be after the keyframe before it in the array.** |
+
+**InteractionCamera Fields**
+
+| Field Name | Type                         | Required? | Notes                                                                                                                                       |
+| ---------- | ---------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------- |
+| Time       | `Float`<br />(Default: 0.1f) | **No**    | How long after the interaction begins executing that the camera should arrive at this keyframe.<br />**Cannot be less than or equal to 0.** |
+| Position   | `Vector3`                    | **Yes**   | Where the camera should be located when it arrives at this keyframe.                                                                        |
+| Rotation   | `Direction`                  | **Yes**   | Where the camera should be pointing when it arrives at this keyframe.                                                                       |
+
+### SimpleInteraction
+
+Most interaction types below are inherited from SimpleInteraction and have these
+fields.  If a type does not have these fields, the documentation will mention it.
+
+The purpose of SimpleInteraction is to facilitate Interaction chaining by taking different paths
+based on whether the Interaction succeeded or failed.  The circumstances under which
+a given Interaction fails are generally type-specific (and described in the documentation
+below), but all interactions will be marked failed if they are cancelled via one of the
+many, many mechanisms for doing so.
+
+It is valid to create an interaction asset of type "Simple", which can be valuable when you want to use the
+interaction fields with no additional functionality.
+
+**SimpleInteraction Fields**
+
+| Field Name | Type                                     | Required? | Notes                                                                                          |
+| ---------- | ---------------------------------------- | --------- | ---------------------------------------------------------------------------------------------- |
+| Next       | `Asset`<br />(Asset Type: `Interaction`) | **No**    | After this Interaction has finished, "Next" will be executed if this Interaction did not fail. |
+| Failed     | `Asset`<br />(Asset Type: `Interaction`) | **No**    | After this Interaction has finished, "Failed" will be executed if this Interaction failed.     |
+
+## Flow Control
+
+These are interaction types used to control the flow of an interaction chain and allow interactions
+to be composed into more complex behaviors.  These interaction types generally do not pertain to
+the game and instead pertain to the interaction system itself.
+
+### Condition
+
+This interaction will fail if one of the fields is provided but does not match the current state.
+
+**Condition Fields**
+
+| Field Name       | Type       | Required? | Notes                                                                                                                                                                                    |
+| ---------------- | ---------- | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| RequiredGameMode | `GameMode` | **No**    | If provided, the interaction will fail if the current GameMode does not match the provided value.                                                                                        |
+| Jumping          | `Boolean`  | **No**    | If provided, the interaction will fail if the player's Jumping state does not match the provided value. (i.e. if True, the player must be jumping, if False, the player must not be)     |
+| Swimming         | `Boolean`  | **No**    | If provided, the interaction will fail if the player's Swimming state does not match the provided value. (i.e. if True, the player must be swimming, if False, the player must not be)   |
+| Crouching        | `Boolean`  | **No**    | If provided, the interaction will fail if the player's Crouching state does not match the provided value. (i.e. if True, the player must be crouching, if False, the player must not be) |
+| Running          | `Boolean`  | **No**    | If provided, the interaction will fail if the player's Running state does not match the provided value. (i.e. if True, the player must be running, if False, the player must not be)     |
+| Flying           | `Boolean`  | **No**    | If provided, the interaction will fail if the player's Flying state does not match the provided value. (i.e. if True, the player must be flying, if False, the player must not be)       |
+
+**GameMode Values**
+
+- `Creative`: The game is currently in Creative Mode
+- `Adventure`: The game is currently in Adventure Mode
+
+### FirstClick
+
+This interaction does not inherit from SimpleInteraction and therefore has no Next or Failed fields.
+
+This interaction has two fields that each contain a reference to an Interaction: Click and Hold.  If the root interaction
+of the chain was initiated by a client button/key press (or simulated NPC input) and the input was a tap, then
+the Click interaction is run. if it was a longer press, then the Hold interaction is run.
+
+As a minor implementation detail, this interaction is internally marked as failed when the Hold path is followed.
+This generally shouldn't matter.  If the interaction was not initiated by a key press at all, the Click path will be followed,
+but it seems risky to rely on that behavior.
+
+**FirstClick Fields**
+
+| Field Name | Type                                     | Required? | Notes                                                                                                                                                    |
+| ---------- | ---------------------------------------- | --------- | -------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Click      | `Asset`<br />(Asset Type: `Interaction`) | **No**    | If provided and the root interaction of the chain was initiated by button/key press, this interaction is executed next if the press was a quick tap.     |
+| Hold       | `Asset`<br />(Asset Type: `Interaction`) | **No**    | If provided and the root interaction of the chain was initiated by a button/key press, this interaction is executed next if the press was a longer hold. |
+
+### Interrupt
+
+This interaction can be used to cancel one or more running interaction chains on an entity and **all forked interaction
+chains those chains have spawned that are still currently running**.  All interaction chains canceled in this manner will be marked as
+Failed, which may have additional implications if the canceled chains are themselves forked from
+other chains that are still running.
+
+**Interrupt Fields**
+
+| Field Name     | Type                                           | Required? | Notes                                                                                                                                                                                               |
+| -------------- | ---------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Entity         | `InteractionTarget`<br />(Default: User)       | **Yes**   | The entity that is the owner of the target interaction chains.  This field can indicate the Owner, User, or Target of this interaction chain.                                                       |
+| InterruptTypes | `Array`<br />(Element Type: `InteractionType`) | **No**    | A set of InteractionTypes that are to be interrupted. Only interactions of these types are affected. If null, all types will be interrupted.<br />**(Note: An empty set will interrupt NO TYPES.)** |
+| RequiredTag    | `String`                                       | **No**    | An asset tag that, if provided, the RootInteraction of the interaction chain must have in order to be canceled.                                                                                     |
+| ExcludedTag    | `String`                                       | **No**    | An asset tag that, if provided, the RootInteraction of the interaction chain must not have in order to be canceled.                                                                                 |
+
+**InteractionTarget Values**
+
+- `User` - The user of this interaction chain. The entity whose actions caused this interaction chain to be executed. This is usually the same as the Owner.
+- `Owner` - The owner of this interaction chain. The entity upon whom this interaction chain is executing.
+- `Target` - The entity target of this interaction chain, if any.  This value is mutable (and can therefore come from many places) but most commonly, it is an entity the User was targeting when this interaction chain began executing.
+
+**InteractionType Values**
+
+- `Primary`
+- `Secondary`
+- `Ability1`
+- `Ability2`
+- `Ability3`
+- `Use`
+- `Pick`
+- `Pickup`
+- `CollisionEnter`
+- `CollisionLeave`
+- `Collision`
+- `EntityStatEffect`
+- `SwapTo`
+- `SwapFrom`
+- `Death`
+- `Wielding`
+- `ProjectileSpawn`
+- `ProjectileHit`
+- `ProjectileMiss`
+- `ProjectileBounce`
+- `Held`
+- `HeldOffhand`
+- `Equipped`
+- `Dodge`
+- `GameModeSwap`
+
+### Parallel
+
+This interaction does not inherit from SimpleInteraction and therefore has no Next or Failed fields.
+
+This interaction has a field `Interactions` that is an array of RootInteraction assets. The list must contain at least
+two RootInteractions.  This interaction will fork all of its children except for the first into their
+own interaction chains and immediately complete. After this interaction completes, this interaction chain will
+execute the first RootInteraction in the `Interactions` list.
+
+This interaction does not have any failure conditions and is indifferent to the fate of the forked interaction chains.
+
+**Parallel Fields**
+
+| Field Name   | Type                                                | Required? | Notes                                                         |
+| ------------ | --------------------------------------------------- | --------- | ------------------------------------------------------------- |
+| Interactions | `AssetArray`<br />(Element Type: `RootInteraction`) | **Yes**   | An array of RootInteractions that will be forked or executed. |
+
+### Repeat
+
+This interaction has a field `ForkInteractions` that is an asset of type RootInteraction. This interaction will fork that
+RootInteraction into its own interaction chain and then wait for it to complete. If the RootInteraction fails, this
+interaction will complete immediately and be marked failed. Otherwise, the RootInteraction will be forked and run again,
+up to a specified total number of times.
+
+**Repeat Fields**
+
+| Field Name       | Type                                                                                   | Required? | Notes                                                                                                                                                                                                              |
+| ---------------- | -------------------------------------------------------------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| ForkInteractions | `Asset`<br />(Asset Type: `RootInteraction`)                                           | **Yes**   | A RootInteraction that will be forked.                                                                                                                                                                             |
+| Repeat           | `Integer`<br />(Default: 1)<br />**Must be -1 or a positive integer. 0 is not valid.** | **No**    | The total number of times to fork ForkInteractions. If -1 is provided, ForkInteractions will continue being forked and executed indefinitely, until this interaction is cancelled or until ForkInteractions fails. |
+
+### Replace
+
+This interaction does not inherit from SimpleInteraction and therefore has no Next or Failed fields.
+
+This interaction uses the InteractionVars system that is avaiable for items. InteractionVars are RootInteractions that
+can be attached to an Item asset with a name.
+
+This interaction specifies a var name, and if this interaction chain was executed through
+an item and that item has an InteractionVar of the same name, then this interaction will immediately execute
+the RootInteraction on the var.  Otherwise, it will execute the default RootInteraction specified in this interaction.
+If no default is specified, then this interaction will be marked as failed.
+
+**Replace Fields**
+
+| Field Name   | Type                                         | Required? | Notes                                                                                                                                                                                                           |
+| ------------ | -------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Var          | `String`                                     | **Yes**   | The name of the InteractionVar to execute.                                                                                                                                                                      |
+| DefaultValue | `Asset`<br />(Asset Type: `RootInteraction`) | **No**    | The RootInteraction to execute if the owning item does not have an InteractionVar by the specified name. If not provided, the interaction will be marked as failed instead.                                     |
+| DefaultOk    | `Boolean`<br />(Default: false)              | **No**    | If false, then an angry message will be printed to the server logs if the owning item does not have an InteractionVar by the specified name.  The functioning of this interaction will be otherwise unaffected. |
+
+### RunRootInteraction
+
+This interaction immediately executes the provided RootInteraction as part of this interaction chain. This interaction
+does not have any failure conditions.
+
+**RunRootInteraction Fields**
+
+| Field Name      | Type                                         | Required? | Notes                           |
+| --------------- | -------------------------------------------- | --------- | ------------------------------- |
+| RootInteraction | `Asset`<br />(Asset Type: `RootInteraction`) | **Yes**   | The RootInteraction to execute. |
+
+### Selector
+
+This interaction will execute a Selector to find entities and/or blocks (depending on the Selector) and fork off an
+interaction chain for each located entity or block. This interaction will not wait for those interaction chains
+to complete and is indifferent to their fate. The forked interaction chains will use the located entity/block as
+their target entity/target block. Each entity or block will only fork one interaction chain over the life of this
+interaction.  The Selector is guaranteed to run once for each execution of this interaction, but some Selectors
+are intended to be run over a period of time and sweep across an area to locate targets. In order to use those Selectors
+properly, you will need to extend the execution time of this interaction using `RunTime` or `WaitForAnimationToFinish`.
+The Selector will be executed repeatedly over the lifetime of the interaction.
+
+If the Selector is configured to locate entities, you can add additional sets of entity matching rules. If a located entity
+matches one of the rules, the matching RootInteraction will be forked instead of the standard `HitEntity` RootInteraction.
+
+Entities located by the Selector will be ignored if they do not have a NetworkId, if they are dead, or if they are invulnerable.
+The only exception to this rule is that players in Creative Mode that are marked to receive hits will not be ignored.
+
+This interaction's failure conditions are configurable via the `FailOn` field. You can configure this interaction to never
+fail, to fail if the Selector does not locate any blocks before this interaction finishes executing, to fail if the
+Selector does not locate any entities before this interaction finishes executing, or to fail in either case.
+
+**Selector Fields**
+
+| Field Name     | Type                                         | Required? | Notes                                                                                                                                                                                                                                     |
+| -------------- | -------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Selector       | `Selector`                                   | **Yes**   | The Selector is executed at least once and may be executed repeatedly to locate blocks and/or entities in an area.                                                                                                                        |
+| HitEntity      | `Asset`<br />(Asset Type: `RootInteraction`) | **No**    | If included and the `Selector` locates an entity that does not match any `HitEntityRules`, this RootInteraction will be forked into a new interaction chain with the located entity as the target entity.                                 |
+| HitEntityRules | `Array`<br />(Element Type: `HitEntity`)     | **No**    | If included, these rules will be matched against any entity located by the `Selector`. If an entity matches a set of rules, the RootInteraction associated with the rules will be forked instead of the standard `HitEntity` interaction. |
+| HitBlock       | `Asset`<br />(Asset Type: `RootInteraction`) | **No**    | If included and the `Selector` locates a block, this RootInteraction will be forked into a new interaction chain with the located block as the block target.                                                                              |
+| FailOn         | `FailOnType`<br />(Default: `Neither`)       | **No**    | Defines under what circumstances this interaction will fail.  It can be marked to fail when it completes without locating any blocks, it can be marked to fail when it completes without locating any entities, both, or neither.         |
+| IgnoreOwner    | `Boolean`<br />(Default: true)               | **No**    | If true, the Selector will not locate the User entity of this interaction.                                                                                                                                                                |
+
+**HitEntity Fields**
+
+| Field Name | Type                                         | Required? | Notes                                                                                                 |
+| ---------- | -------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------- |
+| Matchers   | `Array`<br />(Element Type: `EntityMatcher`) | **Yes**   | A set of rules that an entity must match. An entity must successful match all rules to be considered. |
+| Next       | `Asset`<br />(Asset Type: `RootInteraction`) | **Yes**   | The RootInteraction to fork if an entity matches all rules.                                           |
+
+**EntityMatcher Fields**
+
+| Field Name | Type                            | Required? | Notes                                                                                                     |
+| ---------- | ------------------------------- | --------- | --------------------------------------------------------------------------------------------------------- |
+| Type       | `String`                        | **Yes**   | If provided, specifies a type of EntityMatcher to use. Each matcher type may come with additional fields. |
+| Invert     | `Boolean`<br />(Default: false) | **No**    | If true, an entity must fail this rule for it to be marked as succeeded.                                  |
+
+**EntityMatcher Type: Player**
+
+This EntityMatcher will succesfully match the entity only if they are a player.
+
+**EntityMatcher Type: Vulnerable**
+
+This Entitymatcher will successfully match the entity only if they are not marked as invulnerable.
+
+**FailOnType Values**
+
+- `Neither`
+- `Entity`
+- `Block`
+- `Either`
+
+### Serial
+
+This interaction does not inherit from SimpleInteraction and therefore has no Next or Failed fields.
+
+This interaction has a field `Interactions` which is a list of Interaction assets. This interaction immediately
+completes and the interaction chain continues by executing the interactions in the list one at a time. This
+interaction does not have any failure conditions.
+
+**Serial Fields**
+
+| Field Name   | Type                                            | Required? | Notes                                      |
+| ------------ | ----------------------------------------------- | --------- | ------------------------------------------ |
+| Interactions | `AssetArray`<br />(Element Type: `Interaction`) | **Yes**   | An array of Interaction assets to execute. |
+
+## Cooldowns
+
+RootInteractions interface with a complex cooldown system that can be used for a variety of purposes. Aside from simply
+adding an important aspect of resource management to your game design, cooldowns can be used to ensure that click-activated
+interaction chains don't repeatedly spam if the player holds down the input.
+
+By default, every RootInteraction has a cooldown timer that is keyed to the RootInteraction name, and by default, it
+will launch a cooldown of 0.35 seconds when activated by client input.  Otherwise, no cooldown will be activated.  However,
+by configuring your RootInteraction, you can change the key for the cooldown (so that multiple RootInteractions can share
+a single cooldown), set the cooldown timer to whatever you like, and configure multiple charges that can build up over time
+to allow the entity to activate the RootInteraction multiple times before being forced to pause.
+
+One important concept to keep in mind is the difference between **cooldown** and **charge time**.  The cooldown, if any,
+is activated each time a RootInteraction triggers, even if the player has more available charges. If the RootInteraction
+is configured to use charges, then they will gradually build up over time. In order for a RootInteraction to be activated,
+the cooldown (if any) must be expired, and the RootInteraction must have at least one charge (if it has been
+configured to use charges).
+
+Bear in mind that the entire Cooldown configuration is shared between different RootInteractions with the same cooldown id.
+If you activate an ability with 5 charges and a short cooldown and then another ability with a much longer cooldown and no
+charges, the second ability will use the cooldown properties of the first ability until/unless the first ability finishes
+charging and is cleared from the system.  You should generally only have multiple RootInteractions share a cooldown id
+if they have the same configuration.
+
+The interactions below interact with the cooldown system to allow you to manipulate cooldowns via the interaction system. By
+using these interactions, you can have several interaction chains with different cooldown configurations share cooldowns
+that are checked and activated as part of the interaction chain itself, or have some components of an interaction change
+use a second cooldown separate from the main one.
+
+### CooldownCondition
+
+**CooldownCondition Fields**
+
+This interaction will fail if the specified cooldown id is on cooldown for the User entity.  This interaction will only
+function for players- the interaction will always succeed for NPCs.  In order for this interaction to succeed, the
+cooldown, if any, must have expired and at least one charge, if any, must have filled.
+
+| Field Name | Type     | Required? | Notes                     |
+| ---------- | -------- | --------- | ------------------------- |
+| Id         | `String` | **Yes**   | The cooldown id to check. |
+
+### IncrementCooldown
+
+**IncrementCooldown Fields**
+
+This interaction will modify a cooldown that is currently active on the User entity, allowing charges and remaining
+cooldown to be modified.
+Despite its name, this interaction can be used to reduce a cooldown as well as increase it. If the cooldown is not
+currently active, this interaction will have no effect. The interaction has no special failure conditions.
+
+| Field Name        | Type                        | Required? | Notes                                                                                                                                                                                                                                                                                     |
+| ----------------- | --------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Id                | `String`                    | **No**    | If provided, the cooldown id of the cooldown to be manipulated. If not provided, the cooldown id of the current chain's RootInteraction will be used.                                                                                                                                     |
+| Time              | `Float`<br />(Default: 0.0) | **No**    | The amount to increase the remaining cooldown by. Can be negative. The remaining cooldown time will not be reduced below zero or increased above the maximum cooldown time.                                                                                                               |
+| ChargeTime        | `Float`<br />(Default: 0.0) | **No**    | The amount to increase the remaining time until the next charge is filled by. Can be negative. The remaining charge time cannot be reduced below zero or increased above the maximum cooldown time. **This will not work on abilities that have a maximum of 1 charge, for some reason.** |
+| Charge            | `Integer`<br />(Default: 0) | **No**    | The amount to increase the number of charges by. Can be negative. The number of charges cannot be reduced below 0 or increased above the maximum.                                                                                                                                         |
+| InterruptRecharge | `Boolean`(Default: false)   | **No**    | If true and `Charge` is not 0, will reset the remaining time to the next charge to the maximum value after changing the charge count.                                                                                                                                                     |
+
+### ResetCooldown
+
+This interaction will trigger a cooldown on the User entity with a specified configuration. The charges will be refilled
+but the cooldown will be immediately triggered.  The mechanisms for deciding on the configuration are a little bit complicated.
+You may specify a cooldown configuration via the `Cooldown` field. If you do not include an `Id` field, then the
+interaction chain's RootInteraction will be used for any field not specified in the configuration. If there is an active
+cooldown under the specified `Id` (or under the RootInteraction's cooldown id if none is specified) then the fields
+from that active cooldown will overwrite data in the RootInteraction's cooldown, but not data in your `Cooldown` field.
+
+**ResetCooldown Fields**
+
+| Field Name | Type                  | Required? | Notes                                                        |
+| ---------- | --------------------- | --------- | ------------------------------------------------------------ |
+| Cooldown   | `InteractionCooldown` | **No**    | A cooldown configuration to use for the new, reset cooldown. |
+
+**InteractionCooldown Fields**
+
+| Field Name        | Type                                 | Required? | Notes                                                                                                                                                                                                 |
+| ----------------- | ------------------------------------ | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Id                | `String`                             | **No**    | The cooldown id to use for this cooldown. If not provided, the RootInteraction's cooldown id will be used, if any.                                                                                    |
+| Cooldown          | `Float`<br />(Default: 0.0)          | **No**    | The duration of the cooldown, in seconds.                                                                                                                                                             |
+| Charges           | `Array`<br />(Element Type: `Float`) | **No**    | If provided, a list of how many charges this cooldown can build, and how long each charge takes to build, in seconds.                                                                                 |
+| InterruptRecharge | `Boolean`<br />(Default: false)      | **No**    | If true, the charge time will be reset when the number of charges changes.                                                                                                                            |
+| ClickBypass       | `Boolean`<br />(Default: false)      | **No**    | If true, RootInteractions keyed to this cooldown can still be activated when it is on cooldown provided that the RootInteraction was triggered by a distinct key or mouse button press on the client. |
+
+### TriggerCooldown
+
+This interaction is similar to ResetCooldown, except instead of refilling the cooldown's charges, one charge will be deducted
+as normal.
+
+**TriggerCooldown Fields**
+
+| Field Name | Type                  | Required? | Notes                                                        |
+| ---------- | --------------------- | --------- | ------------------------------------------------------------ |
+| Cooldown   | `InteractionCooldown` | **No**    | A cooldown configuration to use for the new, reset cooldown. |
+
+**InteractionCooldown Fields**
+
+| Field Name        | Type                                 | Required? | Notes                                                                                                                                                                                                 |
+| ----------------- | ------------------------------------ | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Id                | `String`                             | **No**    | The cooldown id to use for this cooldown. If not provided, the RootInteraction's cooldown id will be used, if any.                                                                                    |
+| Cooldown          | `Float`<br />(Default: 0.0)          | **No**    | The duration of the cooldown, in seconds.                                                                                                                                                             |
+| Charges           | `Array`<br />(Element Type: `Float`) | **No**    | If provided, a list of how many charges this cooldown can build, and how long each charge takes to build, in seconds.                                                                                 |
+| InterruptRecharge | `Boolean`<br />(Default: false)      | **No**    | If true, the charge time will be reset when the number of charges changes.                                                                                                                            |
+| ClickBypass       | `Boolean`<br />(Default: false)      | **No**    | If true, RootInteractions keyed to this cooldown can still be activated when it is on cooldown provided that the RootInteraction was triggered by a distinct key or mouse button press on the client. |
+
+## Combo Chains
+
+Hytale additionally comes with a rich "combo chaining" system, which allows several inputs in a row to result in different
+attacks and special moves.  Rather than being attached to the RootInteraction like the cooldown system, these are
+primarily driven by the `Chaining` interaction.
+
+### Chaining
+
+This interaction does not inherit from SimpleInteraction and therefore has no Failed field. Its Next field works differently
+from most interaction types.
+
+Chaining is a type of flow control interaction- each time a Chaining interaction with the same `ChainId` is called, a single
+interaction in the `Next` list is chosen and the others are ignored. The first time the `ChainId` is used, the first
+interaction in the list is chosen, the next time the second, etc. Once the end of the list is reached, the first
+interaction will be chosen again.
+
+Bear in mind: the progress through the Next list is based on the **ChainId**, not the interaction!  That means that two
+different Chaining interactions can share a single combo chain. You could have a pair of daggers that attacks with
+the left when the left mouse button is clicked and with the right when the right mouse button is clicked.  You could give
+both interaction chains a Chaining interaction with the same `ChainId` and three `Next` entries that do a light-light-heavy
+combo.  Each specific hit would occur with either the left or the right knife based on which button you clicked, but
+the combo would be otherwise identical regardless of which you chose.
+
+The Chaining interaction also has a concept called "flags".  It is possible to attach named flags to a `ChainId` by using
+the ChainFlag interaction.  Then, you specify the flag name in Chaining's `Flags` field. If a Flag is active when the
+Chaining interaction is run, the Flag's interaction will be run instead of the appropriate interaction in `Next`.
+Bear in mind: the entity's progress through the `Next` list still advances, the resulting `Next` interaction is just not
+run.  Only one flag can be active at a time.
+
+Lastly, it is possible to cancel the entity's progress through the combo chain and reset them to the first interaction in
+the list. This can be done with the CancelChain interaction, but it will also happen automatically if the player does
+not trigger an interaction with the ChainId for the specified ChainingAllowance.  When either of these happen, all flags will be
+canceled as well.
+
+All of these effects are triggered on the User entity only. Non-players can use the chaining system, but Flags do not currently
+work for non-players.  This interaction has no special failure conditions.
+
+**Chaining Fields**
+
+| Field Name        | Type                                                       | Required? | Notes                                                                                                                                                                                                                       |
+| ----------------- | ---------------------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| ChainId           | `String`                                                   | **No**    | If provided, acts as a key that multiple Chaining interactions can use to share combo chain progress and flags. If not provided, a unique ChainId will be generated for this interaction.                                   |
+| ChainingAllowance | `Double`<br />(Default: 0.0)                               | **No**    | If, at the time this interaction is triggered, it has been this long in seconds since the last time a Chaining interaction with the same ChainId was executed, all state for this ChainId will be cleared before execution. |
+| Next              | `AssetArray`<br />(Element Type: `Interaction`)            | **Yes**   | A list of interactions to cycle between each time this interaction is run.                                                                                                                                                  |
+| Flags             | `Map`<br />(Key Type: `String`, Value Type: `Interaction`) | **No**    | A map of flag names to interactions to run if the flag is active when this interaction executes.                                                                                                                            |
+
+### CancelChain
+
+This interaction resets all progress and flag data on the User entity for the provided `ChainId`.  The next time a Chaining
+interaction is called for the provided `ChainId`, it will begin at the first interaction in the `Next` list. This
+interaction has no special failure conditions.
+
+**CancelChain Fields**
+
+| Field Name | Type     | Required? | Notes                                 |
+| ---------- | -------- | --------- | ------------------------------------- |
+| ChainId    | `String` | **Yes**   | A ChainId whose data should be reset. |
+
+### ChainFlag
+
+This interaction activates a flag on the User entity for the provided `ChainId`, which can be used to change behavior the
+next time a Chaining interaction with this `ChainId` is run. This will overwrite any flag that has
+already been raised. This interaction will have no effect for non-players. This interaction has no special failure
+conditions.
+
+| Field Name | Type     | Required? | Notes                                        |
+| ---------- | -------- | --------- | -------------------------------------------- |
+| ChainId    | `String` | **Yes**   | A ChainId on whom the flag should be raised. |
+| Flag       | `String` | **Yes**   | The name of the flag to raise.               |
+
+## Charging
+
+A unique flow-control interaction that is frequently used is the Charging interaction.  It is a flow-control interaction
+that delays while the input button used to trigger the interaction chain is held.  When it is released (or the interaction
+is forced to end), the interaction chain can continue with a different interaction based on how long the input was held
+for.
+
+These interactions are all related by either being the Charging interaction, or other interaction types that inherit the
+Charging interaction's behavior.
+
+### Charging
+
+This interaction does not inherit from SimpleInteraction and therefore its Next field works different from most interactions.
+This interaction adds its own Failed field which works the same way that SimpleInteraction's does.
+
+This interaction only works properly when its interaction chain was triggered by a client key or button press (or
+NPC-simulated equivalent). This interaction will continue executing for as long as the key or button press is held (with
+some exceptions, covered below) by the User entity.  Like other interactions, it has a `Next` field indicating which interaction to execute
+after this one, but the field is a map from `Float` values to `Interaction` assets. When this interaction ends, either
+due to the input being released or the charge duration completing, this interaction will determine the largest `Float` key that is less
+than the amount of time in seconds that the interaction was executing for.  The Interaction mapped to that key will be
+executed next.
+
+The interaction includes some cancellation conditions that are specific to this interaction. For instance, the interaction
+has a `CancelOnOtherClick` field that matches the field on RootInteraction. If it is active on this interaction but not
+the RootInteraction, then clicking while charging will cancel this interaction (and execute the `Failed` interaction rather
+than any of the `Next` interactions) but otherwise continue the interaction chain.
+
+Another valuable feature Charging has is the `Forks` field.  For input-triggered interactions that are triggered while the
+Charging interaction is executing, you can add an entry for the relevant InteractionType to this field and instead of
+triggering the usual interaction chain based on held item, targeted block, etc. the RootInteraction specified in the
+`Forks` field will be triggered.  This can unlock rich attack modes and behaviors. For instance, having a shield bash attack
+triggered off left click while blocking, or a special attack that triggers when both mouse buttons are pressed at the
+same time.
+
+There are two modes of operation for the Charging interaction. One is to have the ability charge for as long
+as the input is held and only end execution when the entity releases the input.  Bows in the main Hytale game work
+that way.  That is accomplished by setting `AllowIndefiniteHold` to true.  Another mode of operation is to have the
+interaction complete execution when the execution time has surpassed the largest key value in the `Next` field and
+immediately begin executing the Interaction mapped to that key.  Food in the main Hytale game work like this.  It
+is accomplished by setting `AllowIndefiniteHold` to false.
+
+One pitfall to be careful of when setting `AllowIndefiniteHold` to false is the way it interacts with cooldowns.\
+Normally, input-initiated interaction chains start a 0.35s cooldown on the triggered RootInteraction that prevents
+holding the mouse button from immediately spamming a new interaction when the first one completes.  However, if the
+duration of a Charging interaction is longer than 0.35s, then the cooldown will have already completed when the
+interaction chain finishes, which will often result in a new execution beginning immediately before the player can
+stop pressing the mouse button.  One solution for this problem is to add a `Simple` interaction to the end of your
+interaction chain with a `RunTime` of 0.35s to simulate the cooldown.  Alternatively, you can add a longer cooldown
+(the maximum duration of your Charging interaction plus 0.35s) to the RootInteraction. However, the longer cooldown is
+not always desirable, as the interaction may have ended prematurely, resulting in an unusually long lockout between
+executions.
+
+**Charging Fields**
+
+| Field Name                         | Type                                                                    | Required? | Notes                                                                                                                                                                                                                                                                                                                                                                                       |
+| ---------------------------------- | ----------------------------------------------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| FailOnDamage                       | `Boolean`<br />(Default: false)                                         | **No**    | If true, this interaction will fail and end immediately if the User entity takes any damage while it is executing.                                                                                                                                                                                                                                                                          |
+| CancelOnOtherClick                 | `Boolean`<br />(Default: true)                                          | **No**    | If true, this interaction will fail and end immediately if the User entity sends another button or key press while it is executing.                                                                                                                                                                                                                                                         |
+| Forks                              | `Map`<br />(Key Type: `InteractionType`, Value Type: `RootInteraction`) | **No**    | A map of InteractionType to RootInteraction. If entity input triggers the InteractionType while this interaction is executing, the mapped RootInteraction will be forked into its own interaction chain. This will happen instead of the usual handling for that InteractionType.  This fork will occur even if `CancelOnOtherClick` is set to true.                                        |
+| Failed                             | `Asset`<br />(Asset Type: `Interaction`)                                | **No**    | After this Interaction has finished, "Failed" will be executed if this Interaction failed.                                                                                                                                                                                                                                                                                                  |
+| AllowIndefiniteHold                | `Boolean`<br />(Default: false)                                         | **No**    | If true, this interaction will continue executing for as long as the User entity continues to hold the input. If false, execution will end as soon as the execution time in seconds reaches the largest key value in the `Next` map.                                                                                                                                                        |
+| DisplayProgress                    | `Boolean`<br />(Default: true)                                          | **No**    | If true, players executing this interaction will see a progress bar will be displayed below their cursor indicating how close to reaching the highest key value in `Next` they are.                                                                                                                                                                                                         |
+| Next                               | `Map`<br />(Key Type: `Float`, Value Type: `Interaction`)               | **No**    | A map from `Float` to `Interaction`.  When this interaction successfully finishes executing (either because the input was released or because the maximum duration was reached), this interaction will find the `Float` value with the largest duration in seconds that is less than the amount of time this interaction executed for. That key's mapped Interaction will then be executed. |
+| MouseSensitivityAdjustmentTarget   | `Float`<br />(Default: 1.0)                                             | **No**    | While charging, this mouse sensitivity multiplier will gradually be applied.                                                                                                                                                                                                                                                                                                                |
+| MouseSensitivityAdjustmentDuration | `Float`<br />(Default: 1.0)                                             | **No**    | Duration in seconds. After this many seconds, `MouseSensitivityAdjustmentTarget` will be fully applied to the mouse sensitivity.                                                                                                                                                                                                                                                            |
+| Delay                              | `ChargingDelay`                                                         | **No**    | Settings that allow charging progress to be pushed back when the User entity takes damage.                                                                                                                                                                                                                                                                                                  |
+
+**ChargingDelay Fields**
+
+| Field Name    | Type                        | Required? | Notes                                                                                                                                                                                                                                                                     |
+| ------------- | --------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| MinHealth     | `Float`<br />(Default: 0.0) | **No**    | Damage taken as a percentage of entity health (0.0-1.0). If a hit deals less than this much damage, no pushback will be applied.  If a hit deals exactly this much damage, `MinDelay` seconds worth of pushback will be applied.                                          |
+| MaxHealth     | `Float`<br />(Default: 0.0) | **No**    | Damage taken as a percentage of entity health (0.0-1.0). If a hit deals at least this much damage, `MaxDelay` seconds worth of pushback will be applied.                                                                                                                  |
+| MinDelay      | `Float`<br />(Default: 0)   | **No**    | The amount of pushback, in seconds, to apply if the entity takes a hit that deals `MinHealth` damage. The amount of pushback applied by a hit is a gradiant between `MinDelay` and `MaxDelay` based on the amount of damage between `MinHealth` and `MaxHealth`.          |
+| MaxDelay      | `Float`<br />(Default: 0)   | **No**    | The amount of pushback, in seconds, to apply if the entity takes a hit that deals at least `MaxHealth` damage. The amount of pushback applied by a hit is a gradiant between `MinDelay` and `MaxDelay` based on the amount of damage between `MinHealth` and `MaxHealth`. |
+| MaxTotalDelay | `Float`<br />(Deault: 0)    | **No**    | The maximum amount of pushback the entity can receive over the course of a single charge, regardless of how many times they are hit.                                                                                                                                      |
+
+**InteractionType Values**
+
+- `Primary`
+- `Secondary`
+- `Ability1`
+- `Ability2`
+- `Ability3`
+- `Use`
+- `Pick`
+- `Pickup`
+- `CollisionEnter`
+- `CollisionLeave`
+- `Collision`
+- `EntityStatEffect`
+- `SwapTo`
+- `SwapFrom`
+- `Death`
+- `Wielding`
+- `ProjectileSpawn`
+- `ProjectileHit`
+- `ProjectileMiss`
+- `ProjectileBounce`
+- `Held`
+- `HeldOffhand`
+- `Equipped`
+- `Dodge`
+- `GameModeSwap`
+
+### Wielding
+
+This interaction is inherited from Charging rather than SimpleInteraction.  However, its `Failed` and `Next` fields function
+identically to SimpleInteraction.  It does not inherit all fields from Charging, so be sure to pay close attention to
+the field list below.
+
+This interaction drives most blocking behavior in the game. While this interaction is executing, attacks made against
+the Owner entity will (conditionally) trigger effects defined in this interaction.  Unlike the Charging interaction,
+this interaction can always execute indefinitely and will only end when it fails or when the input is released.
+
+One option available in Wielding is `AngledWielding`, which allows damage and knockback modifiers to only be applied
+depending on the direction the attack against the Owner entity is coming from.  The AngledWielding type has a
+field `Angle` which determines which direction the protection points relative to the player (0 is the player's
+front), and `AngleDistance` which determines how wide the cone of protection extends around the player.  Block effects
+from this interaction (such as `BlockedEffects`, `BlockedInteractions`, and `StaminaCost`) will only apply if
+the DamageCause matches `DamageModifiers` OR if the DamageCause matches `AngledWielding.DamageModifiers` and
+the source of the damage matches `Angle` and `AngleDistance`.  It is possible for damage and knockback multipliers
+specified on both this interaction's modifier fields and `AngledWielding`'s modifier fields to stack, if both
+have entries for the same DamageCause.
+
+This interaction will only have an effect on damage taken by one of the DamageCause entries in `DamageModifiers` or
+`AngledWielding.DamageModifiers`.  If a DamageCause is in `DamageModifiers`, then the block effect will be triggered
+and the damage modifier applied regardless of what direction the Owner entity is attacked from.  If a DamageCause is in
+`AngledWielding.DamageModifiers`, then the damage modifier is only applied if the
+
+\*\* Wielding Fields\*\*
+
+| Field Name          | Type                                                                    | Required? | Notes                                                                                                                                                                                                                                                                                                                                                                                                      |
+| ------------------- | ----------------------------------------------------------------------- | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| FailOnDamage        | `Boolean`<br />(Default: false)                                         | **No**    | If true, this interaction will fail and end immediately if the User entity takes any damage while it is executing.                                                                                                                                                                                                                                                                                         |
+| CancelOnOtherClick  | `Boolean`<br />(Default: true)                                          | **No**    | If true, this interaction will fail and end immediately if the User entity sends another button or key press while it is executing.                                                                                                                                                                                                                                                                        |
+| Forks               | `Map`<br />(Key Type: `InteractionType`, Value Type: `RootInteraction`) | **No**    | A map of InteractionType to RootInteraction. If entity input triggers the InteractionType while this interaction is executing, the mapped RootInteraction will be forked into its own interaction chain. This will happen instead of the usual handling for that InteractionType.  This fork will occur even if `CancelOnOtherClick` is set to true (after which this interaction chain will be canceled). |
+| Next                | `Asset`<br />(Asset Type: `Interaction`)                                | **No**    | After this interaction has finished, "Next" will be executed if this interaction did not fail.                                                                                                                                                                                                                                                                                                             |
+| Failed              | `Asset`<br />(Asset Type: `Interaction`)                                | **No**    | After this interaction has finished, "Failed" will be executed if this interaction failed.                                                                                                                                                                                                                                                                                                                 |
+| DamageModifiers     | `Map`<br />(Key Type: `DamageCause`, Value Type: `Float`)               | **No**    | A map from DamageCause to Float, where the Float is multiplied against any damage received from the mapped DamageCause while this interaction is executing.                                                                                                                                                                                                                                                |
+| KnockbackModifiers  | `Map`<br />(Key Type: `DamageCause`, Value Type: `Float`)               | **No**    | A map from DamageCause to Float, where the Float is multiplied against any knockback force received from the mapped DamageCause while this interaction is executing.                                                                                                                                                                                                                                       |
+| AngledWielding      | `AngledWielding`                                                        | **No**    | Configuration to only trigger block effects from certain angles.                                                                                                                                                                                                                                                                                                                                           |
+| StaminaCost         | `StaminaCost`                                                           | **No**    | If the Owner entity receives damage that matches `DamageModifiers` or `AngledWielding` while this interaction is executing, then the entity's stamina will be deducted according to this configuration.                                                                                                                                                                                                    |
+| BlockedEffects      | `DamageEffects`                                                         | **No**    | If the Owner entity receives damage that matches `DamageModifiers` or `AngledWielding` while this interaction is executing, then these effects will be applied to the instance of damage.                                                                                                                                                                                                                  |
+| BlockedInteractions | `Asset`<br />(Asset Type: `RootInteraction`)                            | **No**    | If the Owner entity receives damage that matches `DamageModifiers` or `AngledWielding` while this interaction is executing, then this RootInteraction will be launched as a brand new interaction chain with the Owner entity as both Owner and User, and the attacker as the Target entity.  This new interaction chain is, notably, brand new, **not** forked from the current one.                      |
+
+**AngledWielding Fields**
+
+| Field Name         | Type                                                      | Required? | Notes                                                                                                                                                                                                            |
+| ------------------ | --------------------------------------------------------- | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Angle              | `Float`<br />(Default: 0.0)                               | **No**    | Angle in degrees relative to the Owner entity where the angled protection is centered. 0.0 means pointed towards the front of the Owner entity.                                                                  |
+| AngleDistance      | `Float`<br />(Default: 0.0)                               | **No**    | Angle in degrees indicating how wide the cone of protection is.                                                                                                                                                  |
+| DamageModifiers    | `Map`<br />(Key Type: `DamageCause`, Value Type: `Float`) | **No**    | A map from DamageCause to Float, where the Float is multiplied against any damage received from the mapped DamageCause received from within the cone of protection while this interaction is executing.          |
+| KnockbackModifiers | `Map`<br />(Key Type: `DamageCause`, Value Type: `Float`) | **No**    | A map from DamageCause to Float, where the Float is multiplied against any knockback force received from the mapped DamageCause received from within the cone of protection while this interaction is executing. |
+
+**StaminaCost Fields**
+
+| Field Name | Type                                             | Required? | Notes                                                                                                                                                                                                                                                |
+| ---------- | ------------------------------------------------ | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| CostType   | `CostType`<br />(Default: `MaxHealthPercentage`) | **No**    | How to calculate stamina consumed by blocking from the raw pre-block damage. If `Damage`, then the stamina consumed will be `rawDamage / Value`. If `MaxHealthPercentage`, then the stamina consumed will be `rawDamage / (EntityMaxHealth * Value)` |
+| Value      | `Float`<br />(Default: 0.04)                     | **No**    | The value to use in the `CostType` formula.                                                                                                                                                                                                          |
+
+**DamageEffects Fields**
+
+| Field Name             | Type                                         | Required? | Notes                                                                           |
+| ---------------------- | -------------------------------------------- | --------- | ------------------------------------------------------------------------------- |
+| ModelParticles         | `Array`<br />(Element Type: `ModelParticle`) | **No**    | Particle systems to trigger in the first-person view.                           |
+| WorldParticles         | `Array`<br />(Element Type: `WorldParticle`) | **No**    | Particle systems to trigger in the third-person view.                           |
+| LocalSoundEventId      | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | 2D sound to play locally to the attacking entity if they are a player.          |
+| WorldSoundEventId      | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | Sound to play in the world at the Owner entity's location.                      |
+| PlayerSoundEventId     | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | 2D sound to play locally to the Owner entity if they are a player.              |
+| ViewDistance           | `Double`<br />(Default: 75.0)                | **No**    | Distance at which these effects should play for other players.                  |
+| Knockback              | `Knockback`                                  | **No**    | The properties of the knockback that will be applied.                           |
+| CameraEffect           | `Asset`<br />(Asset Type: `CameraEffect`)    | **No**    | CameraEffect to briefly apply locally to the Owner entity if they are a player. |
+| StaminaDrainMultiplier | `Float`<br />(Default: 1.0)                  | **No**    | This multiplier is applied to the `StaminaCost`, if any.                        |
+
+**Knockback Fields**
+
+| Field Name     | Type                                       | Required? | Notes                                                                                                                      |
+| -------------- | ------------------------------------------ | --------- | -------------------------------------------------------------------------------------------------------------------------- |
+| Type           | `String`                                   | **No**    | If provided, specifies a type of knockback to use. Each knockback type may come with additional fields.                    |
+| Force          | `Double`<br />(Default: 0.0)               | **No**    | The amount of force to apply to the Owner entity.                                                                          |
+| Duration       | `Double`<br />(Default: 0.0)               | **No**    | If 0.0, apply the force as a single impulse.  If more, continuously apply the force over a period of time.                 |
+| VelocityType   | `ChangeVelocityType`<br />(Default: `Add`) | **No**    | How to apply the force, either adding it to the entity's current velocity, or setting the velocity to the knockback force. |
+| VelocityConfig | `VelocityConfig`                           | **No**    | Characteristics of friction as the Owner entity is thrown by this knockback.                                               |
+
+**Knockback Type: Force**
+
+Apply the calculated knockback force along the provided direction.
+
+| Field Name | Type                         | Required? | Notes                                                                                |
+| ---------- | ---------------------------- | --------- | ------------------------------------------------------------------------------------ |
+| Direction  | `Vector3`<br />(Default: Up) | **No**    | Which direction the player should be flung, relative to the direction of the attack. |
+
+**Knockback Type: Point**
+
+Apply the calculated knockback force laterally along the XZ plane, plus provided Y velocity.
+
+| Field Name | Type                        | Required? | Notes                                                                                                   |
+| ---------- | --------------------------- | --------- | ------------------------------------------------------------------------------------------------------- |
+| OffsetX    | `Integer`<br />(Default: 0) | **No**    | Offset the source position of the knockback left or right perpendicular to the direction of the attack. |
+| OffsetZ    | `Integer`<br />(Default: 0) | **No**    | Offset the source position of the knockback, forward or backward along the directon of the attack.      |
+| RotateY    | `Integer`<br />(Default: 0) | **No**    | Rotate the knockback direction around the Y axis, where 0 is the default attack direction.              |
+| VelocityY  | `Float`<br />(Default: 0.0) | **No**    | Add vertical velocity to the knockback force after the direction and force has been calculated.         |
+
+**Knockback Type: Directional**
+
+Apply the calculated knockback force along the attack direction, removing any vertical component and replacing it with a provided Y velocity.
+
+| Field Name | Type                      | Required? | Notes                                                                                                                                            |
+| ---------- | ------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------ |
+| RelativeX  | `Float`<br />(Default: 0) | **No**    | Apply additional force left or right perpendicular to the direction of the attack. The additional force is multiplied by the knockback strength. |
+| RelativeZ  | `Float`<br />(Default: 0) | **No**    | Apply additional force forward or backward along the attack direction. The additional force is multiplied by the knockback strength.             |
+| VelocityY  | `Float`<br />(Default: 0) | **No**    | Replace the vertical velocity of the knockback with this value.  This value is not multiplied by knockback strength.                             |
+
+**VelocityConfig Fields**
+
+| Field Name          | Type                                              | Required? | Notes                                                                                                                                                                                           |
+| ------------------- | ------------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| GroundResistance    | `Float`<br />(Default: 0.82)                      | **No**    | The minimum amount of friction applied when the entity is in contact with the ground.  1.0 = no friction, 0.0 = total friction                                                                  |
+| GroundResistanceMax | `Float`<br />(Default: 0.0)                       | **No**    | The maximum amount of friction applied when the entity is in contact with the ground.  1.0 = no friction, 0.0 = total friction                                                                  |
+| AirResistance       | `Float`<br />(Default: 0.96)                      | **No**    | The minimum amount of friction applied when the entity is in the air. 1.0 = no friction, 0.0 = total friction                                                                                   |
+| AirResistanceMax    | `Float`<br />(Default: 0.0)                       | **No**    | The maximum amount of friction applied when the entity is in the air. 1.0 = no friction, 0.0 = total friction                                                                                   |
+| Threshold           | `Float`<br />(Default: 1.0)                       | **No**    | The speed at which the maximum amount of friction will be applied to the entity. The amount of friction applied will increase from minimum to maximum as the entity moves from 0 to this speed. |
+| Style               | `VelocityThresholdStyle`<br />(Default: `Linear`) | **No**    | The curve that friction follows as the entity's speed increases toward the `Threshold`.                                                                                                         |
+
+**CostType Values**
+
+- `MaxHealthPercentage`
+- `Damage`
+
+**ChangeVelocityType Values**
+
+- `Add`
+- `Set`
+
+**VelocityThresholdStyle Values**
+
+- `Linear`
+- `Exp`
+
+## Blocks
+
+These are interaction types meant to reason about and modify blocks in the world.  The most important concept unique
+to these interactions is the Block Target.  Like the Entity Target, it is mutable and can come from many places.
+However, for interaction chains initiated by the client, the block target will initially be the block that the player's cursor was
+over, if any.
+
+Additionally, for interaction chains initiated by the client, the client will send along which face of the block is targeted,
+which is used by a few block-related interactions.
+It is left up to each interaction type that cares about block faces as to how to handle this behavior for simulated input
+(i.e. NPCs initiating chains that are normally initated by the client).  At the time of this writing, all block-related
+interactions choose the top face where relevant in simulated input.
+
+### BlockCondition
+
+This interaction has a field `Matchers` which specifies certain conditions, such as block type, state, etc.  This
+interaction fails if the current target block does not match all of them.
+
+**BlockCondition Fields**
+
+| Field Name       | Type                                        | Required? | Notes                                                                                                                                                                                                                                                                                                                                   |
+| ---------------- | ------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false)             | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction.                                                                                                                                                                                                       |
+| Matchers         | `Array`<br />(Element Type: `BlockMatcher`) | **Yes**   | A list of conditions that the target block must match or this condition will fail.<br />**Note: This field is technically not required but there is a bug that makes it dangerous to not provide at the time of this writing.**<br />**Note: If no conditions are added to this array, the interaction will fail, counterintuitively.** |
+
+**BlockMatcher Fields**
+
+| Field Name | Type                       | Required? | Notes                                                                          |
+| ---------- | -------------------------- | --------- | ------------------------------------------------------------------------------ |
+| Block      | `BlockIdMatcher`           | **No**    | If provided, requires the block itself match some set of conditions.           |
+| Face       | `BlockFace`                | **No**    | If provided and not 'None', requires a specific block face be targeted.        |
+| StaticFace | `Boolean` (Default: false) | **No**    | If false, the face condition will be adjusted by the block's current rotation. |
+
+**BlockFace Values**
+
+- `Up`
+- `Down`
+- `North`
+- `South`
+- `East`
+- `West`
+- `None`
+
+**BlockIdMatcher Fields**
+
+| Field Name | Type                                   | Required? | Notes                                                                      |
+| ---------- | -------------------------------------- | --------- | -------------------------------------------------------------------------- |
+| Id         | `Asset`<br />(Asset Type: `BlockType`) | **No**    | If provided, the block must match the specified `BlockType`.               |
+| State      | `String`                               | **No**    | If provided, the block's current state must match the provided state name. |
+| Tag        | `String`                               | **No**    | If provided, the block type's asset tags must contain the provided tag.    |
+
+### DestroyCondition
+
+This interaction fails if the current User entity cannot destroy the current target blcok.
+
+**DestroyCondition Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+
+### PlacementCountCondition
+
+This interaction accepts the name of a BlockType that has the TrackedPlacement BlockEntity. The interaction will fail if the number of
+blocks of the provided BlockType in the world do not match the provided condition.
+
+**PlacementCountCondition Fields**
+
+| Field Name | Type                           | Required? | Notes                                                                                                                                                                                                                                                           |
+| ---------- | ------------------------------ | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Block      | `String`                       | **Yes**   | The BlockType to examine. The number of instances of the BlockType in the world will be compared to Value.<br />**Note: The specified BlockType must have the TrackedPlacement BlockEntity. Otherwise, the number of blocks in the world will always be zero.** |
+| Value      | `Integer`<br />(Default: 0)    | **No**    | The value to compare the number of blocks in the world with.                                                                                                                                                                                                    |
+| LessThan   | \`Boolean<br />(Default: true) | **No**    | If true, the interaction will fail if the number of blocks in the world is greater than or equal to Value. If false, the interaction will fail if the number of blocks in the world is less than or equal to Value.                                             |
+
+### BreakBlock
+
+This interaction attempts to break the target block while acting as the User entity. The User entity must be a player. It
+is not guaranteed to work, depending on world settings and the User entity's current state, it may not work.  If it
+fails, it will fail the interaction under some circumstances, but not others.
+
+**Note: In particular, if `Harvest`=false and the player is in Survival mode, the player will simply execute a damage operation
+against the block. Even when the Tool field is specified, the player's currently-held item can impact the results in unintuitive
+ways.**
+
+This interaction will fail if there is no block target, if `Harvest`=true and the
+block is not harvestable, or if the world settings prevent the Harvest/Break operation.
+It will generally not fail otherwise, even if the block was not broken or damaged.
+The block will generally break every time if `Harvest`=true or the player is in
+Creative mode.
+
+**BreakBlock Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                                                                                                                                                                                                  |
+| ---------------- | ------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction.                                                                                                                                                                      |
+| Harvest          | `Boolean` (Default: false)      | **No**    | If true, harvest the block and deposit the drops in the player's inventory. This operation will generally always succeed.  If false, this interaction will effectively perform whatever action would have occurred if the player had left-clicked the block.                                           |
+| Tool             | `String`                        | **No**    | If `Harvest`=true, the player is in Survival mode, and this field is provided, then the break operation will be performed as though with this tool type.<br />**This field mostly doesn't work.  Your held item will be used for most block damage calculations regardless of this field's contents.** |
+| MatchTool        | `Boolean` (Default: false)      | **No**    | If true, `Harvest`=true, the player is in Survival mode, and `Tool` is provided, block breaking will be prevented unless `Tool` is a valid gathering tool for the target block. The interaction will not be failed, even if block breaking is prevented in this manner.                                |
+
+### ChangeBlock
+
+This interaction requires a mapping from one or more current BlockTypes to one or more target BlockTypes.  If the
+target block is one of the key BlockTypes, then it will be changed to the mapped target BlockType.  If the current
+BlockType of the target block does not appear as a key in the Changes field, then this interaction fails.
+
+**ChangeBlock Fields**
+
+| Field Name        | Type                                                        | Required? | Notes                                                                                                                             |
+| ----------------- | ----------------------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget  | `Boolean`<br />(Default: false)                             | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+| Changes           | `Map`<br />(Key Type: `BlockType`, Value Type: `BlockType`) | **No**    | A list of potential block type changes, with each entry having a current and new BlockType id.                                    |
+| WorldSoundEventId | `Asset`<br />(Asset Type: `SoundEvent`)                     | **No**    | If provided, this SoundEvent is played in the world at the position of the block if the block successfully changes.               |
+| RequireNotBroken  | `Boolean`<br />(Default: false)                             | **No**    | If true, this interaction will fail if the player's held item is broken (durability 0), and the block change will not take place. |
+
+### ChangeState
+
+This interaction requires a mapping from one or more current block state names to one or more state names. If the
+target block is in one of the key block states, then it will be changed to the mapped target blocks tate. If the
+current block state of the target block does nto appear as a key in the Changes field, then this interaction fails.
+
+All blocks start out with a null state by default.  This null state can be referenced by the key "default" and the block
+can be returned to that state with the value "default".
+
+**ChangeState Fields**
+
+| Field Name       | Type                                                  | Required? | Notes                                                                                                                                          |
+| ---------------- | ----------------------------------------------------- | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false)                       | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction.              |
+| Changes          | `Map`<br />(Key Type: `String`, Value Type: `String`) | **No**    | A list of potential block state changes, with each entry having a current and new state name.                                                  |
+| UpdateBlockState | `Boolean`<br />(Default: false)                       | **No**    | If true, performs a full refresh of the block's BlockEntity component and notifies nearby players as though a full block type change occurred. |
+
+### CycleBlockGroup
+
+This interaction will attempt to change the target block to the next block type in one of the BlockGroups it belongs to.
+If the block type belongs to multiple BlockGroups, which one is used is effectively arbitrary. The User entity must be
+a player. If the block cannot be changed for any reason (entity not a player, no block target, block does not belong
+to a BlockGroup, etc.). If the block is the only entry in the BlockGroup, this interaction will succeed and the block
+will be considered changed despite nothing happening.  Unlike most other block-changing interactions, this one will
+fail if the world settings prevent players from breaking blocks.
+
+**This interaction always reduces the player's held item's durability by a single 'hit' worth of damage if the block
+changes. There is no way to prevent it. The block type will change and the interaction will succeed even if the player's
+held item is broken, however.**
+
+**CycleBlockGroup Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+
+### DestroyBlock
+
+This interaction destroys the target block without dropping anything.  It will successfully destroy the block if the
+target block exists and this interaction has no failure conditions.
+
+**This interaction has no additional fields.**
+
+### PickBlock
+
+This interaction is effectively equivalent to using the middle mouse button in creative mode. In survival mode, the
+block's item will be moved to the user's current active hotbar slot if it is in the player's inventory.  This
+interaction is performed entirely on the client and cannot be performed by non-players.  It is unclear if this
+interaction has failure conditions.
+
+**PickBlock Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+
+### PlaceBlock
+
+This interaction is effectively identical to a right clicking while holding a block in their hand, with some
+additional options. For one, it can be executed with any LivingEntity as the User entity. For another, it has some
+useful fields.  For the most part, though, it follows the same behaviors and rules as any ordinary block placement
+by a player.
+
+It's not clear under what circumstances this interaction can fail. The server will not fail the interaction under any
+special circumstances (including when there is no target block, or when `BlockTypeToPlace` is not provided and the
+LivingEntity is not holding a block). However, the client is very involved with the function of this interaction and
+its behavior is unknown.
+
+**PlaceBlock Fields**
+
+| Field Name         | Type                                   | Required? | Notes                                                                                                                                                                                                                                                                                                                                                           |
+| ------------------ | -------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| BlockTypeToPlace   | `Asset`<br />(Asset Type: `BlockType`) | **No**    | If provided, the block placed by this interaction will be the specified BlockType. If not provided, the User entity's held item will be used, instead, if it is a block.                                                                                                                                                                                        |
+| RemoveItemInHand   | `Boolean`<br />(Default: True)         | **No**    | If true and the User entity is not a player in Creative mode, the item in the player's hand must match the block being placed and one quantity will be removed for each block placed. If the item does not match, the block cannot be placed.  If false, the player's hand item is ignored entirely.\*\*                                                        |
+| AllowDragPlacement | `Boolean`<br />(Default: True)         | **No**    | If true and the interaction was triggered on the client by a player, then the player can hold the input that was used to activate this interaction chain and move the mouse around in order to execute this interaction repeatedly and place several blocks. The interaction chain will not move onto the next interaction until the player releases the input. |
+
+### RunOnBlockTypes
+
+This interaction retrieves all blocks within a provided radius of the User entity. For each block that matches any of
+the provided BlockSets, a new interaction chain will be forked that uses the matching block as the target block.
+This interaction will continue executing until all forked interaction chains have completed.  The interaction will fail if no
+blocks within the radius match the provided BlockSets or if all of the forked interaction chains fail.
+
+**RunOnBlockTypes Fields**
+
+| Field Name   | Type                                         | Required?        | Notes                                                                                                                                                                                                                                                                                      |
+| ------------ | -------------------------------------------- | ---------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| Range        | `Integer`                                    | **Yes**          | The spherical radius around the User entity to search for blocks. Must be at least 1.                                                                                                                                                                                                      |
+| BlockSets    | `AssetArray`<br />(Element Type: `BlockSet`) | **No**           | A list of BlockSets to match nearby blocks again. Only blocks that match any of the BlockSets will have interaction chains forked for them.                                                                                                                                                |
+| MaxCount     | `Integer`                                    | **Yes**          | The maximum number of blocks that will be located with the search. Further blocks will be ignored. If there are more matching blocks within the radius than this number, the specific set of blocks that will be found is completely arbitrary and may change from execution to execution. |
+| Interactions | `Asset`<br />(Asset Type: `RootInteraction`) | **No, but yes.** | The RootInteraction that will be forked for each matching block.  This interaction will not fail to validate if it is missing, but every execution of this interaction will fail.                                                                                                          |
+
+### UseBlock
+
+If the target block has an interaction for this interaction chain's interaction type, execute it immediately as part of
+this interaction chain. The execution will be wrapped in UseBlockEvent.Pre and UseBlockEvent.Post events, and cancellations
+of the UserBlockEvent.Pre event are respected. The User entity is considered the triggering entity for both events.
+
+If the target block does not have an interaction for this interaction chain's interaction type, this interaction fails.
+
+**This interaction has no additional fields.**
+
+## Items
+
+These are interactions intended to interface with an entity's inventory. There is no concept of an "item target",
+unfortunately, so these generally either interact with the entity's held item or the entity's inventory at a high level.
+
+### AddItem
+
+Adds a specified quantity of a specified item to the User entity's inventory, preferring to add it to the
+entity's hotbar where possible. This interaction will have no effect on User entities that are not LivingEntities.
+This interaction has no failure states.
+
+**Note: This interaction has a bug in its field validators that will cause interactions that reference items declared
+in the same mod to fail validation on startup.  Additionally, this interaction has a bug that will cause it to
+fail and have no effect if the User entity has no block target. Use ModifyInventory instead.**
+
+**AddItem Fields**
+
+| Field Name       | Type                              | Required? | Notes                                                                                                                             |
+| ---------------- | --------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false)   | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+| ItemId           | `Asset`<br />(Asset Type: `Item`) | **Yes**   | The item id of the item to add to the player's inventory.                                                                         |
+| Quantity         | `Integer`<br />(Default: 0)       | **No**    | The quantity of the item to add to the player's inventory.                                                                        |
+
+### CheckUniqueItemUsage
+
+This interaction will check whether it has run once for the User entity with their currently-held item before. If it hasn't,
+it will succeed. If it has, it will fail. It will also fail if the User entity is not a player. The interaction will record
+the item id of the User entity's currently-held item on success, ensuring it cannot be successfully run with that player
+and item id combination again.
+
+**This interaction has no additional fields.**
+
+### ChangeActiveSlot
+
+This interaction does not inherit from SimpleInteraction and therefore has no Next or Failed fields.  The `CancelOnItemChange`
+field is ignored for this interaction and is always treated as false. This interaction will set the User entity's currently-
+active hotbar slot to the specified slot index. If none is specified, the interaction chain's target slot will be used,
+if any. Otherwise, slot 0 will be used.  If a slot is specified and it is already active, then this interaction will
+have no effect, but if no slot is specified and the interaction chain's target slot is already active, the logic in
+the next paragraph will still be executed. This interaction will also have no effect if the User entity is not a
+LivingEntity.
+
+Once the slot has changed, a new SwapTo interaction chain will be forked off for the selected slot.
+If a target slot was specified, then the interaction chain's current target slot will be set to the specified slot, as will
+the forked SwapTo interaction chain. If this interaction chain was initiated by a player swapping an item into or out of
+an occupied active hotbar slot, then the swap will be executed after the slot is changed and before the SwapTo
+interaction is forked. Not running this interaction in the resulting SwapFrom interaction chain is a way for the server
+to cancel players performing these sorts of swap interactions. The default behavior for these swap interactions is that
+the SwapFrom interaction chain will be initiated with the currently-active-slot as the target slot. As a result, the
+target slot will usually not change when this interaction runs, it merely exists as a signal for the server to continue the
+item swap.
+
+**ChangeActiveSlot Fields**
+
+| Field Name | Type      | Required? | Notes                                                                                                                                                                                                     |
+| ---------- | --------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| TargetSlot | `Integer` | **No**    | If not provided, indicates the slot the player's active hotbar slot should be changed to.  Otherwise, the interaction chain's target slot will be used (which is usually the already-active hotbar slot). |
+
+### EquipItem
+
+This interaction will equip the User entity's currently-held item into the appropriate armor slot, if it is armor. The
+interaction will fail if the item is armor but it cannot be equipped for some reason. The interaction will succeed but
+take no action if the User entity cannot equip armor or if the item is not armor.
+
+**This interaction has no additional fields.**
+
+### IncreaseBackpackCapacity
+
+This interaction will increase the User entity's backpack size by the provided amount.  **It will additionally remove one
+quantity from the player's currently-held item. There is no way to prevent this.**  This interaction will have no effect
+if the User entity is not a player.  This interaction has no special failure conditions, even if the User entity
+is not a player, or the player is not currently holding an item.
+
+| Field Name | Type                        | Required? | Notes                                                                                   |
+| ---------- | --------------------------- | --------- | --------------------------------------------------------------------------------------- |
+| Capacity   | `Integer`<br />(Default: 1) | **No**    | The additional backpack capacity to add to the player. **Must be between 1 and 32767.** |
+
+### ModifyInventory
+
+This interaction attempts to perform one or more inventory-modifying actions against the User entity. The User entity must
+be a player. If they are not, no actions will be performed, but the interaction will not fail. Any item removals performed
+by this interaction, either as a result of `ItemToRemove` or `AdjustHeldItemQuantity`, are both atomic (meaning the entire
+quantity must be removed, or none) and required (meaning that the interaction will fail and no further actions taken if
+the removal fails for any reason).  Item additions performed by this interaction, either as a result of `ItemToAdd` or
+`AdjustHeldItemQuantity` will drop excess items on the ground near the player if necesary and continue on.
+
+This interaction first executes the item removal in `ItemToRemove`, if any, then adjusts the held item as specified by
+`AdjustHeldItemQuantity`, if provided, then executes the item addition in `ItemToAdd`, if any, and then finally executes
+the damage/healing of the held item in `AdjustHeldItemDurability`, if provided.
+
+**ModifyDurability Fields**
+
+| Field Name               | Type                            | Required? | Notes                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
+| ------------------------ | ------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| RequiredGameMode         | `GameMode`                      | **No**    | If provided, only execute the inventory-modifying actions if the player is in the provided GameMode. The interaction will not fail if the GameMode doesn't match.                                                                                                                                                                                                                                                                                                                                                                               |
+| ItemToRemove             | `ItemStack`                     | **No**    | If provided, a matching item will be removed in the provided quantity. If there is no matching item in the player inventory in the required quantity, then the interaction will fail and further actions will not be executed.                                                                                                                                                                                                                                                                                                                  |
+| AdjustHeldItemQuantity   | `Integer`<br />(Default: 0)     | **No**    | The player's held item, if any, will have its quantity will be modified by the provided amount- subtracted from if this number is negative or added to if this item is positive.  If the player has no held item, then this field will have no effect regardless of its value and the interaction will NOT fail.  If the player's inventory does not have sufficient quantity of items to support the removal, this interaction will fail and further actions will not be executed. Excess items will be dropped on the ground near the player. |
+| ItemToAdd                | `ItemStack`                     | **No**    | If provided, the ItemStack will be added to the player's inventory. Excess items will be dropped on the ground near the player.                                                                                                                                                                                                                                                                                                                                                                                                                 |
+| AdjustHeldItemDurability | `Double`<br />(Default: 0.0)    | **No**    | The player's held item, if any, will have its durability adjusted by the specified amount.  The durability cannot go below 0 or raise above the item's maximum durability. Invalid durability values in this field will not cause the interaction to fail. Neither will it fail if the player has no held item.                                                                                                                                                                                                                                 |
+| BrokenItem               | `String`                        | **No**    | This field should contain an ItemId, but it is not validated by the server on startup, so be careful.  This field can have the value of "Empty" to specify no item, or an empty hand. If specified and the `AdjustHeldItemDurability` operation reduces the player's held item to 0 durability, the player's held item is changed to this ItemId. If the inventory replacement fails, this interaction will fail.                                                                                                                               |
+| NotifyOnBreak            | `Boolean`<br />(Default: false) | **No**    | If true and the `AdjustHeldItemDurability` operation reduces the player's held item to 0 durability, this interaction will perform the usual audiovisual feedback of a broken tool. It will play the usual tool breaking sound and send the player a text message in chat that their item has broken.                                                                                                                                                                                                                                           |
+| NotifyOnBreakMessage     | `String`                        | **No**    | If provided, and `NotifyOnBreak` is true, when the player is notified of a broken tool by this interaction, the message sent to their chat will instead be the translation key specified by this field. The translation key supports the templating parameter `{itemName}`. See the translation key `server.general.repair.itemBroken_Hoe` for an example.                                                                                                                                                                                      |
+
+**GameMode Values**
+
+- `Creative`: The game is currently in Creative Mode
+- `Adventure`: The game is currently in Adventure Mode
+
+**ItemStack Fields**
+
+| Field Name                   | Type                              | Required? | Notes                                                                                |
+| ---------------------------- | --------------------------------- | --------- | ------------------------------------------------------------------------------------ |
+| Id                           | `Asset`<br />(Asset Type: `Item`) | **Yes**   | The id of the Item asset this stack contains.                                        |
+| Quantity                     | `Integer`<br />(Default: 1)       | **No**    | The number of items in this stack.<br />**Must be greater than 0.**                  |
+| Durability                   | `Double`<br />(Default: 0.0)      | **No**    | The durability of the item stack.<br />**Cannot be negative.**                       |
+| MaxDurability                | `Double`<br />(Default: 0.0)      | **No**    | The maximum durability of the item this stack contains.<br />**Cannot be negative.** |
+| Metadata                     | `Bson Document`                   | **No**    | If provided, applies the bson to the item stack metadata.                            |
+| OverrideDroppedItemAnimation | `Boolean`\*(Default: false)       | **No**    | ???                                                                                  |
+
+### PickupItem
+
+This interaction will attempt to pick up the User entity's current target entity and add it to their inventory. It will
+fail if the User entity is not a player, if they do not have a target entity, or if the target entity is not an item
+located in the world.  It will not fail if the player simply cannot pick up the item.
+
+**This interaction has no additional fields.**
+
+### RefillContainer
+
+This interaction will fail if the User entity is not a player. The interaction will draw a ray from the player's head
+down their look direction until the edge of the player's held item's interaction range or until the first solid block.
+The nearest fluid block of a type listed in this interaction's `States` map will result in the one of the player's
+currently-held items being converted to the fluid's related item state.  If the `States` map indicates a durability
+for the new item state, then the converted item will use that durability. If the item is already in the fluid's related
+item state, then this interaction will fail if the player's held item is already at maximum durability (unless the
+`States` map indicates a durability value greater than the item's maximum, in which case the interaction will succeed
+but the item will not change).  Otherwise, the durability listed for the fluid in the `States` map will be added to the
+item's current durability.
+
+If the interaction has not failed by this point, the fluid block in the world may be transformed to a different type if one is listed
+in the `States` map.
+
+If any part of this process does not proceed for any reason (for instance, if the player is not holding an item),
+then this interaction will fail.
+
+**RefillContainer Fields**
+
+| Field Name | Type                                                       | Required? | Notes                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| ---------- | ---------------------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| States     | `Map`<br />(Key Type: `String`, Value Type: `RefillState`) | **Yes**   | A map from item state names to `RefillState` objects, which contain information such as acceptable fluid block types, durability increases, and what fluid type to convert the targeted fluid block to after refill, if any. If the player targets a fluid block that matches one of the fluid types in the `RefillState`, the item will be converted to the keyed item state and the `RefillState` will be used to decide what happens next. |
+
+**RefillState Fields**
+
+| Field Name     | Type                                  | Required? | Notes                                                                                                                                                                                                                                                                                                                           |
+| -------------- | ------------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| AllowedFluids  | `Array`<br />(Element Type: `String`) | **Yes**   | If any of these fluids are targeted by the player, the player's held item will be converted to the keyed item state and `Durability` and `TransformFluid` will be used.                                                                                                                                                         |
+| Durability     | `Double`<br />(Default: -1.0)         | **No**    | If the player's held item changes item states, this value is the new item's durability, unless it is negative, in which case the item will begin at full durability. If the player's held item is already in the item state, and the item is not already at full durability, this value will be added to the item's durability. |
+| TransformFluid | `String`                              | **No**    | If provided, this field is a fluid id that the targeted fluid block should be transformed to if the player's held item is successfully updated.                                                                                                                                                                                 |
+
+## Entities
+
+### DamageEntity
+
+This interaction does not inherit from SimpleInteraction, but adds its own Next and Failed fields that
+work similarly.
+
+This interaction will cause the User entity to damage the Target entity.  It has the capability to apply different
+damage based on the direction of the attack or what body part was targeted by the User entity, with each possibility
+providing different damage calculations, effects, and Next interaction. If multiple entires match the attack, `TargetedDamage`
+(body part damage) takes highest priority, then the first matching `AngledDamage` in the list, then the default
+damage in the base interaction fields.  It is possible for elements of these different damage priorities to be taken peacemeal if higher-priority
+damage fields do not overwrite lower-priority damage fields. For instance,
+damage calculation could be taken from `TargetedDamage`, the damage effects could be taken from the first matching
+`AngledDamage`, and the Next interaction coming from the default damage field.
+
+If all damage dealt by this interaction is cancelled, then this interaction will fail, and the `Failed` interaction
+will be executed next in the chain. If any damage dealt by this interaction is blocked, then this interaction will
+succeed, but the `Blocked` interaction wil lbe executed next in the chain. Otherwise, the highest-precedent matching
+`Next` interaction that you provide will be executed.  For instance, if you provide `Next` interactions for all
+`TargetedDamage` and `AngledDamage` entries, and one in the interaction's `Next` field, then a headshot could result
+in a unique `Next` interaction being executed, even if there is a matching `AngledDamage` entry. However, if you leave
+the `Next` interaction out of your `TargetedDamage` entries, a special `Next` interaction for backstabs could be
+executed.  Otherwise, the `Next` field in the root of the interaction will be executed instead.
+
+DamageEntity has an unusual relationship with `RunTime`. This interaction always ends immediately after its first tick,
+regardless of the status of `RunTime` or `WaitForAnimationToFinish`.  However, if damage dealt by this interaction is
+calculated as `DamageCalculatorType` `Dps`, then the `RunTime` will be used to determine the precise amount of damage to
+deal. If `RunTime` is 0, then no damage will be dealt.
+
+**DamageEntity Fields**
+
+| Field Name       | Type                                                          | Required?                                                                                                                    | Notes                                                                                                                                                                                                                                                                                                                                                                         |
+| ---------------- | ------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| DamageCalculator | `DamageCalculator`                                            | **No**                                                                                                                       | If provided, describes the damage amounts and types to apply to the Target entity.                                                                                                                                                                                                                                                                                            |
+| DamageEffects    | `DamageEffects`                                               | **No**                                                                                                                       | If provided, describes particles, sounds, knockback, etc. to apply to the target entity on damage.                                                                                                                                                                                                                                                                            |
+| Next             | `Asset`<br />(Asset Type: `Interaction`)                      | **No**  After this interaction has finished, "Next" will be executed if damage was dealt to the target and none was blocked. |                                                                                                                                                                                                                                                                                                                                                                               |
+| AngledDamage     | `Array`<br />(Element Type: `AngledDamage`)                   | **No**                                                                                                                       | If provided, allows alternative `DamageCalculator`, `DamageEffects`, and `Next` entries for attacks that approach the target from certain angles.                                                                                                                                                                                                                             |
+| TargetedDamage   | `Map`<br />(Key Type: `String`, Value Type: `TargetedDamage`) | **Yes**                                                                                                                      | This field must be provided, but is not required to have any entries.  This is a map from body part names to `TargetedDamage` values. Hypixel only uses one body part name: `Head`, and it is not clear whether there are others.  If provided, allows alternative `DamageCalculator`, `DamageEffects`, and `Next` entries for attacks that damage specific enemy body parts. |
+| EntityStatsOnHit | `Array`<br />(Element Type: `EntityStatOnHit`)                | **No**                                                                                                                       | If provided, allows this attack to reduce enemy stats other than health.  Each individual damage application dealt by the same ability will apply stat reductions, at diminishing returns. All damage dealt in interaction chains forked by a Selector interaction will share the number of hits across all targets.                                                          |
+| Failed           | `Asset`<br />(Asset Type: `Interaction`)                      | **No**                                                                                                                       | After this interaction has finished, "Failed" will be executed if no damage hits were applied to the player, or if all damage hits were cancelled.                                                                                                                                                                                                                            |
+| Blocked          | `Asset`<br />(Asset Type: `Interaction`)                      | **No**                                                                                                                       | After this interaction has finished, "Blocked" will be executed if any damage hits were blocked by the target.                                                                                                                                                                                                                                                                |
+
+**DamageCalculator Fields**
+
+| Field Name                | Type                                                      | Required? | Notes                                                                                                                                                                                                                                                 |
+| ------------------------- | --------------------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Type                      | `DamageCalculatorType`<br />(Default: Absolute)           | **No**    | Whether the damage being applied is `Absolute` or \`Dps'.                                                                                                                                                                                             |
+| Class                     | `DamageClass`<br />(Default: Unknown)                     | **No**    | The type of attack producing the damage. Some weapon systems apply equipment modifiers based on this value.                                                                                                                                           |
+| BaseDamage                | `Map`<br />(Key Type: `DamageCause`, Value Type: `Float`) | **No**    | A set of DamageCauses and how much base damage is dealt for each.                                                                                                                                                                                     |
+| SequentialModifierStep    | `Float`<br />(Default: 0.0)                               | **No**    | Value between 0.0-1.0. Each additional hit from a single ability will have its damage reduced by this much as a percentage. All damage dealt in interaction chains forked by a Selector interaction will share the number of hits across all targets. |
+| SequentialModifierMinimum | `Float`<br />(Default: 0.0)                               | **No**    | Value between 0.0-1.0. `SequentialModifierStep` cannot reduce damage below this percentage regardless of the number of hits.                                                                                                                          |
+| RandomPercentageModifier  | `Float`<br />(Default: 0.0)                               | **No**    | A random value between +/- this amount multiplied by the base damage will be added to the base damage.                                                                                                                                                |
+
+**DamageEffects Fields**
+
+| Field Name             | Type                                         | Required? | Notes                                                                                   |
+| ---------------------- | -------------------------------------------- | --------- | --------------------------------------------------------------------------------------- |
+| ModelParticles         | `Array`<br />(Element Type: `ModelParticle`) | **No**    | Particle systems to trigger in the first-person view.                                   |
+| WorldParticles         | `Array`<br />(Element Type: `WorldParticle`) | **No**    | Particle systems to trigger in the third-person view.                                   |
+| LocalSoundEventId      | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | 2D sound to play locally to the attacking entity if they are a player.                  |
+| WorldSoundEventId      | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | Sound to play in the world at the Target entity's location.                             |
+| PlayerSoundEventId     | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | 2D sound to play locally to the Target entity if they are a player.                     |
+| ViewDistance           | `Double`<br />(Default: 75.0)                | **No**    | Distance at which these effects should play for other players.                          |
+| Knockback              | `Knockback`                                  | **No**    | The properties of the knockback that will be applied.                                   |
+| CameraEffect           | `Asset`<br />(Asset Type: `CameraEffect`)    | **No**    | CameraEffect to briefly apply locally to the Target entity if they are a player.        |
+| StaminaDrainMultiplier | `Float`<br />(Default: 1.0)                  | **No**    | This multiplier is applied to the stamina cost incurred by the target blocking, if any. |
+
+**AngledDamage Fields**
+
+| Field Name       | Type                                     | Required? | Notes                                                                                                                                                                                                     |
+| ---------------- | ---------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| AngleDistance    | `Float`<br />(Default: 0)                | **No**    | The width in degrees of the matching arc around the Target entity. If the attack against the Target originates from within the arc, then the properties below will be applied to the attack, if provided. |
+| Angle            | `Float`<br />(Default: 0.0)              | **No**    | The angle in degrees around the Target entity at which the matching arc is centered.                                                                                                                      |
+| DamageCalculator | `DamageCalculator`                       | **No**    | If provided and the attack against the Target entity originates from within the provided arc, this DamageCalculator will override the interaction's `DamageCalculator` field.                             |
+| DamageEffects    | `DamageEffects`                          | **No**    | If provided and the attack against the Target entity originates from within the provided arc, this DamageEffects will override the interaction's `DamageEffects` field.                                   |
+| Next             | `Asset`<br />(Asset Type: `Interaction`) | **No**    | If provided and the attack against the Target entity originates from within the provided arc, this Interaction will override the interaction's `Next` field.                                              |
+
+**TargetedDamage Fields**
+
+| Field Name       | Type                                     | Required? | Notes                                                                                                                                                                                            |
+| ---------------- | ---------------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| DamageCalculator | `DamageCalculator`                       | **No**    | If provided and this TargetedDamage was matched, this DamageCalculator will override the interaction's `DamageCalculator` field and the `DamageCalculator` field of any matching `AngledDamage`. |
+| DamageEffects    | `DamageEffects`                          | **No**    | If provided and this TargetedDamage was matched, this DamageEffects will override the interaction's `DamageEffects` field and the `DamageEffects` field of any matching `AngledDamage`.          |
+| Next             | `Asset`<br />(Asset Type: `Interaction`) | **No**    | If provided and this TargetedDamage was matched, this Interaction will override the interaction's `Next` field and the `Next` field of any matching `AngledDamage`.                              |
+
+**EntityStatOnHit Fields**
+
+| Field Name                  | Type                                                                       | Required? | Notes                                                                                                                                                                                                                                                                                        |
+| --------------------------- | -------------------------------------------------------------------------- | --------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| EntityStatId                | `Asset`<br />(AssetType: `EntityStatType`)                                 | **Yes**   | Which entity stat to affect.                                                                                                                                                                                                                                                                 |
+| Amount                      | `Float`<br />(Default: 0.0)                                                | **No**    | How much of the stat to apply for each damage application. Use negative numbers to reduce stats.                                                                                                                                                                                             |
+| MultipliersPerEntitiesHit   | `Array`<br />(Element Type: `Float`, Default: `[1.0, 0.6, 0.4, 0.2, 0.1]`) | **No**    | The diminishing returns curve to be applied for multiple damage applications by the same ability. Each hit's stat impact will be multiplied by the next value in the list.  If there are more hits than array elements, subsequent hits will be multiplied by `MultiplierPerExtraEntityHit`. |
+| MultiplierPerExtraEntityHit | `Float`<br />(Default: 0.05)                                               | **No**    | If an ability carries out more damage applications than there are elements in the `MultipliersPerEntitiesHit` array, then subsequent stat values will be multiplied by this number.                                                                                                          |
+
+**Knockback Fields**
+
+| Field Name     | Type                                       | Required? | Notes                                                                                                                      |
+| -------------- | ------------------------------------------ | --------- | -------------------------------------------------------------------------------------------------------------------------- |
+| Type           | `String`                                   | **No**    | If provided, specifies a type of knockback to use. Each Target type may come with additional fields.                       |
+| Force          | `Double`<br />(Default: 0.0)               | **No**    | The amount of force to apply to the Owner entity.                                                                          |
+| Duration       | `Double`<br />(Default: 0.0)               | **No**    | If 0.0, apply the force as a single impulse.  If more, continuously apply the force over a period of time.                 |
+| VelocityType   | `ChangeVelocityType`<br />(Default: `Add`) | **No**    | How to apply the force, either adding it to the entity's current velocity, or setting the velocity to the knockback force. |
+| VelocityConfig | `VelocityConfig`                           | **No**    | Characteristics of friction as the Owner entity is thrown by this knockback.                                               |
+
+**Knockback Type: Force**
+
+Apply the calculated knockback force along the provided direction.
+
+| Field Name | Type                         | Required? | Notes                                                                                |
+| ---------- | ---------------------------- | --------- | ------------------------------------------------------------------------------------ |
+| Direction  | `Vector3`<br />(Default: Up) | **No**    | Which direction the entity should be flung, relative to the direction of the attack. |
+
+**Knockback Type: Point**
+
+Apply the calculated knockback force laterally along the XZ plane, plus provided Y velocity.
+
+| Field Name | Type                        | Required? | Notes                                                                                                   |
+| ---------- | --------------------------- | --------- | ------------------------------------------------------------------------------------------------------- |
+| OffsetX    | `Integer`<br />(Default: 0) | **No**    | Offset the source position of the knockback left or right perpendicular to the direction of the attack. |
+| OffsetZ    | `Integer`<br />(Default: 0) | **No**    | Offset the source position of the knockback, forward or backward along the directon of the attack.      |
+| RotateY    | `Integer`<br />(Default: 0) | **No**    | Rotate the knockback direction around the Y axis, where 0 is the default attack direction.              |
+| VelocityY  | `Float`<br />(Default: 0.0) | **No**    | Add vertical velocity to the knockback force after the direction and force has been calculated.         |
+
+**Knockback Type: Directional**
+
+Apply the calculated knockback force along the attack direction, removing any vertical component and replacing it with a provided Y velocity.
+
+| Field Name | Type                      | Required? | Notes                                                                                                                                            |
+| ---------- | ------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------ |
+| RelativeX  | `Float`<br />(Default: 0) | **No**    | Apply additional force left or right perpendicular to the direction of the attack. The additional force is multiplied by the knockback strength. |
+| RelativeZ  | `Float`<br />(Default: 0) | **No**    | Apply additional force forward or backward along the attack direction. The additional force is multiplied by the knockback strength.             |
+| VelocityY  | `Float`<br />(Default: 0) | **No**    | Replace the vertical velocity of the knockback with this value.  This value is not multiplied by knockback strength.                             |
+
+**VelocityConfig Fields**
+
+| Field Name          | Type                                              | Required? | Notes                                                                                                                                                                                           |
+| ------------------- | ------------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| GroundResistance    | `Float`<br />(Default: 0.82)                      | **No**    | The minimum amount of friction applied when the entity is in contact with the ground.  1.0 = no friction, 0.0 = total friction                                                                  |
+| GroundResistanceMax | `Float`<br />(Default: 0.0)                       | **No**    | The maximum amount of friction applied when the entity is in contact with the ground.  1.0 = no friction, 0.0 = total friction                                                                  |
+| AirResistance       | `Float`<br />(Default: 0.96)                      | **No**    | The minimum amount of friction applied when the entity is in the air. 1.0 = no friction, 0.0 = total friction                                                                                   |
+| AirResistanceMax    | `Float`<br />(Default: 0.0)                       | **No**    | The maximum amount of friction applied when the entity is in the air. 1.0 = no friction, 0.0 = total friction                                                                                   |
+| Threshold           | `Float`<br />(Default: 1.0)                       | **No**    | The speed at which the maximum amount of friction will be applied to the entity. The amount of friction applied will increase from minimum to maximum as the entity moves from 0 to this speed. |
+| Style               | `VelocityThresholdStyle`<br />(Default: `Linear`) | **No**    | The curve that friction follows as the entity's speed increases toward the `Threshold`.                                                                                                         |
+
+**DamageCalculatorType Values**
+
+- `Absolute`
+- `Dps`
+
+**DamageClass Values**
+
+- `Unknown`
+- `Light`
+- `Charged`
+- `Signature`
+
+**ChangeVelocityType Values**
+
+- `Add`
+- `Set`
+
+**VelocityThresholdStyle Values**
+
+- `Linear`
+- `Exp`
+
+### LaunchProjectile
+
+This is just a worse version of Projectile and is slated to be removed.  Use Projectile.
+
+### Projectile
+
+This interaction will spawn a new projectile at the User entity's eye position that will travel in its look direction.
+
+| Field Name | Type                                          | Required? | Notes                                                  |
+| ---------- | --------------------------------------------- | --------- | ------------------------------------------------------ |
+| Config     | `Asset`<br />(Asset Type: `ProjectileConfig`) | **No**    | Configuration describing the projectile to be spawned. |
+
+### RemoveEntity
+
+Despawns the specified entity from the world. This interaction will have no effect if the specified entity is a player. This
+interaction has no special failure conditions.
+
+| Field Name | Type                                     | Required? | Notes                  |
+| ---------- | ---------------------------------------- | --------- | ---------------------- |
+| Entity     | `InteractionTarget`<br />(Default: User) | **No**    | The entity to despawn. |
+
+**InteractionTarget Values**
+
+- `User` - The user of this interaction chain. The entity whose actions caused this interaction chain to be executed. This is usually the same as the Owner.
+- `Owner` - The owner of this interaction chain. The entity upon whom this interaction chain is executing.
+- `Target` - The entity target of this interaction chain, if any.  This value is mutable (and can therefore come from many places) but most commonly, it is an entity the User was targeting when this interaction chain began executing.
+
+### SendMessage
+
+This interaction sends a message to the Owner entity if that entity can receive messages.  Otherwise, the message
+is written to the server logs.  If the entity is a player, the message will appear in the player's chat window.
+
+\*\*SendMessage
+
+| Field Name | Type     | Required? | Notes                                                                                                                 |
+| ---------- | -------- | --------- | --------------------------------------------------------------------------------------------------------------------- |
+| Message    | `String` | **No**    | A text message to be sent to the Owner entity.  If this field is not provided, `Key` is used instead.                 |
+| Key        | `String` | **No**    | A translation key for a message to be sent to the Owner entity. If `Message` is provided, then this field is ignored. |
+
+### UseEntity
+
+This interaction is not in use by Hypixel and has some unusual qualities that mean it probably won't do what you want it
+to.  Do not use it.
+
+This interaction will retrieve the entity currently targeted by the client (NOT the interaction chain's current Target
+entity) and execute that entity's RootInteraction for this interaction chain's current interaction type. The
+RootInteraction will be executed as part of this current interaction chain. None of the properties of this interaction
+chain will be modified.
+
+This interaction will fail if the client is not currently targeting an entity, or if no interaction for the current
+interaction type exists on the entity.
+
+## Stats
+
+Hytale's resource system has been written about fairly extensively.  You can use these interactions to modify stats in
+response to actions or use stats as a cost for abilities.
+
+### ChangeStat
+
+This interaction applies a set of raw stat changes to the User entity. It has no special failure conditions.
+
+| Field Name    | Type                                                         | Required? | Notes                                                                                                                                                                                                                      |
+| ------------- | ------------------------------------------------------------ | --------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| StatModifiers | `Map`<br />(Key Type: `EntityStatType`, Value Type: `Float`) | **Yes**   | A set of stats to modify and what value to apply to them.                                                                                                                                                                  |
+| ValueType     | `ValueType`<br />(Default: Absolute)                         | **No**    | Whether the values in the `StatModifiers` map represent flat values to apply to the stat total, or percentages (0.0-100.0). Percentage values are percentage of the difference between the maximum and minimum stat value. |
+| Behaviour     | `ChangeStatBehavior`<br />(Default: Add)                     | **No**    | Whether the values in the `StatModifiers` map represent deltas to add into the User entity's current stat values, or fixed values to set the entity's stats to.                                                            |
+
+**ValueType Values**
+
+- `Absolute`
+- `Percent`
+
+**ChangeStatBehaviour Values**
+
+- `Add`
+- `Set`
+
+### ChangeStatWithModifier
+
+This interaction is like ChangeStat, except an armor stat modifier can be chosen which will apply bonuses and penalties
+to a stat from the User entity's equipped armor before it is applied.
+
+| Field Name            | Type                                                         | Required? | Notes                                                                                                                                                                                                                      |
+| --------------------- | ------------------------------------------------------------ | --------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| StatModifiers         | `Map`<br />(Key Type: `EntityStatType`, Value Type: `Float`) | **Yes**   | A set of stats to modify and what value to apply to them.                                                                                                                                                                  |
+| ValueType             | `ValueType`<br />(Default: Absolute)                         | **No**    | Whether the values in the `StatModifiers` map represent flat values to apply to the stat total, or percentages (0.0-100.0). Percentage values are percentage of the difference between the maximum and minimum stat value. |
+| Behaviour             | `ChangeStatBehavior`<br />(Default: Add)                     | **No**    | Whether the values in the `StatModifiers` map represent deltas to add into the User entity's current stat values, or fixed values to set the entity's stats to.                                                            |
+| InteractionModifierId | `InteractionModifierId`                                      | **Yes**   | The armor interaction modifier to apply bonuses and penalties for.                                                                                                                                                         |
+
+**ValueType Values**
+
+- `Absolute`
+- `Percent`
+
+**ChangeStatBehaviour Values**
+
+- `Add`
+- `Set`
+
+**InteractionModifierId Values**
+
+- `Dodge`
+
+### StatsCondition
+
+This interaction will fail if the User entity cannot afford the specified stats costs, or if it does not have the
+requested stats.
+
+| Field Name | Type                                                         | Required? | Notes                                                                                                                                                                                    |
+| ---------- | ------------------------------------------------------------ | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Costs      | `Map`<br />(Key Type:` EntityStatType`, Value Type: `Float`) | **Yes**   | A set of costs that the User entity needs to be able to afford for this interaction to succeed.                                                                                          |
+| ValueType  | `ValueType`<br />(Default: Absolute)                         | **No**    | Whether the values in the `Costs` map represetn flat values or percentages (0.0-100.0).  Percentage values are percentage of the difference between the maximum and minimum value.       |
+| LessThan   | `Boolean`<br />(Default: false)                              | **No**    | If true, this interaction will fail unless the User entity's current stat values are at or **below** the specified levels.  If false, they must be at or **above** the specified levels. |
+| Lenient    | `Boolean`<br />(Default: false)                              | **No**    | If true and `LessThan` is true, and a player's minimum stat value is below zero, then the player can afford a stat cost if the current value of a stat if above 0.                       |
+
+**ValueType Values**
+
+- `Absolute`
+- `Percent`
+
+### StatsConditionWithModifier
+
+This interaction is like StatsCondition, except an armor stat modifier can be chosen which will apply bonuses and penalties
+to a stat's cost from the User entity's equipped armor before it is compared.
+
+| Field Name            | Type                                                         | Required? | Notes                                                                                                                                                                                    |
+| --------------------- | ------------------------------------------------------------ | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Costs                 | `Map`<br />(Key Type:` EntityStatType`, Value Type: `Float`) | **Yes**   | A set of costs that the User entity needs to be able to afford for this interaction to succeed.                                                                                          |
+| ValueType             | `ValueType`<br />(Default: Absolute)                         | **No**    | Whether the values in the `Costs` map represetn flat values or percentages (0.0-100.0).  Percentage values are percentage of the difference between the maximum and minimum value.       |
+| LessThan              | `Boolean`<br />(Default: false)                              | **No**    | If true, this interaction will fail unless the User entity's current stat values are at or **below** the specified levels.  If false, they must be at or **above** the specified levels. |
+| Lenient               | `Boolean`<br />(Default: false)                              | **No**    | If true and `LessThan` is true, and a player's minimum stat value is below zero, then the player can afford a stat cost if the current value of a stat if above 0.                       |
+| InteractionModifierId | `InteractionModifierId`                                      | **Yes**   | The armor interaction modifier to apply bonuses and penalties for.                                                                                                                       |
+
+**ValueType Values**
+
+- `Absolute`
+- `Percent`
+
+**InteractionModifierId Values**
+
+- `Dodge`
+
+## EntityEffects
+
+EntityEffects are buff or debuff effects that can be applied to a LivingEntity.  These can have a variety of effects from
+movement speed changes to periodic damage.
+
+### EffectCondition
+
+This interaction will fail if the specified entity's EntityEffects do not match the provided conditions.
+
+**EffectCondition Fields**
+
+| Field Name      | Type                                             | Required? | Notes                                                                                                                                                                                                             |
+| --------------- | ------------------------------------------------ | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Entity          | `InteractionTarget`<br />(Default: User)         | **Yes**   | The entity to examine for EntityEffects. This field can indicate the Owner, User, or Target of this interaction chain.                                                                                            |
+| Match           | `Match`<br />(Default: All)                      | **No**    | If `All`, then this interaction will fail if any EntityEffect in the `EntityEffectIds` is not on the specified entity. If `None`, then this interaction will fail if any EntityEffect IS on the specified entity. |
+| EntityEffectIds | `AssetArray`<br />(Element Type: `EntityEffect`) | **Yes**   | The set of EntityEffects to check against the specified entity and `Match`.                                                                                                                                       |
+
+**InteractionTarget Values**
+
+- `User` - The user of this interaction chain. The entity whose actions caused this interaction chain to be executed. This is usually the same as the Owner.
+- `Owner` - The owner of this interaction chain. The entity upon whom this interaction chain is executing.
+- `Target` - The entity target of this interaction chain, if any.  This value is mutable (and can therefore come from many places) but most commonly, it is an entity the User was targeting when this interaction chain began executing.
+
+**Match Values**
+
+- `All` - All EntityEffects must be on the specified entity for this interaction to succeed.
+- `None` - None of the EntityEffects must be on the specified entity for this interaction to succeed.
+
+### ApplyEffect
+
+This interaction will apply the specified EntityEffect to the specified Entity.  It has no special failure conditions.
+
+**ApplyEffect Fields**
+
+| Field Name | Type                                      | Required? | Notes                                                                                                                  |
+| ---------- | ----------------------------------------- | --------- | ---------------------------------------------------------------------------------------------------------------------- |
+| Entity     | `InteractionTarget`<br />(Default: User)  | **Yes**   | The entity to apply the EntityEffect to. This field can indicate the Owner, User, or Target of this interaction chain. |
+| EffectId   | `Asset`<br />(Asset Type: `EntityEffect`) | **Yes**   | The effect to apply.                                                                                                   |
+
+**InteractionTarget Values**
+
+- `User` - The user of this interaction chain. The entity whose actions caused this interaction chain to be executed. This is usually the same as the Owner.
+- `Owner` - The owner of this interaction chain. The entity upon whom this interaction chain is executing.
+- `Target` - The entity target of this interaction chain, if any.  This value is mutable (and can therefore come from many places) but most commonly, it is an entity the User was targeting when this interaction chain began executing.
+
+### ClearEntityEffect
+
+This interaction will remove the specified EntityEffect from the specified Entity. It has no special failure conditions.
+It will not fail if the Entity does not have the EntityEffect.
+
+**ClearEntityEffect Fields**
+
+| Field Name | Type                                      | Required? | Notes                                                                                                                     |
+| ---------- | ----------------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------- |
+| Entity     | `InteractionTarget`<br />(Default: User)  | **Yes**   | The entity to remove the EntityEffect from. This field can indicate the Owner, User, or Target of this interaction chain. |
+| EffectId   | `Asset`<br />(Asset Type: `EntityEffect`) | **Yes**   | The effect to remove.                                                                                                     |
+
+**InteractionTarget Values**
+
+- `User` - The user of this interaction chain. The entity whose actions caused this interaction chain to be executed. This is usually the same as the Owner.
+- `Owner` - The owner of this interaction chain. The entity upon whom this interaction chain is executing.
+- `Target` - The entity target of this interaction chain, if any.  This value is mutable (and can therefore come from many places) but most commonly, it is an entity the User was targeting when this interaction chain began executing.
+
+## Farming
+
+These are interaction types built to support the in-game farming system in Hytale. They are mostly block-related interactions
+with a few exceptions.
+
+### ChangeFarmingStage
+
+If the target block is a farming block, this interaction will attempt to modify the current farming stage in one of
+three ways.  The interaction can optionally specify which StageSet to use for the new stage. If it is not specified,
+the current StageSet will be used. If any part of the the process of changing the growth stage fails, this interaction
+will fail, with the one exception that attempting to set the stage to the crop's existing stage will have no effect but
+still succeed.
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                                                                                                                                                                          |
+| ---------------- | ------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction.                                                                                                                                              |
+| StageSet         | `String`                        | **No**    | If provided, set the block's current stage to one in the provided StageSet. Otherwise, use the crop's current StageSet.                                                                                                                                                        |
+| Increase         | `Integer`                       | **No**    | If provided, increase the current stage by the specified amount. If the specified stage does not exist, the block will be set to the closest extant stage.                                                                                                                     |
+| Decrease         | `Integer`                       | **No**    | If provided and `Increase` is not provided, decrease the current stage by the specified amount. If the specified stage does not exist, the block will be set to the closest extant stage.                                                                                      |
+| Stage            | `Integer`<br />(Default: -1)    | **No**    | If provided and `Increase`/`Decrease` are not provided, set the current stage to the specified stage. If this value is less than 0, set the current stage to the final growth stage. If the specified stage does not exist, the block will be set to the closest extant stage. |
+
+### FertilizeSoil
+
+If the target block is unfertilized tilled soil or a farming block on top of unfertilized tilled soil, fertilizes the soil.
+The interaction will fail otherwise.
+
+**FertilizeSoil Fields**
+
+| Field Name       | Type                                  | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false)       | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+| RefreshModifiers | `Array`<br />(Element Type: `String`) | **No**    | Does nothing.                                                                                                                     |
+
+### HarvestCrop
+
+This interaction will attempt to execute the harvest action on the current block target and add the crop's drops to the User entity's
+inventory.  The block will either be destroyed or set to its post-harvest growth stage, depending on the farming
+configuration of the block.  This will happen (and the player will receive the full harvest drops) regardless of the
+block's current growth stage. This interaction has no special failure conditions, even if the block target isn't a
+farming block or gathering isn't permitted in the current world, but nothing will occur in those cases.
+
+**HarvestCrop Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+
+### UseWateringCan
+
+If the target block is tilled soil or a farming block on top of tilled soil, waters the soil for the specified duration.
+The interaction will fail otherwise.
+
+**UseWateringCan Fields**
+
+| Field Name       | Type                                  | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false)       | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+| Duration         | `Integer`<br />(Default: 0)           | **No**    | The duration in seconds to water the soil for.                                                                                    |
+| RefreshModifiers | `Array`<br />(Element Type: `String`) | **No**    | Does nothing.                                                                                                                     |
diff --git a/content/docs/fr-FR/contributing/index.mdx b/content/docs/fr-FR/contributing/index.mdx
index 8e8c505b..d67241d5 100644
--- a/content/docs/fr-FR/contributing/index.mdx
+++ b/content/docs/fr-FR/contributing/index.mdx
@@ -8,9 +8,9 @@ Nous accueillons les contributions de la communauté pour aider à améliorer et
 
 ## Comment contribuer
 
-### Reporting Issues
+### Signaler des problèmes
 
-If you've found a issue with the documentation, please report it by opening a new issue on our [GitHub repository](https://github.com/HytaleModding/site/issues).
+Si vous avez trouvé un problème avec la documentation, signalez-le en ouvrant une issue sur notre [Dépôt GitHub](https://github.com/HytaleModding/site/issues).
 
 Si vous pouvez travailler sur ce problème vous-même, vous pouvez demander à y être assigné et soumettre une PR.
 
@@ -30,10 +30,10 @@ git checkout -b my-feature-branch
 git commit -m "feat: add feature X to documentation"
 ```
 
-5. Push your changes to your fork.
+5. Poussez vos changements dans votre fork.
 
 ```bash
 git push origin my-feature-branch
 ```
 
-6. Open a Pull Request on the original repository, describing your changes and why they should be merged.
+6. Ouvrez une Pull Request sur le dépôt original, en décrivant vos changements et pourquoi ils devraient être fusionnés.
diff --git a/content/docs/fr-FR/contributing/pr-guidelines.mdx b/content/docs/fr-FR/contributing/pr-guidelines.mdx
index 7a251032..76537abc 100644
--- a/content/docs/fr-FR/contributing/pr-guidelines.mdx
+++ b/content/docs/fr-FR/contributing/pr-guidelines.mdx
@@ -1,39 +1,41 @@
 ---
-title: PR Guidelines
-description: Guidelines that reviewers and contributors should follow when submitting and reviewing pull requests.
+title: Règles concernant les PRs
+description: Règles que les examinateurs et contributeurs doivent suivre quand ils soumettent et examinent des pull requests.
 ---
 
-# Pull Request Guidelines
+# Règles concernant les Pull Requests
 
-To ensure a smooth and efficient review process, both contributors and reviewers should adhere to the following guidelines when submitting and reviewing pull requests (PRs).
+Pour assurer un processus d'examen fluide et efficace, les contributeurs et les examinateurs doivent adhérer aux règles suivantes lorsqu'ils soumettent et examinent des pull requests (PRs)
 
-## For Contributors
+## Pour les contributeurs
 
-1. **Descriptive Titles and Descriptions**
-   - Use clear and concise titles that summarize the changes.
-   - Provide detailed descriptions of what the PR does, why the changes are necessary, and any relevant context.
-2. **Link to Issues**
-   - In your PR title, add `GH-ISSUE-NUMBER` to link the PR to the relevant issue. This is required for all PRs.
-3. **Small, Focused Changes**
-   - Aim to keep PRs small and focused on a single issue or feature. This makes it easier for reviewers to understand and provide feedback.
-4. **Code Quality**
-   - Ensure your code follows the project's coding standards and best practices.
-   - Include comments where necessary to explain complex logic.
-5. **Testing**
-   - Test your changes thoroughly before submitting the PR.
-   - If applicable, include unit tests or integration tests to verify your changes.
+1. **Titres et descriptions descriptifs**
+   - Utilisez des titres clairs et concis qui résument les changements.
+   - Donnez des descriptions détaillées de ce que la PR fait, pourquoi les changements sont nécessaires, et aussi tout contexte pertinent à savoir.
+2. **Lien vers les issues**
+   - Dans le titre de votre PR, ajoutez `GH-ISSUE-NUMBER` pour lier la PR à l'issue correspondante. Ceci est requis pour toutes les PRs.
+3. **Changements petits et ciblés**
+   - Visez à garder les PRs de petite taille et ciblée sur une seule issue ou fonctionnalité. Ce qui permet aux examinateurs de plus facilement comprendre et faire des retours.
+4. **Qualité du code**
+   - Assurez-vous que votre code suive les standards de programmation du projet et les bonnes pratiques.
+   - Ajoutez des commentaires quand c'est nécessaire pour expliquer les logiques complexes.
+   - Testez toujours vos modifications localement avant de soumettre la PR afin de détecter les problèmes le plus tôt possible.
+   - Formatez votre code en utilisant le `format bun` pour maintenir la cohérence dans l'ensemble dans la codebase.
+5. **Tests**
+   - Testez rigoureusement vos changements avant de soumettre une PR.
+   - Si possible, incluez des tests unitaires ou des tests d'intégration pour valider vos changements
 6. **Documentation**
-   - Update or add documentation as needed to reflect your changes.
-7. **Commit Messages**
-   - Use clear and descriptive commit messages that follow the [conventional commits](https://www.conventionalcommits.org/en/v1.0.0/) format.
-8. **Check for Conflicts**
-   - Before submitting your PR, ensure that your branch is up to date with the base branch to minimize merge conflicts.
+   - Mettez à jour ou ajoutez de la documentation si besoin, qui reflète vos changements.
+7. **Messages de commit**
+   - Utilisez des messages de commit clairs et descriptifs qui suivent le format de convention [Commits conventionnels](https://www.conventionalcommits.org/fr/v1.0.0/).
+8. **Vérifiez les conflits**
+   - Avant de soumettre votre PR, assurez-vous que votre branche est à jour avec la branche de base pour minimiser les conflits de fusions.
 
-## For Reviewers
+## Pour les examinateurs
 
-- You are supposed to review PRs thoroughly, and request changes if needed.
-- Provide constructive feedback and suggestions for improvement.
-- Verify that the changes meet the project's coding standards and best practices.
-- Deploy the PR using the dokploy integration to ensure the changes work as expected.
-- Ensure that documentation is updated as necessary.
-- Approve the PR only when you are satisfied with the changes and all checks have passed.
+- Vous être supposés examiner les PRs rigoureusement, et demander des changements si nécessaire.
+- Fournissez des commentaires constructifs et des suggestions d'amélioration.
+- Vérifiez que les changements sont en accord avec les standards de programmation du projet et les bonnes pratiques.
+- Déployez la PR en utilisant l'intégration dokploy pour s'assurer que les changements fonctionnent comme prévu.
+- Assurez-vous que la documentation est mise à jour si besoin.
+- Approuvez la PR seulement si vous êtes satisfaits des changements et que toutes les vérifications sont validées.
diff --git a/content/docs/fr-FR/contributing/translate.mdx b/content/docs/fr-FR/contributing/translate.mdx
new file mode 100644
index 00000000..c62ffdde
--- /dev/null
+++ b/content/docs/fr-FR/contributing/translate.mdx
@@ -0,0 +1,74 @@
+---
+title: Translate
+description: How to translate HytaleModding to your language
+---
+
+# Translating HytaleModding
+
+HytaleModding is translated with the help of the community using **Crowdin**. If you want to help translate or improve existing translations, this is the right place.
+
+## Steps to Translate
+
+All translations are managed **via Crowdin**.
+
+1. Visit [our Crowdin project](https://crowdin.com/project/hytalemodding) and log in if required.
+2. Click on your language.
+3. Click on the file/article you wish to translate. We recommend starting with Official Documentation, and then Server Plugin Documentation.
+4. Start translating!
+5. Approved translations will appear on the website.
+
+### Video Guide
+
+<iframe src="https://www.youtube.com/embed/NHiG1rDRgks" allowFullScreen />
+
+## How to discuss
+
+You can always report issues or discuss specific topics directly on Crowdin, but we recommend using Discord instead of the Crowdin comment system to keep everything organized in one place.
+
+1. Join [our Discord](https://discord.gg/hytalemodding)
+2. Open `#translations` channel. Here you can discuss or ask questions that are not related to a specific language.
+3. If you want to join a thread, you are required to run `/translator <your-language>` command here. The bot will add you to the thread for your language.
+
+## Translation Guidelines
+
+- You need to be confident in what you are translating. You should be able to read the text you just translated and understand the meaning of it very easily.
+- It should use the simplest form of language possible. Use English words if the translation is unknown to the majority in your country.
+- Use your imagination, trust yourself. Feel free to change any context as you wish as long as it can still get the same point across and is understandable.
+- These guidelines are more important than language-specific guidelines, but less important than Hytale terminology and rules.
+
+## What not to translate
+
+We request you all to not translate these specific sections of the website:
+
+### Callout types
+
+Callouts are the boxes that contain important information. We request you to not translate the types as they only work in English.
+
+**Example:**
+
+```mdx
+<Callout type="warning" title="Translate this title!">
+Translate the text inside the callout!
+</Callout>
+```
+
+In this example, please don't translate the word warning, the rest you can translate.
+
+### Icons
+
+Icon names must not be translated.
+They are technical identifiers mapped directly to existing icons. Translating them will break the icon rendering.
+
+```mdx
+icon: Globe
+```
+
+---
+
+{/* 
+For translators who will edit this page:
+
+- You are required to translate the Guidelines as they change.
+- General guidelines should be translated but not edited.
+- Learn how to use Markdown from writing_guides.mdx
+*/}
diff --git a/content/docs/fr-FR/contributing/writing-guides.mdx b/content/docs/fr-FR/contributing/writing-guides.mdx
index 55c52ade..40ee1c08 100644
--- a/content/docs/fr-FR/contributing/writing-guides.mdx
+++ b/content/docs/fr-FR/contributing/writing-guides.mdx
@@ -1,86 +1,86 @@
 ---
-title: Writing Guides
+title: Écrire des guides
 ---
 
-## Creating a guide file
+## Créer un fichier de guide
 
-To start writing a guide, you need to create a file with extension `.mdx`. You need to create this file inside the `/content/docs/en` directory, now it depends in which section you want to make the guide, so you can decide which folder you should put it in after that.
+Pour commencer à écrire un guide, vous devez créer un fichier avec l'extension `.mdx`. Vous devez créer ce fichier dans le répertoire `/content/docs/en`, après tout dépend dans quelle section vous voulez faire le guide, donc vous pouvez décider dans quel sous-dossier vous devriez le mettre.
 
-Suppose I want to make a java basics guide, I'd put it in `/content/docs/en/guides/java-basics`. You'll have to do some digging to find out where you want to place it.
+Supposons que je veux faire un guide sur les bases de Java, je le mettrais dans `/content/docs/en/guides/java-basics`. Vous aurez à fouiller un peu pour trouver où vous voulez le mettre.
 
 <Callout>
-  If there's already a guide in the section you want to write about, you can just press on the "Edit On GitHub" button on our website and it'll take you to the folder, now you can write in the same folder to have your guide appear in the same section.
+  S'il y a déjà un guide dans la section sur laquelle vous souhaitez écrire, vous pouvez simplement appuyer sur le bouton "Modifier sur GitHub" sur notre site Web et il vous mènera dans le dossier, vous pouvez maintenant écrire dans le même dossier pour que votre guide apparaisse dans la même section.
 </Callout>
 
-## Frontmatter
+## Avant-propos
 
-Frontmatter is the metadata of your guide, it tells our website how to display your guide. This needs to be at the very top of the file, which starts with `---` and ends with `---`.
+L'avant-propos sont les métadonnées de votre guide, cela indique à notre site web comment afficher votre guide. Il doit être placé au tout début du fichier, et commence avec `---` et se finit par `---`.
 
-Here's an example:
+Voici un exemple :
 
 ```mdx
 ---
-title: "Java Basics"
-description: "Learn the basics of Java programming."
+title: "Bases de Java"
+description: "Apprenez les bases de la programmation Java."
 authors:
-    - name: "Your Name"
-      url: "https://yourwebsite.com"
+    - name: "Votre nom"
+      url: "https://votresiteweb.com"
 ---
 ```
 
-Now as you can see, it's pretty self explanatory, you just need to fill in the details for your specific guide. If you don't have a URL you want to link yourself to, just don't write that whole line. Additionally, the authors section is optional, so if you don't want to add it, you can just leave it out although we encourage you to do so and credit yourself.
+Comme vous pouvez le voir, c'est assez intuitif, vous avez juste besoin de remplir les détails pour votre guide. Si vous n'avez pas d'URL à laquelle vous voulez vous rattacher, n'écrivez juste pas cette ligne. De plus, la section auteurs est optionnelle, donc si vous ne voulez pas l'ajouter, vous pouvez juste l'omettre, même si nous vous encourageons à le faire et à vous créditer.
 
-The indentation in the frontmatter is important, so make sure to keep it consistent with the example.
+L'indentation dans l'avant-propos est important, donc soyez sûrs de le faire comme dans l'exemple.
 
-## Content Structure
+## Structure du contenu
 
-You should structure the content of your guide in a clear and organized manner. Here are some tips on how to do that:
+Vous devriez structurer le contenu de votre guide de manière claire et organisée. Voici quelques astuces pour le faire :
 
-- **Introduction:** Start with an overview of the topic and what the reader can expect to learn.
-- **Prerequisites:** List any prerequisites or prior knowledge the reader should have before diving into the guide.
-- **Step-by-Step Instructions:** Break down the content into clear, actionable steps. Use headings and subheadings to organize the information.
-- **Code Examples:** Include code snippets to illustrate key points. Make sure to explain each example thoroughly.
-- **Conclusion:** Summarize the main points and encourage the reader to explore further or try out what they've learned.
+- **Introduction :** Commencez avec un aperçu du sujet et ce que le lecteur peut espérer apprendre.
+- **Prérequis :** Listez tous les prérequis ou les connaissances préalables que le lecteur doit avoir avant de plonger dans le guide.
+- **Instructions pas-à-pas :** Divisez le contenu en étapes claires et concrètes. Utilisez les titres et sous-titres pour organiser les informations.
+- **Exemples de code :** Incluez des extraits de code pour illustrer les points clés. Soyez sûr d'expliquer chaque exemple rigoureusement.
+- **Conclusion :** Résumez les points importants et encouragez le lecteur à explorer plus loin ou essayer ce qu'ils ont appris.
 
-Now if you're writing a really big section, you should split this into multiple pages so that it's easier for the reader to digest the information. No one wants to read a big wall of text all at once!
+Maintenant, si vous rédigez une section vraiment importante, vous devriez la diviser en plusieurs pages afin de faciliter la lecture et la compréhension pour le lecteur. Personne n'a envie de lire un gros bloc de texte d'un seul coup !
 
-When we write guides, we should also think of how people will consume them, and many people prefer to skim content rather than read it in detail. This is why it's better to split information into multiple pages, so it looks like a smaller amount of information to the reader. Also, consider using bullet points, numbered lists, and other formatting techniques to make the content more scannable.
+Lorsque nous rédigeons des guides, nous devrions aussi réfléchir à la manière dont les lecteurs vont les consulter, car beaucoup de personne préfèrent parcourir le contenu plutôt que de le lire en détail. C'est pourquoi il est préférable de répartir l'information sur plusieurs pages, afin qu'elle paraisse moins volumineuse pour le lecteur. Pensez également à utiliser des listes à puces, des listes numérotées et d'autres techniques de mise en forme afin de rendre le contenu plus facile à parcourir.
 
-## Formatting
+## Mise en forme
 
-We use [Markdown](https://www.markdownguide.org/) for formatting our guides. Here are some key points to keep in mind:
+Nous utilisons [Markdown](https://www.markdownguide.org/) pour la mise en forme de nos guides. Voici quelques points clés à garder à l'esprit :
 
-- Use headings (`#`, `##`, `###`) to organize your content.
-- Use bullet points and numbered lists for clarity.
-- Use code blocks (\`\`\`) for code snippets.
-- Use links to reference other guides or external resources.
+- Utilisez les en-têtes (`#`, `##`, `###`) pour organiser votre contenu.
+- Utilisez des listes à puces et des listes numérotées pour plus de clarté.
+- Utilisez les blocs (\`\`\`) pour les extraits de code
+- Utilisez des liens pour référencer d'autres guides ou ressources externes.
 
-This is the same type of formatting you'll see on most documentation websites, and also social media platforms like Discord.
+Il s’agit du même type de mise en forme que vous verrez sur la plupart des sites de documentation, ainsi que sur des plateformes de médias sociaux comme Discord.
 
-You can also make a Callout to highlight important information or tips. Use the following syntax:
+Vous pouvez également créer un "Callout" pour mettre en avant des informations importantes ou des conseils. Utilisez la syntaxe suivante :
 
 ```mdx
 <Callout>
-    This is a callout message.
+    Ceci est un message de callout.
 </Callout>
 ```
 
 <Callout>
-  This is a callout message.
+  Ceci est un message de callout.
 </Callout>
 
-You can change the color of the callout by adding a `type` attribute. For example:
+Vous pouvez changer la couleur du callout en ajoutant un attribut `type`. Par exemple :
 
 ```mdx
 <Callout type="info">
-    This is an info callout.
+    Ceci est un callout d'information.
 </Callout>
 ```
 
-Available types are: `info`, `warning`, `error`, and `success`.
+Les types disponibles sont : `info`, `warning`, `error`, et `success`.
 
 ## Conclusion
 
-That's all! You are now a master at writing guides. Just remember, do not think you need to be perfect with your English, write the guide the way you will explain the topic to someone, and don't hesitate to ask for feedback or help if you need it.
+C'est tout! Vous êtes maintenant un maître dans la rédaction de guides. Rappelez-vous, ne pensez pas que vous devez être parfait avec votre anglais, écrivez le guide de la manière dont vous expliquerez le sujet à quelqu'un, et n'hésitez pas à demander des commentaires ou de l'aide si vous en avez besoin.
 
-Happy writing!
+Bonne écriture !
diff --git a/content/docs/fr-FR/established-information/faq.mdx b/content/docs/fr-FR/established-information/faq.mdx
index f9b651ef..80b40f67 100644
--- a/content/docs/fr-FR/established-information/faq.mdx
+++ b/content/docs/fr-FR/established-information/faq.mdx
@@ -1,45 +1,45 @@
 ---
-title: Frequently Asked Questions
-description: Frequently Asked Questions about Hytale modding.
+title: Foire aux questions
+description: Foire aux questions sur le modding d'Hytale.
 ---
 
-On this page, we'll answer some of your Frequently Asked Questions.
+Sur cette page, nous répondrons à certaines de vos questions les plus fréquentes.
 
-## 1. Can the client be modded?
+## 1. Est-ce que le client peut être moddé ?
 
-No, the client is not able to be modded, although the Client will not have control over how the game and the UI looks.
+Non, le client ne peut pas être moddé, de plus, le client n'aura pas le contrôle sur l'apparence du jeu et de l'interface utilisateur.
 
-The server decides the visuals, more like the "Resource Packs" available in Minecraft. The server decides what mods are used
+Le serveur décide des visuels, un peu comme les "Packs de ressources" disponibles dans Minecraft. Le serveur décide des mods utilisés
 
-## 2. What Network Protocol will be used?
+## 2. Quel protocole réseau sera utilisé ?
 
-Hytale will use the QUIC transport protocol.
+Hytale utilisera le protocole de transport QUIC.
 
-For context, the two main Internet protocols are UDP and TCP.
+Pour plus de contexte, les deux protocoles Internet principaux sont l'UDP et le TCP.
 
-* UDP is connectionless, fast, fire-and-forget packets but has less reliability as packets can be lost.
-* TCP is connection-based, slower than UDP, can guarantee packet delivery with much more reliability.
-  Both are pretty fast in modern times, games can run fine on both (but generally prefer UDP).
+* L’UDP est sans connexion, rapide, mais envoie les paquets sans accusé de réception. Il est donc moins fiable, car certains paquets peuvent être perdus.
+* Le TCP est basé sur une connexion, plus lent que l’UDP, et permet une livraison des données bien plus fiable.
+  Les deux sont plutôt rapides dans les temps modernes, les jeux peuvent bien fonctionner sur les deux (mais préfèrent généralement l'UDP).
 
-QUIC is a **hybrid protocol** that builds off UDP to get the same speed benefits, but adds some layers of reliability like TCP.
-Essentially, a solid choice for game development that blends speed and reliability.
+QUIC est un **protocole hybride** qui se base sur l'UDP pour avoir les mêmes avantages de vitesse, mais ajoute quelques couches de fiabilité comme le TCP.
+Fondamentalement, un choix solide pour le développement de jeux qui conjugue vitesse et fiabilité.
 
-## 3. What are Transfer Packets?
+## 3. Que sont les paquets de transfert ?
 
-Transfer packets in Hytale are small data payloads *(4kb)* that allow players to move from one server to another while carrying information.
-They are not equivalent to something like BungeeCord or Velocity and are primarily intended for smaller servers.
+Les paquets de transfert dans Hytale sont de petits blocs de données (4 Ko) permettant aux joueurs de se déplacer d’un serveur à l’autre tout en transportant des informations.
+Ils ne sont pas équivalents à BungeeCord ou Velocity et sont principalement destinés aux serveurs de plus petite taille.
 
-Unlike BungeeCord, they do not manage network-wide features such as global plugins.
-Implementing DDOS protection would also be incredibly hard for smaller networks by using transfer packets.
+Contrairement à BungeeCord, ils ne gèrent pas les fonctionnalités globales du réseau comme les plugins globaux.
+Implémenter une protection contre le DDOS serait également très dur pour des petits réseaux en utilisant les paquets de transfert.
 
-Transfer packets work quite well in scenarios such as small server networks or hubs where players will hop between servers without the loss of progress. For example, a player might finish a dungeon on one server and then move to a lobby or different game mode with their inventory and stats intact. This lessens server costs and enables the developers to put more effort into gameplay improvement rather than complicated network setups.
+Les paquets de transfert fonctionnent assez bien dans des scénarios comme des petits réseaux de serveurs ou des hubs dans lesquels les joueurs passeront d'un serveur à l'autre sans perte de progression. Par exemple, un joueur pourrait finir un donjon sur un serveur et ensuite aller dans un lobby ou un mode de jeu différent, avec son inventaire et ses statistiques intactes. Ce qui réduit les coûts du serveur et permet aux développeurs de mettre plus d'efforts dans l'amélioration du gameplay plutôt que dans la configuration complexe du réseau.
 
-## 4. Will Hytale support dedicated servers?
+## 4. Est-ce qu'Hytale supportera les serveurs dédiés ?
 
-Yes, Hytale will support dedicated servers. This allows server owners to host their own Hytale servers on their own hardware or through third-party hosting services.
+Oui, Hytale supportera les serveurs dédiés. Cela permet aux propriétaires de serveurs d'héberger leur propre serveurs Hytale sur leur propre machine ou à travers des services d'hébergement tiers.
 
-Dedicated servers provide more control over server settings, mods, and performance compared to using official hosting solutions.
+Les serveurs dédiés offrent plus de contrôle sur les paramètres serveur, les mods, et les performances en comparaison aux solutions d'hébergement officielles.
 
-## 5. Will Hytale support modding on consoles?
+## 5. Est-ce qu'Hytale supportera le modding sur console ?
 
-As of now, Hytale modding is primarily focused on PC platforms.
+Pour l'instant, le modding d'Hytale est principalement axé sur les plateformes PC.
diff --git a/content/docs/fr-FR/established-information/gameplay/creative.mdx b/content/docs/fr-FR/established-information/gameplay/creative.mdx
index c6aeebb2..212325e4 100644
--- a/content/docs/fr-FR/established-information/gameplay/creative.mdx
+++ b/content/docs/fr-FR/established-information/gameplay/creative.mdx
@@ -78,21 +78,21 @@ Les pinceaux sont utilisés pour faire des modifications importantes au monde, m
 - Origine (Liste déroulante : Centre, Bas, Haut) : description inconnue en décembre 2025.
 - Axes miroirs (Liste déroulante : Aucun, Autres options inconnues) : description inconnue en décembre 2025.
 - Épaisseur du mur (Slider entier) : description inconnue en décembre 2025.
-- Density (Integer Slider): Description unknown as of December 2025.
+- Densité (Slider entier) : description inconnue en décembre 2025.
 
 #### Presets:
 
 - Boulder: Creates a boulder at the point at which the player is looking.
-- Grassy Path: Transforms the terrain into a grass path at the point at which the player is looking.
-- Rubble: Generate rubble at the point at which the player is looking.
-- Tentacle: TBD
-- Lava Cracks: Transforms the terrain into a lava crack at the point at which the player is looking.
-- Hot Springs: TBD
-- Ruins: Generates a ruin at the point at which the player is looking.
-- Ruin Roofs: Generates a ruin with a roof at the point at which the player is looking.
-- Grass: TBD
+- Chemin d'herbe : transforme le terrain en un chemin d'herbe à l'endroit où le joueur regarde.
+- Gravats : génère des gravats à l'endroit où le joueur regarde.
+- Tentacule : à déterminer.
+- Fissures de lave : transforme le terrain en fissures de lave à l'endroit ou le joueur regarde.
+- Sources chaudes : à déterminer.
+- Ruines : génère une ruine à l'endroit ou le joueur regarde.
+- Toits en ruine : génère une ruine avec un toit à l'endroit ou le joueur regarde.
+- Herbe : à déterminer.
 - Mountain: Places consecutive chunks of terrain to form a mountain at the point at which the player is looking.
-- Ruins: TBD
+- Ruines : à déterminer.
 
 ---
 
@@ -139,19 +139,19 @@ Unknown as of December 2025.
 Note that these are WIP and subject to change. **Not all settings and functionality are currently known**.
 
 - Tool Reach Distance (Integer Slider): Description unknown as of December 2025.
-- Tool Delay Minimum (Integer Slider): Description unknown as of December 2025.
-- Brush Opacity (Integer Slider): Description unknown as of December 2025.
-- Selection Opacity (Integer Slider): Description unknown as of December 2025.
-- Selection Panel Opacity (Integer Slider): Description unknown as of December 2025.
-- Enable Brush Shape Rendering (Toggle): Description unknown as of December 2025.
-- Display Legend (Toggle): Description unknown as of December 2025.
-- Show Tool Notifications (Toggle): Description unknown as of December 2025.
-- Default Laser Pointer (Hex Color Code): Description unknown as of December 2025.
-- Enable Brush Spacing (Toggle): Description unknown as of December 2025.
-- Spacing Between Br? (Integer Slider): Description unknown as of December 2025.
-- Flight Intertia (Integer Slider): Description unknown as of December 2025.
-- Flight Mode (Combo Box: Hover, Directional): Description unknown as of December 2025.
-- No Clip (Toggle): Description unknown as of December 2025.
+- Délai minimum de l'outil (Slider entier) : description inconnue en décembre 2025.
+- Opacité du pinceau (Slider entier) : description inconnue en décembre 2025.
+- Opacité de la sélection (Slider entier) : description inconnue en décembre 2025.
+- Opacité du panneau de sélection (Slider entier) : description inconnue en décembre 2025.
+- Activer le rendu de forme du pinceau (Toggle) : description inconnue en décembre 2025.
+- Afficher la légende (Toggle) : description inconnue en décembre 2025.
+- Afficher les notifications de l'outil (Toggle) : description inconnue en décembre 2025.
+- Pointeur laser par défaut (Couleur en code hexadécimal) : description inconnue en décembre 2025.
+- Activer l'espacement du pinceau (Toggle) : description inconnue en décembre 2025.
+- Espacement entre les pinceaux Espacement entre les pinceaux Espacement entre les pinceaux Espacement entre les pinceaux (Slider entier) : description inconnue en décembre 2025.
+- Inertie de vol (Slider entier) : description inconnue en décembre 2025.
+- Mode de vol (Liste déroulante : Stationnaire, Directionnel) : description inconnue en décembre 2025.
+- Pas de Clip (Toggle) : description inconnue en décembre 2025.
 - Air Placement (Toggle): Description unknown as of December 2025.
 
 ## Content Creation Tools
@@ -182,62 +182,62 @@ Allows the user to create or edit prefabs in a separate space.
 
 - Saved configs (Unknown type; presumably a file)
 - Root Dir (Unknown type; presumably a folder)
-- Prefab Paths or Folders (Unknown type; presumably a list of paths or folders)
-- Recursively Search for Prefabs (Toggle)
-- Spawn Entities and NPCs (Toggle)
-- Desired Y Level to Paste (Integer)
-- Blocks Between Prefabs (Integer)
-- WorldGen Type (Combo Box: Flat, Unknown other options): Description unknown as of December 2025.
-- (Flat WorldGen Only) Num Air Blocks Below Prefabs (Integer): Description unknown as of December 2025.
-- Axis to Paste On (Combo Box: X, Unknown other options): Description unknown as of December 2025.
-- Alignment Method (Combo Box: By Anchor, Unknown other options): Description unknown as of December 2025.
+- Chemins ou dossiers de préfabriqués (Type inconnu ; probablement une liste de chemins ou de dossiers)
+- Recherche récursive de préfabriqués (Toggle)
+- Générer des entités et des PNJs (Toggle)
+- Hauteur Y désirée pour le collage (Entier)
+- Blocs entre les préfabriqués (Entier)
+- Type de génération de monde (Liste déroulante : Plate, Autres options inconnues) : description inconnue en décembre 2025.
+- (Seulement pour la génération plate) Nombre de blocs d'air sous les préfabriqués (Entier) : description inconnue en décembre 2025.
+- Axe sur lequel coller (Liste déroulante : X, Autres options inconnues) : description inconnue en décembre 2025.
+- Méthode d'alignement (Liste déroulante : Par ancre, Autres options inconnues) : description inconnue en décembre 2025.
 
-#### Prefab List
+#### Liste de préfabriqués
 
-- Lists all user created prefabs and allows the user to load a prefab into the Paste tool.
-- User can pick from server, assets, or worldgen prefabs.
+- Liste tous les préfabriqués créés par l'utilisateur et lui permet de charger un préfabriqué dans l'outil de collage.
+- L'utilisateur peut prendre des préfabriqués de serveurs, d'assets ou de génération de monde
 
-#### Spawn NPC
+#### Générer un PNJ
 
-Unknown as of December 2025.
+Inconnu en décembre 2025.
 
-#### Spawn Particle
+#### Générer des particules
 
-Unknown as of December 2025.
+Inconnu en décembre 2025.
 
-#### Change Player Model
+#### Changer le modèle du joueur
 
-- Allows the player to change their model with an adjustable scale.
+- Permet au joueur de changer leur modèle avec une échelle ajustable.
 
-#### Tint Chunk
+#### Morceau de teinture
 
-Unknown as of December 2025.
+Inconnu en décembre 2025.
 
 #### Instances
 
-Unknown as of December 2025.
+Inconnu en décembre 2025.
 
-### Builder Tools
+### Outils de construction
 
-Unknown as of December 2025.
+Inconnu en décembre 2025.
 
 ### Machinima
 
-Machinima is a built-in sequence editor, allowing the user to create and edit sequences of actions to be played back in game. It includes a built-in interactive keyframe editor.
+Le machinima est un éditeur de séquence intégré, permettant à l'utilisateur de créer et modifier des séquences d'actions pour les rejouer en jeu. Cela comprend un éditeur interactif d'images clés.
 
-The speed of playback can be adjusted via commands.
+La vitesse de lecture peut être ajustée par des commandes.
 
-The user may add actors for the sequence to control.
+L'utilisateur peut ajouter des acteurs pour la séquence à contrôler.
 
-- Reference
-- Camera
-- Entity
-- Item
-- Player
+- Référence
+- Caméra
+- Entité
+- Objet
+- Joueur
 
-## Commands
+## Commandes
 
-Commands are entered into the world's chat console and begin with a forward slash `/`.
+Les commandes sont entrées dans la console de discussion du monde et débutent avec une barre oblique `/`.
 
-- `set <block>`: allows the user to set the blocks in a selection to the specified block.
-- `inventory clear`: allows the user to clear their inventory.
+- `set <block>` : permet à l'utilisateur de transformer les blocs d'une sélection en un bloc spécifié.
+- `inventory clear` : permet à l'utilisateur de vider leur inventaire.
diff --git a/content/docs/fr-FR/established-information/server/content-categories/art-assets.mdx b/content/docs/fr-FR/established-information/server/content-categories/art-assets.mdx
index 5fa63448..229480be 100644
--- a/content/docs/fr-FR/established-information/server/content-categories/art-assets.mdx
+++ b/content/docs/fr-FR/established-information/server/content-categories/art-assets.mdx
@@ -14,7 +14,7 @@ Hytale fournit un support complet pour la modélisation 3D et la création de te
 Hytale utilise **Blockbench** comme outil principal pour la modélisation 3D et les animations :
 
 * **Support officiel** : Utilisé pour « la création de modèles pour Hytale, de textures, et d'animations »
-* **Plugin spécial** : Hytale disposera d'un plugin Blockbench dédié, à publier dès que possible
+* **Special plugin**: Hytale has a dedicated [Blockbench Plugin](https://www.blockbench.net/plugins/hytale_plugin).
 * **Compatibilité directe** : Le plugin permet aux créateurs de « créer des modèles compatibles avec Hytale, des textures, et des animations directement dans Blockbench »
 * **Remplace les anciens outils** : Remplace entièrement l'ancien créateur de modèle de Hytale pour mieux soutenir les workflows créatifs établis dans la communauté
 * **Fonctions de sécurité** : permet uniquement d’ajouter des éléments compatibles avec le moteur du jeu, sans risque de casser quoi que ce soit
@@ -96,7 +96,7 @@ Hytale adopte une approche différente des matériaux par rapport aux autres mot
 
 ## Meilleures pratiques
 
-### Asset Optimization
+### Optimisation des assets
 
 Key considerations from Hytale's development team:
 
diff --git a/content/docs/fr-FR/established-information/server/server-first-dev.mdx b/content/docs/fr-FR/established-information/server/server-first-dev.mdx
index 1ed97a61..3e881941 100644
--- a/content/docs/fr-FR/established-information/server/server-first-dev.mdx
+++ b/content/docs/fr-FR/established-information/server/server-first-dev.mdx
@@ -1,29 +1,28 @@
 ---
-title: Server-First Development
-description: Information regarding what Server-First Development means, and more.
+title: Développement Server-First (Priorité au serveur)
+description: Informations sur ce que signifie le développement Server-First et plus encore.
 ---
 
-Hytale is being developed with a "server-first" approach. This means that the server is considered the authoritative source of game state and logic, while the client primarily handles rendering and user input.
+Hytale est développé avec une approche "Server-First". Ce qui signifie que le serveur est considéré comme la source d'autorité de l'état et de la logique du jeu, alors que le client gère principalement le rendu et les inputs de l'utilisateur.
 
-## What does "Server-First" mean?
+## Qu'est-ce que "Server-First" signifie ?
 
-In a server-first architecture, the server is responsible for managing the game world, enforcing rules, and processing player actions. The client connects to the server to receive updates about the game state and to send player inputs. This approach helps ensure consistency and fairness in multiplayer environments, as the server has control over the game logic.
+Dans une architecture Server-First, le serveur est responsable de la gestion du monde du jeu, de l'application des règles du jeu, et du traitement des actions du joueur. Le client se connecte au serveur pour recevoir les mises à jour de l'état du jeu, et pour envoyer les inputs du joueur. Cette approche permet de s'assurer de la cohérence et l'équité dans les environnements multijoueurs, puisque le serveur a le contrôle sur la logique du jeu.
 
-## Benefits of Server-First Development
+## Les avantages du développement Server-First
 
-* **Consistency**: Since the server is the authoritative source, all players experience the same game state, reducing discrepancies and cheating.
-* **Scalability**: Server-first architectures can be more easily scaled to accommodate large numbers
-  of players, as the server can manage resources and distribute load effectively.
-* **Security**: By centralizing game logic on the server, it becomes more difficult for players to manipulate the game state unfairly.
-* **Easier Updates**: Updates and changes can be made on the server side without requiring players to download new client versions.
-* **Only One Version**: There won't be a version selector for the Hytale Client, meaning that server owners do not need to support multiple versions and can rely on everyone being on the latest client. This will help both server owners and modders.
+* **Cohérence** : Puisque le serveur est la source d'autorité, tous les joueurs font face au même état du jeu, réduisant ainsi les écarts entre eux et la triche.
+* **Extensibilité** : Les architectures Server-First peuvent être plus facilement étendues pour s'adapter à un grand nombre de joueurs, car le serveur peut gérer les ressources et distribuer la charge efficacement.
+* **Sécurité** : En centralisant la logique du jeu sur le serveur, il est plus difficile pour les joueurs de manipuler l'état du jeu de manière injuste.
+* **Mises à jour plus simples** : Les mises à jour et les changements peuvent être faits côté-serveur sans avoir besoin que les joueurs téléchargent de nouvelles versions du client.
+* **Seulement une version** : Il n'y aura pas de sélecteur de version pour le client d'Hytale, ce qui veut dire que les propriétaires de serveurs n'auront pas besoin de supporter plusieurs versions du jeu et pourront compter sur le fait que tout le monde sera sur la dernière version du client. Ce qui aidera non seulement les propriétaires de serveur, mais également les moddeurs.
 
-## Implications for Modding
+## Conséquences pour le modding
 
-Modders will primarily interact with the server-side components of Hytale. This means that mods will often focus on altering game logic, rules, and behaviors that are managed by the server. Client-side modifications are not allowed (as of the information given right now).
+Les moddeurs interagiront principalement avec les composants côté-serveur d'Hytale. Cela signifie que les mods se concentreront souvent sur les modifications de la logique, les règles et des comportements du jeu qui sont gérés par le serveur. Les modifications côté-client ne sont pas permises (au vu des informations connues à ce jour).
 
-Overall, the server-first approach in Hytale aims to create a robust and fair multiplayer experience while providing modders with powerful tools to customize and enhance the game.
+Globalement, l'approche Server-First d'Hytale vise à créer une expérience multijoueur robuste et juste, tout en offrant aux moddeurs des outils puissants pour personnaliser et améliorer le jeu.
 
 ## Conclusion
 
-The server-first development model is a key aspect of Hytale's architecture, ensuring a consistent and secure multiplayer experience. Modders should focus on server-side modifications to fully leverage the capabilities of this approach and create engaging content for players.
+Le modèle de développement Server-First est l'un des aspects clé de l'architecture d'Hytale, garantissant une expérience multijoueur cohérente et sûre. Les moddeurs doivent se concentrer sur les modifications côté-serveur pour tirer pleinement parti des possibilités de cette approche et créer du contenu engageant pour les joueurs.
diff --git a/content/docs/fr-FR/guides/ecs/block-components.mdx b/content/docs/fr-FR/guides/ecs/block-components.mdx
new file mode 100644
index 00000000..ca68b38a
--- /dev/null
+++ b/content/docs/fr-FR/guides/ecs/block-components.mdx
@@ -0,0 +1,247 @@
+---
+title: Block Components
+description: Learn how to use the block components.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+  - name: oskarscot
+    link: https://oskar.scot
+---
+
+# Overview
+
+In this guide, you'll learn how to use block components to create a ticking block.
+
+<Callout>
+  For a more complete reference, you may also want to review FarmingSystems.Ticking, as much of the underlying logic is based on its implementation.
+</Callout>
+
+## Steps
+
+### 1. ExampleBlock - holds block behavior
+
+```java
+public class ExampleBlock implements Component<ChunkStore> {
+
+    public static final BuilderCodec CODEC = BuilderCodec.builder(ExampleBlock.class, ExampleBlock::new).build();
+
+    // Components usually require a copy constructor as well but since we don't actually hold any data in this component this is not neccessary
+    public ExampleBlock() { }
+
+    public static ComponentType getComponentType() {
+        return ExamplePlugin.get().getExampleBlockComponentType();
+    }
+
+    @Nullable
+    public Component<ChunkStore> clone() {
+        return new ExampleBlock();
+    }
+}
+```
+
+ExampleBlock is a custom component that stores the behavior and data for your ticking block. Here, it simply places an Ice Block at x + 1 relative to its current position when it ticks.
+
+---
+
+### 2. ExampleInitializer - marks blocks as ticking when placed
+
+```java
+public class ExampleInitializer extends RefSystem {
+
+    @Override
+    public void onEntityAdded(@Nonnull Ref ref, @Nonnull AddReason reason, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+        BlockModule.BlockStateInfo info = (BlockModule.BlockStateInfo) commandBuffer.getComponent(ref, BlockModule.BlockStateInfo.getComponentType());
+        if (info == null) return;
+
+        ExampleBlock generator = (ExampleBlock) commandBuffer.getComponent(ref, ExamplePlugin.get().getExampleBlockComponentType());
+        if (generator != null) {
+            int x = ChunkUtil.xFromBlockInColumn(info.getIndex());
+            int y = ChunkUtil.yFromBlockInColumn(info.getIndex());
+            int z = ChunkUtil.zFromBlockInColumn(info.getIndex());
+
+            WorldChunk worldChunk = (WorldChunk) commandBuffer.getComponent(info.getChunkRef(), WorldChunk.getComponentType());
+            if (worldChunk != null) {
+				worldChunk.setTicking(x, y, z, true);
+            }
+        }
+    }
+
+    @Override
+    public void onEntityRemove(@Nonnull Ref ref, @Nonnull RemoveReason reason, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+    }
+
+    @Override
+    public Query getQuery() {
+        return Query.and(BlockModule.BlockStateInfo.getComponentType(), ExamplePlugin.get().getExampleBlockComponentType());
+    }
+}
+```
+
+ExampleInitializer is a RefSystem that reacts when block entities with the ExampleBlock component are added or removed. This is crucial for marking blocks as ticking when they're first placed.
+
+**Key Points:**
+
+- Tells the game that this block should tick, allowing `ExampleSystem` to process it.
+
+```java
+worldChunk.setTicking(x, y, z, true);
+```
+
+---
+
+### 3. ExampleSystem - handles ticking
+
+```java
+public class ExampleSystem extends EntityTickingSystem {
+
+    public void tick(float dt, int index, @Nonnull ArchetypeChunk archetypeChunk, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+        BlockSection blocks = (BlockSection) archetypeChunk.getComponent(index, BlockSection.getComponentType());
+
+        assert blocks != null;
+
+        if (blocks.getTickingBlocksCountCopy() != 0) {
+            ChunkSection section = (ChunkSection) archetypeChunk.getComponent(index, ChunkSection.getComponentType());
+
+            assert section != null;
+
+            BlockComponentChunk blockComponentChunk = (BlockComponentChunk) commandBuffer.getComponent(section.getChunkColumnReference(), BlockComponentChunk.getComponentType());
+
+            assert blockComponentChunk != null;
+
+            blocks.forEachTicking(blockComponentChunk, commandBuffer, section.getY(), (blockComponentChunk1, commandBuffer1, localX, localY, localZ, blockId) -> {
+                Ref<ChunkStore> blockRef = blockComponentChunk.getEntityReference(ChunkUtil.indexBlockInColumn(localX, localY, localZ));
+                if (blockRef == null) {
+                    return BlockTickStrategy.IGNORED;
+                } else {
+                    ExampleBlock exampleBlock = (ExampleBlock) commandBuffer1.getComponent(blockRef, ExampleBlock.getComponentType());
+                    if (exampleBlock != null) {
+                        WorldChunk worldChunk = (WorldChunk) commandBuffer.getComponent(section.getChunkColumnReference(), WorldChunk.getComponentType());
+                        World world = worldChunk.getWorld();
+
+                        int globalX = localX + (worldChunk.getX() * 32);
+                        int globalZ = localZ + (worldChunk.getZ() * 32);
+
+                        // We need to execute setBlock on the world thread as you cannot call store functions from a system
+                        // This is because of the architecture of the server, depending on your needs you can also use the CommandBuffer
+                        world.execute(() -> {
+                            world.setBlock(globalX + 1, localY, globalZ, "Rock_Ice");
+                        });
+
+                        return BlockTickStrategy.CONTINUE;
+
+                    } else {
+                        return BlockTickStrategy.IGNORED;
+                    }
+                }
+            });
+        }
+    }
+
+    @Nullable
+    public Query getQuery() {
+        return Query.and(BlockSection.getComponentType(), ChunkSection.getComponentType());;
+    }
+}
+```
+
+ExampleSystem is an EntityTickingSystem that runs every tick to execute the logic for all ticking blocks with the ExampleBlock component.
+
+**Key Points:**
+
+- **Get the block component**
+
+```java
+ExampleBlock exampleBlock = (ExampleBlock) commandBuffer.getComponent(blockRef, ExampleBlock.getComponentType());
+```
+
+- **Convert local chunk coordinates to world coordinates**
+
+```java
+int globalX = localX + (worldChunk.getX() * 32);
+int globalZ = localZ + (worldChunk.getZ() * 32);
+```
+
+- **Run the block logic**
+
+```java
+exampleBlock.runBlockAction(globalX, localY, globalZ, worldChunk.getWorld());
+```
+
+- **Keep the block ticking in the next tick**
+
+```java
+return BlockTickStrategy.CONTINUE;
+```
+
+---
+
+### 4. ExamplePlugin - registers components and systems
+
+```java
+public class ExamplePlugin extends JavaPlugin {
+    protected static ExamplePlugin instance;
+    private static final HytaleLogger LOGGER = HytaleLogger.forEnclosingClass();
+    private ComponentType exampleBlockComponentType;
+
+    public static ExamplePlugin get() {
+        return instance;
+    }
+
+    public ExamplePlugin(@Nonnull JavaPluginInit init) {
+        super(init);
+        LOGGER.atInfo().log("Hello from " + this.getName() + " version " + this.getManifest().getVersion().toString());
+    }
+
+    @Override
+    protected void setup() {
+        instance = this;
+        LOGGER.atInfo().log("Setting up plugin " + this.getName());
+        this.exampleBlockComponentType = this.getChunkStoreRegistry().registerComponent(ExampleBlock.class, "ExampleBlock", ExampleBlock.CODEC);
+    }
+	
+	@Override
+	protected void start() {
+		this.getChunkStoreRegistry().registerSystem(new ExampleSystem());
+		this.getChunkStoreRegistry().registerSystem(new ExampleInitializer());
+	}
+
+    public ComponentType getExampleBlockComponentType() {
+        return this.exampleBlockComponentType;
+    }
+}
+```
+
+---
+
+### 5. Configure In-Game
+
+![block-component-1](/assets/guides/block-component-1.png)
+
+![block-component-2](/assets/guides/block-component-2.png)
+
+With this logic, the block will now continuously place an Ice Block at the coordinates x + 1 relative to its current position every time it ticks.
+
+---
+
+## Common Issues
+
+### NullPointerException on Startup
+
+**Error message:**
+
+```java
+java.lang.NullPointerException: Cannot invoke "com.hypixel.hytale.component.query.Query.validateRegistry(com.hypixel.hytale.component.ComponentRegistry)" because "query" is null
+```
+
+**Cause:**
+This error occurs when your module is loaded **before** the required Hytale modules.
+
+**Fix:**
+Add `EntityModule` and `BlockModule` as dependencies in your `manifest.json` to ensure proper load order.
+
+```json
+"Dependencies": {
+  "Hytale:EntityModule": "*",
+  "Hytale:BlockModule": "*"
+}
+```
diff --git a/content/docs/fr-FR/guides/ecs/hytale-ecs-theory.mdx b/content/docs/fr-FR/guides/ecs/hytale-ecs-theory.mdx
index 20c3a94d..52d8b1f5 100644
--- a/content/docs/fr-FR/guides/ecs/hytale-ecs-theory.mdx
+++ b/content/docs/fr-FR/guides/ecs/hytale-ecs-theory.mdx
@@ -29,7 +29,7 @@ for now this is the basic understanding for the `ChunkStore`. You can use it to
 
 ## Holder
 
-A Holder is essentially a blueprint for an entity. Before an entity exists in the Store (and thus in the world), is exists as a `Holder`. It collects and holds all the necessary components (data). You can compare it analogous to shopping cart. You grab all components you need and once you have everything, check out at the store which will take your cart and create a valid entity ID and hand you back a receipt (a Ref).
+A Holder is essentially a blueprint for an entity. Before an entity exists in the Store (and thus in the world), it exists as a `Holder`. It collects and holds all the necessary components (data). You can compare it analogous to shopping cart. You grab all components you need and once you have everything, check out at the store which will take your cart and create a valid entity ID and hand you back a receipt (a Ref).
 
 Let's take a look at an example: initializing players. In `Universe`, the `addPlayer` method demonstrates it perfectly.
 When a player connects, we don't immediately throw them into the ECS. We first construct their data in a Holder.
@@ -167,7 +167,7 @@ MyComponent comp = commandBuffer.getComponent(ref, componentType);
 
 Codecs handle serialization and deserialization of components. Hytale uses them to save and load entity data to and from disk as well as sending component data over the network. When creating a custom component, you must also create a corresponding Codec.
 
-There are mutliple Codec types already implemented in the default Codec Interface:
+There are multiple Codec types already implemented in the default Codec Interface:
 
 - Codec.STRING
 - Codec.BOOLEAN
@@ -215,7 +215,7 @@ This might seem tedious at first but it ensures that your component can be corre
   KeyedCodec<Integer> exampleInt = new KeyedCodec<Integer>("ExampleIntIdForCodec", Codec.INTEGER);
   ```
 
-- **Setter Function**: This is a lambda function that takes an instance of your component and returns the value of the field you want to serialize. For example, if you have a field called `myCustomField` in your custom component, your getter function would look like this:
+- **Setter Function**: This is a lambda function that takes an instance of your component + the value to set and sets the field value on the component. For example, if you have a field called `myCustomField` in your custom component, your setter function would look like this:
   ```java
   (data, value) -> data.myCustomField = value
   ```
@@ -276,7 +276,7 @@ public class PoisonComponent implements Component<EntityStore> {
 
 You can also add validators to your Codec fields to ensure that the data being serialized/deserialized meets certain criteria. For example, if you want to ensure that the `damagePerTick` field is always non-negative or the poison name is never null, you can add a validator like this:
 
-````java
+```java
 .append(
     new KeyedCodec<Float>("DamagePerTick", Codec.FLOAT),
     (data, value) -> data.damagePerTick = value,
@@ -292,14 +292,15 @@ You can also add validators to your Codec fields to ensure that the data being s
 )
 .addValidator(Validators.nonNull())
 .add()
+```
 
 ### Complex Codec Examples
 
-If you want to have a map inside your component, you can use the MapCodec class to build a KeyedCoded for it. Here's an example of how to create a Codec for a Map field:
+If you want to have a map inside your component, you can use the MapCodec class to build a KeyedCodec for it. Here's an example of how to create a Codec for a Map field:
 
 ```java
 var damagePerTick = new KeyedCodec<>("DamagePerTick", new MapCodec<>(Codec.FLOAT, HashMap<String, Float>::new));
-````
+```
 
 <Callout type="info">
   This also works with custom Objects as long as you have a Codec defined for the Object type.
diff --git a/content/docs/fr-FR/guides/java-basics/00-introduction.mdx b/content/docs/fr-FR/guides/java-basics/00-introduction.mdx
index a03ad638..b0130d74 100644
--- a/content/docs/fr-FR/guides/java-basics/00-introduction.mdx
+++ b/content/docs/fr-FR/guides/java-basics/00-introduction.mdx
@@ -7,7 +7,7 @@ Welcome to your journey into Java Programming! This guide is designed to introdu
 
 ## What is Java?
 
-Java is a powerful, object-oriented programming language created in 1995. It's one of the most popular programming languages in the world and is used for everything from mobile apps to enterprise software. Most importantly for us, it's the language Hytale uses for it's servers & modding API.
+Java is a powerful, object-oriented programming language created in 1995. It's one of the most popular programming languages in the world and is used for everything from mobile apps to enterprise software. Most importantly for us, it's the language Hytale uses for its servers & modding API.
 
 ## What You'll Learn
 
diff --git a/content/docs/fr-FR/guides/java-basics/02-operators.mdx b/content/docs/fr-FR/guides/java-basics/02-operators.mdx
index a132b1c0..18634665 100644
--- a/content/docs/fr-FR/guides/java-basics/02-operators.mdx
+++ b/content/docs/fr-FR/guides/java-basics/02-operators.mdx
@@ -119,7 +119,7 @@ String greetingWithName = "Hello, " + name + "!"; // "Hello, Alice!"
 
 ## Operator Precedence
 
-Operator Precendence means which operator gets evaluated first in an line of code. Think of it like BODMAS/PEMDAS in math!
+Operator Precedence means which operator gets evaluated first in an line of code. Think of it like BODMAS/PEMDAS in math!
 
 ```java
 int result = 10 + 5 * 2; // result is 20, not 30
diff --git a/content/docs/fr-FR/guides/java-basics/03-control-flow-if.mdx b/content/docs/fr-FR/guides/java-basics/03-control-flow-if.mdx
index b9d6c479..af2d1c22 100644
--- a/content/docs/fr-FR/guides/java-basics/03-control-flow-if.mdx
+++ b/content/docs/fr-FR/guides/java-basics/03-control-flow-if.mdx
@@ -7,7 +7,7 @@ Programs need to make decisions. If statements let your code choose different pa
 
 ## Basic If Statement
 
-The simplest form checks one condition;
+The simplest form checks one condition:
 
 ```java
 int health = 20;
diff --git a/content/docs/fr-FR/guides/java-basics/08-access-modifiers.mdx b/content/docs/fr-FR/guides/java-basics/08-access-modifiers.mdx
index af560932..da2bf33b 100644
--- a/content/docs/fr-FR/guides/java-basics/08-access-modifiers.mdx
+++ b/content/docs/fr-FR/guides/java-basics/08-access-modifiers.mdx
@@ -484,7 +484,7 @@ class Data {
     // Static member:
     // cannot access to non-static variables
     public static void bar() {
-        x = 100; // Error: non-static variable x cannot be renference from a static context
+        x = 100; // Error: non-static variable x cannot be referenced from a static context
         y = 100; // OK
     }
 }
@@ -504,7 +504,7 @@ Data.x = 1000; // Error: cannot access instanced variables in a static context
 
 ### Static Fields
 
-A static field represents a data member owned by the class type rather then the object. Static fields are also stored in a specific memory location that's been shared between all the object instances that are created.
+A static field represents a data member owned by the class type rather than the object. Static fields are also stored in a specific memory location that's been shared between all the object instances that are created.
 
 It is declared as following:
 
diff --git a/content/docs/fr-FR/guides/learning-to-learn.mdx b/content/docs/fr-FR/guides/learning-to-learn.mdx
index 567e514e..d9467057 100644
--- a/content/docs/fr-FR/guides/learning-to-learn.mdx
+++ b/content/docs/fr-FR/guides/learning-to-learn.mdx
@@ -1,37 +1,37 @@
 ---
-title: Learning to Learn
-description: A guide to help you become a better learner and adapt to new information effectively.
+title: Apprendre à apprendre
+description: Un guide pour vous aider à devenir un meilleur apprenant et vous adapter efficacement aux nouvelles informations.
 icon: CircleQuestionMark
 ---
 
-## Why learn to code? We have visual scripting!
+## Pourquoi apprendre à coder ? Nous avons le visual scripting !
 
-Yes we do, and honestly you should try that out. Visual scripting is a great addition to Hytale and we know it'll be powerful, but nothing beats the ability of being able to read and write Java code, with the ability to build even more powerful mods and plugins.
+Oui nous l'avons, et honnêtement vous devriez l'essayer. Le visual scripting est un excellent ajout à Hytale et nous savons qu'il sera puissant, mais rien ne bat la capacité à savoir lire et écrire du code Java, avec la possibilité de construire des mods et des plugins encore plus puissants.
 
-<Callout type="info" title="Visual Scripting vs Coding">
-  Visual scripting is great for beginners and for simple tasks, but coding allows for more complex and efficient solutions. Learning to code opens up a wider range of possibilities for modding Hytale.
+<Callout type="info" title="Visual Scripting vs Codage">
+  Le visual scripting est excellent pour les débutants et pour les tâches simples, mais coder permet des solutions plus complexes et efficaces. Apprendre à coder ouvre une plus grande variété de possibilités pour modder Hytale.
 
-  We will have guides on visual scripting when Hytale releases from Day 1.
+  Nous aurons des guides sur le visual scripting lorsqu'Hytale sortira dès le jour 1.
 </Callout>
 
-## Should everyone trying to mod Hytale learn how to code?
+## Est-ce que tous ceux qui veulent modder Hytale devraient apprendre comment coder ?
 
-No one should feel like they HAVE to learn to code to make stuff in Hytale. Simon and his team have validated this time and time again with their strives in graph editors and visual scripting. You can change mob behavior, world generation, etc. all with just these tools.
+Personne ne devrait se dire qu'ils ont BESOIN d'apprendre à coder pour faire des choses dans Hytale. Simon et son équipe l'ont confirmé à maintes reprises avec leurs efforts sur les éditeurs graphiques et le visual scripting. Vous pouvez changer le comportement des mobs, la génération du monde, etc. Tout ça avec juste ces outils.
 
-But if you're looking to build more complex things (from utilities to entirely custom server software) that could be used by large scale server networks and big names, you'll want to learn how to code. And that's where this guide comes in...
+Mais si vous recherchez à construire des choses plus complexes (de l'utilitaire au logiciel de serveur entièrement personnalisé) qui pourraient être utilisés par de grands réseaux de serveurs et des gros noms, vous voudrez apprendre à coder. Et c'est là que ce guide entre en jeu...
 
-## Okay, I'm interested. What's to come?
+## Ok, je suis intéressé. Qu'est-ce qui m'attend ?
 
-Over the course of these next several lessons you'll learn the basics of coding, how to read documentation, and how to find resources to help you learn more on your own.
+Au cours de ces prochaines leçons, vous allez apprendre les bases de la programmation, comment lire de la documentation, et comment trouver des ressources pour vous aider à apprendre davantage par vous-même.
 
-The guides themselves will take a very big "bird's-eye view" approach to things and provide links to resources to do the actual coding. This is done because, quite frankly, enough resources exist on how to learn this stuff, it's just the act of finding the right stuff on Google that can be hard. Learning to be able to code without guidance is the goal. The Hytale Modding community is always there to help you, but to become a truly well rounded developer, you'll have to pick up a lot of this stuff just by reading from resources.
+Les guides eux-mêmes, prendront une approche "vue aérienne" des choses et vous offriront des liens vers les ressources pour faire le code. Nous faisons tout ça parce que, franchement, suffisamment de ressources existent sur comment apprendre tout cela, c'est l'action de trouver les bonnes choses sur Google qui peut être dur. Apprendre à être capable de coder sans conseils est l'objectif. La communauté de Hytale Modding est toujours là pour vous aider, mais pour devenir un développeur équilibré, vous allez devoir récupérer beaucoup de choses simplement en lisant des ressources.
 
-<Callout type="info" title="Finding Resources">
-  We have created a small Java Basics series to help you get started with the language itself, but beyond that, you'll be expected to find your own resources to learn more. We recommend sites like [w3schools](https://www.w3schools.com/java/) and [GeeksforGeeks](https://www.geeksforgeeks.org/java/) as great starting points.
+<Callout type="info" title="Trouver des ressources">
+  Nous avons créé une petite série de bases Java pour vous aider à commencer avec le langage lui-même, mais au-delà, vous pourrez trouver vos propres ressources pour en apprendre davantage. Nous recommandons des sites comme [w3schools](https://www.w3schools.com/java/) et [GeeksforGeeks](https://www.geeksforgeeks.org/java/) comme bons points de départ.
 </Callout>
 
-Our goal is to teach you how to Mod Hytale, and that will always be our goal. This is the reason we can't teach you everything about Java or programming in general. Instead, we want to give you the tools to be able to learn on your own, so you can continue to grow as a developer even after you've completed our guides.
+Notre but est de vous apprendre à modder Hytale, et ce sera toujours notre objectif. C'est la raison pour laquelle nous ne pouvons pas tout vous apprendre sur Java ou la programmation en général. A la place, nous voulons vous donner les outils pour être capables d'apprendre par vous-même, pour que vous puissiez continuer à grandir en tant que développeur même après avoir complété nos guides.
 
-## Any closing thoughts?
+## Quelques mots pour conclure ?
 
-Remember, learning to code is hard. You will trip and fall, but you will be able to get back up. Stay resilient, believe you can make cool stuff, and I promise you success will come. Happy coding!
+Souvenez-vous, apprendre à coder est difficile. Vous allez trébucher et tomber, mais vous serez capable de vous relever. Restez résilient, croyez au fait que vous pouvez faire des choses superbes, et je vous promets que le succès viendra. Bon code !
diff --git a/content/docs/fr-FR/guides/plugin/animated-block-textures.mdx b/content/docs/fr-FR/guides/plugin/animated-block-textures.mdx
new file mode 100644
index 00000000..42bfa51f
--- /dev/null
+++ b/content/docs/fr-FR/guides/plugin/animated-block-textures.mdx
@@ -0,0 +1,101 @@
+---
+title: Animated Block Textures
+description: Learn how to attach a .blockyanim to a block
+authors:
+  - name: Burkino
+---
+
+import { File, Folder, Files } from 'fumadocs-ui/components/files';
+
+So, you want to make your blocks feel more alive through animations, do you?\
+Now for the most part this is the exact same as [Creating custom blocks](./creating-block).
+![blue fire gif](/assets/guides/blue_fire.gif)
+
+## Prerequisites
+
+This is NOT a guide on animating or texturing or even using BlockBench, why? Because I don't know how to do that.\
+The only thing we will be doing is taking the fire texture, changing the color, and applying it to our new fire block.
+
+## Setup
+
+To start, you're obviously going to want to grab the `Common/VFX/Fire/Fire.png` file. How you do it is up to you, in the Asset Editor you'll need to switch to the Common tab.\
+I'll assume you know how colorize or change the hue of an image, so go ahead and do that now and save it as `Blue_Fire.png`.
+
+The other assets used in this guide are `Common/VFX/Fire/Fire.blockymodel` and `Common/Blocks/Animations/Fire/Fire_Burn.blockyanim` (both renamed to `Blue_Fire`) but since we won't be changing them it's probably fine to leave them. I will reference the `Blue_Fire` versions as a way to point out what should be custom assets.\
+I will also duplicate `Server/Item/Item/Deco/Deco_Fire.json` and call it `Deco_Blue_Fire.json`.
+
+## Applying the changes
+
+The `Deco_Blue_Fire` block is actually just a particle emitter, however we will not be using particles, so lets start by removing them in `Block > Particles`.\
+Next we want to set the Block Model (called `CustomModel` in JSON) to `VFX/Blue_Fire/Blue_Fire.blockymodel` and Block Model Textures (`CustomModelTexture` in JSON) to
+
+```json
+[
+    {
+        "Texture": "VFX/Blue_Fire/Blue_Fire.png",
+        "Weight": 1
+    }
+]
+```
+
+Finally, we will apply the .blockyanim to our model, this is done through the Block Model Animation property (`CustomModelAnimation` in JSON) and the value should be `Blocks/Animations/Blue_Fire/Blue_Fire_Burn.blockyanim`.
+
+## Final Code
+
+With that your new blue fire should be done. Here is the minimal JSON for our blue fire.\
+There is an additional `Looping` and `RequiresAlphaBlending` property that I have not gone over, however I hope it is self-explanatory.
+
+```json
+{
+  "BlockType": {
+    "DrawType": "Model",
+    "CustomModel": "VFX/Blue_Fire/Blue_Fire.blockymodel",
+    "CustomModelAnimation": "Blocks/Animations/Blue_Fire/Blue_Fire_Burn.blockyanim",
+    "CustomModelTexture": [
+      {
+        "Texture": "VFX/Blue_Fire/Blue_Fire.png",
+        "Weight": 1
+      }
+    ],
+    "Looping": true,
+    "RequiresAlphaBlending": false
+  },
+  "PlayerAnimationsId": "Block"
+}
+```
+
+<Files>
+  <Folder name="resources" defaultOpen>
+    <Folder name="Server" defaultOpen>
+      <Folder name="Item" defaultOpen>
+        <Folder name="Items" defaultOpen>
+          <Folder name="Deco" defaultOpen>
+            <File name="Deco_Blue_Fire.json" />
+          </Folder>
+        </Folder>
+      </Folder>
+    </Folder>
+
+    <Folder name="Common" defaultOpen>
+      <Folder name="Blocks" defaultOpen>
+        <Folder name="Animations" defaultOpen>
+          <Folder name="Blue_Fire" defaultOpen>
+            <File name="Blue_Fire_Burn.blockyanim" />
+          </Folder>
+        </Folder>
+      </Folder>
+
+      <Folder name="VFX" defaultOpen>
+        <Folder name="Blue_Fire" defaultOpen>
+          <File name="Blue_Fire.blockymodel" />
+
+          <File name="Blue_Fire.png" />
+        </Folder>
+      </Folder>
+    </Folder>
+  </Folder>
+</Files>
+
+## Next steps
+
+Now that you know how to attach an animation to a block, try adding it to a block state.
diff --git a/content/docs/fr-FR/guides/plugin/build-and-test.mdx b/content/docs/fr-FR/guides/plugin/build-and-test.mdx
index 0e7fe7eb..f37534c3 100644
--- a/content/docs/fr-FR/guides/plugin/build-and-test.mdx
+++ b/content/docs/fr-FR/guides/plugin/build-and-test.mdx
@@ -9,18 +9,18 @@ If you followed along with the [Setting Up Your Development Environment](./setti
 
 ## Building Your Mod
 
-In our case, we've **Maven** as the build system. Maven is a powerful build automation tool that manages dependencies, compiles your code, and packages everything into a distributable JAR file.
+In our case, we've **Gradle** as the build system. Gradle is a powerful build automation tool that manages dependencies, compiles your code, and packages everything into a distributable JAR file.
 
-### Understanding Maven
+### Understanding Gradle
 
-Maven uses a `pom.xml` file (Project Object Model) to define your project's configuration, dependencies, and build settings. You can learn more about Maven at the [official Apache Maven website](https://maven.apache.org/).
+Gradle can use a `build.gradle.kts` file (Kotlin DSL) to define your project's configuration, dependencies, and build settings. You can learn more about Gradle at the [official Gradle website](https://gradle.org/).
 
-### Building with Maven
+### Building with Gradle
 
 To build your mod, open a terminal in your project directory and run:
 
 ```bash
-mvn package
+./gradlew build
 ```
 
 This command will:
@@ -29,16 +29,35 @@ This command will:
 2. Run any tests (if present)
 3. Package everything into a JAR file
 
+<Callout type="info">
+  If you are using the plugin template from the [Setting Up Your Development Environment](./setting-up-env) guide, then the build script is already set up for you. It includes paths to your Hytale game library and handles the packaging of your mod, managing hytale dependencies and manifest changes.
+
+  If you have a different path to your Hytale installation, you may receive the following error:
+
+  ```bash
+  FAILURE: Build failed with an exception.
+
+  * What went wrong:
+  Failed to find Hytale at the expected location. Please make sure you have installed the game. The expected location can be changed using the hytale.home_path property. Currently looking in 'C:\Path\To\Hytale'
+  ```
+
+  You can change the path by adding a property to your `gradle.properties` file (if it doesn't exist, create it in the root of your project):
+
+  ```properties
+  hytale.home_path=C:\Correct\Path\To\Hytale
+  ```
+</Callout>
+
 ### Build Output
 
-Once the build completes successfully, your mod will be located in the `target` directory and named:
+Once the build completes successfully, your mod will be located in the `build/libs` directory and named:
 
 ```
-ExamplePlugin-1.0-SNAPSHOT.jar
+ExamplePlugin-1.0.jar
 ```
 
 <Callout type="info">
-  The exact name may vary depending on what you configured in your `pom.xml` file. Check the `artifactId` and `version` fields to see what your JAR will be named.
+  The exact name may vary depending on what you configured in your `build.gradle.kts` and `settings.gradle.kts` file. Check the `rootProject.name` and `version` fields to see what your JAR will be named.
 </Callout>
 
 ## Testing Your Mod
@@ -49,11 +68,11 @@ Now that you've built your mod, it's time to test it in Hytale!
 
 First, you need to find Hytale's mods directory:
 
-1. Press **Win + R** on your keyboard
-2. Type `%appdata%` and press Enter
-3. Navigate to: `Hytale\UserData\Mods`
+1. Go to your Hytale installation directory (The default location is usually in your AppData folder)
+   > On Windows, you can access it by clicking `windows + R` and typing `%appdata%`.
+2. Navigate to: `/UserData/Mods`
 
-The full path should look like:
+The default path would look like:
 
 ```
 C:\Users\YourUsername\AppData\Roaming\Hytale\UserData\Mods
@@ -65,7 +84,7 @@ C:\Users\YourUsername\AppData\Roaming\Hytale\UserData\Mods
 
 ### 2. Copy Your Mod
 
-Copy the `ExamplePlugin-1.0-SNAPSHOT.jar` file from your project's `target` directory into the `Mods` folder you just located.
+Copy the `ExamplePlugin-1.0.jar` file from your project's `build/libs` directory into the `Mods` folder you just located.
 
 ### 3. Launch Hytale and Verify
 
@@ -84,7 +103,7 @@ If your mod doesn't appear in the mods list:
 - Make sure the JAR file is in the correct `Mods` folder
 - Check that your `manifest.json` file is properly configured
 - Look for any error messages in the Hytale logs
-- Verify that you're using the correct version of Java and Maven
+- Verify that you're using the correct version of Java and Gradle
 
 ## Next Steps
 
diff --git a/content/docs/fr-FR/guides/plugin/creating-commands.mdx b/content/docs/fr-FR/guides/plugin/creating-commands.mdx
index d33597f3..08572f16 100644
--- a/content/docs/fr-FR/guides/plugin/creating-commands.mdx
+++ b/content/docs/fr-FR/guides/plugin/creating-commands.mdx
@@ -8,6 +8,8 @@ authors:
     url: https://oskar.scot
   - name: jacobwojoski
     url: https://github.com/jacobwojoski
+  - name: Marcel-TO
+    url: https://marcel-to.net
 ---
 
 In this guide, you will learn how to create custom commands for your Hytale mod.
@@ -36,7 +38,7 @@ The most basic command is an `AbstractAsyncCommand`. It has very minimal data av
   `AbstractAsyncCommand` runs on its own background thread. This means its execute is not tied to any world instance and because of this it can not edit any **Stores** or **Refs** without getting the desired world first. To access this data any of the other command types would be preferred and are likely what you will want to use instead.
 </Callout>
 
-The main purpose for a command like this would be for something that can happen everywhere and is not tied to a specific world. For example a `serverRules` command to tell the user thats running the command in chat what the servers rules are nomatter what world they are in.
+The main purpose for a command like this would be for something that can happen everywhere and is not tied to a specific world. For example a `serverRules` command to tell the user that's running the command in chat what the server's rules are no matter what world they are in.
 
 ```java
 // Command that can be run that lists the server rules in chat to the player
@@ -49,7 +51,7 @@ public class ServerRulesCommand extends AbstractAsyncCommand {
     }
 
     // Run the command
-    // conetext - info about who ran the command. Server console?, Some player?
+    // context - info about who ran the command. Server console?, Some player?
     @Override
     protected CompletableFuture<Void> executeAsync(@Nonnull CommandContext context) {
         context.sendMessage(Message.raw("The only rule is there are no rules."));
@@ -134,7 +136,7 @@ Uses a Ray to see what the player is looking at and tries to run the command on
 
 ## Adding Arguments
 
-Arguments are additional fields that the user can input when running a command. The different types of arguments along with small snipits and a large example can be seen below.
+Arguments are additional fields that the user can input when running a command. The different types of arguments along with small snippets and a large example can be seen below.
 
 ### Command Argument Types
 
@@ -163,14 +165,14 @@ this.messageArg = this.withOptionalArg("message", "Message to print while healin
 
 ### Default Arguments
 
-Adding a default argument has two additional arguemnt for the default value and default value description. You need to use `withDefaultArg` method.
+Adding a default argument has two additional argument for the default value and default value description. You need to use `withDefaultArg` method.
 
 ```java
 // args <Command String> <Description> <Default Value> <Desc of default value>
 this.healthArg = this.withDefaultArg("health", "Amount to heal player", ArgTypes.FLOAT, (float)100, "Desc of Default: 100");
 ```
 
-### Flag Arguemnts
+### Flag Arguments
 
 Similar as above but the flags return is either true if it exists or false if it does not. You need to use `withFlagArg` method.
 
@@ -181,20 +183,13 @@ this.debugArg = this.withFlagArg("debug", "Add debug logs");
 
 ### ArgTypes
 
-The following ArgTypes are available (only lists common types):
-
-- `ArgTypes.STRING`
-- `ArgTypes.INTEGER`
-- `ArgTypes.BOOLEAN`
-- `ArgTypes.FLOAT`
-- `ArgTypes.DOUBLE`
-- `ArgTypes.UUID`
+You can find all the available argument types on the [ArgTypes](../../argtypes) page.
 
 ### Example Command Arg Types
 
-Shows all Command arguemnt types with different various input types.
+Shows all Command argument types with different various input types.
 
-**NOTE:** When getting the value of an argument during execute you need to pass the context with `someArg.get(commandContext)`. Where `commandContext` is the first variable in the execute funtion.
+**NOTE:** When getting the value of an argument during execute you need to pass the context with `someArg.get(commandContext)`. Where `commandContext` is the first variable in the execute function.
 
 ```java
 // Example usage: /healplayer --health 50 --message "Feels Good" --debug
@@ -204,7 +199,7 @@ public class HealPlayerCommand extends AbstractTargetPlayerCommand {
     private final FlagArg debugArg;
 
     public HealPlayerCommand() {
-        super("healplayer", "Healing a player for an <input> ammount of HP (default: 100)");
+        super("healplayer", "Healing a player for an <input> amount of HP (default: 100)");
 
         // Abstract TargetPlayerCommand passes the player that ran the command by default and implements
         // the use of `--player <value>` to specify someone else
@@ -213,10 +208,10 @@ public class HealPlayerCommand extends AbstractTargetPlayerCommand {
         this.healthArg = this.withDefaultArg("health", "Amount to heal player", ArgTypes.FLOAT, (float)100, "Desc of Default: 100");
 
         // Or you could do the following making the health value required instead of with a default.
-        //    You would need to change the decleration to RequiredArg<Float>
+        //    You would need to change the declaration to RequiredArg<Float>
         // this.healthArg = this.withRequiredArg("health", "Amount to heal player", ArgTypes.FLOAT);
 
-        // Optional args reguare the user the input `--<key> <value>` so the following would require `--message "Good Luck"`
+// Optional args require the user the input `--<key> <value>` so the following would require `--message "Good Luck"`
         this.messageArg = this.withOptionalArg("message", "Message to print while healing", ArgTypes.STRING);
 
         // No type needed due to being a bool
@@ -230,7 +225,7 @@ public class HealPlayerCommand extends AbstractTargetPlayerCommand {
             commandContext.sendMessage(Message.raw("We are debugging"));
         }
 
-        // Health is stored in a generic stat map to allowing mods/future contect to easily add more stats if desired.
+        // Health is stored in a generic stat map to allowing mods/future content to easily add more stats if desired.
         EntityStatMap stats = store.getComponent(ref, EntityStatMap.getComponentType());
         int healthIdx = DefaultEntityStatTypes.getHealth();
         EntityStatValue health = stats.get(healthIdx);
@@ -252,7 +247,7 @@ public class HealPlayerCommand extends AbstractTargetPlayerCommand {
 
 ## Argument Validators
 
-Argument validators are a way to check the command before the command gets executed. They are added with the `addValidator` method on an argument when calling `withXxxArg`. They provide a nice output to the user when an input value is invalid.
+Argument validators are a way to check the command before the command gets executed. They are added with the `addValidator` method on an argument when calling `withXxxArg`. They provide a nice output to the user when an input value is invalid. There are some common validators provided in the `Validators` class such as `greaterThan`, `lessThan`, and `or`, `max`, `range`, etc.
 
 ```java
 ...
@@ -260,18 +255,59 @@ Argument validators are a way to check the command before the command gets execu
     OptionalArg<Integer> healAmount = withOptionalArg("amount", "Heal Amount", ArgTypes.INTEGER)
         .addValidator(Validators.greaterThan(0))
         .addValidator(Validators.lessThan(1000));
-
-    // Custom check example
-    OptionalArg<Integer> healAmount = withOptionalArg("amount", "Heal Amount", ArgTypes.INTEGER)
-            .addValidator( value -> {
-                if (value != null && value <= 0) {
-                    return ValidationResult.error("ammount argument must be a positive number");
-                }
-                return ValidationResult.success();
-            });
 ...
 ```
 
+### Custom Validators
+
+You can also create custom validators by implementing the `com.hypixel.hytale.codec.validation.Validator` interface. The interfaces forces you to implement the `accept` and `updateSchema` method. The `accept` method takes in the argument value and validates it. If the validation fails, you can use the `fail` method of the `com.hypixel.hytale.codec.validation.ValidationResults` class to return an error message.
+The `updateSchema` method is used to update the schema of the command argument. This is used for commands that have dynamic schemas based on the input value. For example, if you have a command that takes in a player name as an argument, you can use the `updateSchema` method to update the schema to include a list of online players for validation.
+
+Here is an example of a custom validator that checks if a string value is equal to a banned word. In this example, the banned word is "badword". If the input value is "badword", the validator will fail and return an error message.
+
+```java
+import com.hypixel.hytale.codec.schema.SchemaContext;
+import com.hypixel.hytale.codec.schema.config.Schema;
+import com.hypixel.hytale.codec.validation.ValidationResults;
+import com.hypixel.hytale.codec.validation.Validator;
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+
+public class MyCustomValidator implements Validator<String> {
+    @Nonnull
+    private final String value;
+
+    public MyCustomValidator(@Nonnull String value) {
+        this.value = value;
+    }
+
+    @Override
+    public void accept(@Nullable String input, @Nonnull ValidationResults results) {
+        if (this.value.equalsIgnoreCase(input)) {
+            results.fail("The given role has been banned.");
+        }
+    }
+
+    @Override
+    public void updateSchema(SchemaContext context, @Nonnull Schema target) {
+        // This method can be used to update the schema of the command argument. This is useful for commands that have dynamic schemas based on the input value. For example, if you have a command that takes in a player name as an argument, you can use the `updateSchema` method to update the schema to include a list of online players for validation.
+        throw new UnsupportedOperationException("Not implemented yet.");
+    }
+}
+```
+
+After the custom validator is created, you can add it to an argument like the following example. In this example, we add the `MyCustomValidator` to a string argument called "role". If the user inputs "badword" as the role, the command will fail and return the error message defined in the `MyCustomValidator`.
+
+```java
+    ...
+    // Custom validator example
+    String bannedRole = "badword";
+
+    OptionalArg<String> roleArg = withOptionalArg("role", "Role to assign", ArgTypes.STRING)
+        .addValidator(new MyCustomValidator(bannedRole));
+    ...
+```
+
 ---
 
 ## Permissions
@@ -312,7 +348,7 @@ This allows the server to control who has access to specific commands. You add t
 
 If you want variants of the same command without doing argument parsing you can instead use `addUsageVariant(new OtherCommandClass())` in the original commands constructor.
 
-The only difference is in the `OtherCommandClass()` constrcutor you don't pass the command name to the super class.
+The only difference is in the `OtherCommandClass()` constructor you don't pass the command name to the super class.
 
 <Callout type="info">
   You can also use `addAliases("some_alias", "some_other_alias")` as a way to add shorthand or other ways to write the same command.
@@ -387,7 +423,7 @@ public class AdminCommand extends AbstractCommandCollection {
     public AdminCommand () {
         super("admin", "Admin commands");
         addSubCommand(new UserCommandCollection());
-        addSybCommand(new ServerCommandCollection);
+        addSubCommand(new ServerCommandCollection);
     }
 }
 ```
@@ -417,5 +453,5 @@ public class MyPlugin extends JavaPlugin {
 
 ## Video Link
 
-_Special Thanks to [TroubleDev](https://www.youtube.com/@TroubleDEV) for his excelent video guide on all of these features._
+_Special Thanks to [TroubleDev](https://www.youtube.com/@TroubleDEV) for his excellent video guide on all of these features._
 _Video Link: [TroubleDev - Hytale's Command API Explained](https://www.youtube.com/watch?v=KnmhG9MDMgo)_
diff --git a/content/docs/fr-FR/guides/plugin/creating-events.mdx b/content/docs/fr-FR/guides/plugin/creating-events.mdx
index 95863990..d3f0925d 100644
--- a/content/docs/fr-FR/guides/plugin/creating-events.mdx
+++ b/content/docs/fr-FR/guides/plugin/creating-events.mdx
@@ -1,6 +1,6 @@
 ---
-title: Creating Events
-description: Learn how to create custom events for your Hytale mod.
+title: Creating Events Listeners
+description: Learn how to create event listeners for your Hytale mod.
 authors:
   - name: Neil Revin
     url: https://itsneil.dev
@@ -10,7 +10,7 @@ authors:
 
 ## Event Class
 
-You can import a Event class and create a function with the Event as a argument. [Click here](../../server/events) to look at all available events.
+You can import an Event class and create a function with the Event as an argument. [Click here](../../server/events) to look at all available events.
 
 Example plugin when a player is ready (joins a server):
 
diff --git a/content/docs/fr-FR/guides/plugin/inventory-management.mdx b/content/docs/fr-FR/guides/plugin/inventory-management.mdx
index e38c644f..11d6965c 100644
--- a/content/docs/fr-FR/guides/plugin/inventory-management.mdx
+++ b/content/docs/fr-FR/guides/plugin/inventory-management.mdx
@@ -1,125 +1,109 @@
 ---
-title: Inventory Management
-description: Learn how to manage player inventories in your Hytale mod.
+title: Gestion de l'inventaire
+description: Apprenez à gérer les inventaires des joueurs dans votre mod Hytale.
 authors:
-  - name: Neil Revin
-    url: https://itsneil.dev
+  - name: ""
+    url: ""
 ---
 
-In this guide, you'll learn how to manage player inventories in your Hytale mod.
+Dans ce guide, vous apprendrez à gérer les inventaires des joueurs dans votre mod Hytale.
 
-## Accessing the Player Inventory
+## Accéder à l'inventaire du joueur
 
-To access the Inventory of a `Player`, you can use the `getInventory()` method which returns the `Inventory` object.
+Vous pouvez accéder à l'inventaire d'un joueur de type `Player` avec la méthode `getInventory()` qui donnent un objet de type `Inventory`.
 
 ```java
-Inventory inventory = player.getInventory();
 ```
 
-## Opening Inventories
+## Ouverture des inventaires
 
-You can open different types of inventories, these inventories are known as "Pages". You can also add custom pages, this will be covered in a guide later on.
+Vous pouvez ouvrir différents types d'inventaires, ces inventaires sont appelés "Pages". Vous pouvez également ajouter des pages personnalisées, qui seront couvertes dans un guide plus tard.
 
-You can use the `Page` enum to reference existing inventories, currently the following pages are available:
+Vous pouvez utiliser l'énumération `Page` pour référencer les inventaires existants, actuellement les pages suivantes sont disponibles:
 
-- `Page.None`
-- `Page.Bench`
-- `Page.Inventory`
-- `Page.ToolsSettings`
-- `Page.Map`
-- `Page.MachinimaEditor`
-- `Page.ContentCreation`
-- `Page.Custom`
+-
+-
+-
+-
+-
+-
+-
+-
 
 ```java
-PageManager pageManager = player.getPageManager();
-Store<EntityStore> store = player.getWorld().getEntityStore().getStore();
-pageManager.setPage(player.getReference(), store, Page.Inventory);
 ```
 
-## `ItemStack` Class
+## Classe `ItemStack`
 
-You can create and manipulate items in a player's inventory using the `ItemStack` class. This class represents a stack of items, and provides methods for managing the quantity and type of items in the stack.
+Vous pouvez créer et manipuler des objets dans l'inventaire d'un joueur en utilisant la classe `ItemStack`. Cette classe représente une pile d'objets, et fournit des méthodes pour gérer la quantité et le type des objets dans la pile.
 
-### Creating an ItemStack
+### Création d'un ItemStack
 
-To create an `ItemStack`, you need to specify the material type and the quantity of items in the stack.
+Pour créer un `ItemStack`, vous devez spécifier le type de matériau et la quantité d'éléments dans la pile.
 
 ```java
-ItemStack item = new ItemStack("Stone");
+ItemStack item = new ItemStack("Stone"); 
 ItemStack withQuantity = new ItemStack("Stone", 64);
 ```
 
-#### Adding custom metadata
+#### Ajout de métadonnées personnalisées
 
-You can also add custom metadata to a `ItemStack` by passing a `BsonDocument` when creating it.
+Vous pouvez également ajouter des métadonnées personnalisées à un `ItemStack` en passant un `BsonDocument` lors de sa création.
 
 ```java
-BsonDocument metadata = new BsonDocument();
-metadata.append("customData", new BsonString("value"));
-ItemStack item = new ItemStack("Stone", 64, metadata);
 ```
 
-### Setting a durability
+### Définir une durabilité
 
 ```java
-ItemStack stackWithDurability = new ItemStack(
-    "DiamondSword", // itemId
-    1,              // quantity
-    100.0,          // durability
-    100.0,          // maxDurability
-    metadata        // metadata (optional)
-);
 ```
 
-## Getting the `ItemContainer`
+## Obtention du `ItemContainer`
 
-The `Inventory` class provides methods to get multiple `ItemContainer` objects, like:
+La classe `Inventory` fournit des méthodes pour obtenir plusieurs objets `ItemContainer`, comme:
 
-- `.getStorage()`
-- `.getArmor()`
-- `.getBackpack()`
-- `.getHotbar()`
-- `.getUtility()`
+-
+-
+-
+-
+-
 
-There are also combined methods like:
+Il existe également des méthodes combinées comme:
 
-- `.getCombinedEverything()`
-- `.getCombinedArmorHotbarStorage()`
-- `.getCombinedBackpackStorageHotbar()`
-- `.getCombinedHotbarFirst()`
-- `.getCombinedStorageFirst()`
-- `.getCombinedArmorHotbarUtilityStorage()`
-- `.getCombinedHotbarUtilityConsumableStorage()`
+-
+-
+-
+-
+-
+-
+-
 
-## Adding `ItemStack` objects to the Inventory
+## Ajout d'objets `ItemStack` à l'Inventaire
 
-To add an `ItemStack` to a player's inventory, you can use the `addItemStack()` method of the `ItemContainer` class.
+To add an `ItemStack` to a player's inventory, you can use the `addItemStack()` method of the `Inventory` class.
 
 ```java
 Inventory inventory = player.getInventory();
-ItemContainer storageContainer = inventory.getStorage();
-storageContainer.addItemStack(item);
+inventory.addItemStack(item);
 ```
 
-Or you can specify a certain slot to add it to:
+Ou vous pouvez spécifier un certain emplacement à ajouter à :
 
 ```java
-storageContainer.addItemStackToSlot((short) 4, stack)
+inventory.addItemStackToSlot((short) 4, stack)
 ```
 
-## Removing `ItemStack` objects from the Inventory
+## Suppression d'objets `ItemStack` de l'inventaire
 
-To remove an `ItemStack` from a player's inventory, you can use the `removeItemStack()` method of the `Inventory` class.
+Pour supprimer un `ItemStack` de l'inventaire d'un joueur, vous pouvez utiliser la méthode `removeItemStack()` de la classe `Inventory`.
 
 ```java
 Inventory inventory = player.getInventory();
-ItemContainer storageContainer = inventory.getStorage();
-storageContainer.removeItemStack(item);
+inventory.removeItemStack(item);
 ```
 
-Or you can specify a certain slot to remove it from:
+Ou vous pouvez spécifier une case spécifique depuis laquelle faire la supression:
 
 ```java
-storageContainer.removeItemStackFromSlot((short) 4);
+inventory.removeItemStackFromSlot((short) 4);
 ```
diff --git a/content/docs/fr-FR/guides/plugin/item-registry.mdx b/content/docs/fr-FR/guides/plugin/item-registry.mdx
new file mode 100644
index 00000000..9a0fd53a
--- /dev/null
+++ b/content/docs/fr-FR/guides/plugin/item-registry.mdx
@@ -0,0 +1,95 @@
+---
+title: Working with the Item Registry
+description: Learn how to access and query the game's item registry to list all items, check if items exist, and retrieve item properties.
+authors:
+  - name: Denis
+---
+
+In this guide, you'll learn how to work with Hytale's Item Registry system. This is useful when you need to programmatically list all available items, validate item IDs, or retrieve item properties at runtime.
+
+## Prerequisites
+
+Before diving in, you should be familiar with:
+
+- [Setting up your development environment](./setting-up-env)
+- [Creating commands](./creating-commands) (optional, for testing)
+
+## Required Imports
+
+To work with the Item Registry, you'll need the following imports:
+
+```java
+import com.hypixel.hytale.assetstore.map.DefaultAssetMap;
+import com.hypixel.hytale.server.core.asset.type.item.config.Item;
+```
+
+## Getting the Item Registry
+
+The Item Registry is accessed through the `Item.getAssetMap()` method, which returns a `DefaultAssetMap<String, Item>` containing all registered items in the game:
+
+```java
+DefaultAssetMap<String, Item> itemMap = Item.getAssetMap();
+```
+
+## Listing All Items
+
+To iterate through all items in the registry, you can get the underlying map and loop through its entries:
+
+```java
+DefaultAssetMap<String, Item> itemMap = Item.getAssetMap();
+var map = itemMap.getAssetMap();
+
+for (var entry : map.entrySet()) {
+    String itemId = String.valueOf(entry.getKey());
+    Item item = entry.getValue();
+    
+    // Do something with the item
+    LOGGER.atInfo().log("Item ID: " + itemId);
+}
+```
+
+You can also get the total count of registered items:
+
+```java
+int totalItems = map.size();
+```
+
+## Checking if an Item Exists
+
+To check if a specific item exists in the registry, use `getAsset()` and verify the result:
+
+```java
+public boolean itemExists(String itemId) {
+    var assetMap = Item.getAssetMap();
+    if (assetMap != null) {
+        Item item = assetMap.getAsset(itemId);
+        return item != null && item != Item.UNKNOWN;
+    }
+    return false;
+}
+```
+
+<Callout type="info">
+  The `Item.UNKNOWN` constant represents an invalid or unrecognized item. Always check for both `null` and `Item.UNKNOWN` when validating items.
+</Callout>
+
+## Accessing Item Properties
+
+Once you have an `Item` instance, you can access various properties:
+
+```java
+var assetMap = Item.getAssetMap();
+Item item = assetMap.getAsset("Soil_Grass");
+
+if (item != null && item != Item.UNKNOWN) {
+    String id = item.getId(); // Soil_Grass
+    int maxStack = item.getMaxStack(); // 100
+    boolean isBlock = item.hasBlockType(); // true
+    boolean isConsumable = item.isConsumable(); // false
+}
+```
+
+## Related Guides
+
+- [Inventory Management](./inventory-management) - Learn how to add and remove items from player inventories
+- [Create Custom Item and Interaction](./item-interaction) - Learn how to create your own custom items
diff --git a/content/docs/fr-FR/guides/plugin/permission-management.mdx b/content/docs/fr-FR/guides/plugin/permission-management.mdx
index 6b7cfd46..55f06101 100644
--- a/content/docs/fr-FR/guides/plugin/permission-management.mdx
+++ b/content/docs/fr-FR/guides/plugin/permission-management.mdx
@@ -10,132 +10,569 @@ authors:
     link: https://discord.com/users/292656109939064833
   - name: Ivan
     link: https://discord.com/users/505770451218333717
+  - name: ZenithDevHQ
+    link: https://github.com/ZenithDevHQ
 ---
 
-In this guide, you'll learn how to manage permission nodes and groups in your Hytale plugin.
+In this guide, you'll learn how to manage permission nodes and groups in your Hytale plugin. Permissions control what actions players can perform on your server, from basic commands to advanced administrative functions.
 
-## The `PermissionsModule` class
+## What Are Permissions?
 
-The `PermissionsModule` class is responsible for managing permission nodes and groups in your plugin. It provides methods to check, grant and revoke permissions and groups for players. It allows the following operations
+Permissions are string identifiers that control access to features and commands. When a player tries to perform an action (like using a command), the server checks if they have the required permission.
 
-- Add permissions to user
-- Remove permissions from user
-- Add permissions to group (this also creates the group if it doesn't exist)
-- Remove permissions from group
-- Add user to group
-- Remove user from group
-- List all groups for a user
-- Check if a user has a permission (it checks both user and group permissions for the given player UUID)
+**Example permission nodes:**
 
-With this class you cannot:
+- `hytale.command.gamemode` - Permission to use the gamemode command
+- `hytale.editor.brush.use` - Permission to use brush tools
+- `myplugin.teleport.home` - A custom permission for your plugin
 
-- List all defined groups
-- Remove a group
+Permissions follow a hierarchical naming pattern: `namespace.category.action`
 
-### Adding Permission Nodes
+## Key Concepts
 
-You need a `Set<String>` containing all the permission nodes you want to add, these are added on top of the already existing permission nodes the user may have, it is not a replacement.
+Before diving into code, let's understand the core concepts:
+
+| Concept             | Description                                                                |
+| ------------------- | -------------------------------------------------------------------------- |
+| **Permission Node** | A string like `myplugin.feature.use` that represents a specific permission |
+| **Group**           | A named collection of permissions (e.g., "Admin", "VIP", "Default")        |
+| **Provider**        | The backend that stores and retrieves permissions                          |
+| **Wildcard**        | A pattern like `*` or `myplugin.*` that matches multiple permissions       |
+
+### How Permissions Are Checked
+
+When checking if a player has a permission, Hytale follows this order:
+
+1. **User's direct permissions** - Permissions granted directly to the player
+2. **Group permissions** - Permissions from groups the player belongs to
+3. **Virtual groups** - Game-mode-based permissions (e.g., Creative mode grants builder tools)
+4. **Default value** - Falls back to `false` if no match found
+
+<Callout type="info">
+  The first definitive match wins. If a player has a permission granted at the user level, group permissions won't override it.
+</Callout>
+
+---
+
+## The `PermissionsModule` Class
+
+The `PermissionsModule` class is the central hub for managing permissions. Access it using the singleton pattern:
 
 ```java
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.addUserPermission(playerUUID, permissions);
 ```
 
-### Removing Permission Nodes
+### Available Operations
+
+The module supports these operations:
+
+| Operation                     | Method                                          |
+| ----------------------------- | ----------------------------------------------- |
+| Add permissions to user       | `addUserPermission(uuid, permissions)`          |
+| Remove permissions from user  | `removeUserPermission(uuid, permissions)`       |
+| Add permissions to group      | `addGroupPermission(groupName, permissions)`    |
+| Remove permissions from group | `removeGroupPermission(groupName, permissions)` |
+| Add user to group             | `addUserToGroup(uuid, groupName)`               |
+| Remove user from group        | `removeUserFromGroup(uuid, groupName)`          |
+| Get user's groups             | `getGroupsForUser(uuid)`                        |
+| Check permission              | `hasPermission(uuid, permissionNode)`           |
+
+<Callout type="warning">
+  The module does **not** support:
+
+  - Listing all defined groups
+  - Deleting a group entirely
+
+  Groups are implicitly created when you first add permissions to them.
+</Callout>
+
+---
 
-Same as above, we just use the `removeUserPermission` method instead to remove permission nodes.
+## Checking Permissions
+
+The most common operation is checking if a player has a permission.
+
+### Basic Permission Check
+
+```java
+// Returns true if player has the permission, false otherwise
+boolean canUse = PermissionsModule.get().hasPermission(playerUUID, "myplugin.feature.use");
+
+if (canUse) {
+    // Player has permission, allow the action
+} else {
+    // Player lacks permission, deny or show error
+}
+```
+
+### Permission Check with Default Value
+
+You can specify what to return when no permission is explicitly set:
+
+```java
+// Returns true by default if no explicit permission is found
+boolean canUse = PermissionsModule.get().hasPermission(playerUUID, "myplugin.feature.use", true);
+```
+
+This is useful for features that should be enabled by default but can be revoked.
+
+### Using PermissionHolder Interface
+
+Players and command senders implement `PermissionHolder`, allowing direct checks:
+
+```java
+// In a command or event handler where you have access to the player
+if (player.hasPermission("myplugin.admin.manage")) {
+    // Player has admin permission
+}
+```
+
+---
+
+## Managing User Permissions
+
+### Adding Permissions to a User
+
+Permissions are additive - new permissions are added on top of existing ones, not replaced.
+
+```java
+PermissionsModule perms = PermissionsModule.get();
+
+// Add a single permission
+perms.addUserPermission(playerUUID, Set.of("myplugin.vip.chat"));
+
+// Add multiple permissions at once
+Set<String> newPerms = Set.of(
+    "myplugin.vip.chat",
+    "myplugin.vip.fly",
+    "myplugin.vip.kit"
+);
+perms.addUserPermission(playerUUID, newPerms);
+```
+
+### Removing Permissions from a User
 
 ```java
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.removeUserPermission(playerUUID, permissions);
+
+// Remove specific permissions
+Set<String> toRemove = Set.of("myplugin.vip.fly");
+perms.removeUserPermission(playerUUID, toRemove);
 ```
 
-### Add permissions to group
+---
+
+## Managing Groups
+
+Groups let you assign a collection of permissions to multiple players. This is more manageable than assigning permissions individually.
+
+### Adding Permissions to a Group
+
+If the group doesn't exist, it will be created automatically.
 
 ```java
-String groupName = "testGroup";
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.addGroupPermission(groupName, permissions);
+
+// Create/update the "VIP" group with permissions
+Set<String> vipPerms = Set.of(
+    "myplugin.vip.chat",
+    "myplugin.vip.fly",
+    "myplugin.vip.kit"
+);
+perms.addGroupPermission("VIP", vipPerms);
 ```
 
-### Remove permissions from group
+### Removing Permissions from a Group
 
 ```java
-String groupName = "testGroup";
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.removeGroupPermission(groupName, permissions);
+
+// Remove specific permissions from the group
+Set<String> toRemove = Set.of("myplugin.vip.fly");
+perms.removeGroupPermission("VIP", toRemove);
 ```
 
-### Add user to group
+### Adding a User to a Group
 
 ```java
-String groupName = "testGroup";
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.addUserToGroup(playerUUID, groupName);
+
+// Add player to the VIP group - they now have all VIP permissions
+perms.addUserToGroup(playerUUID, "VIP");
 ```
 
-### Remove user from group
+### Removing a User from a Group
 
 ```java
-String groupName = "testGroup";
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.removeUserFromGroup(playerUUID, groupName);
+
+// Remove player from VIP group
+perms.removeUserFromGroup(playerUUID, "VIP");
 ```
 
-### List all groups for a user
+### Getting a User's Groups
 
 ```java
 PermissionsModule perms = PermissionsModule.get();
-perms.getGroupsForUser(playerUUID);
+
+// Get all groups the player belongs to
+Set<String> groups = perms.getGroupsForUser(playerUUID);
+
+for (String group : groups) {
+    System.out.println("Player is in group: " + group);
+}
 ```
 
-### Check Permission Nodes
+---
+
+## Built-in Groups
+
+Hytale includes two default groups:
+
+| Group     | Default Permissions   | Purpose                           |
+| --------- | --------------------- | --------------------------------- |
+| `OP`      | `*` (all permissions) | Server operators with full access |
+| `Default` | None                  | Base group for all players        |
+
+Players without any explicit group assignment are automatically part of the `Default` group.
 
-To check if a player has a specific permission node, you can use the `hasPermission` method.
+---
+
+## Wildcards
+
+Wildcards let you grant or deny multiple permissions with a single pattern.
+
+### Wildcard Patterns
+
+| Pattern             | Meaning                                          |
+| ------------------- | ------------------------------------------------ |
+| `*`                 | Grants **all** permissions                       |
+| `myplugin.*`        | Grants all permissions starting with `myplugin.` |
+| `-*`                | Denies **all** permissions                       |
+| `-myplugin.admin.*` | Denies all admin permissions in your plugin      |
+
+### Example: Admin Group with Wildcards
 
 ```java
-boolean hasPermission = PermissionsModule.hasPermission(playerUUID, "permission.node");
+// Grant all permissions to admins
+perms.addGroupPermission("Admin", Set.of("*"));
+
+// Grant all plugin permissions to moderators
+perms.addGroupPermission("Moderator", Set.of("myplugin.*"));
+
+// Grant all permissions except admin commands
+perms.addGroupPermission("Helper", Set.of(
+    "*",
+    "-myplugin.admin.*"  // Deny admin permissions
+));
 ```
 
-## Additional: Defining your own provider for permissions and groups
+<Callout type="warning">
+  Negation permissions (starting with `-`) take precedence at each level. Use them carefully to avoid accidentally blocking permissions.
+</Callout>
+
+---
+
+## Built-in Permission Nodes
+
+Hytale provides constants for common permissions in the `HytalePermissions` class:
+
+### Command Permissions
+
+```java
+// Generate permission for a command
+String perm = HytalePermissions.fromCommand("gamemode");
+// Result: "hytale.command.gamemode"
+
+// Generate permission for a subcommand
+String perm = HytalePermissions.fromCommand("gamemode", "creative");
+// Result: "hytale.command.gamemode.creative"
+```
+
+### Common Permission Nodes
+
+| Permission                    | Description                  |
+| ----------------------------- | ---------------------------- |
+| `hytale.command.op.add`       | Add players to OP group      |
+| `hytale.command.op.remove`    | Remove players from OP group |
+| `hytale.editor.brush.use`     | Use brush tools              |
+| `hytale.editor.prefab.use`    | Use prefabs                  |
+| `hytale.editor.selection.use` | Use selection tools          |
+| `hytale.editor.history`       | Undo/redo operations         |
+| `hytale.camera.flycam`        | Use fly camera mode          |
+
+---
+
+## Listening to Permission Events
+
+You can react to permission changes using Hytale's event system.
+
+### Available Events
+
+| Event                                            | Triggered When                   |
+| ------------------------------------------------ | -------------------------------- |
+| `PlayerPermissionChangeEvent.PermissionsAdded`   | Permissions added to a user      |
+| `PlayerPermissionChangeEvent.PermissionsRemoved` | Permissions removed from a user  |
+| `PlayerGroupEvent.Added`                         | User added to a group            |
+| `PlayerGroupEvent.Removed`                       | User removed from a group        |
+| `GroupPermissionChangeEvent.Added`               | Permissions added to a group     |
+| `GroupPermissionChangeEvent.Removed`             | Permissions removed from a group |
 
-The PermissionsModule also enables us to define our own PermissionProvider's, this can be useful for:
+### Example: Reacting to Permission Changes
 
-- Cross server permission systems
-- Implementing features missing in the `HytalePermissionsProvider` like permission expiry
+```java
+public class PermissionListener {
+
+    public static void onPermissionsAdded(PlayerPermissionChangeEvent.PermissionsAdded event) {
+        UUID playerUUID = event.getPlayerUuid();
+        Set<String> added = event.getAddedPermissions();
+
+        System.out.println("Permissions added to " + playerUUID + ": " + added);
 
-To implement our PermissionProvider, first we need to define a provider class that implements PermissionProvider:
+        // Maybe notify the player or update cached data
+    }
+
+    public static void onGroupAdded(PlayerGroupEvent.Added event) {
+        UUID playerUUID = event.getPlayerUuid();
+        String groupName = event.getGroupName();
+
+        System.out.println("Player " + playerUUID + " joined group: " + groupName);
+    }
+}
+```
+
+### Registering the Events
 
 ```java
-public class DatabasePermissionProvider implements PermissionProvider
+public class MyPlugin extends JavaPlugin {
+
+    @Override
+    public void setup() {
+        EventRegistry events = this.getEventRegistry();
+
+        events.registerGlobal(
+            PlayerPermissionChangeEvent.PermissionsAdded.class,
+            PermissionListener::onPermissionsAdded
+        );
+
+        events.registerGlobal(
+            PlayerGroupEvent.Added.class,
+            PermissionListener::onGroupAdded
+        );
+    }
+}
 ```
 
-Then we just implement the required methods using a database implementation.
+---
+
+## Creating a Custom Permission Provider
+
+For advanced use cases, you can create your own permission provider. This is useful for:
+
+- Database-backed permissions (MySQL, MongoDB, etc.)
+- Cross-server permission synchronization
+- Custom features like permission expiry or contexts
+
+### Implementing PermissionProvider
+
+```java
+public class DatabasePermissionProvider implements PermissionProvider {
+
+    @Nonnull
+    @Override
+    public String getName() {
+        return "DatabasePermissionProvider";
+    }
+
+    // User permission methods
+    @Override
+    public void addUserPermissions(@Nonnull UUID uuid, @Nonnull Set<String> permissions) {
+        // Save to your database
+    }
+
+    @Override
+    public void removeUserPermissions(@Nonnull UUID uuid, @Nonnull Set<String> permissions) {
+        // Remove from your database
+    }
+
+    @Override
+    public Set<String> getUserPermissions(@Nonnull UUID uuid) {
+        // Query your database
+        return Set.of();
+    }
+
+    // Group permission methods
+    @Override
+    public void addGroupPermissions(@Nonnull String group, @Nonnull Set<String> permissions) {
+        // Save to your database
+    }
+
+    @Override
+    public void removeGroupPermissions(@Nonnull String group, @Nonnull Set<String> permissions) {
+        // Remove from your database
+    }
+
+    @Override
+    public Set<String> getGroupPermissions(@Nonnull String group) {
+        // Query your database
+        return Set.of();
+    }
+
+    // User-group membership methods
+    @Override
+    public void addUserToGroup(@Nonnull UUID uuid, @Nonnull String group) {
+        // Save to your database
+    }
+
+    @Override
+    public void removeUserFromGroup(@Nonnull UUID uuid, @Nonnull String group) {
+        // Remove from your database
+    }
+
+    @Override
+    public Set<String> getGroupsForUser(@Nonnull UUID uuid) {
+        // Query your database
+        return Set.of("Default");
+    }
+}
+```
 
 <Callout type="warning">
-  Hytale will try to use the first available permissions provider to add/remove gamemode groups (i.e. `Creative`, `Adventure`).
+  Hytale automatically assigns players to game-mode groups (like `Creative` or `Adventure`) using the first available provider.
+
+  If your provider throws an error when the group doesn't exist, the player will be disconnected! Always handle missing groups gracefully.
+</Callout>
+
+### Registering Your Provider
 
-  If your provider throws an error (for instance, if the group does not exist) when the server is preparing the player, the player will be disconnected.
+```java
+public class MyPlugin extends JavaPlugin {
+
+    @Override
+    public void setup() {
+        // Add your provider alongside the default one
+        PermissionsModule.get().addProvider(new DatabasePermissionProvider());
+    }
+}
+```
+
+The `PermissionsModule` aggregates permissions from all registered providers. This means:
+
+- Permission checks query all providers
+- Write operations (add/remove) use the **first** provider
+
+### Replacing the Default Provider
+
+If you want full control, you can remove the default provider:
+
+```java
+public class MyPlugin extends JavaPlugin {
+
+    @Override
+    public void setup() {
+        PermissionsModule perms = PermissionsModule.get();
+
+        // Remove the default provider FIRST
+        perms.removeProvider(perms.getFirstPermissionProvider());
+
+        // Then add your provider
+        perms.addProvider(new DatabasePermissionProvider());
+    }
+}
+```
+
+<Callout type="info">
+  When you remove the default provider, the `/op self` command will stop working since it checks for provider tampering.
 </Callout>
 
-We can then register the provider using the built-in permission module:
+---
+
+## Best Practices
+
+### Permission Naming Conventions
+
+Follow the pattern: `namespace.category.action`
 
 ```java
-PermissionsModule.get().addProvider(new DatabasePermissionProvider());
+// Good - clear hierarchy
+"myplugin.admin.ban"
+"myplugin.user.teleport.home"
+"myplugin.vip.chat.color"
+
+// Bad - unclear structure
+"myplugin_ban"
+"teleport"
+"vipChatColor"
 ```
 
-Please note that the `HytalePermissionsProvider` will still be enabled alongside your provider.
-The `PermissionsModule` will aggregate groups and permissions from all available providers.
+### Use Constants for Permissions
 
-If you want to disable the default `HytalePermissionsProvider`, you can use:
+Define your permissions as constants to avoid typos:
 
 ```java
-// put this **before** you add your provider
-PermissionsModule.get().removeProvider(PermissionsModule.get().getFirstPermissionProvider());
+public final class MyPermissions {
+    public static final String ADMIN_BAN = "myplugin.admin.ban";
+    public static final String ADMIN_KICK = "myplugin.admin.kick";
+    public static final String USER_HOME = "myplugin.user.home";
+    public static final String VIP_FLY = "myplugin.vip.fly";
+}
+
+// Usage
+if (player.hasPermission(MyPermissions.ADMIN_BAN)) {
+    // ...
+}
 ```
+
+### Don't Over-Permission
+
+Only create permissions for actions that genuinely need access control. Not everything needs a permission check.
+
+### Thread Safety
+
+If you create a custom provider, ensure it's thread-safe. Permission checks can occur from multiple threads simultaneously. Use `ReadWriteLock` or `ConcurrentHashMap` for your data structures.
+
+---
+
+## In-Game Commands
+
+Hytale provides built-in commands for managing permissions:
+
+### `/op` Command
+
+| Command               | Description                                                        |
+| --------------------- | ------------------------------------------------------------------ |
+| `/op self`            | Toggle your own OP status (singleplayer or with `--allow-op` flag) |
+| `/op add <player>`    | Add a player to the OP group                                       |
+| `/op remove <player>` | Remove a player from the OP group                                  |
+
+### `/perm` Command
+
+Use `/perm --help` in-game for full usage. Common operations:
+
+| Command                                  | Description                   |
+| ---------------------------------------- | ----------------------------- |
+| `/perm user list <uuid>`                 | List user's permissions       |
+| `/perm user add <uuid> <perm>`           | Add permission to user        |
+| `/perm user remove <uuid> <perm>`        | Remove permission from user   |
+| `/perm user group list <uuid>`           | List user's groups            |
+| `/perm user group add <uuid> <group>`    | Add user to group             |
+| `/perm user group remove <uuid> <group>` | Remove user from group        |
+| `/perm group list <group>`               | List group's permissions      |
+| `/perm group add <group> <perm>`         | Add permission to group       |
+| `/perm group remove <group> <perm>`      | Remove permission from group  |
+| `/perm test <perm>`                      | Test if you have a permission |
+
+---
+
+## Summary
+
+You've learned how to:
+
+- **Check permissions** using `PermissionsModule.hasPermission()`
+- **Manage user permissions** with `addUserPermission()` and `removeUserPermission()`
+- **Work with groups** using `addGroupPermission()`, `addUserToGroup()`, etc.
+- **Use wildcards** like `*` and `myplugin.*` for bulk permissions
+- **Listen to events** for permission changes
+- **Create custom providers** for database-backed permissions
+
+For more advanced permission systems with features like inheritance, expiry, and contexts, we're looking into expanding this guide with advanced permission management techniques in the future.
diff --git a/content/docs/fr-FR/guides/plugin/setting-up-env.mdx b/content/docs/fr-FR/guides/plugin/setting-up-env.mdx
index d2718098..5be5e9e0 100644
--- a/content/docs/fr-FR/guides/plugin/setting-up-env.mdx
+++ b/content/docs/fr-FR/guides/plugin/setting-up-env.mdx
@@ -4,6 +4,10 @@ description: Learn how to set up your development environment for modding Hytale
 authors:
   - name: Neil Revin
     link: https://itsneil.dev
+  - name: Marcel-TO
+    url: https://marcel-to.net
+  - name: Ádám Liszkai
+    link: https://adaliszk.dev
 ---
 
 This guide will walk you through setting up a complete development environment for Hytale modding, including all necessary tools and dependencies.
@@ -19,24 +23,73 @@ Before we begin, make sure you have:
 
 ## Required Software
 
-### 1. Java Development Kit (JDK)
+### Integrated Development Environment (IDE)
 
+We recommend IntelliJ IDEA Community Edition for Hytale modding. If you use IntelliJ IDEA, **almost everything is built-in**. You can clone a template, open a new project, and start working right away!
+
+1. Download from [JetBrains website](https://www.jetbrains.com/idea/download/)
+2. Install with default settings
+3. Launch and complete the initial setup wizard
+
+When opening a project, wait for indexing to finish, then start coding.
+Now, IDEA may say "No JDK configured" at the top of the source file you have.
+In that case, you can click Download JDK and choose JetBrains JDK 25.
+
+<Callout type="success">
+  If IDEA opened the project without errors, your environment is ready.
+</Callout>
+
+More details by [JetBrains](https://www.jetbrains.com/help/idea/2026.1/run-for-the-first-time.html)
+help page, where we recommend that you also check the
+[SDK configuration](https://www.jetbrains.com/help/idea/2026.1/sdk.html) guide.
+
+<Callout type="info">
+  We recommened following
+  [TheNullicorn's](https://gist.github.com/TheNullicorn/90a619796c40f20ae1fcf13094c1a57d) guide to ensure
+  you are using the correct `Nonnull` in your projects.
+</Callout>
+
+#### What the IDE Does for You
+
+When opened in IntelliJ IDEA, the project automatically:
+
+- Detects and configures Gradle or Maven
+- Downloads all dependencies
+- Sets up project structure and classpaths
+- Configures run/build tasks
+
+You do **not** need to manually install or configure Maven or Gradle if you stay inside the IDE.
+
+Skip to the [Setting Up Your Workspace](#setting-up-your-workspace).
+
+### Manual Setup: Java Development Kit (JDK)
+
+For any other setup, you will need to install and configure your system to have and load Java.
 Hytale modding requires Java 25 or later. We recommend using OpenJDK.
 
-#### Windows
+#### Windows via Installer
 
 1. Download OpenJDK 25 from [Adoptium](https://adoptium.net/)
 2. Run the installer with default settings
+   - Optionally enable feature `Set or Override JAVA_HOME variable` to resolve version related build issues with your project.
 3. Verify installation by opening Command Prompt and running:
 
+#### Windows via Scoop
+
+1. Install Scoop via PowerShell using [scoop.sh](https://scoop.sh/)
+2. Install OpenJDK 25:
+
 ```bash
-java -version
+scoop bucket add java
+scoop install java/openjdk25
 ```
 
 #### macOS
 
+1. Install Brew via Terminal using [brew.sh](https://brew.sh)
+2. Install JDK via Homebrew:
+
 ```bash
-# Using Homebrew
 brew install openjdk@25
 ```
 
@@ -51,22 +104,41 @@ brew install openjdk@25
 
 #### Linux (Ubuntu/Debian)
 
+1. Install JDK via the built-in package repository:
+
 ```bash
 sudo apt update
 sudo apt install openjdk-25-jdk
 ```
 
-### 2. Integrated Development Environment (IDE)
+### Verify installation:
 
-We recommend IntelliJ IDEA Community Edition for Hytale modding.
+Run the following command to see what version of Java you have:
 
-1. Download from [JetBrains website](https://www.jetbrains.com/idea/download/)
-2. Install with default settings
-3. Launch and complete the initial setup wizard
+```bash
+java -version
+```
+
+### Java Build Tool (Optional)
+
+We recommend using a Gradle Wrapper for managing dependencies and building your Hytale plugins. It provides benefits by eliminating the need for a system-wide Gradle installation and ensuring consistent Gradle versions across different environments. (Alternatively you can use Maven, but this guide focuses on Gradle since it is the default for our plugin template.)
+
+The plugin template in the following sections includes a Gradle Wrapper, so you can skip this step if you plan to use the template.
+
+#### Choosing Gradle (if not using the template)
+
+If you prefer to install Gradle manually, follow these steps:
 
-### 3) Java Build Tool
+1. Visit the official website: https://gradle.org/releases/
+2. Download the newest gradle binary: `gradle-9.3.1-bin.zip` (Binary zip archive)
+3. Unzip it
+4. Add the `gradle-9.3.1/bin/` folder to your PATH
+
+You can now try the command `gradle -version` to verify Gradle is installed correctly. Make sure to do this in a fresh new terminal instead of one you had opened from before!
+
+#### Choosing Maven (if not using the template)
 
-We recommend using Apache Maven for managing dependencies and building your Hytale plugins. (Alternatively you can use Gradle, but this guide focuses on Maven.)
+If you prefer to use Maven instead of Gradle, follow these steps to install Maven:
 
 1. Visit the official website: https://maven.apache.org/download.cgi
 2. Download this file: `apache-maven-3.9.12-bin.zip` (Binary zip archive)
@@ -89,22 +161,61 @@ cd MyFirstMod
 
 If you don't have Git installed, you can download the ZIP file from the repository page and extract it to a folder named `MyFirstMod`.
 
-### 2. Open Plugin in your IDEA
+### 2. Open Plugin in your IDE
 
-1. Open IntelliJ IDEA
+1. Open Your IDE (e.g., IntelliJ IDEA)
 2. Click "Open" and navigate to your `MyFirstMod` directory
-3. IntelliJ will automatically detect it as a Maven project
+3. Most IDEs like IntelliJ will automatically detect it as a Gradle project
 4. Wait for the project to index and dependencies to download
 
-<Callout type="info">
-  We recommened following [this](https://gist.github.com/TheNullicorn/90a619796c40f20ae1fcf13094c1a57d) guide to ensure you are using the correct `Nonnull` in your projects.
-</Callout>
+## Alternate Approach: Hytale Dependency
+
+If you prefer to set up your project from scratch without using the template and importing the hytale dependencies manually, ensure your build configuration includes the Hytale repositories and dependencies:
+
+For Gradle, add the following to your `build.gradle.kts`:
+
+```kotlin
+repositories {
+    mavenCentral()
+    maven {
+        name = "hytale"
+        url = uri("https://maven.hytale.com/release") // Or "hytale-pre-release" for pre-release versions
+    }
+}
+dependencies {
+    // + here means the latest version, but you can hard-wire any known version!
+    implementation("com.hypixel.hytale:Server:+")
+}
+```
+
+For Maven, add the following to your `pom.xml`:
+
+```xml
+<project>
+    <repositories>
+        <repository>
+            <id>hytale-release</id> <!-- Or "hytale-pre-release" for pre-release versions -->
+            <url>https://maven.hytale.com/release</url> <!-- Or "https://maven.hytale.com/pre-release" -->
+        </repository>
+    </repositories>
+
+    <dependencies>
+        <dependency>
+            <groupId>com.hypixel.hytale</groupId>
+            <artifactId>Server</artifactId>
+            <!-- Replace with latest version, Hytale provides jars for the last five releases -->
+            <version>LATEST_VERSION_HERE</version>
+            <scope>provided</scope>
+        </dependency>
+    </dependencies>
+</project>
+```
 
 ## Next Steps
 
 Now that you have your development environment set up with the plugin template:
 
-1. **Customize the template** - Edit the `pom.xml` and `manifest.json` file to change your mod's name and details
+1. **Customize the template** - Edit the `settings.gradle.kts`, `build.gradle.kts` and `manifest.json` file to change your mod's name and details
 2. **Explore the code structure** - Familiarize yourself with the template's organization
 3. **Start modding** - Begin writing your first Hytale plugin!
 
diff --git a/content/docs/fr-FR/guides/plugin/spawning-entities.mdx b/content/docs/fr-FR/guides/plugin/spawning-entities.mdx
index e12c0aea..15be2fb3 100644
--- a/content/docs/fr-FR/guides/plugin/spawning-entities.mdx
+++ b/content/docs/fr-FR/guides/plugin/spawning-entities.mdx
@@ -36,7 +36,7 @@ Store<EntityStore> store = world.getEntityStore().getStore();
 
 ## Creating Entities
 
-Once you have the `EntityStore` instance, you can start to create a entity and give it components. Entities are just instances of `Holder<EntityStore>` with several components attached to them.
+Once you have the `EntityStore` instance, you can start to create an entity and give it components. Entities are just instances of `Holder<EntityStore>` with several components attached to them.
 
 <Callout type="warning">
   To interact with the `World` instance, some methods require you to run the code inside the world's execution context.
@@ -118,3 +118,48 @@ Finally, we can add the entity to the world by calling the `addEntity` method on
 ```java
 store.addEntity(holder, AddReason.SPAWN);
 ```
+
+## Making the entity persist
+
+Hytale automatically saves all entities, but the `NetworkId` component (required for players to be able to see the entity) needs to be manually added every time the entity is loaded.
+
+### Using a system
+
+If you have a component that is unique to your entities, this can be done by creating and registering a custom system as follows:
+
+```java
+public class AddNetworkIdToMyEntitySystem extends HolderSystem<EntityStore> {
+    private final ComponentType<EntityStore, MyEntityComponent> myEntityComponentType = MyEntityComponent.getComponentType();
+    private final ComponentType<EntityStore, NetworkId> networkIdComponentType = NetworkId.getComponentType();
+    private final Query<EntityStore> query = Query.and(this.myEntityComponentType, Query.not(this.networkIdComponentType));
+
+    @Override
+    public void onEntityAdd(@NotNull Holder<EntityStore> holder, @NotNull AddReason reason, @NotNull Store<EntityStore> store) {
+        if (!holder.getArchetype().contains(NetworkId.getComponentType())) {
+            holder.addComponent(NetworkId.getComponentType(), new NetworkId(store.getExternalData().takeNextNetworkId()));
+        }
+    }
+
+    @Override
+    public void onEntityRemoved(@NotNull Holder<EntityStore> holder, @NotNull RemoveReason reason, @NotNull Store<EntityStore> store) {}
+
+    @Override
+    public @Nullable Query<EntityStore> getQuery() {
+        return query;
+    }
+}
+```
+
+In your plugin's `setup()` function
+
+```java
+this.getEntityStoreRegistry().registerSystem(new AddNetworkIdToMyEntitySystem())
+```
+
+### Using PropComponent
+
+Alternatively you can add `PropComponent` to your entity. Hytale adds `PropComponent` to entities spawned with the Entity Tool, and such entities automatically get `NetworkId` and `PrefabCopyableComponent` (which makes the entity work with prefabs).
+
+<Callout type="warning">
+  There is no guarantee, that Hytale will not add some other behavior to this component in the future, which may break your entity, so be careful if you decide to rely on it.
+</Callout>
diff --git a/content/docs/fr-FR/guides/plugin/store-persistent-data.mdx b/content/docs/fr-FR/guides/plugin/store-persistent-data.mdx
new file mode 100644
index 00000000..1071dff3
--- /dev/null
+++ b/content/docs/fr-FR/guides/plugin/store-persistent-data.mdx
@@ -0,0 +1,171 @@
+---
+title: Storing Persistent Data on the Player
+description: Learn how to save and load persistent data using Components
+authors:
+  - name: Neil Revin
+    url: https://itsneil.dev/
+  - name: ArcticDev
+    url: https://github.com/ArcticRaven
+  - name: oskarscot
+    url: https://oskar.scot
+  - name: JammingEng
+    url: https://github.com/JammingEnd
+---
+
+Here is how to store persistent data using a custom component on a Player.
+
+## Build your Component Class
+
+Creating a custom component class leverages the Component system made with the ECS architecture in mind. For more information on Components, check out the [ECS Guide](../ecs/hytale-ecs-theory#components).
+
+Start by creating your custom component class. This will be extremely similar to how regular components are created, however we'll setup a custom Codec so the server can translate this data to BSON, or the server's internal json encoder.
+
+<Callout type="info">
+  Each variable you want to store in your component must have its own Codec field defined in the BuilderCodec.
+  For more information on how to create custom Codecs, check out the [ECS Codec Guide](../ecs/hytale-ecs-theory#codec).
+</Callout>
+
+```java
+public class YourPlayerData implements Component<EntityStore> {
+
+    // define some vars!
+    private int someInteger;
+    private String someString;
+    private Map<String, String> someMap;
+
+    public static final BuilderCodec<YourPlayerData> CODEC =
+            BuilderCodec.builder(YourPlayerData.class, YourPlayerData::new)
+            .append(new KeyedCodec<>("SomeInteger", Codec.INTEGER),
+                    (data, value) -> data.someInteger = value, // setter
+                    data -> data.someInteger) // getter
+            .addValidator(Validators.nonNull())
+            .add()
+            .append(new KeyedCodec<>("SomeString", Codec.STRING),
+                    (data, value) -> data.someString = value, // setter
+                    data -> data.someString) // getter
+            .add()
+            .append(new KeyedCodec<>("SomeMap",
+                            new MapCodec<>(Codec.STRING, HashMap::new, false)),
+                    (data, value) -> data.someMap = value, // setter
+                    data -> data.someMap) // getter
+            .add()
+            .build();
+
+
+
+    // Getters and Setters are for the purpose of this example omitted.
+
+    // constructor
+    public YourPlayerData() {
+        this.someInteger = 0;
+        this.someString = "";
+        this.someMap = new HashMap<>();
+    }
+
+    // copy constructor for cloning
+    public YourPlayerData(YourPlayerData clone) {
+        this.someInteger = clone.someInteger;
+        this.someString = clone.someString;
+        this.someMap = clone.someMap;
+    }
+
+    @Nonnull
+    @Override
+    public Component<EntityStore> clone() {
+        return new YourPlayerData(this);
+    }
+}
+```
+
+## Register your Component
+
+Inside your main class's `setup()` method, register your new Component.
+
+```java
+public class YourPlugin extends JavaPlugin {
+
+    private ComponentType<EntityStore, YourPlayerData> yourPlayerDataComponent;
+
+    public YourPlugin(@Nonnull JavaPluginInit init) {
+        super(init);
+    }
+
+    @Override
+    protected void setup(){
+        this.yourPlayerDataComponent = this.getEntityStoreRegistry().registerComponent(
+            YourPlayerData.class,
+            "YourPlayerDataComponent",
+            YourPlayerData.CODEC
+        );
+    }
+
+    public ComponentType<EntityStore, YourPlayerData> getYourPlayerDataComponent() {
+        return this.yourPlayerDataComponent;
+    }
+}
+```
+
+## Using your Component
+
+To use your newly created component, you can add the Component to a player using the `addComponent` method, although this only adds it temporarily, meaning when the player/entity leaves the world, the component is removed. You can use `putComponent` to ensure the component persists between sessions.
+
+```java
+// You will need the Ref and Store to apply components
+private void someEntryMethod(@Nonnull Ref<EntityStore> ref, @Nonnull Store<EntityStore> store)
+{
+       // Any entity will work, for now we will use the player
+      Player player = (Player) store.getComponent(ref, Player.getComponentType());
+
+      // since we're using putComponent, it could be useful to check if it already exists on the player in case we want to update it
+     if(store.getComponent(ref, YourPlugin.instance().getYourPlayerDataComponent()) != null)
+     {
+          // here we implement logic that updates the component
+         var comp = store.getComponent(ref, YourPlugin.instance().getYourPlayerDataComponent())
+         // declare public fields or methods in the component class
+         comp.SomeString = "An Updated Field";
+     } else {
+          // Here we put the component
+          var myCustomComp = new CustomComponent();
+          // declare public fields or methods in the component class
+          myCustomComp.SomeString = "Edited String";
+
+          // putComponent allows you to insert declared objects
+          store.putComponent(ref, YourPlugin.instance().getYourPlayerDataComponent(), myCustomComp);
+     }
+}
+```
+
+## Using your Data
+
+Your component will be stored within the `Store<EntityStore>` when added to the player. In the provided example,
+we'll fetch this data off the player using the `ensureAndGetComponent()` method, which will add the component to
+the player if it does not exist with the default values.
+
+```java
+public class IncompleteCustomCommand extends AbstractPlayerCommand {
+
+    public IncompleteCustomCommand() {
+        super("nope", "don't use this command");
+    }
+
+    @Override
+    protected void execute(
+        @NonNullDecl CommandContext commandContext,
+        @NonNullDecl Store<EntityStore> store,
+        @NonNullDecl Ref<EntityStore> ref,
+        @NonNullDecl PlayerRef playerRef,
+        @NonNullDecl World world
+    ) {
+        YourPlayerData customData = store.ensureAndGetComponent(ref, YourPlugin.instance().getYourPlayerDataComponent());
+        // ensureAndGetComponent adds the component to the ref, with the default values defined inside your component.
+ 		// use your data
+    }
+}
+```
+
+And that's it! Your data will now be saved and loaded automatically with the player.
+
+Using custom components to store persistent data on players is a powerful way to maintain state across sessions.
+By following the steps outlined above, you can easily create, register, and utilize your own data structures within the Hytale ECS framework.
+This approach ensures that your data is seamlessly integrated with the game's existing systems.
+For more information about Hytale's Entity Component System visit the [Hytale ECS Theory](https://hytalemodding.dev/en/docs/guides/ecs/hytale-ecs-theory) guide.
diff --git a/content/docs/fr-FR/guides/plugin/teleporting-players.mdx b/content/docs/fr-FR/guides/plugin/teleporting-players.mdx
index 57cee77f..32ce0435 100644
--- a/content/docs/fr-FR/guides/plugin/teleporting-players.mdx
+++ b/content/docs/fr-FR/guides/plugin/teleporting-players.mdx
@@ -1,26 +1,32 @@
 ---
 title: Teleporting the player
 description: Learn how to teleport the player.
+authors:
+  - name: oskarscot
+    url: https://oskar.scot
 ---
 
-To teleport players in Hytale, you will need to get a `World` object so we can safely run the teleport on the world thread. The world thread manages all entity updates, so modifying entities off-thread can crash the server or cause inconsistent state.
-Next, we get the entity store and make a `Teleport` object.
-We add a `Teleport` component to the player’s entity reference in the entity store. This triggers the teleportation logic for that player.
+Teleporting players in Hytale works by simply attaching a `Teleport` component to a player with the desired world and transform.
+You can only trigger teleports from a world where the player is currently present.
+Teleport itself is a component but it also provides factory methods to configure the Teleport. Just as with any entity component, an EntityStore and a Ref to the EntityStore is required
+
+We can create a simple teleport utility like this:
 
 ```java
-public static void teleportPlayer(Player player, int x, int y, int z) {
-        World world = player.getWorld();
-        if (world == null) return;
-        world.execute(() -> {
-            if (player.getReference() == null) return;
-            Store<EntityStore> store = player.getReference().getStore();
-            Teleport teleport = Teleport.createForPlayer(world,
-                new Vector3d(x ,y, z), // Target position
-                new Vector3f(0, 0, 0)  // Target rotation (pitch, yaw, roll)
-            );
+public static void teleportPlayer(Ref<EntityStore> ref, Store<EntityStore> store, World targetWorld, double x, double y, double z) {                                                                                       
+    Transform transform = new Transform(x, y, z);                                                                                                                           
+    Teleport teleport = Teleport.createForPlayer(targetWorld, transform);                                                                                                   
+    store.addComponent(ref, Teleport.getComponentType(), teleport);                                                                                                         
+}  
+```
 
-            store.addComponent(player.getReference(), Teleport.getComponentType(), teleport);
-        });
+A `Transform` is a representation of a position Vector3d and rotation Vector3f which works in the following way:
 
-}
+```java
+Transform transform = new Transform(
+    new Vector3d(x, y, z),      // Position
+    new Rotation(yaw, pitch, 0) // Rotation, last value seems to always be 0
+);
+Teleport teleport = Teleport.createForPlayer(targetWorld, transform);
+store.addComponent(ref, Teleport.getComponentType(), teleport);
 ```
diff --git a/content/docs/fr-FR/guides/plugin/tracking-mod-analytics-with-hstats.mdx b/content/docs/fr-FR/guides/plugin/tracking-mod-analytics-with-hstats.mdx
new file mode 100644
index 00000000..45c022e0
--- /dev/null
+++ b/content/docs/fr-FR/guides/plugin/tracking-mod-analytics-with-hstats.mdx
@@ -0,0 +1,65 @@
+---
+title: Tracking Mod Analytics with HStats
+description: Learn how you can track Analytics for your Hytale Mod for Free using hstats.dev
+authors:
+  - name: Al3x
+    url: https://hstats.dev
+---
+
+In this guide, you will learn how to integrate HStats into your Plugin/Mod which will allow you to track how many Servers are using it along with other stats.
+
+<Callout type="info">
+  HStats is a third-party tool and is not affiliated with HytaleModding or Hypixel Studios
+</Callout>
+
+# Step 1: Register your Mod to HStats
+
+Before you touch any code, you will need to add your mod to the HStats website which will give you a UUID for your mod.
+
+- Create or Login to an Account on https://hstats.dev
+- Navigate to the dashboard page (https://hstats.dev/dashboard)
+- On the left, type in your mod's name and click "Add Mod"
+- Keep note of the UUID generated for later.
+
+# Step 2: Add the HStats Class to Your Project
+
+To keep things simple, HStats uses a single Java class file that handles everything for you.
+
+- Download / Copy the File from the GitHub page (https://github.com/hstats-dev/HStatsExamplePlugin/blob/main/src/main/java/com/al3x/HStats.java)
+- Paste into your Project. You should now have a HStats.java file somewhere in your projects directory.
+- Update the package name from com.al3x to whatever fits your project.
+
+# Step 3: Initialize HStats in your code
+
+You only need to add one line of code to your mod's setup method in your main class to start tracking.
+
+`new HStats("YOUR-MOD-UUID", "1.0.0");`
+
+Replace `YOUR-MOD-UUID` with the Mod UUID we made note of earlier and change the `1.0.0` version to whatever version your mod is currently on.
+
+Your setup method should now look something like this:
+
+```java
+@Override
+protected void setup() {
+  super.setup();
+  new HStats("c34a2b2a-afd8-4d6a-821e-7a63e12c5ea6", "1.0.0");
+}
+```
+
+# Extras
+
+Your done! Your mod should now be listed under the Mods page (https://hstats.dev/mods) as well as under your dashboard.
+
+Servers using your mod should now post updates about every minute to HStats which you can view in the Dashboard.
+
+### Embeds
+
+HStats allows you to generate an Embed Card that you can place on your CurseForge or GitHub page. This is useful for server owners to be able to see how many other servers are using your mod.
+
+- In your dashboard, scroll down to the Embed Card section.
+- Customize the appearance (Light/Dark mode, layout, etc).
+- Copy the generated URL to display your "Active Servers" and "Players Online" live on your mod's description page
+
+Heres an example of what they look like:
+![HStats Example](https://api.hstats.dev/api/embed/d52fa672-6966-47b2-b501-1a11bddebac3/card.svg?theme=light\&layout=compact\&size=md\&show_id=true\&dark=false)
diff --git a/content/docs/fr-FR/guides/plugin/world-gen.mdx b/content/docs/fr-FR/guides/plugin/world-gen.mdx
index 4c23b0c9..7b193ffd 100644
--- a/content/docs/fr-FR/guides/plugin/world-gen.mdx
+++ b/content/docs/fr-FR/guides/plugin/world-gen.mdx
@@ -100,7 +100,7 @@ Biome biome = biomeGen.generateBiomeAt(zoneResult, seed, x, z);
 
 ### Zone & Cave Integration
 
-Each zone defines it's own cave patterns:
+Each zone defines its own cave patterns:
 
 ```java
 Zone zone = /* ... */;
diff --git a/content/docs/fr-FR/guides/prefabs.mdx b/content/docs/fr-FR/guides/prefabs.mdx
index 08404b30..54b8b40e 100644
--- a/content/docs/fr-FR/guides/prefabs.mdx
+++ b/content/docs/fr-FR/guides/prefabs.mdx
@@ -1,6 +1,6 @@
 ---
 title: Prefabs
-description: Documentation about Prefabs in Hytale.
+description: Documentation sur les Prefabs dans Hytale.
 icon: Box
 authors:
   - name: Ben Cressman
@@ -9,84 +9,84 @@ authors:
 
 # Introduction
 
-Prefabs are Hytale's way of creating reusable structures.
+Les Prefabs sont le moyen pour Hytale de créer des structures réutilisables.
 
-There are a few fundamental concepts to understand about prefabs:
+Il y a quelques concepts fondamentaux à comprendre sur les prefabs :
 
-- Users interact with prefabs via a prefab editing world.
-- Prefabs the physical structures in the game world, and are saved as JSON files.
+- Les utilisateurs interagissent avec les prefabs via un monde d'édition de prefab.
+- Les Prefabs sont les structures physiques dans le monde du jeu, et sont sauvegardés en fichiers JSON.
 
-## How to Create a Prefab
+## Comment créer un Prefab
 
-Be sure to check the Known Issues section at the end of this guide if you encounter any problems.
+Consultez la section "Problèmes Connus" à la fin de ce guide si vous rencontrez des problèmes.
 
-1. `/editprefab new <world name>` to create a new prefab editing world: `/editprefab new my_prefab_world`
-   - Note that `my_prefab` is the name of the _world_, not the prefab itself. Worlds can contain multiple prefabs.
-2. Build whatever you want in the prefab editing world.
-3. Use the selection brush to select the area you want to save as a prefab.
-4. `/prefab save` to save the structure as a prefab.
-5. `/editprefab exit` to exit the prefab editing world.
-6. Using the Paste brush, press 'e' on your keyboard to select the prefab you just created. It will be in the "server" dropdown, which can be selected from the top right of the menu.
-   - You can also select it with `/prefab list` and selecting the prefab you just created.
+1. `/editprefab new <nom du monde>` pour créer un nouveau monde d'édition de prefab : `/editprefab new my_prefab_world`
+   - Notez que `my_prefab` est le nom du _monde_, pas le prefab lui-même. Les mondes peuvent contenir de multiples prefabs.
+2. Construisez ce que vous voulez dans le monde d'édition de prefab.
+3. Utilisez la brosse de sélection pour sélectionner la zone que vous voulez enregistrer en tant que prefab.
+4. `/prefab save` pour enregistrer la structure en tant que prefab.
+5. `/editprefab exit` pour quitter le monde d'édition du prefab.
+6. À l'aide de la brosse Coller, appuyez sur 'e' sur votre clavier pour sélectionner le prefab que vous venez de créer. Il sera dans le menu déroulant "serveur", qui peut être sélectionné en haut à droite du menu.
+   - Vous pouvez également le sélectionner avec `/prefab list` et en sélectionnant le prefab que vous venez de créer.
 
-There is a lot more that you can do with prefabs; this is just the basic flow. Keep reading for more information.
+Il y a beaucoup plus de choses que vous pouvez faire avec les prefabs ; il s'agit  simplement du fonctionnement de base. Continuez à lire pour plus d'informations.
 
-## Commands
+## Commandes
 
-There are two main commands for prefabs, `/prefab` and `/editprefab`.
+Il y a deux commandes principales pour les prefabs, `/prefab` et `/editprefab`.
 
-This list does not cover the various options for each command. You can use the `--help` flag at the end of any command to see the available options, e.g. `/prefab save --help`, or use `/help` in game and find the `prefab` and `editprefab` commands.
+Cette liste ne couvre pas les différentes options pour chaque commande. Vous pouvez utiliser le flag `--help` à la fin de n'importe quelle commande pour voir les options disponibles, par ex. `/prefab save --help`, ou utilisez `/help` dans le jeu et trouvez les commandes `prefab` et `editprefab`.
 
 ### `/prefab`
 
-This command allows the user to interact with an existing prefab's file.
+Cette commande permet à l'utilisateur d'interagir avec un fichier de prefab existant.
 
-Subcommands:
+Sous-commandes :
 
 - `save`
-  - Saves the prefab to the file system.
+  - Sauvegarde le prefab vers le système de fichiers.
 - `load`
-  - Loads the prefab into the game.
+  - Charge le prefab dans le jeu.
 - `delete`
-  - Deletes the prefab from the file system.
+  - Supprime le prefab du système de fichiers.
 - `list`
-  - Lists all prefabs in the file system.
+  - Liste tous les prefabs du système de fichiers.
 
 ### `/editprefab`
 
-The `/editprefab` command is used to create or edit the physical structure in the game the prefab is holding.
+La commande `/editprefab` est utilisée pour créer ou éditer la structure physique dans le jeu que le prefab contient.
 
-Subcommands:
+Sous-commandes :
 
 - `exit`
-  - Exits the current prefab editing world.
+  - Quitte le monde d'édition du prefab actuel.
 - `load`
-  - Creates a new prefab editing world to paste an existing prefab into.
+  - Crée un nouveau monde d'édition de préfab pour y coller un prefab existant.
 - `new`
-  - Creates a new prefab editing world to create a new prefab from scratch.
+  - Crée un nouveau monde d'édition de prefab pour créer un nouveau préfab à partir de rien.
 - `select`
-  - Selects the area of the prefab the user is looking at (within 200 blocks).
+  - Sélectionne la zone du prefab que l'utilisateur regarde (dans les 200 blocs).
 - `save`
-  - Saves the current prefab using the existing area, or the currently selected area.
+  - Enregistre le prefab courant en utilisant la zone existante, ou la zone actuellement sélectionnée.
 - `saveui`
-  - Opens the save UI for the current world, allowing the user to interact with all prefabs that are in the world.
+  - Ouvre l'interface utilisateur de sauvegarde pour le monde actuel, permettant à l'utilisateur d'interagir avec tous les prefabs présent dans le monde.
 - `kill`
-  - Despawn all entities in the currently selected prefab.
+  - Fais disparaître toutes les entités dans le prefab actuellement sélectionné.
 - `saveas`
-  - Save the selected prefab into a new file.
+  - Enregistre le prefab sélectionné dans un nouveau fichier.
 - `setbox`
-  - Set the bounding box of the currently selected prefab.
+  - Définissez la boîte englobante du prefab actuellement sélectionné.
 - `info`
-  - General information about the currently selected prefab.
+  - Informations générales sur le prefab actuellement sélectionné.
 - `tp`
-  - Opens the teleport UI to teleport to a prefab in the current editing world.
+  - Ouvre l'interface de téléportation pour se téléporter à un prefab dans le monde d'édition actuel.
 - `modified`
-  - Lists all modified prefabs with unsaved changes in the current editing world.
+  - Liste tous les prefabs modifiés avec des modifications non enregistrées dans le monde en cours d'édition.
 
-# Known Issues
+# Problèmes connus
 
-- After saving edits to an existing prefab, the prefab does not reflect the changes in the game.
-  - Workaround: exit and re-enter the world.
-- When pasting a prefab, the prefab is not always shown accurately.
-  - Workaround: hit 't' on your keyboard to toggle the material being shown; usually at least one view is accurate.
-- `/prefab delete` errors with `Assert not in thread`.
+- Après avoir sauvegardé les modifications dans un prefab existant, le prefab ne reflète pas les changements dans le jeu.
+  - Contournement : sortir et retourner dans le monde.
+- Lorsque vous collez un prefab, le prefab n'est pas toujours affiché avec précision.
+  - Contournement : appuyez sur 't' sur votre clavier pour activer/désactiver le matériel affiché ; généralement au moins une vue est précise.
+- Erreurs `/prefab delete` avec `Assert not in thread`.
diff --git a/content/docs/fr-FR/official-documentation/custom-ui/common-styling.mdx b/content/docs/fr-FR/official-documentation/custom-ui/common-styling.mdx
new file mode 100644
index 00000000..c36e3e3a
--- /dev/null
+++ b/content/docs/fr-FR/official-documentation/custom-ui/common-styling.mdx
@@ -0,0 +1,50 @@
+---
+title: Common Styling
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# Common Styling
+
+## Common UI Styling Library
+
+This document describes the shared UI components and styles defined in `Common.ui`.
+
+---
+
+### Styles
+
+We are providing some styles that can be re-used in any custom UI that, provide a cohesive UI experience with the core game UI. These styles are available in the `Common.ui` file.
+
+You can find a list of all the styles defined with live examples by running the `/ui-gallery` command ingame.
+
+<Callout type="warning">
+  This command is not available yet, but will be in a future patch.
+</Callout>
+
+![Gallery](/assets/official-documentation/ui/gallery.png)
+
+### Importing
+
+To use these styles in your UI file:
+
+```
+$Common = "Common.ui";
+
+// Then reference styles and components:
+$Common.@TextButton { @Text = "My Button"; }
+$Common.@Container { ... }
+```
+
+<Callout type="info">
+  The `Common.ui` file is at `Common/UI/Custom/Common.ui` within the Hytale pack. If your custom ui document is in a subfolder of `Common/UI/Custom/`, reference it via relative path traversal:
+
+  ```
+  $Common = "../Common.ui";
+  ```
+
+  You can find more info about paths [here](markup#path).
+</Callout>
diff --git a/content/docs/fr-FR/official-documentation/custom-ui/index.mdx b/content/docs/fr-FR/official-documentation/custom-ui/index.mdx
new file mode 100644
index 00000000..f94c4e88
--- /dev/null
+++ b/content/docs/fr-FR/official-documentation/custom-ui/index.mdx
@@ -0,0 +1,125 @@
+---
+title: Custom UI
+icon: LayoutDashboard
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# Custom UI
+
+## What is Custom UI?
+
+Custom UI is Hytale's framework for creating **custom user interfaces** controlled by the game server. Unlike the built-in Client UI (which is part of the game client and cannot be modified), Server UI allows you to create interactive screens and HUD overlays through Java plugins and asset packs.
+
+As a modder, Custom UI gives you the power to:
+
+- **Create custom interactive pages** - Shop interfaces, quest dialogs, server settings menus, admin panels
+- **Add custom HUD overlays** - Quest trackers, status displays, custom health bars, server information
+- **Design with markup** - Use `.ui` files to define reusable UI templates
+- **Handle user interactions** - Respond to button clicks, form submissions, and other events
+- **Localize your UI** - Support multiple languages using the game's translation system
+
+## How Custom UI Fits Into Hytale's UI
+
+Hytale's user interface is divided into two main categories:
+
+### Client UI (Not Moddable)
+
+Built-in interfaces controlled by the C# game client:
+
+- Main menu and settings
+- Character creation
+- Built-in HUD (health, hotbar, chat)
+- Inventory and crafting screens
+- Development tools
+
+**You cannot modify these** - they are part of the core game client.
+
+### In-Game UI (Moddable via Server)
+
+Server-controlled interfaces that you can create and customize:
+
+#### Custom Pages
+
+Full-screen interactive overlays that appear during gameplay:
+
+- Can be dismissed by the player (ESC key)
+- Capture all input (keyboard and mouse)
+- Support loading states while waiting for server responses
+- Perfect for: shops, dialogs, menus, configuration screens
+
+#### Custom HUDs
+
+Persistent overlay elements drawn on top of the game world:
+
+- Display-only (no user interaction)
+- Always visible during gameplay
+- Lightweight and non-intrusive
+- Perfect for: quest objectives, status indicators, server info panels
+
+## Architecture Overview
+
+Server UI uses a **command-based architecture**:
+
+```
+┌─────────────────────┐         ┌──────────────────────┐
+│   Java Server       │         │    C# Client         │
+│   (Your Plugin)     │         │    (Game)            │
+├─────────────────────┤         ├──────────────────────┤
+│                     │         │                      │
+│ InteractiveCustomUI │         │   CustomPage or      │
+│ Page                │         │   CustomHud          │
+│   ↓ build()         ├────────→│     ↓ Apply          │
+│ UICommandBuilder    │         │   Element Tree       │
+│   - append()        │         │     ↓ Layout         │
+│   - set()           │         │   Rendered UI        │
+│   - clear()         │         │                      │
+│                     │         │                      │
+│ ↓ handleDataEvent() │← Events │   User Interaction   │
+│   Process input     │         │   (click, type, etc) │
+│   sendUpdate()      │         │                      │
+└─────────────────────┘         └──────────────────────┘
+```
+
+**The flow:**
+
+1. Your Java code builds UI using `UICommandBuilder`
+2. Commands are sent to the client as data
+3. Client parses `.ui` markup files and creates visual elements
+4. User interacts with the UI
+5. Events are sent back to your Java code
+6. You process events and send updates back
+
+## Key Principles
+
+### Declarative, Not Imperative
+
+You don't create UI objects directly. Instead, you send **commands** that describe what you want:
+
+- "Append this button template to that container"
+- "Set this label's text to 'Hello World'"
+- "Clear all children from this list"
+
+### Asset-Driven
+
+UI structure is defined in `.ui` markup files (assets), not hardcoded in Java. This enables:
+
+- Designers to modify layouts without touching code
+- Reusable UI components
+- Consistent visual language
+
+### Event-Driven
+
+User interactions trigger events that flow back to your server code. You register event bindings and handle them in `handleDataEvent()`.
+
+### Selector-Based
+
+You target specific UI elements using **selectors:**
+
+- `#MyButton` - Element with ID "MyButton"
+- `#List[0]` - First child of element "List"
+- `#List[0] #Title` - Element with ID "Title" in the first child of element "List"
+- `#Label.TextColor` - The TextColor property of element "Label"
diff --git a/content/docs/fr-FR/official-documentation/custom-ui/layout.mdx b/content/docs/fr-FR/official-documentation/custom-ui/layout.mdx
new file mode 100644
index 00000000..0a24ca09
--- /dev/null
+++ b/content/docs/fr-FR/official-documentation/custom-ui/layout.mdx
@@ -0,0 +1,492 @@
+---
+title: Layout
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# Layout
+
+The layout system determines how UI elements are positioned and sized on screen. Understanding layout is crucial for creating well-structured, responsive interfaces.
+
+## Layout Fundamentals
+
+Every UI element has:
+
+- **Container Rectangle** - The space allocated by the parent
+- **Anchor** - How the element positions/sizes itself within the container
+- **Padding** - Inner spacing that affects child layout
+- **LayoutMode** - How the element arranges its children (if it's a container)
+
+```
+┌─────────────────────────────────────┐
+│  Container Rectangle (from parent)  │
+│  ┌───────────────────────────────┐  │
+│  │  Anchored Rectangle           │  │
+│  │  ┌─────────────────────────┐  │  │
+│  │  │ Padding                 │  │  │
+│  │  │  ┌───────────────────┐  │  │  │
+│  │  │  │  Content Area     │  │  │  │
+│  │  │  └───────────────────┘  │  │  │
+│  │  └─────────────────────────┘  │  │
+│  └───────────────────────────────┘  │
+└─────────────────────────────────────┘
+```
+
+## Anchor
+
+`Anchor` controls how an element positions and sizes itself within its container rectangle.
+
+### Fixed Size
+
+```
+Button {
+    Anchor: (Width: 200, Height: 40);
+}
+```
+
+Creates a 200×40 pixel button.
+
+### Positioning
+
+```
+Label {
+    Anchor: (Top: 10, Left: 20, Width: 100, Height: 30);
+}
+```
+
+- **Top**: 10 pixels from container's top edge
+- **Left**: 20 pixels from container's left edge
+- **Width**: 100 pixels wide
+- **Height**: 30 pixels tall
+
+### Anchoring to Edges
+
+```
+Button {
+    Anchor: (Bottom: 10, Right: 10, Width: 100, Height: 30);
+}
+```
+
+Anchors the button to the bottom-right corner, 10 pixels from each edge.
+
+### Stretching
+
+```
+Group {
+    Anchor: (Top: 0, Bottom: 0, Left: 0, Right: 0);
+}
+```
+
+Stretches to fill the entire container (all edges at 0 pixels).
+
+**Shorthand:**
+
+```
+Group {
+    Anchor: (Full: 0);
+}
+```
+
+### Mixed Anchoring
+
+```
+Panel {
+    Anchor: (Top: 10, Bottom: 10, Left: 20, Width: 300);
+}
+```
+
+- Fixed width of 300 pixels
+- Stretches vertically between top and bottom edges
+- 10 pixels from top and bottom
+- 20 pixels from left
+
+## Padding
+
+`Padding` creates inner spacing, affecting where children are positioned.
+
+### Uniform Padding
+
+```
+Group {
+    Padding: (Full: 20);
+}
+```
+
+20 pixels of padding on all sides.
+
+### Directional Padding
+
+```
+Group {
+    Padding: (Top: 10, Bottom: 20, Left: 15, Right: 15);
+}
+```
+
+Different padding per edge.
+
+### Shorthand
+
+```
+// Horizontal and vertical
+Group {
+    Padding: (Horizontal: 20, Vertical: 10);
+}
+
+// Equivalent to:
+// Top: 10, Bottom: 10, Left: 20, Right: 20
+```
+
+### Effect on Children
+
+```
+Group {
+    Anchor: (Width: 200, Height: 100);
+    Padding: (Full: 10);
+
+    Label {
+        Anchor: (Full: 0);
+    }
+}
+```
+
+The label fills the group, but there's a 10-pixel gap on all sides due to padding.
+
+```
+┌──────────────────────┐
+│ Group (200×100)      │
+│  ┌────────────────┐  │
+│  │ Label          │  │ ← 10px padding all around
+│  │                │  │
+│  └────────────────┘  │
+└──────────────────────┘
+```
+
+## LayoutMode
+
+`LayoutMode` determines how a container arranges its children.
+
+### Top (Vertical Stack)
+
+```
+Group {
+    LayoutMode: Top;
+
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+}
+```
+
+Children stack vertically from top to bottom:
+
+```
+┌──────────┐
+│ Button 1 │
+├──────────┤
+│ Button 2 │
+├──────────┤
+│ Button 3 │
+└──────────┘
+
+
+```
+
+Each child's `Anchor.Bottom` adds spacing between elements:
+
+```
+Button { Anchor: (Height: 30, Bottom: 10); }  // 10px gap after this button
+```
+
+### Bottom (Vertical Stack)
+
+```
+Group {
+    LayoutMode: Bottom;
+
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+}
+```
+
+Children stack vertically from top to bottom but aligned to the bottom edge of the parent:
+
+```
+
+
+
+┌──────────┐
+│ Button 1 │
+├──────────┤
+│ Button 2 │
+├──────────┤
+│ Button 3 │
+└──────────┘
+```
+
+### Left (Horizontal Stack)
+
+```
+Group {
+    LayoutMode: Left;
+
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+}
+```
+
+Children arrange horizontally from left to right:
+
+```
+┌────────┬────────┬────────┐
+│ Button │ Button │ Button │
+│   1    │   2    │   3    │
+└────────┴────────┴────────┘
+```
+
+Use `Anchor.Right` for spacing between elements.
+
+### Right (Horizontal Stack)
+
+```
+Group {
+    LayoutMode: Right;
+
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+}
+```
+
+Children arrange horizontally from left to right but aligned to the right side of the parent:
+
+```
+                                                                 ┌────────┬────────┬────────┐
+                                                                 │ Button │ Button │ Button │
+                                                                 │   1    │   2    │   3    │
+                                                                 └────────┴────────┴────────┘
+```
+
+### Center
+
+```
+Group {
+    LayoutMode: Center;
+
+    Group #Dialog {
+        Anchor: (Width: 400, Height: 300);
+    }
+}
+```
+
+Centers the children horizontally.
+
+### Middle
+
+```
+Group {
+    LayoutMode: Middle;
+
+    Group #Dialog {
+        Anchor: (Width: 400, Height: 300);
+    }
+}
+```
+
+Centers the children vertically.
+
+### CenterMiddle (Horizontal Stack, Fully Centered)
+
+```
+Group {
+    LayoutMode: CenterMiddle;
+
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+}
+```
+
+Children stack horizontally from left to right, centered both horizontally and vertically within the parent:
+
+```
+┌────────────────────────────────────────────┐
+│                                            │
+│                                            │
+│         ┌──────┐ ┌──────┐ ┌──────┐         │
+│         │  B1  │ │  B2  │ │  B3  │         │
+│         └──────┘ └──────┘ └──────┘         │
+│                                            │
+│                                            │
+└────────────────────────────────────────────┘
+```
+
+---
+
+### MiddleCenter (Vertical Stack, Fully Centered)
+
+```
+Group {
+    LayoutMode: MiddleCenter;
+
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+}
+```
+
+Children stack vertically from top to bottom, centered both horizontally and vertically within the parent:
+
+```
+┌────────────────────────────────────────────┐
+│                                            │
+│              ┌──────────┐                  │
+│              │ Button 1 │                  │
+│              ├──────────┤                  │
+│              │ Button 2 │                  │
+│              ├──────────┤                  │
+│              │ Button 3 │                  │
+│              └──────────┘                  │
+│                                            │
+└────────────────────────────────────────────┘
+```
+
+---
+
+### Full
+
+```
+Group {
+    LayoutMode: Full;
+
+    Label {
+        Anchor: (Top: 20, Left: 20, Width: 100, Height: 30);
+    }
+}
+```
+
+Children use absolute positioning via their `Anchor` properties.
+
+### TopScrolling
+
+```
+Group {
+    LayoutMode: TopScrolling;
+    ScrollbarStyle: $Common.@DefaultScrollbar;
+
+    // ... many children
+}
+```
+
+Like `Top`, but adds a scrollbar if content exceeds container height.
+
+Or use `BottomScrolling` for bottom-aligned content.
+
+### LeftScrolling
+
+```
+Group {
+    LayoutMode: LeftScrolling;
+    ScrollbarStyle: $Common.@DefaultScrollbar;
+
+    // ... many children
+}
+```
+
+Like `Left`, but adds a scrollbar for horizontal scrolling.
+
+Or use `RightScrolling` for right-aligned content.
+
+### LeftCenterWrap (Wrapping Horizontal Stack, Horizontally Centered)
+
+```
+Group {
+    LayoutMode: LeftCenterWrap;
+
+    Button { Anchor: (Width: 80, Height: 30); }
+    Button { Anchor: (Width: 80, Height: 30); }
+    Button { Anchor: (Width: 80, Height: 30); }
+    Button { Anchor: (Width: 80, Height: 30); }
+    Button { Anchor: (Width: 80, Height: 30); }
+}
+```
+
+Children flow left to right. When there's no more horizontal space, they wrap to the next row. Each row is horizontally centered within the parent:
+
+```
+┌────────────────────────────────────────────┐
+│                                            │
+│       ┌──────┐ ┌──────┐ ┌──────┐           │
+│       │  B1  │ │  B2  │ │  B3  │           │
+│       └──────┘ └──────┘ └──────┘           │
+│            ┌──────┐ ┌──────┐               │
+│            │  B4  │ │  B5  │               │
+│            └──────┘ └──────┘               │
+│                                            │
+└────────────────────────────────────────────┘
+```
+
+## FlexWeight
+
+`FlexWeight` distributes remaining space among children.
+
+```
+Group {
+    LayoutMode: Left;
+    Anchor: (Width: 400);
+
+    Button {
+        Anchor: (Width: 100);
+    }
+
+    Group {
+        FlexWeight: 1;  // Takes all remaining space
+    }
+
+    Button {
+        Anchor: (Width: 100);
+    }
+}
+```
+
+Result:
+
+- First button: 100px
+- Middle group: 200px (400 - 100 - 100 = 200)
+- Last button: 100px
+
+### Multiple FlexWeights
+
+```
+Group {
+    LayoutMode: Left;
+    Anchor: (Width: 600);
+
+    Group { FlexWeight: 1; }
+    Group { FlexWeight: 2; }
+    Group { FlexWeight: 1; }
+}
+```
+
+Remaining space (600px) is split:
+
+- First group: 600 × (1/4) = 150px
+- Second group: 600 × (2/4) = 300px
+- Third group: 600 × (1/4) = 150px
+
+## Visibility
+
+```
+Button #HiddenButton {
+    Visible: false;
+}
+```
+
+**Effect:**
+
+- Element and its children are not displayed
+- Element is **not included in layout** (doesn't take up space)
diff --git a/content/docs/fr-FR/official-documentation/custom-ui/markup.mdx b/content/docs/fr-FR/official-documentation/custom-ui/markup.mdx
new file mode 100644
index 00000000..564110ed
--- /dev/null
+++ b/content/docs/fr-FR/official-documentation/custom-ui/markup.mdx
@@ -0,0 +1,226 @@
+---
+title: Markup
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# Markup
+
+## Markup
+
+An element is the basic building block of a user interface. There are various types of elements with different properties, which are documented below.
+
+Here's what the syntax looks like:
+
+```
+// Basic declaration of an element
+// with its Anchor property set to attach on all sides of its parent
+// with 10 pixels of margin
+Group { Anchor: (Left: 10, Top: 10, Right: 10, Bottom: 10); }
+
+Group { Anchor: (Full: 10); } // More concise version
+
+// Declaration of a Label with a name
+// (can be used to access the element from game code)
+Label #MyLabel {
+  Style: LabelStyle(FontSize: 16); // or just Style: (FontSize: 16), type can be inferred.
+  Text: "Hi! I am text.";
+}
+
+// Declaration of a Group containing 2 children
+// You can use FlexWeight to distribute any left-over space after explicit widths/heights have been subtracted
+Group {
+  LayoutMode: Left;
+  Label { Text: "Child 1"; FlexWeight: 2; }
+  Label { Text: "Child 2"; FlexWeight: 1; }
+}
+```
+
+### Documents
+
+A UI document (_.ui_ file) contains trees of elements. There can be multiple root elements.
+
+### Named Expressions
+
+Named expressions can be declared at any level of a document (including at the root) and will be scoped to that subtree, though they need to be declared at the top of the block.
+
+```
+// Example of named expressions, declared and used with @ prefix
+@Title = "Hytale";
+@ExtraSpacing = 5;
+
+Label {
+  Text: @Title;
+  Style: (LetterSpacing: 2 + @ExtraSpacing);
+}
+```
+
+You can use the spread operator `...` to reuse a named expression while overriding some of its fields:
+
+```
+@MyBaseStyle = LabelStyle(FontSize: 24, LetterSpacing: 2);
+
+Label {
+  Style: (...@MyBaseStyle, FontSize: 36);
+}
+```
+
+You can even layer multiple named expressions like so:
+
+```
+@TitleStyle = LabelStyle(FontSize: 24, HorizontalAlignment: Center);
+@SpacedTextStyle = LabelStyle(LetterSpacing: 2);
+
+Label {
+  Style: (...@BigTextStyle, ...@SpacedTextStyle);
+}
+```
+
+#### Document references
+
+A document can reference another document and access its named expressions.
+
+```
+// Document references are defined with $ prefix
+$Common = "../Common.ui";
+
+TextButton {
+  Style: $Common.@DefaultButtonStyle;
+}
+```
+
+### Templates
+
+You can declare a reusable bit of interface as a named expression and then instantiate it as many times as you want in the tree while customizing it.
+
+You can override local named expressions as well as insert additional children at any point in the template tree. However, local named expressions must be defined at the very top of the block, before properties and child elements.
+
+```
+// This is the template
+@Row = Group {
+  Anchor: (Height: 50);
+  Label #Label { Anchor: (Left: 0, Width: 100); Text: @LabelText; }
+  Group #Content { Anchor: (Left: 100); }
+};
+
+// Here we'll be using it twice in the document tree
+Group #Rows {
+  LayoutMode: TopScrolling;
+
+  @Row #MyFirstRow {
+    @LabelText = "First row";
+    #Content { TextInput {} }
+  }
+
+  @Row #MySecondRow {
+    @LabelText = "Second row";
+  }
+}
+```
+
+### Property Types
+
+#### Basic Types
+
+- **Boolean**
+  - `Visible: false;`
+  - `Visible: true;`
+- **Int**
+  - `Height: 20;`
+- **Float, Double, Decimal**
+  - `Min: 0.2;`
+- **String**
+  - `Text: "Hi!";`
+- **Char**
+  - `PasswordChar: "*";`
+  - _Note: The syntax is the same as a string, however a value of this type cannot contain more than one character!_
+- **Color**
+  - `Background: #ffffff;`&#x20;
+- **Objects**
+  - `Style: (Background: #ffffff)`
+- **Array**&#x20;
+  - `TextSpans: [(Text: "Hi", IsBold: true)]`
+
+#### Translations
+
+Translation keys can be referenced anywhere in markup where you can provide a string, and they are then converted to a string when an element gets instantiated.
+
+**Example:**
+
+```
+Label {
+  Text: %ui.general.cancel;
+}
+```
+
+#### Colors
+
+A color literal can be written as follows:
+
+- `#rrggbb`: 6-digit hexadecimal representation for red, green, blue (fully opaque)
+- `#rrggbb(a.a)`: 6-digit hexadecimal representation for red, green, blue with alpha between 0 and 1
+- `#rrggbbaa`: 8-digit hexadecimal representation for red, green, blue and alpha
+
+```
+Group {
+  Background: #000000(0.3);
+}
+```
+
+<Callout>
+  The `#rrggbb(a.a)` format is prefered over the `#rrggbbaa` format for
+  readability reasons.
+</Callout>
+
+#### Font Name
+
+Font names can be referenced directly by their string ID. Internally this is using a custom type called `UIFontName`, however strings will be converted automatically to this type in markup.
+
+```
+Label {
+  Text: "Hi";
+  Style: (FontName: "Secondary");
+}
+```
+
+**Available Font Names**
+
+- _Default_ - This is the default font that is used for most text and is always used unless a different option has been specified
+- _Secondary_ - This font is mostly used for headlines or elements that are supposed to stick out
+- _Mono_ - This is only used for development; For things such as profiling or error overlays.
+
+#### Path
+
+We can reference other UI assets with the `UIPath` type. Similar to `UIFontName`_,_ Strings are automatically converted to a `UIPath`. Paths are always relative to the file where they have been declared in. Looking up _MyButton.png_ in _Menu/MyAwesomeMenu.ui_ will result in _Menu/MyButton.png_. If you want to reference a file that is in a parent folder you can go back one directory by writing two dots (_../MyButton.png_).
+
+The markup syntax of a `UIPath` is the same as a String. (e.g. `Path: "Test.png"`)
+
+Here are some more examples:
+
+| UIPath             | .ui File                              | Resulting Path    |
+| ------------------ | ------------------------------------- | ----------------- |
+| MyButton.png       | Menu/MyAwesomeMenu.ui                 | Menu/MyButton.png |
+| ../MyButton.png    | Menu/MyAwesomeMenu.ui                 | MyButton.png      |
+| ../../MyButton.png | Menu/Popup/Templates/MyAwesomeMenu.ui | Menu/MyButton.png |
+
+#### Objects
+
+Objects contain a set of properties. In this example we are assigning an Anchor object to the _Anchor_ property:
+
+```
+Group {
+  Anchor: (
+   Height: 10,
+   Width: 20
+ );
+}
+```
+
+You can find all objects that can be used in markup [here](type-documentation#elements).
+
+## Visual Studio Code Extension
+
+There is an official extension for Visual Studio Code which adds syntax highlighting for .ui files. You can find it [here](https://marketplace.visualstudio.com/items?itemName=HypixelStudiosCanadaInc.vscode-hytaleui).
diff --git a/content/docs/fr-FR/official-documentation/custom-ui/type-documentation/index.mdx b/content/docs/fr-FR/official-documentation/custom-ui/type-documentation/index.mdx
new file mode 100644
index 00000000..69cea406
--- /dev/null
+++ b/content/docs/fr-FR/official-documentation/custom-ui/type-documentation/index.mdx
@@ -0,0 +1,127 @@
+---
+title: Type Documentation
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# Type Documentation
+
+This is a generated list of UI elements accessible by markup. More information about the User Interface framework can be found in the main documentation.
+
+## Elements
+
+- [ActionButton](type-documentation/elements/actionbutton)
+- [AssetImage](type-documentation/elements/assetimage)
+- [BackButton](type-documentation/elements/backbutton)
+- [BlockSelector](type-documentation/elements/blockselector)
+- [Button](type-documentation/elements/button)
+- [CharacterPreviewComponent](type-documentation/elements/characterpreviewcomponent)
+- [CheckBox](type-documentation/elements/checkbox)
+- [CheckBoxContainer](type-documentation/elements/checkboxcontainer)
+- [CircularProgressBar](type-documentation/elements/circularprogressbar)
+- [CodeEditor](type-documentation/elements/codeeditor)
+- [ColorOptionGrid](type-documentation/elements/coloroptiongrid)
+- [ColorPicker](type-documentation/lements/colorpicker)
+- [ColorPickerDropdownBox](type-documentation/elements/colorpickerdropdownbox)
+- [CompactTextField](type-documentation/elements/compacttextfield)
+- [DropdownBox](type-documentation/elements/dropdownbox)
+- [DropdownEntry](type-documentation/elements/dropdownentry)
+- [DynamicPane](type-documentation/elements/dynamicpane)
+- [DynamicPaneContainer](type-documentation/elements/dynamicpanecontainer)
+- [FloatSlider](type-documentation/elements/floatslider)
+- [FloatSliderNumberField](type-documentation/elements/floatslidernumberfield)
+- [Group](type-documentation/elements/group)
+- [HotkeyLabel](type-documentation/elements/hotkeylabel)
+- [ItemGrid](type-documentation/elements/itemgrid)
+- [ItemIcon](type-documentation/elements/itemicon)
+- [ItemPreviewComponent](type-documentation/elements/itempreviewcomponent)
+- [ItemSlot](type-documentation/elements/itemslot)
+- [ItemSlotButton](type-documentation/elements/itemslotbutton)
+- [Label](type-documentation/elements/label)
+- [LabeledCheckBox](type-documentation/elements/labeledcheckbox)
+- [MenuItem](type-documentation/elements/menuitem)
+- [MultilineTextField](type-documentation/elements/multilinetextfield)
+- [NumberField](type-documentation/elements/numberfield)
+- [Panel](type-documentation/elements/panel)
+- [ProgressBar](type-documentation/elements/progressbar)
+- [ReorderableList](type-documentation/elements/reorderablelist)
+- [ReorderableListGrip](type-documentation/elements/reorderablelistgrip)
+- [SceneBlur](type-documentation/elements/sceneblur)
+- [Slider](type-documentation/elements/slider)
+- [SliderNumberField](type-documentation/elements/slidernumberfield)
+- [Sprite](type-documentation/elements/sprite)
+- [TabButton](type-documentation/elements/tabbutton)
+- [TabNavigation](type-documentation/elements/tabnavigation)
+- [TextButton](type-documentation/elements/textbutton)
+- [TextField](type-documentation/elements/textfield)
+- [TimerLabel](type-documentation/elements/timerlabel)
+- [ToggleButton](type-documentation/elements/togglebutton)
+
+## Property Types
+
+- [Anchor](type-documentation/property-types/anchor)
+- [BlockSelectorStyle](type-documentation/property-types/blockselectorstyle)
+- [ButtonSounds](type-documentation/property-types/buttonsounds)
+- [ButtonStyle](type-documentation/property-types/buttonstyle)
+- [ButtonStyleState](type-documentation/property-types/buttonstylestate)
+- [CheckBoxStyle](type-documentation/property-types/checkboxstyle)
+- [CheckBoxStyleState](type-documentation/property-types/checkboxstylestate)
+- [ClientItemStack](type-documentation/property-types/clientitemstack)
+- [ColorOptionGridStyle](type-documentation/property-types/coloroptiongridstyle)
+- [ColorPickerDropdownBoxStateBackground](type-documentation/property-types/colorpickerdropdownboxstatebackground)
+- [ColorPickerDropdownBoxStyle](type-documentation/property-types/colorpickerdropdownboxstyle)
+- [ColorPickerStyle](type-documentation/property-types/colorpickerstyle)
+- [DropdownBoxSearchInputStyle](type-documentation/property-types/dropdownboxsearchinputstyle)
+- [DropdownBoxSounds](type-documentation/property-types/dropdownboxsounds)
+- [DropdownBoxStyle](type-documentation/property-types/dropdownboxstyle)
+- [InputFieldButtonStyle](type-documentation/property-types/inputfieldbuttonstyle)
+- [InputFieldDecorationStyle](type-documentation/property-types/inputfielddecorationstyle)
+- [InputFieldDecorationStyleState](type-documentation/property-types/inputfielddecorationstylestate)
+- [InputFieldIcon](type-documentation/property-types/inputfieldicon)
+- [InputFieldStyle](type-documentation/property-types/inputfieldstyle)
+- [ItemGridSlot](type-documentation/property-types/itemgridslot)
+- [ItemGridStyle](type-documentation/property-types/itemgridstyle)
+- [LabeledCheckBoxStyle](type-documentation/property-types/labeledcheckboxstyle)
+- [LabeledCheckBoxStyleState](type-documentation/property-types/labeledcheckboxstylestate)
+- [LabelSpan](type-documentation/property-types/labelspan)
+- [LabelStyle](type-documentation/property-types/labelstyle)
+- [NumberFieldFormat](type-documentation/property-types/numberfieldformat)
+- [Padding](type-documentation/property-types/padding)
+- [PatchStyle](type-documentation/property-types/patchstyle)
+- [PopupStyle](type-documentation/property-types/popupstyle)
+- [ScrollbarStyle](type-documentation/property-types/scrollbarstyle)
+- [SliderStyle](type-documentation/property-types/sliderstyle)
+- [SoundStyle](type-documentation/property-types/soundstyle)
+- [SpriteFrame](type-documentation/property-types/spriteframe)
+- [SubMenuItemStyle](type-documentation/property-types/submenuitemstyle)
+- [SubMenuItemStyleState](type-documentation/property-types/submenuitemstylestate)
+- [Tab](type-documentation/property-types/tab)
+- [TabNavigationStyle](type-documentation/property-types/tabnavigationstyle)
+- [TabStyle](type-documentation/property-types/tabstyle)
+- [TabStyleState](type-documentation/property-types/tabstylestate)
+- [TextButtonStyle](type-documentation/property-types/textbuttonstyle)
+- [TextButtonStyleState](type-documentation/property-types/textbuttonstylestate)
+- [TextTooltipStyle](type-documentation/property-types/texttooltipstyle)
+- [ToggleButtonStyle](type-documentation/property-types/togglebuttonstyle)
+- [ToggleButtonStyleState](type-documentation/property-types/togglebuttonstylestate)
+
+## Enums
+
+- [ActionButtonAlignment](type-documentation/enums/actionbuttonalignment)
+- [CodeEditorLanguage](type-documentation/enums/codeeditorlanguage)
+- [ColorFormat](type-documentation/enums/colorformat)
+- [DropdownBoxAlign](type-documentation/enums/dropdownboxalign)
+- [InputFieldButtonSide](type-documentation/enums/inputfieldbuttonside)
+- [InputFieldIconSide](type-documentation/enums/inputfieldiconside)
+- [ItemGridInfoDisplayMode](type-documentation/enums/itemgridinfodisplaymode)
+- [LabelAlignment](type-documentation/enums/labelalignment)
+- [LayoutMode](type-documentation/enums/layoutmode)
+- [MouseWheelScrollBehaviourType](type-documentation/enums/mousewheelscrollbehaviourtype)
+- [ProgressBarAlignment](type-documentation/enums/progressbaralignment)
+- [ProgressBarDirection](type-documentation/enums/progressbardirection)
+- [ResizeType](type-documentation/enums/resizetype)
+- [TimerDirection](type-documentation/enums/timerdirection)
+- [TooltipAlignment](type-documentation/enums/tooltipalignment)
diff --git a/content/docs/fr-FR/official-documentation/npc/2-getting-started-with-templates.mdx b/content/docs/fr-FR/official-documentation/npc/2-getting-started-with-templates.mdx
index 91081ca1..99d078e0 100644
--- a/content/docs/fr-FR/official-documentation/npc/2-getting-started-with-templates.mdx
+++ b/content/docs/fr-FR/official-documentation/npc/2-getting-started-with-templates.mdx
@@ -9,7 +9,7 @@ authors:
 
 There are no hard and fast rules for making a start on a template. I like to duplicate **BlankTemplate** and start from there because it already provides the basic structure of the file.
 
-This leaves me with the following template (`Template_Goblin_Ogre.json`): (note: the file could be looking different in the current version of the game)
+This leaves me with the following template (`Template_Goblin_Ogre.json`): (**note: the file could be looking different in the current version of the game**)
 
 ```json
 {
@@ -33,7 +33,7 @@ This leaves me with the following template (`Template_Goblin_Ogre.json`): (note:
     }
   },
   "Appearance": { "Compute": "Appearance" },
-  "DropList": { "Compute": "Droplist" },
+  "DropList": { "Compute": "DropList" },
   "MaxHealth": { "Compute": "MaxHealth" },
   "MotionControllerList": [
     {
@@ -65,10 +65,10 @@ And the following variant (`Goblin_Ogre.json`) next to the template. There's a t
   "Type": "Variant",
   "Reference": "Template_Goblin_Ogre",
   "Modify": {
-    "Appearance": "Goblin_Ogre",
+    "Appearance": "Goblin",
     "MaxHealth": 124
   }
 }
 ```
 
-Our artists have defined the `Goblin_Ogre` appearance already so I'm going to use that.
+Our artists have not yet finished animations for the `Goblin_Ogre`, for that sake of the tutorial I am going to use appearance `Goblin`, because it offers a more complete set of animations that we will need.
diff --git a/content/docs/fr-FR/official-documentation/worldgen/pack-tutorial/asset-packs.mdx b/content/docs/fr-FR/official-documentation/worldgen/pack-tutorial/asset-packs.mdx
index 38809fad..dcf1f3b9 100644
--- a/content/docs/fr-FR/official-documentation/worldgen/pack-tutorial/asset-packs.mdx
+++ b/content/docs/fr-FR/official-documentation/worldgen/pack-tutorial/asset-packs.mdx
@@ -9,13 +9,13 @@ authors:
 
 <OfficialDocumentationNotice />
 
-# How to modify Hytale
+# How to modify Hytale?
 
-## What's an Asset Pack
+## What's an Asset Pack?
 
-Hytales gameplay is driven by assets in the game that can be modified by creators. Asset Packs are our solution to let you override or add features to the base game with your own work. These can in the form of zip files of folders, which contain a custom set of assets. This is not the only way for a creator to change Hytale but this is the most accessible form.;
+Hytales gameplay is driven by assets in the game that can be modified by creators. Asset Packs are our solution to let you override or add features to the base game with your own work. These can be the form of zip files of folders, which contain a custom set of assets. This is not the only way for a creator to change Hytale but this is the most accessible form.;
 
-### How do I make an Asset Pack
+### How do I make an Asset Pack?
 
 <video controls className="my-6 aspect-video w-full rounded-lg border">
   <source src="https://cdn.internal.hytalemodding.dev/guides/official/how-to-asset-pack.mp4" type="video/mp4" />
@@ -48,7 +48,7 @@ An asset pack is typically a zip or folder, with a `manifest.json` inside. This
 }
 ```
 
-### Where are they stored
+### Where are they stored?
 
 Asset Packs are stored with other mods in the Mods folder.
 
@@ -76,7 +76,7 @@ C:\Users\<user>\AppData\Roaming\Hytale\UserData\Saves\New World 5\mods
 
 When you have Asset Packs or Mods installed, these will appear in the New World menu under the Options menu.;
 
-### How do I change an existing asset
+### How do I change an existing asset?
 
 <video controls className="my-6 aspect-video w-full rounded-lg border">
   <source src="https://cdn.internal.hytalemodding.dev/guides/official/how-to-asset.mp4" type="video/mp4" />
diff --git a/content/docs/fr-FR/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx b/content/docs/fr-FR/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx
index 44528376..24e628b5 100644
--- a/content/docs/fr-FR/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx
+++ b/content/docs/fr-FR/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx
@@ -106,7 +106,7 @@ If a BaseHeight is provided, the TopY and BottomY values are relative to the Bas
 
 Applies a Material Provider slot on a set of horizontal stripes of blocks of varying thickness and position. Below is an example image of basalt stripes into a stone cliff.
 
-{/* ![](https://540086904-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F7KAmBkOg6d13nZCkf9ku%2Fuploads%2FbcxO9LpArn8gPCaBwFg5%2Funknown.png?alt=media&token=1c72b67a-8253-4d03-8c64-1ad5f6830050) */}
+![Example of basalt stripes](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/basalt-stripes-example.png)
 
 #### Parameters:
 
diff --git a/content/docs/fr-FR/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx b/content/docs/fr-FR/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx
index 5e34acd4..a4418473 100644
--- a/content/docs/fr-FR/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx
+++ b/content/docs/fr-FR/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx
@@ -294,7 +294,7 @@ Combines all the positions into a single Positioins field.
 
 ---
 
-### SimpleHoritontal
+### SimpleHorizontal
 
 Keeps only the positions that are within the provided range.
 
diff --git a/content/docs/fr-FR/official-documentation/worldgen/worldgen-tutorial/README.mdx b/content/docs/fr-FR/official-documentation/worldgen/worldgen-tutorial/README.mdx
new file mode 100644
index 00000000..5f66d245
--- /dev/null
+++ b/content/docs/fr-FR/official-documentation/worldgen/worldgen-tutorial/README.mdx
@@ -0,0 +1,166 @@
+---
+title: How to edit and create Biomes
+description: Explores where world generation assets can be found and how to edit them.
+---
+
+### Where are the Assets
+
+World generation assets are kept in the HytaleGenerator directory within the assets.
+
+```
+/Server/HytaleGenerator/
+```
+
+<div className="flex flex-row rounded-lg border p-4">
+  <div className="flex-1/2 border-r pr-4">
+    ```
+    /Biomes
+    ```
+
+    Biome assets, with content configurations.
+  </div>
+
+  <div className="flex-1/2 pl-4">
+    ```
+    /WorldStructure
+    ```
+
+    Generator files that define which biomes spawn together.
+  </div>
+</div>
+
+<div className="flex flex-row rounded-lg border p-4">
+  <div className="flex-1/2 border-r pr-4">
+    ```
+    /Density
+    ```
+
+    Density assets that can be referenced by any other assets.
+  </div>
+
+  <div className="flex-1/2 pl-4">
+    ```
+    /Assignments
+    ```
+
+    Prop assets that can be referenced by any Biome assets.
+  </div>
+</div>
+
+***
+
+An example of this structure can be found bellow, packed in an asset pack with the instance configuration.
+
+[https://drive.google.com/file/d/1sIz_CluANIIe3n8vNiOi-4PQdeqCO0qY/view?usp=drive_link](https://drive.google.com/file/d/1sIz_CluANIIe3n8vNiOi-4PQdeqCO0qY/view?usp=drive_link)
+
+<Callout>
+  Ensure you place your asset pack in the correct directory, under Mods.
+</Callout>
+
+### How to visit our worlds
+
+https://drive.google.com/file/d/1BJurxyj-taE-PXWm04bk7Dl6X7ZHTH92/view?usp=sharing
+
+#### Requirements
+
+- You must be an **Operator** in the world.
+  - To do this, run <mark style="color:$danger;">`/op self`</mark>
+- You must be in **Creative mode**.
+  - Press the <mark style="color:$danger;">`O`</mark> key, O for Orange.&#x20;
+
+The generation assets define a set of generators but on their own you cannot visit these. Currently you require an Instance with a generator that will allow you to visit your work.
+
+```
+/Server/Instances/
+```
+
+Instances are separate worlds that players can join using the `/instances` command. Each instance has an `Instance.bson` configuration asset that specifies which generator to use, among other worldly settings.
+
+```json
+{
+  "WorldGen": {
+    "Type": "HytaleGenerator",
+    "WorldStructure": "Basic",
+    "playerSpawn" : {
+      "X" : 123,
+      "Y" : 480,
+      "Z" : 10000,
+      "Pitch" : 0,
+      "Yaw" : 0,
+      "Roll" : 0
+    }
+  }
+}
+```
+
+<Callout>
+  You can create custom instances for different world structures and biomes as you need them.
+</Callout>
+
+### How to edit Biomes
+
+<video>
+  <source src="https://cdn.internal.hytalemodding.dev/guides/official/How-to-edit-Biomes.mp4" type="video/mp4" />
+</video>
+
+We currently use the Hytale Node Editor when editing world generation assets. This can be accessed while in-game from the Content Creation menu when pressing B. The node editor is then found under the asset editor dropdown on the upper left.&#x20;
+
+![Node Editor 1](/assets/official-documentation/worldgen/worldgen-tutorial/biomes/node-editor-1.png)
+
+Once you have the Hytale Node Editor open, through the file menu you can open Biomes by navigating to the Biomes directory and selecting one from your pack.&#x20;
+
+```
+/Server/HytaleGenerator/Biomes/
+```
+
+### Biome Asset Structure
+
+Every Biome has a root Biome node, this node splits into 5 structures. This is covered briefly but more information on each field can be found on the World Generation Concepts page.
+
+![Node Editor 2](/assets/official-documentation/worldgen/worldgen-tutorial/biomes/node-editor-2.png)
+
+<Callout>
+  Each biome is for the most part self contained, meaning it has control over what appears with the biome. The only exception to this are Base Heights.
+</Callout>
+
+<Tabs>
+  <Tab value="Terrain">
+    Mathematical function nodes that calculate the physical shape of the Biome's terrain.
+  </Tab>
+
+  <Tab value="Materials">
+    Logical nodes that determine what materials (blocks) make up a Biome's terrain.
+  </Tab>
+
+  <Tab value="Props">
+    Function nodes that add objects like prefabs and decorations to the terrain.
+  </Tab>
+
+  <Tab value="Environments">
+    Logical nodes that determine the environment asset at a given coordinate within the biome. This asset determines things like weather, NPC spawns, and sounds.
+  </Tab>
+
+  <Tab value="Tints">
+    Logical function nodes that determine a colour code that can be used by certain blocks in the world. Typically this will be grasses and soils.
+  </Tab>
+</Tabs>
+
+### How to preview your work
+
+[https://drive.google.com/file/d/1mNcHn9LhFnWDF0DzWFH6_YllmKAUvUry/view?t=6](https://drive.google.com/file/d/1mNcHn9LhFnWDF0DzWFH6_YllmKAUvUry/view?t=6)
+
+Once you are in an Instance world with the Hytale Generator active you will only be able to see your work by generating new chunks. There are a few ways to do this.
+
+The viewport command selects an area around the Player that will live reload as you make changes to the generator.&#x20;
+
+```
+/viewport --radius 5 
+```
+
+You can also create a new world to show your changes.&#x20;
+
+```
+/instances spawn <instance> 
+```
+
+The last option is to simply fly south, new chunks will generate with the changes made.
diff --git a/content/docs/fr-FR/publishing/builtbybit.mdx b/content/docs/fr-FR/publishing/builtbybit.mdx
index d3488448..baeec8b9 100644
--- a/content/docs/fr-FR/publishing/builtbybit.mdx
+++ b/content/docs/fr-FR/publishing/builtbybit.mdx
@@ -1,91 +1,91 @@
 ---
 title: BuiltByBit
-description: Complete guide to publishing and selling your Hytale creations on BuiltByBit.
+description: Guide complet pour la publication et la gestion de vos créations Hytale sur BuiltByBit.
 ---
 
-# Why BuiltByBit?
+# Pourquoi BuiltByBit?
 
-BuiltByBit is the largest third-party marketplace for Minecraft and Roblox, and now Hytale. Unlike other platforms, BuiltByBit is primarily focused on premium content, allowing creators to monetize their work (though free resources are also welcome)!
+BuiltByBit est le plus grand marché tiers pour Minecraft et Roblox, et maintenant Hytale. Contrairement aux autres plates-formes, BuiltByBit se concentre principalement sur le contenu premium, permettant aux créateurs de monétiser leur travail (bien que les ressources gratuites soient également les bienvenues) !
 
-Within just days of Hytale's early access launch, creators on BuiltByBit have already earned thousands of dollars selling their Hytale creations.
+En quelques jours à peine, après le lancement de l'accès anticipé d'Hytale, les créateurs sur BuiltByBit ont déjà gagné des milliers de dollars en vendant leurs créations.
 
-Key advantages:
+Avantages clés :
 
-- Monetize your work - Set your own prices for premium content with no maximum limit
-- Fast approval times - Industry-leading review times averaging just 4 hours
-- More categories - The widest range of content types of any Hytale platform
-- Established marketplace - Join a proven ecosystem with hundreds of thousands of active buyers
+- Monétisez votre travail - Fixez vos propres prix pour le contenu premium sans limites maximale
+- Délai d'approbation rapide - Les temps de révision les plus élevés de l'industrie ne sont que de 4 heures en moyenne
+- Plus de catégories - La plus large gamme de types de contenu de n'importe quelle plateforme Hytale
+- Marché établi - Rejoignez un écosystème éprouvé avec des centaines de milliers d'acheteurs actifs
 
-# Available Categories
+# Catégories disponibles
 
-BuiltByBit supports the following categories:
-Plugins - Server-side plugins and modifications
-Data assets - Custom data packs, loot tables, and data-driven content
-Server setups - Complete server configurations and setups
-Builds - Prefabs, structures, and world builds
-Graphics - UI elements, icons, and visual assets
-Textures - Texture packs and reskins
-Models - Custom 3D models and animations
-Audio - Sound effects and music
-Other - Anything else that doesn't fit the above
+BuiltByBit prend en charge les catégories suivantes :
+Plugins - Plugins côté serveur et modifications
+Assets de données - Packs de données personnalisées, tables de butin et contenu basé sur les données
+Configuration du serveur - Configuration complète des serveurs et des installations
+Constructions - Prefabs, structures, et constructions de monde
+Graphismes - Éléments de l'interface, icônes, et ressources visuelles
+Textures - Packs de textures et reskins
+Modèles - Modèles et animations 3D personnalisés
+Audio - Effets sonores et musique
+Autre - Tout ce qui ne correspond pas à ce qui précède
 
-# Prerequisites
+# Prérequis
 
-Before you start, make sure you have:
+Avant de commencer, assurez-vous d'avoir :
 
-- A compiled `.jar` file (for plugins) or `.zip` file (for other content)
-- A description of your creation's features
-- A Tebex account for receiving payments (can be created during setup)
+- Un fichier compilé `.jar` (pour les plugins) ou `.zip` (pour les autres contenus)
+- Une description des fonctionnalités de votre création
+- Un compte Tebex pour recevoir des paiements (peut être créé pendant l'installation)
 
-We also recommend:
+Nous recommandons également :
 
-- High-quality screenshots showcasing your creation
-- A clear logo or icon
-- Documentation of any dependencies or requirements
+- Des captures d'écran de haute qualité présentant votre création
+- Un logo ou une icône de bonne qualité
+- Documentation de toutes les dépendances ou exigences
 
-# Step-by-Step Publishing Process
+# Processus de publication étape par étape
 
-## 1. Create Your Account
+## 1. Créez votre compte
 
-Register for a BuiltByBit account at [builtbybit.com/login/register](https://builtbybit.com/login/register).
+Inscrivez-vous à un compte BuiltByBit sur [builtbybit.com/login/register](https://builtbybit.com/login/register).
 
-## 2. Set Up Your Wallet
+## 2. Configurez votre porte-monnaie
 
-Link your Tebex Wallet (or create one if you don't have one) at [builtbybit.com/resources/dashboard/wallet](https://builtbybit.com/resources/dashboard/wallet). This is where your earnings will be deposited.
+Liez votre portefeuille Tebex (ou créez-en un si vous n'en avez pas) à [builtbybit.com/resources/dashboard/wallet](https://builtbybit.com/resources/dashboard/wallet). C'est là que vos gains seront déposés.
 
-## 3. Add Your Resource
+## 3. Ajoutez votre ressource
 
-Navigate to [builtbybit.com/resources/add](https://builtbybit.com/resources/add) and select the appropriate category for your content.
+Naviguez vers [builtbybit.com/resources/add](https://builtbybit.com/resources/add) et sélectionnez la catégorie appropriée pour votre contenu.
 
-## 4. Complete Your Listing
+## 4. Complétez votre annonce
 
-Fill out all required fields:
+Remplissez tous les champs obligatoires:
 
-- Title - A clear, descriptive name for your creation
-- Description - Comprehensive details about features and usage
-- Tags - Relevant keywords to help buyers find your content
-- Pricing - Choose free or set a price (minimum $1.99 to $5.99 for paid content depending on category)
-- File Upload - Upload your .jar or .zip file
+- Titre - Un nom clair, descriptif pour votre création
+- Description - Détails complets des fonctionnalités et de leur utilisation
+- Tags - Mots clés pertinents pour aider les acheteurs à trouver votre contenu
+- Prix - Choisissez gratuitement ou fixez un prix (minimum de $1,99 à $5,99 pour le contenu payé selon la catégorie)
+- Envoi de fichier - Envoyez votre fichier .jar ou .zip
 
-## 5. Submit for Approval
+## 5. Soumettre pour approbation
 
-Click "Submit for approval" to send your resource to our moderation team.
+Cliquez sur "Soumettre pour approbation" pour envoyer votre ressource à notre équipe de modération.
 
-## 6. You're Done!
+## 6. Et voilà !
 
-Once approved, your resource will be live and accessible to buyers. With our review times averaging just 4 hours, you won't be waiting long.
+Une fois approuvée, votre ressource sera active et accessible aux acheteurs. Avec nos temps de révision d'en moyenne 4 heures, vous n'attendrez pas longtemps.
 
-# Pricing & Fees
+# Prix et frais
 
-- Minimum price: $1.99 to $5.99 for paid content depending on category (no maximum)
-- Platform fee: 9.9% per transaction
-- Gateway fee: Reduced rate charged per transaction
+- Prix minimum: $1.99 à $5.99 pour le contenu payant selon la catégorie (sans maximum)
+- Frais de plateforme : 9,9 % par transaction
+- Frais de passerelle : Taux réduit facturé par transaction
 
-The 9.9% platform fee allows us to continuously introduce new features and improvements. [Learn more about fees](https://builtbybit.com/resources/creators).
+Les frais de plateforme de 9,9 % nous permettent d'introduire continuellement de nouvelles fonctionnalités et améliorations. [En savoir plus sur les frais] (https://builtbybit.com/resources/creators).
 
-# Getting Help
+# Obtenir de l'aide
 
-- Creator Knowledge Base - [creators.builtbybit.com](https://creators.builtbybit.com) - Articles covering every feature
-- Discord Community - [discord.gg/builtbybit](https://discord.gg/builtbybit) - Dedicated channels for Hytale creators (sync your account to access)
-- Become a Creator - [builtbybit.com/resources/creators](https://builtbybit.com/resources/creators) - Overview of selling on BuiltByBit
-- Browse Hytale Resources - [builtbybit.com/resources/hytale](https://builtbybit.com/resources/hytale) - See what other creators are selling
+- Base de connaissances du créateur - [creators.builtbybit.com](https://creators.builtbybit.com) - Articles couvrant chaque fonctionnalité
+- Communauté Discord - [discord.gg/builtbybit](https://discord.gg/builtbybit) - Salons dédiés aux créateurs d'Hytale (synchronisez votre compte pour y accéder)
+- Devenez un créateur - [builtbybit.com/resources/creators](https://builtbybit.com/resources/creators) - Aperçu de la vente sur BuiltByBit
+- Parcourir les ressources d'Hytale - [builtbybit.com/resources/hytale](https://builtbybit.com/resources/hytale) - Voir ce que les autres créateurs vendent
diff --git a/content/docs/fr-FR/publishing/curseforge.mdx b/content/docs/fr-FR/publishing/curseforge.mdx
index d97327d5..424ccd4f 100644
--- a/content/docs/fr-FR/publishing/curseforge.mdx
+++ b/content/docs/fr-FR/publishing/curseforge.mdx
@@ -1,32 +1,32 @@
 ---
 title: CurseForge
-description: Learn how to publish your mod to CurseForge
+description: Apprenez comment publier votre mod sur CurseForge
 ---
 
-CurseForge is a mod hosting platform, allowing you to share your Hytale mods and creations with players via our website and app.
+CurseForge est une plateforme d'hébergement de mods, vous permettant de partager vos mods et créations Hytale avec les joueurs via notre site web et notre application.
 
-## 1. Create CurseForge Account
+## 1. Créer un compte CurseForge
 
-First, [visit our sign-in page](https://curseforge.com/api/v1/auth/login?returnUrl=https://www.curseforge.com/) and either log in to an existing account or click “Create an account”.
+Tout d’abord, [rendez-vous sur notre page de connexion](https://curseforge.com/api/v1/auth/login?returnUrl=https://www.curseforge.com/) et connectez-vous à un compte existant ou cliquez sur « Créer un compte ».
 
-This can be done using any Google, Discord, GitHub or Twitch account.
+Ce qui peut être fait en utilisant n'importe quel compte Google, Discord, GitHub ou Twitch.
 
-## 2. Create a Project
+## 2. Créer un projet
 
-Now that you're logged in, you can visit our Author Console and navigate to the Projects tab, then click “Create a Project”, either in the sidebar or at the top of the page.
+Maintenant que vous êtes connecté, vous pouvez vous rendre sur votre Console Auteur et accéder à l'onglet Projets, puis cliquez sur « Créer un projet », soit dans la barre latérale ou en haut de la page.
 
-![CurseForge Author Page](/assets/guides/curseforge_author_page.png)
+![CurseForge Page Auteur](/assets/guides/curseforge_author_page.png)
 
-This will then take you to the [project creation](https://authors.curseforge.com/#/projects/create/choose-game) flow. First, select your game (in this case, Hytale) for and the page will be updated with new fields waiting for your inputs. Please see our
+Ce qui vous dirigera vers le processus de [création de projet](https://authors.curseforge.com/#/projects/create/choose-game). Tout d'abord, sélectionnez votre jeu (dans notre cas, Hytale) et la page se mettra à jour avec de nouveaux champs attendant vos informations. Veuillez consulter nos
 
-[Moderation Policies](https://support.curseforge.com/en/support/solutions/articles/9000197279-moderation-policies#:~:text=General%20CurseForge%20Moderation%20Policies,-Policy\&text=The%20description%20can%20include%20descriptive,the%20game%22%20is%20not%20enough) articles for more information about what is and isn't allowed when creating a new project. Below are the fields along with their descriptions:
+[Politiques de modération](https://support.curseforge.com/en/support/solutions/articles/9000197279-moderation-policies#:~:text=General%20CurseForge%20Moderation%20Policies,-Policy\&text=The%20description%20can%20include%20descriptive,the%20game%22%20is%20not%20enough) pour plus d'informations sur ce qui est autorisé ou non lors de la création d'un nouveau projet. Ci-dessous se trouvent les champs ainsi que leurs descriptions :
 
-- **Name:** This is the title of your project. It should be unique to your project. If the name is already taken, it will be rejected.
-- **Summary:** This is a short blurb about the mod that will show up in the project listings
-- **Description:** This is the longer explanation of what your mod does/adds. Make sure you clearly elaborate on your project. We will reject your project if the description is not grammatically correct or if it does not sufficiently describe the project you are creating. This can be edited later. Note: All titles and descriptions must be in English.
-- **Project License:** This is a drop-down field that contains the most common licenses used in modding games. Research the license type you want to use, including its pros and cons. You can also choose to use a Custom License at the bottom of the dropdown list and enter any text you want.
-- **Class:** This is the root category for your project. Ensure you select the correct one, as it may impact supported file types and app support in CurseForge.
-  - For Hytale, there are four types of Class:
+- **Nom :** Il s'agit du titre de votre projet. Il doit être unique. Si le nom est déjà pris, il sera rejeté.
+- **Résumé :** Il s'agit d'un court texte de présentation du mod qui apparaîtra dans les listes de projets.
+- **Description :** Il s'agit d'une explication détaillée de ce que votre mod fait / ajoute. Assurez-vous de bien élaborer sur votre projet. Nous rejetterons votre projet si la description n'est pas grammaticalement correcte ou si elle ne décrit pas suffisamment le projet que vous créez. Cela pourra être modifié ultérieurement. Note : Tous les titres et descriptions doivent être rédigés en anglais.
+- **Licence du projet:** C'est un menu déroulant contenant les licences les plus courantes utilisées dans le modding. Renseignez-vous sur le type de licence que vous souhaitez utiliser, y compris ses avantages et inconvénients. Vous pouvez également choisir d'utiliser une « Custom License » (Licence personnalisée) en bas de la liste et saisir le texte de votre choix.
+- **Classe :** C'est la catégorie à la racine de votre projet. Assurez-vous de sélectionner la bonne, car cela peut avoir un impact sur les types de fichiers pris en charge et le support de l'application dans CurseForge.
+  - Pour Hytale, il existe quatre types de classes :
     - Mods
       - This is the class that contains both Asset Packs and Plugins, and you should upload either here.
     - Worlds
diff --git a/content/docs/fr-FR/quick-start.mdx b/content/docs/fr-FR/quick-start.mdx
index 1748a9fc..c3f8a8d8 100644
--- a/content/docs/fr-FR/quick-start.mdx
+++ b/content/docs/fr-FR/quick-start.mdx
@@ -3,9 +3,14 @@ title: Démarrage rapide
 description: Mettre en place un projet standard sur Hytale.
 ---
 
-Welcome to the Hytale modding documentation! Here you'll find everything you need to know about creating your own mods for Hytale.
+Bienvenue sur la documentation de modding d'Hytale ! Vous trouverez ici tout ce que vous devez savoir sur la création de vos propres mods pour Hytale.
 
-* [Java Basics](./guides/java-basics/00-introduction)
-* [Setting up your dev environment](./guides/plugin/setting-up-env)
-* [Entity Component System (ECS)](./guides/ecs/entity-component-system)
-* [Publishing your mod](./publishing)
+* [Bases du Java](./guides/java-basics/00-introduction)
+* [Mise en place de votre environnement de développement](./guides/plugin/setting-up-env)
+* [Entity Component System (ECS)](./guides/ecs)
+* [Publication de votre mod](./publishing)
+
+### Liens utiles
+
+* [Vidéos de modding de Kaupenjoe](https://www.youtube.com/@ModdingByKaupenjoe)
+* [Vidéos de modding de TroubleDEV](https://www.youtube.com/@TroubleDEV)
diff --git a/content/docs/fr-FR/server/argtypes.mdx b/content/docs/fr-FR/server/argtypes.mdx
new file mode 100644
index 00000000..e54a442e
--- /dev/null
+++ b/content/docs/fr-FR/server/argtypes.mdx
@@ -0,0 +1,61 @@
+---
+title: ArgTypes
+description: Available ArgTypes
+icon: List
+full: true
+authors:
+  - name: Valeena
+---
+
+| Name                        | Target Class                           | Description                                                                                                                               |   |
+| :-------------------------- | :------------------------------------- | :---------------------------------------------------------------------------------------------------------------------------------------- | - |
+| Boolean                     | java.lang.Boolean                      | A 'true' or 'false' input                                                                                                                 |   |
+| Integer                     | java.lang.Integer                      | A whole number                                                                                                                            |   |
+| String                      | java.lang.String                       | Words, text, numbers, letters. To input more than one word at a time, you may need to wrap it with double quotes (`"my fancy sentence"`). |   |
+| Float                       | java.lang.Float                        | A floating-pointer number                                                                                                                 |   |
+| Double                      | java.lang.Double                       | A decimal number                                                                                                                          |   |
+| UUID                        | java.util.UUID                         | A UUID (Universally Unique IDentifier)                                                                                                    |   |
+| Player_UUID                 | java.util.UUID                         | A UUID or an online player username                                                                                                       |   |
+| Game_Profile_Lookup_Async   | ProfileServiceClient.PublicGameProfile | A player UUID or username. If not found locally, performs a remote lookup via the Profile Service.                                        |   |
+| Relative_Double_Coord       | Coord                                  | An x, y, or z coordinate as a decimal, optionally relative by specifying a tilde (~) in front of the number                               |   |
+| Relative_Int_Coord          | IntCoord                               | An x, y, or z coordinate as a whole number, optionally relative by specifying a tilde (~) in front of the number                          |   |
+| Relative_Integer            | RelativeInteger                        | A tilde to mark an integer relative to a base                                                                                             |   |
+| Relative_Float              | RelativeFloat                          | A tilde to mark a float relative to a base                                                                                                |   |
+| Player_Ref                  | PlayerRef                              | A UUID or an online player's username                                                                                                     |   |
+| World                       | World                                  | A world folder name                                                                                                                       |   |
+| Model_Asset                 | ModelAsset                             | A reference to an Asset of type Model                                                                                                     |   |
+| Weather_Asset               | Weather                                | A reference to an Asset of type Weather                                                                                                   |   |
+| Interaction_Asset           | Interaction                            | A reference to an Asset of type Interaction                                                                                               |   |
+| Root_Interaction_Asset      | RootInteraction                        | A reference to an Asset of type Root Interaction                                                                                          |   |
+| Effect_Asset                | EntityEffect                           | A refernece to an Asset of type EntityEffect                                                                                              |   |
+| Environment_Asset           | Environment                            | A reference to an Asset of type Environment                                                                                               |   |
+| Item_Asset                  | Item                                   | A reference to an Asset of type Item                                                                                                      |   |
+| Block_Type_Asset            | BlockType                              | A reference to an Asset of type BlockType                                                                                                 |   |
+| Particle_System             | ParticleSystem                         | A reference to an Asset of type ParticleSystem                                                                                            |   |
+| Hitbox_Collision_Config     | HitboxCollisionConfig                  | A reference to an Asset of type HitboxCollisionConfig                                                                                     |   |
+| Repulsion_Config            | RepulsionConfig                        | A reference to an Asset of type RepulsionConfig                                                                                           |   |
+| Sound_Event_Asset           | SoundEvent                             | A reference to an Asset of type SoundEvent                                                                                                |   |
+| Ambiance_Fx_Asset           | AmbianceFX                             | A reference to an Asset of type AmbianceFX                                                                                                |   |
+| Sound_Category              | SoundCategory                          | A sound category (sfx, music, ambient, ui)                                                                                                |   |
+| Entity_ID                   | `ArgWrapper<EntityWrappedArg, UUID>`   | A UUID representing an entity id                                                                                                          |   |
+| Integer_Comparison_Operator | IntegerComparisonOperator              | A mathematical sign for integer comparison                                                                                                |   |
+| Integer_Operation           | IntegerOperation                       | A mathematical sign for performing an operation                                                                                           |   |
+| Int_Range                   | `Pair<Integer, Integer>`               | Two integers representing a minimum and maximum of a range                                                                                |   |
+| Relative_Int_Range          | RelativeIntRange                       | Two integers representing a minimum and maximum of a range                                                                                |   |
+| Vector2I                    | Vector2i                               | Two integers, generally corresponding to x/z axis                                                                                         |   |
+| Vector3I                    | Vector3i                               | Three integers, generally corresponding to x/y/z axis                                                                                     |   |
+| Relative_Vector3I           | RelativeVector3i                       | Three optionally relative integers, generally corresponding to x/y/z axis                                                                 |   |
+| Relative_Block_Position     | RelativeIntPosition                    | A position with three integer coordinates, representing a block's location in world space.                                                |   |
+| Relative_Position           | Relative                               | A position with three decimal coordinates, representing a location in world space.                                                        |   |
+| Relative_Chunk_Position     | RealtiveChunkPosition                  | A position with two integer coordinates (x, z), representing a chunk's location.                                                          |   |
+| Rotation                    | Vector3f                               | A rotation with three coordinates, representing the pitch, yaw, and roll respectively                                                     |   |
+| Block_Type_Key              | String                                 | A block type                                                                                                                              |   |
+| Block_ID                    | Integer                                | A block type, converted to an int id                                                                                                      |   |
+| Color                       | Integer                                | A color value in hex format, hex integer, or decimal integer                                                                              |   |
+| Weighted_Block_Type         | `Pair<Integer, String>`                | A weight corresponding to a blocktype                                                                                                     |   |
+| Weighted_Block_Entry        | String                                 | A block with optional weight prefix                                                                                                       |   |
+| Block_Pattern               | BlockPattern                           | A list of blocks with optional weights                                                                                                    |   |
+| Individual_Block_Mask       | BlockMask                              | Create a block mask using symbols and block names                                                                                         |   |
+| Block_Mask                  | BlockMask                              | A tick rate value (e.g., 30tps, 33ms, or 30)                                                                                              |   |
+| Tick_Rate                   | Integer                                | A list of block masks that combine together                                                                                               |   |
+| Game_Mode                   | GameMode                               | GameMode                                                                                                                                  |   |
diff --git a/content/docs/fr-FR/server/interaction-reference.mdx b/content/docs/fr-FR/server/interaction-reference.mdx
new file mode 100644
index 00000000..6c0d01b3
--- /dev/null
+++ b/content/docs/fr-FR/server/interaction-reference.mdx
@@ -0,0 +1,1586 @@
+---
+title: Interactions
+description: A list of most Interaction types provided by Hypixel, along with the meaning of their fields, and how they fit together.
+icon: List
+authors:
+  - name: Stephen Baynham
+    url: https://github.com/cannibalvox
+---
+
+### The Interaction Base Type
+
+All interactions of every type below are inherited from Interaction and have these fields.
+
+**Interaction Fields**
+
+| Field Name                | Type                                                                 | Required? | Notes                                                                                                                                                                                                                       |
+| ------------------------- | -------------------------------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| ViewDistance              | `Double`<br />(Default: 96.0)                                        | **No**    | Distance in blocks at which other players can see the effects from this interaction.                                                                                                                                        |
+| Effects                   | `InteractionEffects`                                                 | **No**    | Sound, animations, and particle effects that should trigger when this interaction begins executing.                                                                                                                         |
+| HorizontalSpeedMultiplier | `Float`<br />(Default: 1.0)                                          | **No**    | Multiplier applied to the User entity's movement speed while this interaction is executing                                                                                                                                  |
+| RunTime                   | `Float`                                                              | **No**    | If provided, this interaction will continue executing for at least this long before the interaction chain moves onto the next interaction.                                                                                  |
+| CancelOnItemChange        | `Boolean`<br />(Default: true)                                       | **No**    | If true, this interaction will be cancelled if the User entity's held item changes during execution. This can happen either due to the selected hotbar slot changing or the contents of the item's inventory slot changing. |
+| Rules                     | `InteractionRules`                                                   | **Yes**   | If provided, adds additional limitations and cancellation conditions to this interaction.                                                                                                                                   |
+| Settings                  | `Map`<br />(Key Type: `GameMode`, Value Type: `InteractionSettings`) | **No**    | If provided, adds additional per-GameMode settings to the interaction.                                                                                                                                                      |
+| Camera                    | `InteractionCameraSettings`                                          | **No**    | Arrays of camera motion keyframes for cutscenes and reveals.                                                                                                                                                                |
+
+**GameMode Values**
+
+- `Creative`: The game is currently in Creative Mode
+- `Adventure`: The game is currently in Adventure Mode
+
+**InteractionEffects Fields**
+
+| Field Name               | Type                                              | Required? | Notes                                                                                                                                                 |
+| ------------------------ | ------------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Particles                | `Array`<br />(Element Type: `ModelParticle`)      | **No**    | Particle systems to activate when this interaction begins if the player is in third-person mode.                                                      |
+| FirstPersonParticles     | `Array`<br />(Element Type: `ModelParticle`)      | **No**    | Particle systems to activate when this interaction begins if the player is in first-person mode.                                                      |
+| WorldSoundEventId        | `Asset`<br />(Asset Type: `SoundEvent`)           | **No**    | A sound to play in the world at the User entity's location when this interaction begins.<br />**The SoundEvent must be single-channel (mono) sound.** |
+| LocalSoundEventId        | `Asset`<br />(Asset Type: `SoundEvent`)           | **No**    | A 2D sound to play for the User entity when this interaction begins. Ignored if the User entity is not a player.                                      |
+| Trails                   | `Array`<br />(Element Type: `ModelTrail`)         | **No**    | Trail effects to activate on the User entity when this interaction begins.                                                                            |
+| WaitForAnimationToFinish | `Boolean`<br />(Default: false)                   | **No**    | If true, this interaction will continue executing for at least the length of any animations in this InteractionEffects object.                        |
+| ItemPlayerAnimationsId   | `Asset`<br />(Asset Type: `ItemPlayerAnimations`) | **No**    | If provided, the User entity will use this ItemPlayerAnimations set while this interaction is executing.                                              |
+| ItemAnimationId          | `String`                                          | **No**    | Id of an animation to trigger when this interaction begins executing.<br />**This animation id is not validated on server start.**                    |
+| ClearAnimationOnFinish   | `Boolean`<br />(Default: false)                   | **No**    | If true, animations triggered by this interaction will be halted when the interaction completes.                                                      |
+| ClearSoundEventOnFinish  | `Boolean`<br />(Default: false)                   | **No**    | If true, sounds triggered by this interaction will be halted when the interaction completes.                                                          |
+| CameraEffect             | `Asset`<br />(Asset Type: `CameraEffect` )        | **No**    | If provided, the CameraEffect will be applied while this interaction is executing.                                                                    |
+| MovementEffects          | `MovementEffects`                                 | **No**    | If provided, apply the movement effects to the User entity while this interaction is executing.                                                       |
+| StartDelay               | `Float`<br />(Default: 0.0f)                      | **No**    | The interaction will wait this many seconds before triggering the effects in this object.                                                             |
+
+**InteractionRules Fields**
+
+| Field Name          | Type                                                                                                | Required? | Notes                                                                                                                                                                                                                                     |
+| ------------------- | --------------------------------------------------------------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| BlockedBy           | `Array`<br />(Element Type: `InteractionType`)<br />(Default: Based on the chain's InteractionType) | **No**    | If provided, this RootInteraction cannot be executed while interaction chains of the provided types are executing.<br />**This field only functions for rules attached to a RootInteraction. It has no effect on an Interaction.**        |
+| Blocking            | `Array`<br />(Element Type: `InteractionType`)                                                      | **No**    | If provided, interaction chains with the specified InteractionTypes cannot be executed while this interaction is executing.                                                                                                               |
+| InterruptedBy       | `Array`<br />(Element Type: `InteractionType`)                                                      | **No**    | If provided, interaction chains with the specified InteractionTypes will cancel this interaction chain when they execute.<br />**This field only functions for rules attached to a RootInteraction. It has no effect on an Interaction.** |
+| Interrupting        | `Array`<br />(Element Type: `InteractionType`)                                                      | **No**    | If provided, interaction chains with the specified InteractionTypes will be canceled when this interaction begins.                                                                                                                        |
+| BlockedByBypass     | `String`                                                                                            | **No**    | If provided, this RootInteraction cannot be blocked by interaction chains whose RootInteraction has this value as an asset tag.                                                                                                           |
+| BlockingBypass      | `String`                                                                                            | **No**    | If provided, this interaction will not block RootInteractions that have the this value as an asset tag.                                                                                                                                   |
+| InterruptedByBypass | `String`                                                                                            | **No**    | If provided, this RootInteraction cannot be canceled by RootInteractions that have this value as an asset tag.                                                                                                                            |
+| InterruptingBypass  | `String`                                                                                            | **No**    | If provided, this interaction will not cancel interaction chains whose RootInteraction has this value as an asset tag.                                                                                                                    |
+
+**InteractionType Values**
+
+- `Primary`
+- `Secondary`
+- `Ability1`
+- `Ability2`
+- `Ability3`
+- `Use`
+- `Pick`
+- `Pickup`
+- `CollisionEnter`
+- `CollisionLeave`
+- `Collision`
+- `EntityStatEffect`
+- `SwapTo`
+- `SwapFrom`
+- `Death`
+- `Wielding`
+- `ProjectileSpawn`
+- `ProjectileHit`
+- `ProjectileMiss`
+- `ProjectileBounce`
+- `Held`
+- `HeldOffhand`
+- `Equipped`
+- `Dodge`
+- `GameModeSwap`
+
+**InteractionSettings Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                        |
+| ---------------- | ------------------------------- | --------- | -------------------------------------------------------------------------------------------- |
+| AllowSkipOnClick | `Boolean`<br />(Default: false) | **No**    | If true, the user will be able to skip this interaction by clicking shortly after it starts. |
+
+**InteractionCameraSettings Fields**
+
+| Field Name  | Type                                             | Required? | Notes                                                                                                                                                           |
+| ----------- | ------------------------------------------------ | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| FirstPerson | `Array`<br />(Element Type: `InteractionCamera`) | **No**    | A list of camera keyframes to be played if the player is in first-person.<br />**The time of each keyframe must be after the keyframe before it in the array.** |
+| ThirdPerson | `Array`<br />(Element Type: `InteractionCamera`) | **No**    | A list of camera keyframes to be played if the player is in third-person.<br />**The time of each keyframe must be after the keyframe before it in the array.** |
+
+**InteractionCamera Fields**
+
+| Field Name | Type                         | Required? | Notes                                                                                                                                       |
+| ---------- | ---------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------- |
+| Time       | `Float`<br />(Default: 0.1f) | **No**    | How long after the interaction begins executing that the camera should arrive at this keyframe.<br />**Cannot be less than or equal to 0.** |
+| Position   | `Vector3`                    | **Yes**   | Where the camera should be located when it arrives at this keyframe.                                                                        |
+| Rotation   | `Direction`                  | **Yes**   | Where the camera should be pointing when it arrives at this keyframe.                                                                       |
+
+### SimpleInteraction
+
+Most interaction types below are inherited from SimpleInteraction and have these
+fields.  If a type does not have these fields, the documentation will mention it.
+
+The purpose of SimpleInteraction is to facilitate Interaction chaining by taking different paths
+based on whether the Interaction succeeded or failed.  The circumstances under which
+a given Interaction fails are generally type-specific (and described in the documentation
+below), but all interactions will be marked failed if they are cancelled via one of the
+many, many mechanisms for doing so.
+
+It is valid to create an interaction asset of type "Simple", which can be valuable when you want to use the
+interaction fields with no additional functionality.
+
+**SimpleInteraction Fields**
+
+| Field Name | Type                                     | Required? | Notes                                                                                          |
+| ---------- | ---------------------------------------- | --------- | ---------------------------------------------------------------------------------------------- |
+| Next       | `Asset`<br />(Asset Type: `Interaction`) | **No**    | After this Interaction has finished, "Next" will be executed if this Interaction did not fail. |
+| Failed     | `Asset`<br />(Asset Type: `Interaction`) | **No**    | After this Interaction has finished, "Failed" will be executed if this Interaction failed.     |
+
+## Flow Control
+
+These are interaction types used to control the flow of an interaction chain and allow interactions
+to be composed into more complex behaviors.  These interaction types generally do not pertain to
+the game and instead pertain to the interaction system itself.
+
+### Condition
+
+This interaction will fail if one of the fields is provided but does not match the current state.
+
+**Condition Fields**
+
+| Field Name       | Type       | Required? | Notes                                                                                                                                                                                    |
+| ---------------- | ---------- | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| RequiredGameMode | `GameMode` | **No**    | If provided, the interaction will fail if the current GameMode does not match the provided value.                                                                                        |
+| Jumping          | `Boolean`  | **No**    | If provided, the interaction will fail if the player's Jumping state does not match the provided value. (i.e. if True, the player must be jumping, if False, the player must not be)     |
+| Swimming         | `Boolean`  | **No**    | If provided, the interaction will fail if the player's Swimming state does not match the provided value. (i.e. if True, the player must be swimming, if False, the player must not be)   |
+| Crouching        | `Boolean`  | **No**    | If provided, the interaction will fail if the player's Crouching state does not match the provided value. (i.e. if True, the player must be crouching, if False, the player must not be) |
+| Running          | `Boolean`  | **No**    | If provided, the interaction will fail if the player's Running state does not match the provided value. (i.e. if True, the player must be running, if False, the player must not be)     |
+| Flying           | `Boolean`  | **No**    | If provided, the interaction will fail if the player's Flying state does not match the provided value. (i.e. if True, the player must be flying, if False, the player must not be)       |
+
+**GameMode Values**
+
+- `Creative`: The game is currently in Creative Mode
+- `Adventure`: The game is currently in Adventure Mode
+
+### FirstClick
+
+This interaction does not inherit from SimpleInteraction and therefore has no Next or Failed fields.
+
+This interaction has two fields that each contain a reference to an Interaction: Click and Hold.  If the root interaction
+of the chain was initiated by a client button/key press (or simulated NPC input) and the input was a tap, then
+the Click interaction is run. if it was a longer press, then the Hold interaction is run.
+
+As a minor implementation detail, this interaction is internally marked as failed when the Hold path is followed.
+This generally shouldn't matter.  If the interaction was not initiated by a key press at all, the Click path will be followed,
+but it seems risky to rely on that behavior.
+
+**FirstClick Fields**
+
+| Field Name | Type                                     | Required? | Notes                                                                                                                                                    |
+| ---------- | ---------------------------------------- | --------- | -------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Click      | `Asset`<br />(Asset Type: `Interaction`) | **No**    | If provided and the root interaction of the chain was initiated by button/key press, this interaction is executed next if the press was a quick tap.     |
+| Hold       | `Asset`<br />(Asset Type: `Interaction`) | **No**    | If provided and the root interaction of the chain was initiated by a button/key press, this interaction is executed next if the press was a longer hold. |
+
+### Interrupt
+
+This interaction can be used to cancel one or more running interaction chains on an entity and **all forked interaction
+chains those chains have spawned that are still currently running**.  All interaction chains canceled in this manner will be marked as
+Failed, which may have additional implications if the canceled chains are themselves forked from
+other chains that are still running.
+
+**Interrupt Fields**
+
+| Field Name     | Type                                           | Required? | Notes                                                                                                                                                                                               |
+| -------------- | ---------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Entity         | `InteractionTarget`<br />(Default: User)       | **Yes**   | The entity that is the owner of the target interaction chains.  This field can indicate the Owner, User, or Target of this interaction chain.                                                       |
+| InterruptTypes | `Array`<br />(Element Type: `InteractionType`) | **No**    | A set of InteractionTypes that are to be interrupted. Only interactions of these types are affected. If null, all types will be interrupted.<br />**(Note: An empty set will interrupt NO TYPES.)** |
+| RequiredTag    | `String`                                       | **No**    | An asset tag that, if provided, the RootInteraction of the interaction chain must have in order to be canceled.                                                                                     |
+| ExcludedTag    | `String`                                       | **No**    | An asset tag that, if provided, the RootInteraction of the interaction chain must not have in order to be canceled.                                                                                 |
+
+**InteractionTarget Values**
+
+- `User` - The user of this interaction chain. The entity whose actions caused this interaction chain to be executed. This is usually the same as the Owner.
+- `Owner` - The owner of this interaction chain. The entity upon whom this interaction chain is executing.
+- `Target` - The entity target of this interaction chain, if any.  This value is mutable (and can therefore come from many places) but most commonly, it is an entity the User was targeting when this interaction chain began executing.
+
+**InteractionType Values**
+
+- `Primary`
+- `Secondary`
+- `Ability1`
+- `Ability2`
+- `Ability3`
+- `Use`
+- `Pick`
+- `Pickup`
+- `CollisionEnter`
+- `CollisionLeave`
+- `Collision`
+- `EntityStatEffect`
+- `SwapTo`
+- `SwapFrom`
+- `Death`
+- `Wielding`
+- `ProjectileSpawn`
+- `ProjectileHit`
+- `ProjectileMiss`
+- `ProjectileBounce`
+- `Held`
+- `HeldOffhand`
+- `Equipped`
+- `Dodge`
+- `GameModeSwap`
+
+### Parallel
+
+This interaction does not inherit from SimpleInteraction and therefore has no Next or Failed fields.
+
+This interaction has a field `Interactions` that is an array of RootInteraction assets. The list must contain at least
+two RootInteractions.  This interaction will fork all of its children except for the first into their
+own interaction chains and immediately complete. After this interaction completes, this interaction chain will
+execute the first RootInteraction in the `Interactions` list.
+
+This interaction does not have any failure conditions and is indifferent to the fate of the forked interaction chains.
+
+**Parallel Fields**
+
+| Field Name   | Type                                                | Required? | Notes                                                         |
+| ------------ | --------------------------------------------------- | --------- | ------------------------------------------------------------- |
+| Interactions | `AssetArray`<br />(Element Type: `RootInteraction`) | **Yes**   | An array of RootInteractions that will be forked or executed. |
+
+### Repeat
+
+This interaction has a field `ForkInteractions` that is an asset of type RootInteraction. This interaction will fork that
+RootInteraction into its own interaction chain and then wait for it to complete. If the RootInteraction fails, this
+interaction will complete immediately and be marked failed. Otherwise, the RootInteraction will be forked and run again,
+up to a specified total number of times.
+
+**Repeat Fields**
+
+| Field Name       | Type                                                                                   | Required? | Notes                                                                                                                                                                                                              |
+| ---------------- | -------------------------------------------------------------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| ForkInteractions | `Asset`<br />(Asset Type: `RootInteraction`)                                           | **Yes**   | A RootInteraction that will be forked.                                                                                                                                                                             |
+| Repeat           | `Integer`<br />(Default: 1)<br />**Must be -1 or a positive integer. 0 is not valid.** | **No**    | The total number of times to fork ForkInteractions. If -1 is provided, ForkInteractions will continue being forked and executed indefinitely, until this interaction is cancelled or until ForkInteractions fails. |
+
+### Replace
+
+This interaction does not inherit from SimpleInteraction and therefore has no Next or Failed fields.
+
+This interaction uses the InteractionVars system that is avaiable for items. InteractionVars are RootInteractions that
+can be attached to an Item asset with a name.
+
+This interaction specifies a var name, and if this interaction chain was executed through
+an item and that item has an InteractionVar of the same name, then this interaction will immediately execute
+the RootInteraction on the var.  Otherwise, it will execute the default RootInteraction specified in this interaction.
+If no default is specified, then this interaction will be marked as failed.
+
+**Replace Fields**
+
+| Field Name   | Type                                         | Required? | Notes                                                                                                                                                                                                           |
+| ------------ | -------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Var          | `String`                                     | **Yes**   | The name of the InteractionVar to execute.                                                                                                                                                                      |
+| DefaultValue | `Asset`<br />(Asset Type: `RootInteraction`) | **No**    | The RootInteraction to execute if the owning item does not have an InteractionVar by the specified name. If not provided, the interaction will be marked as failed instead.                                     |
+| DefaultOk    | `Boolean`<br />(Default: false)              | **No**    | If false, then an angry message will be printed to the server logs if the owning item does not have an InteractionVar by the specified name.  The functioning of this interaction will be otherwise unaffected. |
+
+### RunRootInteraction
+
+This interaction immediately executes the provided RootInteraction as part of this interaction chain. This interaction
+does not have any failure conditions.
+
+**RunRootInteraction Fields**
+
+| Field Name      | Type                                         | Required? | Notes                           |
+| --------------- | -------------------------------------------- | --------- | ------------------------------- |
+| RootInteraction | `Asset`<br />(Asset Type: `RootInteraction`) | **Yes**   | The RootInteraction to execute. |
+
+### Selector
+
+This interaction will execute a Selector to find entities and/or blocks (depending on the Selector) and fork off an
+interaction chain for each located entity or block. This interaction will not wait for those interaction chains
+to complete and is indifferent to their fate. The forked interaction chains will use the located entity/block as
+their target entity/target block. Each entity or block will only fork one interaction chain over the life of this
+interaction.  The Selector is guaranteed to run once for each execution of this interaction, but some Selectors
+are intended to be run over a period of time and sweep across an area to locate targets. In order to use those Selectors
+properly, you will need to extend the execution time of this interaction using `RunTime` or `WaitForAnimationToFinish`.
+The Selector will be executed repeatedly over the lifetime of the interaction.
+
+If the Selector is configured to locate entities, you can add additional sets of entity matching rules. If a located entity
+matches one of the rules, the matching RootInteraction will be forked instead of the standard `HitEntity` RootInteraction.
+
+Entities located by the Selector will be ignored if they do not have a NetworkId, if they are dead, or if they are invulnerable.
+The only exception to this rule is that players in Creative Mode that are marked to receive hits will not be ignored.
+
+This interaction's failure conditions are configurable via the `FailOn` field. You can configure this interaction to never
+fail, to fail if the Selector does not locate any blocks before this interaction finishes executing, to fail if the
+Selector does not locate any entities before this interaction finishes executing, or to fail in either case.
+
+**Selector Fields**
+
+| Field Name     | Type                                         | Required? | Notes                                                                                                                                                                                                                                     |
+| -------------- | -------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Selector       | `Selector`                                   | **Yes**   | The Selector is executed at least once and may be executed repeatedly to locate blocks and/or entities in an area.                                                                                                                        |
+| HitEntity      | `Asset`<br />(Asset Type: `RootInteraction`) | **No**    | If included and the `Selector` locates an entity that does not match any `HitEntityRules`, this RootInteraction will be forked into a new interaction chain with the located entity as the target entity.                                 |
+| HitEntityRules | `Array`<br />(Element Type: `HitEntity`)     | **No**    | If included, these rules will be matched against any entity located by the `Selector`. If an entity matches a set of rules, the RootInteraction associated with the rules will be forked instead of the standard `HitEntity` interaction. |
+| HitBlock       | `Asset`<br />(Asset Type: `RootInteraction`) | **No**    | If included and the `Selector` locates a block, this RootInteraction will be forked into a new interaction chain with the located block as the block target.                                                                              |
+| FailOn         | `FailOnType`<br />(Default: `Neither`)       | **No**    | Defines under what circumstances this interaction will fail.  It can be marked to fail when it completes without locating any blocks, it can be marked to fail when it completes without locating any entities, both, or neither.         |
+| IgnoreOwner    | `Boolean`<br />(Default: true)               | **No**    | If true, the Selector will not locate the User entity of this interaction.                                                                                                                                                                |
+
+**HitEntity Fields**
+
+| Field Name | Type                                         | Required? | Notes                                                                                                 |
+| ---------- | -------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------- |
+| Matchers   | `Array`<br />(Element Type: `EntityMatcher`) | **Yes**   | A set of rules that an entity must match. An entity must successful match all rules to be considered. |
+| Next       | `Asset`<br />(Asset Type: `RootInteraction`) | **Yes**   | The RootInteraction to fork if an entity matches all rules.                                           |
+
+**EntityMatcher Fields**
+
+| Field Name | Type                            | Required? | Notes                                                                                                     |
+| ---------- | ------------------------------- | --------- | --------------------------------------------------------------------------------------------------------- |
+| Type       | `String`                        | **Yes**   | If provided, specifies a type of EntityMatcher to use. Each matcher type may come with additional fields. |
+| Invert     | `Boolean`<br />(Default: false) | **No**    | If true, an entity must fail this rule for it to be marked as succeeded.                                  |
+
+**EntityMatcher Type: Player**
+
+This EntityMatcher will succesfully match the entity only if they are a player.
+
+**EntityMatcher Type: Vulnerable**
+
+This Entitymatcher will successfully match the entity only if they are not marked as invulnerable.
+
+**FailOnType Values**
+
+- `Neither`
+- `Entity`
+- `Block`
+- `Either`
+
+### Serial
+
+This interaction does not inherit from SimpleInteraction and therefore has no Next or Failed fields.
+
+This interaction has a field `Interactions` which is a list of Interaction assets. This interaction immediately
+completes and the interaction chain continues by executing the interactions in the list one at a time. This
+interaction does not have any failure conditions.
+
+**Serial Fields**
+
+| Field Name   | Type                                            | Required? | Notes                                      |
+| ------------ | ----------------------------------------------- | --------- | ------------------------------------------ |
+| Interactions | `AssetArray`<br />(Element Type: `Interaction`) | **Yes**   | An array of Interaction assets to execute. |
+
+## Cooldowns
+
+RootInteractions interface with a complex cooldown system that can be used for a variety of purposes. Aside from simply
+adding an important aspect of resource management to your game design, cooldowns can be used to ensure that click-activated
+interaction chains don't repeatedly spam if the player holds down the input.
+
+By default, every RootInteraction has a cooldown timer that is keyed to the RootInteraction name, and by default, it
+will launch a cooldown of 0.35 seconds when activated by client input.  Otherwise, no cooldown will be activated.  However,
+by configuring your RootInteraction, you can change the key for the cooldown (so that multiple RootInteractions can share
+a single cooldown), set the cooldown timer to whatever you like, and configure multiple charges that can build up over time
+to allow the entity to activate the RootInteraction multiple times before being forced to pause.
+
+One important concept to keep in mind is the difference between **cooldown** and **charge time**.  The cooldown, if any,
+is activated each time a RootInteraction triggers, even if the player has more available charges. If the RootInteraction
+is configured to use charges, then they will gradually build up over time. In order for a RootInteraction to be activated,
+the cooldown (if any) must be expired, and the RootInteraction must have at least one charge (if it has been
+configured to use charges).
+
+Bear in mind that the entire Cooldown configuration is shared between different RootInteractions with the same cooldown id.
+If you activate an ability with 5 charges and a short cooldown and then another ability with a much longer cooldown and no
+charges, the second ability will use the cooldown properties of the first ability until/unless the first ability finishes
+charging and is cleared from the system.  You should generally only have multiple RootInteractions share a cooldown id
+if they have the same configuration.
+
+The interactions below interact with the cooldown system to allow you to manipulate cooldowns via the interaction system. By
+using these interactions, you can have several interaction chains with different cooldown configurations share cooldowns
+that are checked and activated as part of the interaction chain itself, or have some components of an interaction change
+use a second cooldown separate from the main one.
+
+### CooldownCondition
+
+**CooldownCondition Fields**
+
+This interaction will fail if the specified cooldown id is on cooldown for the User entity.  This interaction will only
+function for players- the interaction will always succeed for NPCs.  In order for this interaction to succeed, the
+cooldown, if any, must have expired and at least one charge, if any, must have filled.
+
+| Field Name | Type     | Required? | Notes                     |
+| ---------- | -------- | --------- | ------------------------- |
+| Id         | `String` | **Yes**   | The cooldown id to check. |
+
+### IncrementCooldown
+
+**IncrementCooldown Fields**
+
+This interaction will modify a cooldown that is currently active on the User entity, allowing charges and remaining
+cooldown to be modified.
+Despite its name, this interaction can be used to reduce a cooldown as well as increase it. If the cooldown is not
+currently active, this interaction will have no effect. The interaction has no special failure conditions.
+
+| Field Name        | Type                        | Required? | Notes                                                                                                                                                                                                                                                                                     |
+| ----------------- | --------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Id                | `String`                    | **No**    | If provided, the cooldown id of the cooldown to be manipulated. If not provided, the cooldown id of the current chain's RootInteraction will be used.                                                                                                                                     |
+| Time              | `Float`<br />(Default: 0.0) | **No**    | The amount to increase the remaining cooldown by. Can be negative. The remaining cooldown time will not be reduced below zero or increased above the maximum cooldown time.                                                                                                               |
+| ChargeTime        | `Float`<br />(Default: 0.0) | **No**    | The amount to increase the remaining time until the next charge is filled by. Can be negative. The remaining charge time cannot be reduced below zero or increased above the maximum cooldown time. **This will not work on abilities that have a maximum of 1 charge, for some reason.** |
+| Charge            | `Integer`<br />(Default: 0) | **No**    | The amount to increase the number of charges by. Can be negative. The number of charges cannot be reduced below 0 or increased above the maximum.                                                                                                                                         |
+| InterruptRecharge | `Boolean`(Default: false)   | **No**    | If true and `Charge` is not 0, will reset the remaining time to the next charge to the maximum value after changing the charge count.                                                                                                                                                     |
+
+### ResetCooldown
+
+This interaction will trigger a cooldown on the User entity with a specified configuration. The charges will be refilled
+but the cooldown will be immediately triggered.  The mechanisms for deciding on the configuration are a little bit complicated.
+You may specify a cooldown configuration via the `Cooldown` field. If you do not include an `Id` field, then the
+interaction chain's RootInteraction will be used for any field not specified in the configuration. If there is an active
+cooldown under the specified `Id` (or under the RootInteraction's cooldown id if none is specified) then the fields
+from that active cooldown will overwrite data in the RootInteraction's cooldown, but not data in your `Cooldown` field.
+
+**ResetCooldown Fields**
+
+| Field Name | Type                  | Required? | Notes                                                        |
+| ---------- | --------------------- | --------- | ------------------------------------------------------------ |
+| Cooldown   | `InteractionCooldown` | **No**    | A cooldown configuration to use for the new, reset cooldown. |
+
+**InteractionCooldown Fields**
+
+| Field Name        | Type                                 | Required? | Notes                                                                                                                                                                                                 |
+| ----------------- | ------------------------------------ | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Id                | `String`                             | **No**    | The cooldown id to use for this cooldown. If not provided, the RootInteraction's cooldown id will be used, if any.                                                                                    |
+| Cooldown          | `Float`<br />(Default: 0.0)          | **No**    | The duration of the cooldown, in seconds.                                                                                                                                                             |
+| Charges           | `Array`<br />(Element Type: `Float`) | **No**    | If provided, a list of how many charges this cooldown can build, and how long each charge takes to build, in seconds.                                                                                 |
+| InterruptRecharge | `Boolean`<br />(Default: false)      | **No**    | If true, the charge time will be reset when the number of charges changes.                                                                                                                            |
+| ClickBypass       | `Boolean`<br />(Default: false)      | **No**    | If true, RootInteractions keyed to this cooldown can still be activated when it is on cooldown provided that the RootInteraction was triggered by a distinct key or mouse button press on the client. |
+
+### TriggerCooldown
+
+This interaction is similar to ResetCooldown, except instead of refilling the cooldown's charges, one charge will be deducted
+as normal.
+
+**TriggerCooldown Fields**
+
+| Field Name | Type                  | Required? | Notes                                                        |
+| ---------- | --------------------- | --------- | ------------------------------------------------------------ |
+| Cooldown   | `InteractionCooldown` | **No**    | A cooldown configuration to use for the new, reset cooldown. |
+
+**InteractionCooldown Fields**
+
+| Field Name        | Type                                 | Required? | Notes                                                                                                                                                                                                 |
+| ----------------- | ------------------------------------ | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Id                | `String`                             | **No**    | The cooldown id to use for this cooldown. If not provided, the RootInteraction's cooldown id will be used, if any.                                                                                    |
+| Cooldown          | `Float`<br />(Default: 0.0)          | **No**    | The duration of the cooldown, in seconds.                                                                                                                                                             |
+| Charges           | `Array`<br />(Element Type: `Float`) | **No**    | If provided, a list of how many charges this cooldown can build, and how long each charge takes to build, in seconds.                                                                                 |
+| InterruptRecharge | `Boolean`<br />(Default: false)      | **No**    | If true, the charge time will be reset when the number of charges changes.                                                                                                                            |
+| ClickBypass       | `Boolean`<br />(Default: false)      | **No**    | If true, RootInteractions keyed to this cooldown can still be activated when it is on cooldown provided that the RootInteraction was triggered by a distinct key or mouse button press on the client. |
+
+## Combo Chains
+
+Hytale additionally comes with a rich "combo chaining" system, which allows several inputs in a row to result in different
+attacks and special moves.  Rather than being attached to the RootInteraction like the cooldown system, these are
+primarily driven by the `Chaining` interaction.
+
+### Chaining
+
+This interaction does not inherit from SimpleInteraction and therefore has no Failed field. Its Next field works differently
+from most interaction types.
+
+Chaining is a type of flow control interaction- each time a Chaining interaction with the same `ChainId` is called, a single
+interaction in the `Next` list is chosen and the others are ignored. The first time the `ChainId` is used, the first
+interaction in the list is chosen, the next time the second, etc. Once the end of the list is reached, the first
+interaction will be chosen again.
+
+Bear in mind: the progress through the Next list is based on the **ChainId**, not the interaction!  That means that two
+different Chaining interactions can share a single combo chain. You could have a pair of daggers that attacks with
+the left when the left mouse button is clicked and with the right when the right mouse button is clicked.  You could give
+both interaction chains a Chaining interaction with the same `ChainId` and three `Next` entries that do a light-light-heavy
+combo.  Each specific hit would occur with either the left or the right knife based on which button you clicked, but
+the combo would be otherwise identical regardless of which you chose.
+
+The Chaining interaction also has a concept called "flags".  It is possible to attach named flags to a `ChainId` by using
+the ChainFlag interaction.  Then, you specify the flag name in Chaining's `Flags` field. If a Flag is active when the
+Chaining interaction is run, the Flag's interaction will be run instead of the appropriate interaction in `Next`.
+Bear in mind: the entity's progress through the `Next` list still advances, the resulting `Next` interaction is just not
+run.  Only one flag can be active at a time.
+
+Lastly, it is possible to cancel the entity's progress through the combo chain and reset them to the first interaction in
+the list. This can be done with the CancelChain interaction, but it will also happen automatically if the player does
+not trigger an interaction with the ChainId for the specified ChainingAllowance.  When either of these happen, all flags will be
+canceled as well.
+
+All of these effects are triggered on the User entity only. Non-players can use the chaining system, but Flags do not currently
+work for non-players.  This interaction has no special failure conditions.
+
+**Chaining Fields**
+
+| Field Name        | Type                                                       | Required? | Notes                                                                                                                                                                                                                       |
+| ----------------- | ---------------------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| ChainId           | `String`                                                   | **No**    | If provided, acts as a key that multiple Chaining interactions can use to share combo chain progress and flags. If not provided, a unique ChainId will be generated for this interaction.                                   |
+| ChainingAllowance | `Double`<br />(Default: 0.0)                               | **No**    | If, at the time this interaction is triggered, it has been this long in seconds since the last time a Chaining interaction with the same ChainId was executed, all state for this ChainId will be cleared before execution. |
+| Next              | `AssetArray`<br />(Element Type: `Interaction`)            | **Yes**   | A list of interactions to cycle between each time this interaction is run.                                                                                                                                                  |
+| Flags             | `Map`<br />(Key Type: `String`, Value Type: `Interaction`) | **No**    | A map of flag names to interactions to run if the flag is active when this interaction executes.                                                                                                                            |
+
+### CancelChain
+
+This interaction resets all progress and flag data on the User entity for the provided `ChainId`.  The next time a Chaining
+interaction is called for the provided `ChainId`, it will begin at the first interaction in the `Next` list. This
+interaction has no special failure conditions.
+
+**CancelChain Fields**
+
+| Field Name | Type     | Required? | Notes                                 |
+| ---------- | -------- | --------- | ------------------------------------- |
+| ChainId    | `String` | **Yes**   | A ChainId whose data should be reset. |
+
+### ChainFlag
+
+This interaction activates a flag on the User entity for the provided `ChainId`, which can be used to change behavior the
+next time a Chaining interaction with this `ChainId` is run. This will overwrite any flag that has
+already been raised. This interaction will have no effect for non-players. This interaction has no special failure
+conditions.
+
+| Field Name | Type     | Required? | Notes                                        |
+| ---------- | -------- | --------- | -------------------------------------------- |
+| ChainId    | `String` | **Yes**   | A ChainId on whom the flag should be raised. |
+| Flag       | `String` | **Yes**   | The name of the flag to raise.               |
+
+## Charging
+
+A unique flow-control interaction that is frequently used is the Charging interaction.  It is a flow-control interaction
+that delays while the input button used to trigger the interaction chain is held.  When it is released (or the interaction
+is forced to end), the interaction chain can continue with a different interaction based on how long the input was held
+for.
+
+These interactions are all related by either being the Charging interaction, or other interaction types that inherit the
+Charging interaction's behavior.
+
+### Charging
+
+This interaction does not inherit from SimpleInteraction and therefore its Next field works different from most interactions.
+This interaction adds its own Failed field which works the same way that SimpleInteraction's does.
+
+This interaction only works properly when its interaction chain was triggered by a client key or button press (or
+NPC-simulated equivalent). This interaction will continue executing for as long as the key or button press is held (with
+some exceptions, covered below) by the User entity.  Like other interactions, it has a `Next` field indicating which interaction to execute
+after this one, but the field is a map from `Float` values to `Interaction` assets. When this interaction ends, either
+due to the input being released or the charge duration completing, this interaction will determine the largest `Float` key that is less
+than the amount of time in seconds that the interaction was executing for.  The Interaction mapped to that key will be
+executed next.
+
+The interaction includes some cancellation conditions that are specific to this interaction. For instance, the interaction
+has a `CancelOnOtherClick` field that matches the field on RootInteraction. If it is active on this interaction but not
+the RootInteraction, then clicking while charging will cancel this interaction (and execute the `Failed` interaction rather
+than any of the `Next` interactions) but otherwise continue the interaction chain.
+
+Another valuable feature Charging has is the `Forks` field.  For input-triggered interactions that are triggered while the
+Charging interaction is executing, you can add an entry for the relevant InteractionType to this field and instead of
+triggering the usual interaction chain based on held item, targeted block, etc. the RootInteraction specified in the
+`Forks` field will be triggered.  This can unlock rich attack modes and behaviors. For instance, having a shield bash attack
+triggered off left click while blocking, or a special attack that triggers when both mouse buttons are pressed at the
+same time.
+
+There are two modes of operation for the Charging interaction. One is to have the ability charge for as long
+as the input is held and only end execution when the entity releases the input.  Bows in the main Hytale game work
+that way.  That is accomplished by setting `AllowIndefiniteHold` to true.  Another mode of operation is to have the
+interaction complete execution when the execution time has surpassed the largest key value in the `Next` field and
+immediately begin executing the Interaction mapped to that key.  Food in the main Hytale game work like this.  It
+is accomplished by setting `AllowIndefiniteHold` to false.
+
+One pitfall to be careful of when setting `AllowIndefiniteHold` to false is the way it interacts with cooldowns.\
+Normally, input-initiated interaction chains start a 0.35s cooldown on the triggered RootInteraction that prevents
+holding the mouse button from immediately spamming a new interaction when the first one completes.  However, if the
+duration of a Charging interaction is longer than 0.35s, then the cooldown will have already completed when the
+interaction chain finishes, which will often result in a new execution beginning immediately before the player can
+stop pressing the mouse button.  One solution for this problem is to add a `Simple` interaction to the end of your
+interaction chain with a `RunTime` of 0.35s to simulate the cooldown.  Alternatively, you can add a longer cooldown
+(the maximum duration of your Charging interaction plus 0.35s) to the RootInteraction. However, the longer cooldown is
+not always desirable, as the interaction may have ended prematurely, resulting in an unusually long lockout between
+executions.
+
+**Charging Fields**
+
+| Field Name                         | Type                                                                    | Required? | Notes                                                                                                                                                                                                                                                                                                                                                                                       |
+| ---------------------------------- | ----------------------------------------------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| FailOnDamage                       | `Boolean`<br />(Default: false)                                         | **No**    | If true, this interaction will fail and end immediately if the User entity takes any damage while it is executing.                                                                                                                                                                                                                                                                          |
+| CancelOnOtherClick                 | `Boolean`<br />(Default: true)                                          | **No**    | If true, this interaction will fail and end immediately if the User entity sends another button or key press while it is executing.                                                                                                                                                                                                                                                         |
+| Forks                              | `Map`<br />(Key Type: `InteractionType`, Value Type: `RootInteraction`) | **No**    | A map of InteractionType to RootInteraction. If entity input triggers the InteractionType while this interaction is executing, the mapped RootInteraction will be forked into its own interaction chain. This will happen instead of the usual handling for that InteractionType.  This fork will occur even if `CancelOnOtherClick` is set to true.                                        |
+| Failed                             | `Asset`<br />(Asset Type: `Interaction`)                                | **No**    | After this Interaction has finished, "Failed" will be executed if this Interaction failed.                                                                                                                                                                                                                                                                                                  |
+| AllowIndefiniteHold                | `Boolean`<br />(Default: false)                                         | **No**    | If true, this interaction will continue executing for as long as the User entity continues to hold the input. If false, execution will end as soon as the execution time in seconds reaches the largest key value in the `Next` map.                                                                                                                                                        |
+| DisplayProgress                    | `Boolean`<br />(Default: true)                                          | **No**    | If true, players executing this interaction will see a progress bar will be displayed below their cursor indicating how close to reaching the highest key value in `Next` they are.                                                                                                                                                                                                         |
+| Next                               | `Map`<br />(Key Type: `Float`, Value Type: `Interaction`)               | **No**    | A map from `Float` to `Interaction`.  When this interaction successfully finishes executing (either because the input was released or because the maximum duration was reached), this interaction will find the `Float` value with the largest duration in seconds that is less than the amount of time this interaction executed for. That key's mapped Interaction will then be executed. |
+| MouseSensitivityAdjustmentTarget   | `Float`<br />(Default: 1.0)                                             | **No**    | While charging, this mouse sensitivity multiplier will gradually be applied.                                                                                                                                                                                                                                                                                                                |
+| MouseSensitivityAdjustmentDuration | `Float`<br />(Default: 1.0)                                             | **No**    | Duration in seconds. After this many seconds, `MouseSensitivityAdjustmentTarget` will be fully applied to the mouse sensitivity.                                                                                                                                                                                                                                                            |
+| Delay                              | `ChargingDelay`                                                         | **No**    | Settings that allow charging progress to be pushed back when the User entity takes damage.                                                                                                                                                                                                                                                                                                  |
+
+**ChargingDelay Fields**
+
+| Field Name    | Type                        | Required? | Notes                                                                                                                                                                                                                                                                     |
+| ------------- | --------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| MinHealth     | `Float`<br />(Default: 0.0) | **No**    | Damage taken as a percentage of entity health (0.0-1.0). If a hit deals less than this much damage, no pushback will be applied.  If a hit deals exactly this much damage, `MinDelay` seconds worth of pushback will be applied.                                          |
+| MaxHealth     | `Float`<br />(Default: 0.0) | **No**    | Damage taken as a percentage of entity health (0.0-1.0). If a hit deals at least this much damage, `MaxDelay` seconds worth of pushback will be applied.                                                                                                                  |
+| MinDelay      | `Float`<br />(Default: 0)   | **No**    | The amount of pushback, in seconds, to apply if the entity takes a hit that deals `MinHealth` damage. The amount of pushback applied by a hit is a gradiant between `MinDelay` and `MaxDelay` based on the amount of damage between `MinHealth` and `MaxHealth`.          |
+| MaxDelay      | `Float`<br />(Default: 0)   | **No**    | The amount of pushback, in seconds, to apply if the entity takes a hit that deals at least `MaxHealth` damage. The amount of pushback applied by a hit is a gradiant between `MinDelay` and `MaxDelay` based on the amount of damage between `MinHealth` and `MaxHealth`. |
+| MaxTotalDelay | `Float`<br />(Deault: 0)    | **No**    | The maximum amount of pushback the entity can receive over the course of a single charge, regardless of how many times they are hit.                                                                                                                                      |
+
+**InteractionType Values**
+
+- `Primary`
+- `Secondary`
+- `Ability1`
+- `Ability2`
+- `Ability3`
+- `Use`
+- `Pick`
+- `Pickup`
+- `CollisionEnter`
+- `CollisionLeave`
+- `Collision`
+- `EntityStatEffect`
+- `SwapTo`
+- `SwapFrom`
+- `Death`
+- `Wielding`
+- `ProjectileSpawn`
+- `ProjectileHit`
+- `ProjectileMiss`
+- `ProjectileBounce`
+- `Held`
+- `HeldOffhand`
+- `Equipped`
+- `Dodge`
+- `GameModeSwap`
+
+### Wielding
+
+This interaction is inherited from Charging rather than SimpleInteraction.  However, its `Failed` and `Next` fields function
+identically to SimpleInteraction.  It does not inherit all fields from Charging, so be sure to pay close attention to
+the field list below.
+
+This interaction drives most blocking behavior in the game. While this interaction is executing, attacks made against
+the Owner entity will (conditionally) trigger effects defined in this interaction.  Unlike the Charging interaction,
+this interaction can always execute indefinitely and will only end when it fails or when the input is released.
+
+One option available in Wielding is `AngledWielding`, which allows damage and knockback modifiers to only be applied
+depending on the direction the attack against the Owner entity is coming from.  The AngledWielding type has a
+field `Angle` which determines which direction the protection points relative to the player (0 is the player's
+front), and `AngleDistance` which determines how wide the cone of protection extends around the player.  Block effects
+from this interaction (such as `BlockedEffects`, `BlockedInteractions`, and `StaminaCost`) will only apply if
+the DamageCause matches `DamageModifiers` OR if the DamageCause matches `AngledWielding.DamageModifiers` and
+the source of the damage matches `Angle` and `AngleDistance`.  It is possible for damage and knockback multipliers
+specified on both this interaction's modifier fields and `AngledWielding`'s modifier fields to stack, if both
+have entries for the same DamageCause.
+
+This interaction will only have an effect on damage taken by one of the DamageCause entries in `DamageModifiers` or
+`AngledWielding.DamageModifiers`.  If a DamageCause is in `DamageModifiers`, then the block effect will be triggered
+and the damage modifier applied regardless of what direction the Owner entity is attacked from.  If a DamageCause is in
+`AngledWielding.DamageModifiers`, then the damage modifier is only applied if the
+
+\*\* Wielding Fields\*\*
+
+| Field Name          | Type                                                                    | Required? | Notes                                                                                                                                                                                                                                                                                                                                                                                                      |
+| ------------------- | ----------------------------------------------------------------------- | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| FailOnDamage        | `Boolean`<br />(Default: false)                                         | **No**    | If true, this interaction will fail and end immediately if the User entity takes any damage while it is executing.                                                                                                                                                                                                                                                                                         |
+| CancelOnOtherClick  | `Boolean`<br />(Default: true)                                          | **No**    | If true, this interaction will fail and end immediately if the User entity sends another button or key press while it is executing.                                                                                                                                                                                                                                                                        |
+| Forks               | `Map`<br />(Key Type: `InteractionType`, Value Type: `RootInteraction`) | **No**    | A map of InteractionType to RootInteraction. If entity input triggers the InteractionType while this interaction is executing, the mapped RootInteraction will be forked into its own interaction chain. This will happen instead of the usual handling for that InteractionType.  This fork will occur even if `CancelOnOtherClick` is set to true (after which this interaction chain will be canceled). |
+| Next                | `Asset`<br />(Asset Type: `Interaction`)                                | **No**    | After this interaction has finished, "Next" will be executed if this interaction did not fail.                                                                                                                                                                                                                                                                                                             |
+| Failed              | `Asset`<br />(Asset Type: `Interaction`)                                | **No**    | After this interaction has finished, "Failed" will be executed if this interaction failed.                                                                                                                                                                                                                                                                                                                 |
+| DamageModifiers     | `Map`<br />(Key Type: `DamageCause`, Value Type: `Float`)               | **No**    | A map from DamageCause to Float, where the Float is multiplied against any damage received from the mapped DamageCause while this interaction is executing.                                                                                                                                                                                                                                                |
+| KnockbackModifiers  | `Map`<br />(Key Type: `DamageCause`, Value Type: `Float`)               | **No**    | A map from DamageCause to Float, where the Float is multiplied against any knockback force received from the mapped DamageCause while this interaction is executing.                                                                                                                                                                                                                                       |
+| AngledWielding      | `AngledWielding`                                                        | **No**    | Configuration to only trigger block effects from certain angles.                                                                                                                                                                                                                                                                                                                                           |
+| StaminaCost         | `StaminaCost`                                                           | **No**    | If the Owner entity receives damage that matches `DamageModifiers` or `AngledWielding` while this interaction is executing, then the entity's stamina will be deducted according to this configuration.                                                                                                                                                                                                    |
+| BlockedEffects      | `DamageEffects`                                                         | **No**    | If the Owner entity receives damage that matches `DamageModifiers` or `AngledWielding` while this interaction is executing, then these effects will be applied to the instance of damage.                                                                                                                                                                                                                  |
+| BlockedInteractions | `Asset`<br />(Asset Type: `RootInteraction`)                            | **No**    | If the Owner entity receives damage that matches `DamageModifiers` or `AngledWielding` while this interaction is executing, then this RootInteraction will be launched as a brand new interaction chain with the Owner entity as both Owner and User, and the attacker as the Target entity.  This new interaction chain is, notably, brand new, **not** forked from the current one.                      |
+
+**AngledWielding Fields**
+
+| Field Name         | Type                                                      | Required? | Notes                                                                                                                                                                                                            |
+| ------------------ | --------------------------------------------------------- | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Angle              | `Float`<br />(Default: 0.0)                               | **No**    | Angle in degrees relative to the Owner entity where the angled protection is centered. 0.0 means pointed towards the front of the Owner entity.                                                                  |
+| AngleDistance      | `Float`<br />(Default: 0.0)                               | **No**    | Angle in degrees indicating how wide the cone of protection is.                                                                                                                                                  |
+| DamageModifiers    | `Map`<br />(Key Type: `DamageCause`, Value Type: `Float`) | **No**    | A map from DamageCause to Float, where the Float is multiplied against any damage received from the mapped DamageCause received from within the cone of protection while this interaction is executing.          |
+| KnockbackModifiers | `Map`<br />(Key Type: `DamageCause`, Value Type: `Float`) | **No**    | A map from DamageCause to Float, where the Float is multiplied against any knockback force received from the mapped DamageCause received from within the cone of protection while this interaction is executing. |
+
+**StaminaCost Fields**
+
+| Field Name | Type                                             | Required? | Notes                                                                                                                                                                                                                                                |
+| ---------- | ------------------------------------------------ | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| CostType   | `CostType`<br />(Default: `MaxHealthPercentage`) | **No**    | How to calculate stamina consumed by blocking from the raw pre-block damage. If `Damage`, then the stamina consumed will be `rawDamage / Value`. If `MaxHealthPercentage`, then the stamina consumed will be `rawDamage / (EntityMaxHealth * Value)` |
+| Value      | `Float`<br />(Default: 0.04)                     | **No**    | The value to use in the `CostType` formula.                                                                                                                                                                                                          |
+
+**DamageEffects Fields**
+
+| Field Name             | Type                                         | Required? | Notes                                                                           |
+| ---------------------- | -------------------------------------------- | --------- | ------------------------------------------------------------------------------- |
+| ModelParticles         | `Array`<br />(Element Type: `ModelParticle`) | **No**    | Particle systems to trigger in the first-person view.                           |
+| WorldParticles         | `Array`<br />(Element Type: `WorldParticle`) | **No**    | Particle systems to trigger in the third-person view.                           |
+| LocalSoundEventId      | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | 2D sound to play locally to the attacking entity if they are a player.          |
+| WorldSoundEventId      | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | Sound to play in the world at the Owner entity's location.                      |
+| PlayerSoundEventId     | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | 2D sound to play locally to the Owner entity if they are a player.              |
+| ViewDistance           | `Double`<br />(Default: 75.0)                | **No**    | Distance at which these effects should play for other players.                  |
+| Knockback              | `Knockback`                                  | **No**    | The properties of the knockback that will be applied.                           |
+| CameraEffect           | `Asset`<br />(Asset Type: `CameraEffect`)    | **No**    | CameraEffect to briefly apply locally to the Owner entity if they are a player. |
+| StaminaDrainMultiplier | `Float`<br />(Default: 1.0)                  | **No**    | This multiplier is applied to the `StaminaCost`, if any.                        |
+
+**Knockback Fields**
+
+| Field Name     | Type                                       | Required? | Notes                                                                                                                      |
+| -------------- | ------------------------------------------ | --------- | -------------------------------------------------------------------------------------------------------------------------- |
+| Type           | `String`                                   | **No**    | If provided, specifies a type of knockback to use. Each knockback type may come with additional fields.                    |
+| Force          | `Double`<br />(Default: 0.0)               | **No**    | The amount of force to apply to the Owner entity.                                                                          |
+| Duration       | `Double`<br />(Default: 0.0)               | **No**    | If 0.0, apply the force as a single impulse.  If more, continuously apply the force over a period of time.                 |
+| VelocityType   | `ChangeVelocityType`<br />(Default: `Add`) | **No**    | How to apply the force, either adding it to the entity's current velocity, or setting the velocity to the knockback force. |
+| VelocityConfig | `VelocityConfig`                           | **No**    | Characteristics of friction as the Owner entity is thrown by this knockback.                                               |
+
+**Knockback Type: Force**
+
+Apply the calculated knockback force along the provided direction.
+
+| Field Name | Type                         | Required? | Notes                                                                                |
+| ---------- | ---------------------------- | --------- | ------------------------------------------------------------------------------------ |
+| Direction  | `Vector3`<br />(Default: Up) | **No**    | Which direction the player should be flung, relative to the direction of the attack. |
+
+**Knockback Type: Point**
+
+Apply the calculated knockback force laterally along the XZ plane, plus provided Y velocity.
+
+| Field Name | Type                        | Required? | Notes                                                                                                   |
+| ---------- | --------------------------- | --------- | ------------------------------------------------------------------------------------------------------- |
+| OffsetX    | `Integer`<br />(Default: 0) | **No**    | Offset the source position of the knockback left or right perpendicular to the direction of the attack. |
+| OffsetZ    | `Integer`<br />(Default: 0) | **No**    | Offset the source position of the knockback, forward or backward along the directon of the attack.      |
+| RotateY    | `Integer`<br />(Default: 0) | **No**    | Rotate the knockback direction around the Y axis, where 0 is the default attack direction.              |
+| VelocityY  | `Float`<br />(Default: 0.0) | **No**    | Add vertical velocity to the knockback force after the direction and force has been calculated.         |
+
+**Knockback Type: Directional**
+
+Apply the calculated knockback force along the attack direction, removing any vertical component and replacing it with a provided Y velocity.
+
+| Field Name | Type                      | Required? | Notes                                                                                                                                            |
+| ---------- | ------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------ |
+| RelativeX  | `Float`<br />(Default: 0) | **No**    | Apply additional force left or right perpendicular to the direction of the attack. The additional force is multiplied by the knockback strength. |
+| RelativeZ  | `Float`<br />(Default: 0) | **No**    | Apply additional force forward or backward along the attack direction. The additional force is multiplied by the knockback strength.             |
+| VelocityY  | `Float`<br />(Default: 0) | **No**    | Replace the vertical velocity of the knockback with this value.  This value is not multiplied by knockback strength.                             |
+
+**VelocityConfig Fields**
+
+| Field Name          | Type                                              | Required? | Notes                                                                                                                                                                                           |
+| ------------------- | ------------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| GroundResistance    | `Float`<br />(Default: 0.82)                      | **No**    | The minimum amount of friction applied when the entity is in contact with the ground.  1.0 = no friction, 0.0 = total friction                                                                  |
+| GroundResistanceMax | `Float`<br />(Default: 0.0)                       | **No**    | The maximum amount of friction applied when the entity is in contact with the ground.  1.0 = no friction, 0.0 = total friction                                                                  |
+| AirResistance       | `Float`<br />(Default: 0.96)                      | **No**    | The minimum amount of friction applied when the entity is in the air. 1.0 = no friction, 0.0 = total friction                                                                                   |
+| AirResistanceMax    | `Float`<br />(Default: 0.0)                       | **No**    | The maximum amount of friction applied when the entity is in the air. 1.0 = no friction, 0.0 = total friction                                                                                   |
+| Threshold           | `Float`<br />(Default: 1.0)                       | **No**    | The speed at which the maximum amount of friction will be applied to the entity. The amount of friction applied will increase from minimum to maximum as the entity moves from 0 to this speed. |
+| Style               | `VelocityThresholdStyle`<br />(Default: `Linear`) | **No**    | The curve that friction follows as the entity's speed increases toward the `Threshold`.                                                                                                         |
+
+**CostType Values**
+
+- `MaxHealthPercentage`
+- `Damage`
+
+**ChangeVelocityType Values**
+
+- `Add`
+- `Set`
+
+**VelocityThresholdStyle Values**
+
+- `Linear`
+- `Exp`
+
+## Blocks
+
+These are interaction types meant to reason about and modify blocks in the world.  The most important concept unique
+to these interactions is the Block Target.  Like the Entity Target, it is mutable and can come from many places.
+However, for interaction chains initiated by the client, the block target will initially be the block that the player's cursor was
+over, if any.
+
+Additionally, for interaction chains initiated by the client, the client will send along which face of the block is targeted,
+which is used by a few block-related interactions.
+It is left up to each interaction type that cares about block faces as to how to handle this behavior for simulated input
+(i.e. NPCs initiating chains that are normally initated by the client).  At the time of this writing, all block-related
+interactions choose the top face where relevant in simulated input.
+
+### BlockCondition
+
+This interaction has a field `Matchers` which specifies certain conditions, such as block type, state, etc.  This
+interaction fails if the current target block does not match all of them.
+
+**BlockCondition Fields**
+
+| Field Name       | Type                                        | Required? | Notes                                                                                                                                                                                                                                                                                                                                   |
+| ---------------- | ------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false)             | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction.                                                                                                                                                                                                       |
+| Matchers         | `Array`<br />(Element Type: `BlockMatcher`) | **Yes**   | A list of conditions that the target block must match or this condition will fail.<br />**Note: This field is technically not required but there is a bug that makes it dangerous to not provide at the time of this writing.**<br />**Note: If no conditions are added to this array, the interaction will fail, counterintuitively.** |
+
+**BlockMatcher Fields**
+
+| Field Name | Type                       | Required? | Notes                                                                          |
+| ---------- | -------------------------- | --------- | ------------------------------------------------------------------------------ |
+| Block      | `BlockIdMatcher`           | **No**    | If provided, requires the block itself match some set of conditions.           |
+| Face       | `BlockFace`                | **No**    | If provided and not 'None', requires a specific block face be targeted.        |
+| StaticFace | `Boolean` (Default: false) | **No**    | If false, the face condition will be adjusted by the block's current rotation. |
+
+**BlockFace Values**
+
+- `Up`
+- `Down`
+- `North`
+- `South`
+- `East`
+- `West`
+- `None`
+
+**BlockIdMatcher Fields**
+
+| Field Name | Type                                   | Required? | Notes                                                                      |
+| ---------- | -------------------------------------- | --------- | -------------------------------------------------------------------------- |
+| Id         | `Asset`<br />(Asset Type: `BlockType`) | **No**    | If provided, the block must match the specified `BlockType`.               |
+| State      | `String`                               | **No**    | If provided, the block's current state must match the provided state name. |
+| Tag        | `String`                               | **No**    | If provided, the block type's asset tags must contain the provided tag.    |
+
+### DestroyCondition
+
+This interaction fails if the current User entity cannot destroy the current target blcok.
+
+**DestroyCondition Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+
+### PlacementCountCondition
+
+This interaction accepts the name of a BlockType that has the TrackedPlacement BlockEntity. The interaction will fail if the number of
+blocks of the provided BlockType in the world do not match the provided condition.
+
+**PlacementCountCondition Fields**
+
+| Field Name | Type                           | Required? | Notes                                                                                                                                                                                                                                                           |
+| ---------- | ------------------------------ | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Block      | `String`                       | **Yes**   | The BlockType to examine. The number of instances of the BlockType in the world will be compared to Value.<br />**Note: The specified BlockType must have the TrackedPlacement BlockEntity. Otherwise, the number of blocks in the world will always be zero.** |
+| Value      | `Integer`<br />(Default: 0)    | **No**    | The value to compare the number of blocks in the world with.                                                                                                                                                                                                    |
+| LessThan   | \`Boolean<br />(Default: true) | **No**    | If true, the interaction will fail if the number of blocks in the world is greater than or equal to Value. If false, the interaction will fail if the number of blocks in the world is less than or equal to Value.                                             |
+
+### BreakBlock
+
+This interaction attempts to break the target block while acting as the User entity. The User entity must be a player. It
+is not guaranteed to work, depending on world settings and the User entity's current state, it may not work.  If it
+fails, it will fail the interaction under some circumstances, but not others.
+
+**Note: In particular, if `Harvest`=false and the player is in Survival mode, the player will simply execute a damage operation
+against the block. Even when the Tool field is specified, the player's currently-held item can impact the results in unintuitive
+ways.**
+
+This interaction will fail if there is no block target, if `Harvest`=true and the
+block is not harvestable, or if the world settings prevent the Harvest/Break operation.
+It will generally not fail otherwise, even if the block was not broken or damaged.
+The block will generally break every time if `Harvest`=true or the player is in
+Creative mode.
+
+**BreakBlock Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                                                                                                                                                                                                  |
+| ---------------- | ------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction.                                                                                                                                                                      |
+| Harvest          | `Boolean` (Default: false)      | **No**    | If true, harvest the block and deposit the drops in the player's inventory. This operation will generally always succeed.  If false, this interaction will effectively perform whatever action would have occurred if the player had left-clicked the block.                                           |
+| Tool             | `String`                        | **No**    | If `Harvest`=true, the player is in Survival mode, and this field is provided, then the break operation will be performed as though with this tool type.<br />**This field mostly doesn't work.  Your held item will be used for most block damage calculations regardless of this field's contents.** |
+| MatchTool        | `Boolean` (Default: false)      | **No**    | If true, `Harvest`=true, the player is in Survival mode, and `Tool` is provided, block breaking will be prevented unless `Tool` is a valid gathering tool for the target block. The interaction will not be failed, even if block breaking is prevented in this manner.                                |
+
+### ChangeBlock
+
+This interaction requires a mapping from one or more current BlockTypes to one or more target BlockTypes.  If the
+target block is one of the key BlockTypes, then it will be changed to the mapped target BlockType.  If the current
+BlockType of the target block does not appear as a key in the Changes field, then this interaction fails.
+
+**ChangeBlock Fields**
+
+| Field Name        | Type                                                        | Required? | Notes                                                                                                                             |
+| ----------------- | ----------------------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget  | `Boolean`<br />(Default: false)                             | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+| Changes           | `Map`<br />(Key Type: `BlockType`, Value Type: `BlockType`) | **No**    | A list of potential block type changes, with each entry having a current and new BlockType id.                                    |
+| WorldSoundEventId | `Asset`<br />(Asset Type: `SoundEvent`)                     | **No**    | If provided, this SoundEvent is played in the world at the position of the block if the block successfully changes.               |
+| RequireNotBroken  | `Boolean`<br />(Default: false)                             | **No**    | If true, this interaction will fail if the player's held item is broken (durability 0), and the block change will not take place. |
+
+### ChangeState
+
+This interaction requires a mapping from one or more current block state names to one or more state names. If the
+target block is in one of the key block states, then it will be changed to the mapped target blocks tate. If the
+current block state of the target block does nto appear as a key in the Changes field, then this interaction fails.
+
+All blocks start out with a null state by default.  This null state can be referenced by the key "default" and the block
+can be returned to that state with the value "default".
+
+**ChangeState Fields**
+
+| Field Name       | Type                                                  | Required? | Notes                                                                                                                                          |
+| ---------------- | ----------------------------------------------------- | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false)                       | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction.              |
+| Changes          | `Map`<br />(Key Type: `String`, Value Type: `String`) | **No**    | A list of potential block state changes, with each entry having a current and new state name.                                                  |
+| UpdateBlockState | `Boolean`<br />(Default: false)                       | **No**    | If true, performs a full refresh of the block's BlockEntity component and notifies nearby players as though a full block type change occurred. |
+
+### CycleBlockGroup
+
+This interaction will attempt to change the target block to the next block type in one of the BlockGroups it belongs to.
+If the block type belongs to multiple BlockGroups, which one is used is effectively arbitrary. The User entity must be
+a player. If the block cannot be changed for any reason (entity not a player, no block target, block does not belong
+to a BlockGroup, etc.). If the block is the only entry in the BlockGroup, this interaction will succeed and the block
+will be considered changed despite nothing happening.  Unlike most other block-changing interactions, this one will
+fail if the world settings prevent players from breaking blocks.
+
+**This interaction always reduces the player's held item's durability by a single 'hit' worth of damage if the block
+changes. There is no way to prevent it. The block type will change and the interaction will succeed even if the player's
+held item is broken, however.**
+
+**CycleBlockGroup Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+
+### DestroyBlock
+
+This interaction destroys the target block without dropping anything.  It will successfully destroy the block if the
+target block exists and this interaction has no failure conditions.
+
+**This interaction has no additional fields.**
+
+### PickBlock
+
+This interaction is effectively equivalent to using the middle mouse button in creative mode. In survival mode, the
+block's item will be moved to the user's current active hotbar slot if it is in the player's inventory.  This
+interaction is performed entirely on the client and cannot be performed by non-players.  It is unclear if this
+interaction has failure conditions.
+
+**PickBlock Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+
+### PlaceBlock
+
+This interaction is effectively identical to a right clicking while holding a block in their hand, with some
+additional options. For one, it can be executed with any LivingEntity as the User entity. For another, it has some
+useful fields.  For the most part, though, it follows the same behaviors and rules as any ordinary block placement
+by a player.
+
+It's not clear under what circumstances this interaction can fail. The server will not fail the interaction under any
+special circumstances (including when there is no target block, or when `BlockTypeToPlace` is not provided and the
+LivingEntity is not holding a block). However, the client is very involved with the function of this interaction and
+its behavior is unknown.
+
+**PlaceBlock Fields**
+
+| Field Name         | Type                                   | Required? | Notes                                                                                                                                                                                                                                                                                                                                                           |
+| ------------------ | -------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| BlockTypeToPlace   | `Asset`<br />(Asset Type: `BlockType`) | **No**    | If provided, the block placed by this interaction will be the specified BlockType. If not provided, the User entity's held item will be used, instead, if it is a block.                                                                                                                                                                                        |
+| RemoveItemInHand   | `Boolean`<br />(Default: True)         | **No**    | If true and the User entity is not a player in Creative mode, the item in the player's hand must match the block being placed and one quantity will be removed for each block placed. If the item does not match, the block cannot be placed.  If false, the player's hand item is ignored entirely.\*\*                                                        |
+| AllowDragPlacement | `Boolean`<br />(Default: True)         | **No**    | If true and the interaction was triggered on the client by a player, then the player can hold the input that was used to activate this interaction chain and move the mouse around in order to execute this interaction repeatedly and place several blocks. The interaction chain will not move onto the next interaction until the player releases the input. |
+
+### RunOnBlockTypes
+
+This interaction retrieves all blocks within a provided radius of the User entity. For each block that matches any of
+the provided BlockSets, a new interaction chain will be forked that uses the matching block as the target block.
+This interaction will continue executing until all forked interaction chains have completed.  The interaction will fail if no
+blocks within the radius match the provided BlockSets or if all of the forked interaction chains fail.
+
+**RunOnBlockTypes Fields**
+
+| Field Name   | Type                                         | Required?        | Notes                                                                                                                                                                                                                                                                                      |
+| ------------ | -------------------------------------------- | ---------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| Range        | `Integer`                                    | **Yes**          | The spherical radius around the User entity to search for blocks. Must be at least 1.                                                                                                                                                                                                      |
+| BlockSets    | `AssetArray`<br />(Element Type: `BlockSet`) | **No**           | A list of BlockSets to match nearby blocks again. Only blocks that match any of the BlockSets will have interaction chains forked for them.                                                                                                                                                |
+| MaxCount     | `Integer`                                    | **Yes**          | The maximum number of blocks that will be located with the search. Further blocks will be ignored. If there are more matching blocks within the radius than this number, the specific set of blocks that will be found is completely arbitrary and may change from execution to execution. |
+| Interactions | `Asset`<br />(Asset Type: `RootInteraction`) | **No, but yes.** | The RootInteraction that will be forked for each matching block.  This interaction will not fail to validate if it is missing, but every execution of this interaction will fail.                                                                                                          |
+
+### UseBlock
+
+If the target block has an interaction for this interaction chain's interaction type, execute it immediately as part of
+this interaction chain. The execution will be wrapped in UseBlockEvent.Pre and UseBlockEvent.Post events, and cancellations
+of the UserBlockEvent.Pre event are respected. The User entity is considered the triggering entity for both events.
+
+If the target block does not have an interaction for this interaction chain's interaction type, this interaction fails.
+
+**This interaction has no additional fields.**
+
+## Items
+
+These are interactions intended to interface with an entity's inventory. There is no concept of an "item target",
+unfortunately, so these generally either interact with the entity's held item or the entity's inventory at a high level.
+
+### AddItem
+
+Adds a specified quantity of a specified item to the User entity's inventory, preferring to add it to the
+entity's hotbar where possible. This interaction will have no effect on User entities that are not LivingEntities.
+This interaction has no failure states.
+
+**Note: This interaction has a bug in its field validators that will cause interactions that reference items declared
+in the same mod to fail validation on startup.  Additionally, this interaction has a bug that will cause it to
+fail and have no effect if the User entity has no block target. Use ModifyInventory instead.**
+
+**AddItem Fields**
+
+| Field Name       | Type                              | Required? | Notes                                                                                                                             |
+| ---------------- | --------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false)   | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+| ItemId           | `Asset`<br />(Asset Type: `Item`) | **Yes**   | The item id of the item to add to the player's inventory.                                                                         |
+| Quantity         | `Integer`<br />(Default: 0)       | **No**    | The quantity of the item to add to the player's inventory.                                                                        |
+
+### CheckUniqueItemUsage
+
+This interaction will check whether it has run once for the User entity with their currently-held item before. If it hasn't,
+it will succeed. If it has, it will fail. It will also fail if the User entity is not a player. The interaction will record
+the item id of the User entity's currently-held item on success, ensuring it cannot be successfully run with that player
+and item id combination again.
+
+**This interaction has no additional fields.**
+
+### ChangeActiveSlot
+
+This interaction does not inherit from SimpleInteraction and therefore has no Next or Failed fields.  The `CancelOnItemChange`
+field is ignored for this interaction and is always treated as false. This interaction will set the User entity's currently-
+active hotbar slot to the specified slot index. If none is specified, the interaction chain's target slot will be used,
+if any. Otherwise, slot 0 will be used.  If a slot is specified and it is already active, then this interaction will
+have no effect, but if no slot is specified and the interaction chain's target slot is already active, the logic in
+the next paragraph will still be executed. This interaction will also have no effect if the User entity is not a
+LivingEntity.
+
+Once the slot has changed, a new SwapTo interaction chain will be forked off for the selected slot.
+If a target slot was specified, then the interaction chain's current target slot will be set to the specified slot, as will
+the forked SwapTo interaction chain. If this interaction chain was initiated by a player swapping an item into or out of
+an occupied active hotbar slot, then the swap will be executed after the slot is changed and before the SwapTo
+interaction is forked. Not running this interaction in the resulting SwapFrom interaction chain is a way for the server
+to cancel players performing these sorts of swap interactions. The default behavior for these swap interactions is that
+the SwapFrom interaction chain will be initiated with the currently-active-slot as the target slot. As a result, the
+target slot will usually not change when this interaction runs, it merely exists as a signal for the server to continue the
+item swap.
+
+**ChangeActiveSlot Fields**
+
+| Field Name | Type      | Required? | Notes                                                                                                                                                                                                     |
+| ---------- | --------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| TargetSlot | `Integer` | **No**    | If not provided, indicates the slot the player's active hotbar slot should be changed to.  Otherwise, the interaction chain's target slot will be used (which is usually the already-active hotbar slot). |
+
+### EquipItem
+
+This interaction will equip the User entity's currently-held item into the appropriate armor slot, if it is armor. The
+interaction will fail if the item is armor but it cannot be equipped for some reason. The interaction will succeed but
+take no action if the User entity cannot equip armor or if the item is not armor.
+
+**This interaction has no additional fields.**
+
+### IncreaseBackpackCapacity
+
+This interaction will increase the User entity's backpack size by the provided amount.  **It will additionally remove one
+quantity from the player's currently-held item. There is no way to prevent this.**  This interaction will have no effect
+if the User entity is not a player.  This interaction has no special failure conditions, even if the User entity
+is not a player, or the player is not currently holding an item.
+
+| Field Name | Type                        | Required? | Notes                                                                                   |
+| ---------- | --------------------------- | --------- | --------------------------------------------------------------------------------------- |
+| Capacity   | `Integer`<br />(Default: 1) | **No**    | The additional backpack capacity to add to the player. **Must be between 1 and 32767.** |
+
+### ModifyInventory
+
+This interaction attempts to perform one or more inventory-modifying actions against the User entity. The User entity must
+be a player. If they are not, no actions will be performed, but the interaction will not fail. Any item removals performed
+by this interaction, either as a result of `ItemToRemove` or `AdjustHeldItemQuantity`, are both atomic (meaning the entire
+quantity must be removed, or none) and required (meaning that the interaction will fail and no further actions taken if
+the removal fails for any reason).  Item additions performed by this interaction, either as a result of `ItemToAdd` or
+`AdjustHeldItemQuantity` will drop excess items on the ground near the player if necesary and continue on.
+
+This interaction first executes the item removal in `ItemToRemove`, if any, then adjusts the held item as specified by
+`AdjustHeldItemQuantity`, if provided, then executes the item addition in `ItemToAdd`, if any, and then finally executes
+the damage/healing of the held item in `AdjustHeldItemDurability`, if provided.
+
+**ModifyDurability Fields**
+
+| Field Name               | Type                            | Required? | Notes                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
+| ------------------------ | ------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| RequiredGameMode         | `GameMode`                      | **No**    | If provided, only execute the inventory-modifying actions if the player is in the provided GameMode. The interaction will not fail if the GameMode doesn't match.                                                                                                                                                                                                                                                                                                                                                                               |
+| ItemToRemove             | `ItemStack`                     | **No**    | If provided, a matching item will be removed in the provided quantity. If there is no matching item in the player inventory in the required quantity, then the interaction will fail and further actions will not be executed.                                                                                                                                                                                                                                                                                                                  |
+| AdjustHeldItemQuantity   | `Integer`<br />(Default: 0)     | **No**    | The player's held item, if any, will have its quantity will be modified by the provided amount- subtracted from if this number is negative or added to if this item is positive.  If the player has no held item, then this field will have no effect regardless of its value and the interaction will NOT fail.  If the player's inventory does not have sufficient quantity of items to support the removal, this interaction will fail and further actions will not be executed. Excess items will be dropped on the ground near the player. |
+| ItemToAdd                | `ItemStack`                     | **No**    | If provided, the ItemStack will be added to the player's inventory. Excess items will be dropped on the ground near the player.                                                                                                                                                                                                                                                                                                                                                                                                                 |
+| AdjustHeldItemDurability | `Double`<br />(Default: 0.0)    | **No**    | The player's held item, if any, will have its durability adjusted by the specified amount.  The durability cannot go below 0 or raise above the item's maximum durability. Invalid durability values in this field will not cause the interaction to fail. Neither will it fail if the player has no held item.                                                                                                                                                                                                                                 |
+| BrokenItem               | `String`                        | **No**    | This field should contain an ItemId, but it is not validated by the server on startup, so be careful.  This field can have the value of "Empty" to specify no item, or an empty hand. If specified and the `AdjustHeldItemDurability` operation reduces the player's held item to 0 durability, the player's held item is changed to this ItemId. If the inventory replacement fails, this interaction will fail.                                                                                                                               |
+| NotifyOnBreak            | `Boolean`<br />(Default: false) | **No**    | If true and the `AdjustHeldItemDurability` operation reduces the player's held item to 0 durability, this interaction will perform the usual audiovisual feedback of a broken tool. It will play the usual tool breaking sound and send the player a text message in chat that their item has broken.                                                                                                                                                                                                                                           |
+| NotifyOnBreakMessage     | `String`                        | **No**    | If provided, and `NotifyOnBreak` is true, when the player is notified of a broken tool by this interaction, the message sent to their chat will instead be the translation key specified by this field. The translation key supports the templating parameter `{itemName}`. See the translation key `server.general.repair.itemBroken_Hoe` for an example.                                                                                                                                                                                      |
+
+**GameMode Values**
+
+- `Creative`: The game is currently in Creative Mode
+- `Adventure`: The game is currently in Adventure Mode
+
+**ItemStack Fields**
+
+| Field Name                   | Type                              | Required? | Notes                                                                                |
+| ---------------------------- | --------------------------------- | --------- | ------------------------------------------------------------------------------------ |
+| Id                           | `Asset`<br />(Asset Type: `Item`) | **Yes**   | The id of the Item asset this stack contains.                                        |
+| Quantity                     | `Integer`<br />(Default: 1)       | **No**    | The number of items in this stack.<br />**Must be greater than 0.**                  |
+| Durability                   | `Double`<br />(Default: 0.0)      | **No**    | The durability of the item stack.<br />**Cannot be negative.**                       |
+| MaxDurability                | `Double`<br />(Default: 0.0)      | **No**    | The maximum durability of the item this stack contains.<br />**Cannot be negative.** |
+| Metadata                     | `Bson Document`                   | **No**    | If provided, applies the bson to the item stack metadata.                            |
+| OverrideDroppedItemAnimation | `Boolean`\*(Default: false)       | **No**    | ???                                                                                  |
+
+### PickupItem
+
+This interaction will attempt to pick up the User entity's current target entity and add it to their inventory. It will
+fail if the User entity is not a player, if they do not have a target entity, or if the target entity is not an item
+located in the world.  It will not fail if the player simply cannot pick up the item.
+
+**This interaction has no additional fields.**
+
+### RefillContainer
+
+This interaction will fail if the User entity is not a player. The interaction will draw a ray from the player's head
+down their look direction until the edge of the player's held item's interaction range or until the first solid block.
+The nearest fluid block of a type listed in this interaction's `States` map will result in the one of the player's
+currently-held items being converted to the fluid's related item state.  If the `States` map indicates a durability
+for the new item state, then the converted item will use that durability. If the item is already in the fluid's related
+item state, then this interaction will fail if the player's held item is already at maximum durability (unless the
+`States` map indicates a durability value greater than the item's maximum, in which case the interaction will succeed
+but the item will not change).  Otherwise, the durability listed for the fluid in the `States` map will be added to the
+item's current durability.
+
+If the interaction has not failed by this point, the fluid block in the world may be transformed to a different type if one is listed
+in the `States` map.
+
+If any part of this process does not proceed for any reason (for instance, if the player is not holding an item),
+then this interaction will fail.
+
+**RefillContainer Fields**
+
+| Field Name | Type                                                       | Required? | Notes                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| ---------- | ---------------------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| States     | `Map`<br />(Key Type: `String`, Value Type: `RefillState`) | **Yes**   | A map from item state names to `RefillState` objects, which contain information such as acceptable fluid block types, durability increases, and what fluid type to convert the targeted fluid block to after refill, if any. If the player targets a fluid block that matches one of the fluid types in the `RefillState`, the item will be converted to the keyed item state and the `RefillState` will be used to decide what happens next. |
+
+**RefillState Fields**
+
+| Field Name     | Type                                  | Required? | Notes                                                                                                                                                                                                                                                                                                                           |
+| -------------- | ------------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| AllowedFluids  | `Array`<br />(Element Type: `String`) | **Yes**   | If any of these fluids are targeted by the player, the player's held item will be converted to the keyed item state and `Durability` and `TransformFluid` will be used.                                                                                                                                                         |
+| Durability     | `Double`<br />(Default: -1.0)         | **No**    | If the player's held item changes item states, this value is the new item's durability, unless it is negative, in which case the item will begin at full durability. If the player's held item is already in the item state, and the item is not already at full durability, this value will be added to the item's durability. |
+| TransformFluid | `String`                              | **No**    | If provided, this field is a fluid id that the targeted fluid block should be transformed to if the player's held item is successfully updated.                                                                                                                                                                                 |
+
+## Entities
+
+### DamageEntity
+
+This interaction does not inherit from SimpleInteraction, but adds its own Next and Failed fields that
+work similarly.
+
+This interaction will cause the User entity to damage the Target entity.  It has the capability to apply different
+damage based on the direction of the attack or what body part was targeted by the User entity, with each possibility
+providing different damage calculations, effects, and Next interaction. If multiple entires match the attack, `TargetedDamage`
+(body part damage) takes highest priority, then the first matching `AngledDamage` in the list, then the default
+damage in the base interaction fields.  It is possible for elements of these different damage priorities to be taken peacemeal if higher-priority
+damage fields do not overwrite lower-priority damage fields. For instance,
+damage calculation could be taken from `TargetedDamage`, the damage effects could be taken from the first matching
+`AngledDamage`, and the Next interaction coming from the default damage field.
+
+If all damage dealt by this interaction is cancelled, then this interaction will fail, and the `Failed` interaction
+will be executed next in the chain. If any damage dealt by this interaction is blocked, then this interaction will
+succeed, but the `Blocked` interaction wil lbe executed next in the chain. Otherwise, the highest-precedent matching
+`Next` interaction that you provide will be executed.  For instance, if you provide `Next` interactions for all
+`TargetedDamage` and `AngledDamage` entries, and one in the interaction's `Next` field, then a headshot could result
+in a unique `Next` interaction being executed, even if there is a matching `AngledDamage` entry. However, if you leave
+the `Next` interaction out of your `TargetedDamage` entries, a special `Next` interaction for backstabs could be
+executed.  Otherwise, the `Next` field in the root of the interaction will be executed instead.
+
+DamageEntity has an unusual relationship with `RunTime`. This interaction always ends immediately after its first tick,
+regardless of the status of `RunTime` or `WaitForAnimationToFinish`.  However, if damage dealt by this interaction is
+calculated as `DamageCalculatorType` `Dps`, then the `RunTime` will be used to determine the precise amount of damage to
+deal. If `RunTime` is 0, then no damage will be dealt.
+
+**DamageEntity Fields**
+
+| Field Name       | Type                                                          | Required?                                                                                                                    | Notes                                                                                                                                                                                                                                                                                                                                                                         |
+| ---------------- | ------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| DamageCalculator | `DamageCalculator`                                            | **No**                                                                                                                       | If provided, describes the damage amounts and types to apply to the Target entity.                                                                                                                                                                                                                                                                                            |
+| DamageEffects    | `DamageEffects`                                               | **No**                                                                                                                       | If provided, describes particles, sounds, knockback, etc. to apply to the target entity on damage.                                                                                                                                                                                                                                                                            |
+| Next             | `Asset`<br />(Asset Type: `Interaction`)                      | **No**  After this interaction has finished, "Next" will be executed if damage was dealt to the target and none was blocked. |                                                                                                                                                                                                                                                                                                                                                                               |
+| AngledDamage     | `Array`<br />(Element Type: `AngledDamage`)                   | **No**                                                                                                                       | If provided, allows alternative `DamageCalculator`, `DamageEffects`, and `Next` entries for attacks that approach the target from certain angles.                                                                                                                                                                                                                             |
+| TargetedDamage   | `Map`<br />(Key Type: `String`, Value Type: `TargetedDamage`) | **Yes**                                                                                                                      | This field must be provided, but is not required to have any entries.  This is a map from body part names to `TargetedDamage` values. Hypixel only uses one body part name: `Head`, and it is not clear whether there are others.  If provided, allows alternative `DamageCalculator`, `DamageEffects`, and `Next` entries for attacks that damage specific enemy body parts. |
+| EntityStatsOnHit | `Array`<br />(Element Type: `EntityStatOnHit`)                | **No**                                                                                                                       | If provided, allows this attack to reduce enemy stats other than health.  Each individual damage application dealt by the same ability will apply stat reductions, at diminishing returns. All damage dealt in interaction chains forked by a Selector interaction will share the number of hits across all targets.                                                          |
+| Failed           | `Asset`<br />(Asset Type: `Interaction`)                      | **No**                                                                                                                       | After this interaction has finished, "Failed" will be executed if no damage hits were applied to the player, or if all damage hits were cancelled.                                                                                                                                                                                                                            |
+| Blocked          | `Asset`<br />(Asset Type: `Interaction`)                      | **No**                                                                                                                       | After this interaction has finished, "Blocked" will be executed if any damage hits were blocked by the target.                                                                                                                                                                                                                                                                |
+
+**DamageCalculator Fields**
+
+| Field Name                | Type                                                      | Required? | Notes                                                                                                                                                                                                                                                 |
+| ------------------------- | --------------------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Type                      | `DamageCalculatorType`<br />(Default: Absolute)           | **No**    | Whether the damage being applied is `Absolute` or \`Dps'.                                                                                                                                                                                             |
+| Class                     | `DamageClass`<br />(Default: Unknown)                     | **No**    | The type of attack producing the damage. Some weapon systems apply equipment modifiers based on this value.                                                                                                                                           |
+| BaseDamage                | `Map`<br />(Key Type: `DamageCause`, Value Type: `Float`) | **No**    | A set of DamageCauses and how much base damage is dealt for each.                                                                                                                                                                                     |
+| SequentialModifierStep    | `Float`<br />(Default: 0.0)                               | **No**    | Value between 0.0-1.0. Each additional hit from a single ability will have its damage reduced by this much as a percentage. All damage dealt in interaction chains forked by a Selector interaction will share the number of hits across all targets. |
+| SequentialModifierMinimum | `Float`<br />(Default: 0.0)                               | **No**    | Value between 0.0-1.0. `SequentialModifierStep` cannot reduce damage below this percentage regardless of the number of hits.                                                                                                                          |
+| RandomPercentageModifier  | `Float`<br />(Default: 0.0)                               | **No**    | A random value between +/- this amount multiplied by the base damage will be added to the base damage.                                                                                                                                                |
+
+**DamageEffects Fields**
+
+| Field Name             | Type                                         | Required? | Notes                                                                                   |
+| ---------------------- | -------------------------------------------- | --------- | --------------------------------------------------------------------------------------- |
+| ModelParticles         | `Array`<br />(Element Type: `ModelParticle`) | **No**    | Particle systems to trigger in the first-person view.                                   |
+| WorldParticles         | `Array`<br />(Element Type: `WorldParticle`) | **No**    | Particle systems to trigger in the third-person view.                                   |
+| LocalSoundEventId      | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | 2D sound to play locally to the attacking entity if they are a player.                  |
+| WorldSoundEventId      | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | Sound to play in the world at the Target entity's location.                             |
+| PlayerSoundEventId     | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | 2D sound to play locally to the Target entity if they are a player.                     |
+| ViewDistance           | `Double`<br />(Default: 75.0)                | **No**    | Distance at which these effects should play for other players.                          |
+| Knockback              | `Knockback`                                  | **No**    | The properties of the knockback that will be applied.                                   |
+| CameraEffect           | `Asset`<br />(Asset Type: `CameraEffect`)    | **No**    | CameraEffect to briefly apply locally to the Target entity if they are a player.        |
+| StaminaDrainMultiplier | `Float`<br />(Default: 1.0)                  | **No**    | This multiplier is applied to the stamina cost incurred by the target blocking, if any. |
+
+**AngledDamage Fields**
+
+| Field Name       | Type                                     | Required? | Notes                                                                                                                                                                                                     |
+| ---------------- | ---------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| AngleDistance    | `Float`<br />(Default: 0)                | **No**    | The width in degrees of the matching arc around the Target entity. If the attack against the Target originates from within the arc, then the properties below will be applied to the attack, if provided. |
+| Angle            | `Float`<br />(Default: 0.0)              | **No**    | The angle in degrees around the Target entity at which the matching arc is centered.                                                                                                                      |
+| DamageCalculator | `DamageCalculator`                       | **No**    | If provided and the attack against the Target entity originates from within the provided arc, this DamageCalculator will override the interaction's `DamageCalculator` field.                             |
+| DamageEffects    | `DamageEffects`                          | **No**    | If provided and the attack against the Target entity originates from within the provided arc, this DamageEffects will override the interaction's `DamageEffects` field.                                   |
+| Next             | `Asset`<br />(Asset Type: `Interaction`) | **No**    | If provided and the attack against the Target entity originates from within the provided arc, this Interaction will override the interaction's `Next` field.                                              |
+
+**TargetedDamage Fields**
+
+| Field Name       | Type                                     | Required? | Notes                                                                                                                                                                                            |
+| ---------------- | ---------------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| DamageCalculator | `DamageCalculator`                       | **No**    | If provided and this TargetedDamage was matched, this DamageCalculator will override the interaction's `DamageCalculator` field and the `DamageCalculator` field of any matching `AngledDamage`. |
+| DamageEffects    | `DamageEffects`                          | **No**    | If provided and this TargetedDamage was matched, this DamageEffects will override the interaction's `DamageEffects` field and the `DamageEffects` field of any matching `AngledDamage`.          |
+| Next             | `Asset`<br />(Asset Type: `Interaction`) | **No**    | If provided and this TargetedDamage was matched, this Interaction will override the interaction's `Next` field and the `Next` field of any matching `AngledDamage`.                              |
+
+**EntityStatOnHit Fields**
+
+| Field Name                  | Type                                                                       | Required? | Notes                                                                                                                                                                                                                                                                                        |
+| --------------------------- | -------------------------------------------------------------------------- | --------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| EntityStatId                | `Asset`<br />(AssetType: `EntityStatType`)                                 | **Yes**   | Which entity stat to affect.                                                                                                                                                                                                                                                                 |
+| Amount                      | `Float`<br />(Default: 0.0)                                                | **No**    | How much of the stat to apply for each damage application. Use negative numbers to reduce stats.                                                                                                                                                                                             |
+| MultipliersPerEntitiesHit   | `Array`<br />(Element Type: `Float`, Default: `[1.0, 0.6, 0.4, 0.2, 0.1]`) | **No**    | The diminishing returns curve to be applied for multiple damage applications by the same ability. Each hit's stat impact will be multiplied by the next value in the list.  If there are more hits than array elements, subsequent hits will be multiplied by `MultiplierPerExtraEntityHit`. |
+| MultiplierPerExtraEntityHit | `Float`<br />(Default: 0.05)                                               | **No**    | If an ability carries out more damage applications than there are elements in the `MultipliersPerEntitiesHit` array, then subsequent stat values will be multiplied by this number.                                                                                                          |
+
+**Knockback Fields**
+
+| Field Name     | Type                                       | Required? | Notes                                                                                                                      |
+| -------------- | ------------------------------------------ | --------- | -------------------------------------------------------------------------------------------------------------------------- |
+| Type           | `String`                                   | **No**    | If provided, specifies a type of knockback to use. Each Target type may come with additional fields.                       |
+| Force          | `Double`<br />(Default: 0.0)               | **No**    | The amount of force to apply to the Owner entity.                                                                          |
+| Duration       | `Double`<br />(Default: 0.0)               | **No**    | If 0.0, apply the force as a single impulse.  If more, continuously apply the force over a period of time.                 |
+| VelocityType   | `ChangeVelocityType`<br />(Default: `Add`) | **No**    | How to apply the force, either adding it to the entity's current velocity, or setting the velocity to the knockback force. |
+| VelocityConfig | `VelocityConfig`                           | **No**    | Characteristics of friction as the Owner entity is thrown by this knockback.                                               |
+
+**Knockback Type: Force**
+
+Apply the calculated knockback force along the provided direction.
+
+| Field Name | Type                         | Required? | Notes                                                                                |
+| ---------- | ---------------------------- | --------- | ------------------------------------------------------------------------------------ |
+| Direction  | `Vector3`<br />(Default: Up) | **No**    | Which direction the entity should be flung, relative to the direction of the attack. |
+
+**Knockback Type: Point**
+
+Apply the calculated knockback force laterally along the XZ plane, plus provided Y velocity.
+
+| Field Name | Type                        | Required? | Notes                                                                                                   |
+| ---------- | --------------------------- | --------- | ------------------------------------------------------------------------------------------------------- |
+| OffsetX    | `Integer`<br />(Default: 0) | **No**    | Offset the source position of the knockback left or right perpendicular to the direction of the attack. |
+| OffsetZ    | `Integer`<br />(Default: 0) | **No**    | Offset the source position of the knockback, forward or backward along the directon of the attack.      |
+| RotateY    | `Integer`<br />(Default: 0) | **No**    | Rotate the knockback direction around the Y axis, where 0 is the default attack direction.              |
+| VelocityY  | `Float`<br />(Default: 0.0) | **No**    | Add vertical velocity to the knockback force after the direction and force has been calculated.         |
+
+**Knockback Type: Directional**
+
+Apply the calculated knockback force along the attack direction, removing any vertical component and replacing it with a provided Y velocity.
+
+| Field Name | Type                      | Required? | Notes                                                                                                                                            |
+| ---------- | ------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------ |
+| RelativeX  | `Float`<br />(Default: 0) | **No**    | Apply additional force left or right perpendicular to the direction of the attack. The additional force is multiplied by the knockback strength. |
+| RelativeZ  | `Float`<br />(Default: 0) | **No**    | Apply additional force forward or backward along the attack direction. The additional force is multiplied by the knockback strength.             |
+| VelocityY  | `Float`<br />(Default: 0) | **No**    | Replace the vertical velocity of the knockback with this value.  This value is not multiplied by knockback strength.                             |
+
+**VelocityConfig Fields**
+
+| Field Name          | Type                                              | Required? | Notes                                                                                                                                                                                           |
+| ------------------- | ------------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| GroundResistance    | `Float`<br />(Default: 0.82)                      | **No**    | The minimum amount of friction applied when the entity is in contact with the ground.  1.0 = no friction, 0.0 = total friction                                                                  |
+| GroundResistanceMax | `Float`<br />(Default: 0.0)                       | **No**    | The maximum amount of friction applied when the entity is in contact with the ground.  1.0 = no friction, 0.0 = total friction                                                                  |
+| AirResistance       | `Float`<br />(Default: 0.96)                      | **No**    | The minimum amount of friction applied when the entity is in the air. 1.0 = no friction, 0.0 = total friction                                                                                   |
+| AirResistanceMax    | `Float`<br />(Default: 0.0)                       | **No**    | The maximum amount of friction applied when the entity is in the air. 1.0 = no friction, 0.0 = total friction                                                                                   |
+| Threshold           | `Float`<br />(Default: 1.0)                       | **No**    | The speed at which the maximum amount of friction will be applied to the entity. The amount of friction applied will increase from minimum to maximum as the entity moves from 0 to this speed. |
+| Style               | `VelocityThresholdStyle`<br />(Default: `Linear`) | **No**    | The curve that friction follows as the entity's speed increases toward the `Threshold`.                                                                                                         |
+
+**DamageCalculatorType Values**
+
+- `Absolute`
+- `Dps`
+
+**DamageClass Values**
+
+- `Unknown`
+- `Light`
+- `Charged`
+- `Signature`
+
+**ChangeVelocityType Values**
+
+- `Add`
+- `Set`
+
+**VelocityThresholdStyle Values**
+
+- `Linear`
+- `Exp`
+
+### LaunchProjectile
+
+This is just a worse version of Projectile and is slated to be removed.  Use Projectile.
+
+### Projectile
+
+This interaction will spawn a new projectile at the User entity's eye position that will travel in its look direction.
+
+| Field Name | Type                                          | Required? | Notes                                                  |
+| ---------- | --------------------------------------------- | --------- | ------------------------------------------------------ |
+| Config     | `Asset`<br />(Asset Type: `ProjectileConfig`) | **No**    | Configuration describing the projectile to be spawned. |
+
+### RemoveEntity
+
+Despawns the specified entity from the world. This interaction will have no effect if the specified entity is a player. This
+interaction has no special failure conditions.
+
+| Field Name | Type                                     | Required? | Notes                  |
+| ---------- | ---------------------------------------- | --------- | ---------------------- |
+| Entity     | `InteractionTarget`<br />(Default: User) | **No**    | The entity to despawn. |
+
+**InteractionTarget Values**
+
+- `User` - The user of this interaction chain. The entity whose actions caused this interaction chain to be executed. This is usually the same as the Owner.
+- `Owner` - The owner of this interaction chain. The entity upon whom this interaction chain is executing.
+- `Target` - The entity target of this interaction chain, if any.  This value is mutable (and can therefore come from many places) but most commonly, it is an entity the User was targeting when this interaction chain began executing.
+
+### SendMessage
+
+This interaction sends a message to the Owner entity if that entity can receive messages.  Otherwise, the message
+is written to the server logs.  If the entity is a player, the message will appear in the player's chat window.
+
+\*\*SendMessage
+
+| Field Name | Type     | Required? | Notes                                                                                                                 |
+| ---------- | -------- | --------- | --------------------------------------------------------------------------------------------------------------------- |
+| Message    | `String` | **No**    | A text message to be sent to the Owner entity.  If this field is not provided, `Key` is used instead.                 |
+| Key        | `String` | **No**    | A translation key for a message to be sent to the Owner entity. If `Message` is provided, then this field is ignored. |
+
+### UseEntity
+
+This interaction is not in use by Hypixel and has some unusual qualities that mean it probably won't do what you want it
+to.  Do not use it.
+
+This interaction will retrieve the entity currently targeted by the client (NOT the interaction chain's current Target
+entity) and execute that entity's RootInteraction for this interaction chain's current interaction type. The
+RootInteraction will be executed as part of this current interaction chain. None of the properties of this interaction
+chain will be modified.
+
+This interaction will fail if the client is not currently targeting an entity, or if no interaction for the current
+interaction type exists on the entity.
+
+## Stats
+
+Hytale's resource system has been written about fairly extensively.  You can use these interactions to modify stats in
+response to actions or use stats as a cost for abilities.
+
+### ChangeStat
+
+This interaction applies a set of raw stat changes to the User entity. It has no special failure conditions.
+
+| Field Name    | Type                                                         | Required? | Notes                                                                                                                                                                                                                      |
+| ------------- | ------------------------------------------------------------ | --------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| StatModifiers | `Map`<br />(Key Type: `EntityStatType`, Value Type: `Float`) | **Yes**   | A set of stats to modify and what value to apply to them.                                                                                                                                                                  |
+| ValueType     | `ValueType`<br />(Default: Absolute)                         | **No**    | Whether the values in the `StatModifiers` map represent flat values to apply to the stat total, or percentages (0.0-100.0). Percentage values are percentage of the difference between the maximum and minimum stat value. |
+| Behaviour     | `ChangeStatBehavior`<br />(Default: Add)                     | **No**    | Whether the values in the `StatModifiers` map represent deltas to add into the User entity's current stat values, or fixed values to set the entity's stats to.                                                            |
+
+**ValueType Values**
+
+- `Absolute`
+- `Percent`
+
+**ChangeStatBehaviour Values**
+
+- `Add`
+- `Set`
+
+### ChangeStatWithModifier
+
+This interaction is like ChangeStat, except an armor stat modifier can be chosen which will apply bonuses and penalties
+to a stat from the User entity's equipped armor before it is applied.
+
+| Field Name            | Type                                                         | Required? | Notes                                                                                                                                                                                                                      |
+| --------------------- | ------------------------------------------------------------ | --------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| StatModifiers         | `Map`<br />(Key Type: `EntityStatType`, Value Type: `Float`) | **Yes**   | A set of stats to modify and what value to apply to them.                                                                                                                                                                  |
+| ValueType             | `ValueType`<br />(Default: Absolute)                         | **No**    | Whether the values in the `StatModifiers` map represent flat values to apply to the stat total, or percentages (0.0-100.0). Percentage values are percentage of the difference between the maximum and minimum stat value. |
+| Behaviour             | `ChangeStatBehavior`<br />(Default: Add)                     | **No**    | Whether the values in the `StatModifiers` map represent deltas to add into the User entity's current stat values, or fixed values to set the entity's stats to.                                                            |
+| InteractionModifierId | `InteractionModifierId`                                      | **Yes**   | The armor interaction modifier to apply bonuses and penalties for.                                                                                                                                                         |
+
+**ValueType Values**
+
+- `Absolute`
+- `Percent`
+
+**ChangeStatBehaviour Values**
+
+- `Add`
+- `Set`
+
+**InteractionModifierId Values**
+
+- `Dodge`
+
+### StatsCondition
+
+This interaction will fail if the User entity cannot afford the specified stats costs, or if it does not have the
+requested stats.
+
+| Field Name | Type                                                         | Required? | Notes                                                                                                                                                                                    |
+| ---------- | ------------------------------------------------------------ | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Costs      | `Map`<br />(Key Type:` EntityStatType`, Value Type: `Float`) | **Yes**   | A set of costs that the User entity needs to be able to afford for this interaction to succeed.                                                                                          |
+| ValueType  | `ValueType`<br />(Default: Absolute)                         | **No**    | Whether the values in the `Costs` map represetn flat values or percentages (0.0-100.0).  Percentage values are percentage of the difference between the maximum and minimum value.       |
+| LessThan   | `Boolean`<br />(Default: false)                              | **No**    | If true, this interaction will fail unless the User entity's current stat values are at or **below** the specified levels.  If false, they must be at or **above** the specified levels. |
+| Lenient    | `Boolean`<br />(Default: false)                              | **No**    | If true and `LessThan` is true, and a player's minimum stat value is below zero, then the player can afford a stat cost if the current value of a stat if above 0.                       |
+
+**ValueType Values**
+
+- `Absolute`
+- `Percent`
+
+### StatsConditionWithModifier
+
+This interaction is like StatsCondition, except an armor stat modifier can be chosen which will apply bonuses and penalties
+to a stat's cost from the User entity's equipped armor before it is compared.
+
+| Field Name            | Type                                                         | Required? | Notes                                                                                                                                                                                    |
+| --------------------- | ------------------------------------------------------------ | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Costs                 | `Map`<br />(Key Type:` EntityStatType`, Value Type: `Float`) | **Yes**   | A set of costs that the User entity needs to be able to afford for this interaction to succeed.                                                                                          |
+| ValueType             | `ValueType`<br />(Default: Absolute)                         | **No**    | Whether the values in the `Costs` map represetn flat values or percentages (0.0-100.0).  Percentage values are percentage of the difference between the maximum and minimum value.       |
+| LessThan              | `Boolean`<br />(Default: false)                              | **No**    | If true, this interaction will fail unless the User entity's current stat values are at or **below** the specified levels.  If false, they must be at or **above** the specified levels. |
+| Lenient               | `Boolean`<br />(Default: false)                              | **No**    | If true and `LessThan` is true, and a player's minimum stat value is below zero, then the player can afford a stat cost if the current value of a stat if above 0.                       |
+| InteractionModifierId | `InteractionModifierId`                                      | **Yes**   | The armor interaction modifier to apply bonuses and penalties for.                                                                                                                       |
+
+**ValueType Values**
+
+- `Absolute`
+- `Percent`
+
+**InteractionModifierId Values**
+
+- `Dodge`
+
+## EntityEffects
+
+EntityEffects are buff or debuff effects that can be applied to a LivingEntity.  These can have a variety of effects from
+movement speed changes to periodic damage.
+
+### EffectCondition
+
+This interaction will fail if the specified entity's EntityEffects do not match the provided conditions.
+
+**EffectCondition Fields**
+
+| Field Name      | Type                                             | Required? | Notes                                                                                                                                                                                                             |
+| --------------- | ------------------------------------------------ | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Entity          | `InteractionTarget`<br />(Default: User)         | **Yes**   | The entity to examine for EntityEffects. This field can indicate the Owner, User, or Target of this interaction chain.                                                                                            |
+| Match           | `Match`<br />(Default: All)                      | **No**    | If `All`, then this interaction will fail if any EntityEffect in the `EntityEffectIds` is not on the specified entity. If `None`, then this interaction will fail if any EntityEffect IS on the specified entity. |
+| EntityEffectIds | `AssetArray`<br />(Element Type: `EntityEffect`) | **Yes**   | The set of EntityEffects to check against the specified entity and `Match`.                                                                                                                                       |
+
+**InteractionTarget Values**
+
+- `User` - The user of this interaction chain. The entity whose actions caused this interaction chain to be executed. This is usually the same as the Owner.
+- `Owner` - The owner of this interaction chain. The entity upon whom this interaction chain is executing.
+- `Target` - The entity target of this interaction chain, if any.  This value is mutable (and can therefore come from many places) but most commonly, it is an entity the User was targeting when this interaction chain began executing.
+
+**Match Values**
+
+- `All` - All EntityEffects must be on the specified entity for this interaction to succeed.
+- `None` - None of the EntityEffects must be on the specified entity for this interaction to succeed.
+
+### ApplyEffect
+
+This interaction will apply the specified EntityEffect to the specified Entity.  It has no special failure conditions.
+
+**ApplyEffect Fields**
+
+| Field Name | Type                                      | Required? | Notes                                                                                                                  |
+| ---------- | ----------------------------------------- | --------- | ---------------------------------------------------------------------------------------------------------------------- |
+| Entity     | `InteractionTarget`<br />(Default: User)  | **Yes**   | The entity to apply the EntityEffect to. This field can indicate the Owner, User, or Target of this interaction chain. |
+| EffectId   | `Asset`<br />(Asset Type: `EntityEffect`) | **Yes**   | The effect to apply.                                                                                                   |
+
+**InteractionTarget Values**
+
+- `User` - The user of this interaction chain. The entity whose actions caused this interaction chain to be executed. This is usually the same as the Owner.
+- `Owner` - The owner of this interaction chain. The entity upon whom this interaction chain is executing.
+- `Target` - The entity target of this interaction chain, if any.  This value is mutable (and can therefore come from many places) but most commonly, it is an entity the User was targeting when this interaction chain began executing.
+
+### ClearEntityEffect
+
+This interaction will remove the specified EntityEffect from the specified Entity. It has no special failure conditions.
+It will not fail if the Entity does not have the EntityEffect.
+
+**ClearEntityEffect Fields**
+
+| Field Name | Type                                      | Required? | Notes                                                                                                                     |
+| ---------- | ----------------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------- |
+| Entity     | `InteractionTarget`<br />(Default: User)  | **Yes**   | The entity to remove the EntityEffect from. This field can indicate the Owner, User, or Target of this interaction chain. |
+| EffectId   | `Asset`<br />(Asset Type: `EntityEffect`) | **Yes**   | The effect to remove.                                                                                                     |
+
+**InteractionTarget Values**
+
+- `User` - The user of this interaction chain. The entity whose actions caused this interaction chain to be executed. This is usually the same as the Owner.
+- `Owner` - The owner of this interaction chain. The entity upon whom this interaction chain is executing.
+- `Target` - The entity target of this interaction chain, if any.  This value is mutable (and can therefore come from many places) but most commonly, it is an entity the User was targeting when this interaction chain began executing.
+
+## Farming
+
+These are interaction types built to support the in-game farming system in Hytale. They are mostly block-related interactions
+with a few exceptions.
+
+### ChangeFarmingStage
+
+If the target block is a farming block, this interaction will attempt to modify the current farming stage in one of
+three ways.  The interaction can optionally specify which StageSet to use for the new stage. If it is not specified,
+the current StageSet will be used. If any part of the the process of changing the growth stage fails, this interaction
+will fail, with the one exception that attempting to set the stage to the crop's existing stage will have no effect but
+still succeed.
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                                                                                                                                                                          |
+| ---------------- | ------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction.                                                                                                                                              |
+| StageSet         | `String`                        | **No**    | If provided, set the block's current stage to one in the provided StageSet. Otherwise, use the crop's current StageSet.                                                                                                                                                        |
+| Increase         | `Integer`                       | **No**    | If provided, increase the current stage by the specified amount. If the specified stage does not exist, the block will be set to the closest extant stage.                                                                                                                     |
+| Decrease         | `Integer`                       | **No**    | If provided and `Increase` is not provided, decrease the current stage by the specified amount. If the specified stage does not exist, the block will be set to the closest extant stage.                                                                                      |
+| Stage            | `Integer`<br />(Default: -1)    | **No**    | If provided and `Increase`/`Decrease` are not provided, set the current stage to the specified stage. If this value is less than 0, set the current stage to the final growth stage. If the specified stage does not exist, the block will be set to the closest extant stage. |
+
+### FertilizeSoil
+
+If the target block is unfertilized tilled soil or a farming block on top of unfertilized tilled soil, fertilizes the soil.
+The interaction will fail otherwise.
+
+**FertilizeSoil Fields**
+
+| Field Name       | Type                                  | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false)       | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+| RefreshModifiers | `Array`<br />(Element Type: `String`) | **No**    | Does nothing.                                                                                                                     |
+
+### HarvestCrop
+
+This interaction will attempt to execute the harvest action on the current block target and add the crop's drops to the User entity's
+inventory.  The block will either be destroyed or set to its post-harvest growth stage, depending on the farming
+configuration of the block.  This will happen (and the player will receive the full harvest drops) regardless of the
+block's current growth stage. This interaction has no special failure conditions, even if the block target isn't a
+farming block or gathering isn't permitted in the current world, but nothing will occur in those cases.
+
+**HarvestCrop Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+
+### UseWateringCan
+
+If the target block is tilled soil or a farming block on top of tilled soil, waters the soil for the specified duration.
+The interaction will fail otherwise.
+
+**UseWateringCan Fields**
+
+| Field Name       | Type                                  | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false)       | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+| Duration         | `Integer`<br />(Default: 0)           | **No**    | The duration in seconds to water the soil for.                                                                                    |
+| RefreshModifiers | `Array`<br />(Element Type: `String`) | **No**    | Does nothing.                                                                                                                     |
diff --git a/content/docs/hi-IN/contributing/pr-guidelines.mdx b/content/docs/hi-IN/contributing/pr-guidelines.mdx
index 7a251032..c226da04 100644
--- a/content/docs/hi-IN/contributing/pr-guidelines.mdx
+++ b/content/docs/hi-IN/contributing/pr-guidelines.mdx
@@ -19,6 +19,8 @@ To ensure a smooth and efficient review process, both contributors and reviewers
 4. **Code Quality**
    - Ensure your code follows the project's coding standards and best practices.
    - Include comments where necessary to explain complex logic.
+   - Always test your changes locally before submitting the PR to catch any issues early.
+   - Format your code using `bun format` to maintain consistency across the codebase.
 5. **Testing**
    - Test your changes thoroughly before submitting the PR.
    - If applicable, include unit tests or integration tests to verify your changes.
diff --git a/content/docs/hi-IN/contributing/translate.mdx b/content/docs/hi-IN/contributing/translate.mdx
new file mode 100644
index 00000000..c62ffdde
--- /dev/null
+++ b/content/docs/hi-IN/contributing/translate.mdx
@@ -0,0 +1,74 @@
+---
+title: Translate
+description: How to translate HytaleModding to your language
+---
+
+# Translating HytaleModding
+
+HytaleModding is translated with the help of the community using **Crowdin**. If you want to help translate or improve existing translations, this is the right place.
+
+## Steps to Translate
+
+All translations are managed **via Crowdin**.
+
+1. Visit [our Crowdin project](https://crowdin.com/project/hytalemodding) and log in if required.
+2. Click on your language.
+3. Click on the file/article you wish to translate. We recommend starting with Official Documentation, and then Server Plugin Documentation.
+4. Start translating!
+5. Approved translations will appear on the website.
+
+### Video Guide
+
+<iframe src="https://www.youtube.com/embed/NHiG1rDRgks" allowFullScreen />
+
+## How to discuss
+
+You can always report issues or discuss specific topics directly on Crowdin, but we recommend using Discord instead of the Crowdin comment system to keep everything organized in one place.
+
+1. Join [our Discord](https://discord.gg/hytalemodding)
+2. Open `#translations` channel. Here you can discuss or ask questions that are not related to a specific language.
+3. If you want to join a thread, you are required to run `/translator <your-language>` command here. The bot will add you to the thread for your language.
+
+## Translation Guidelines
+
+- You need to be confident in what you are translating. You should be able to read the text you just translated and understand the meaning of it very easily.
+- It should use the simplest form of language possible. Use English words if the translation is unknown to the majority in your country.
+- Use your imagination, trust yourself. Feel free to change any context as you wish as long as it can still get the same point across and is understandable.
+- These guidelines are more important than language-specific guidelines, but less important than Hytale terminology and rules.
+
+## What not to translate
+
+We request you all to not translate these specific sections of the website:
+
+### Callout types
+
+Callouts are the boxes that contain important information. We request you to not translate the types as they only work in English.
+
+**Example:**
+
+```mdx
+<Callout type="warning" title="Translate this title!">
+Translate the text inside the callout!
+</Callout>
+```
+
+In this example, please don't translate the word warning, the rest you can translate.
+
+### Icons
+
+Icon names must not be translated.
+They are technical identifiers mapped directly to existing icons. Translating them will break the icon rendering.
+
+```mdx
+icon: Globe
+```
+
+---
+
+{/* 
+For translators who will edit this page:
+
+- You are required to translate the Guidelines as they change.
+- General guidelines should be translated but not edited.
+- Learn how to use Markdown from writing_guides.mdx
+*/}
diff --git a/content/docs/hi-IN/established-information/server/content-categories/art-assets.mdx b/content/docs/hi-IN/established-information/server/content-categories/art-assets.mdx
index 39c2ed37..1e926874 100644
--- a/content/docs/hi-IN/established-information/server/content-categories/art-assets.mdx
+++ b/content/docs/hi-IN/established-information/server/content-categories/art-assets.mdx
@@ -14,7 +14,7 @@ Hytale provides comprehensive support for 3D modeling and texture art creation,
 Hytale uses **Blockbench** as the primary tool for 3D modeling and animation:
 
 * **Official support**: Used for "creating Hytale models, textures, and animations"
-* **Special plugin**: Hytale will have a dedicated Blockbench plugin, to be released ASAP
+* **Special plugin**: Hytale has a dedicated [Blockbench Plugin](https://www.blockbench.net/plugins/hytale_plugin).
 * **Direct compatibility**: The plugin allows creators to "create Hytale-compatible models, textures, and animations directly in Blockbench"
 * **Replaces legacy tools**: Fully replaces the old Hytale Model Maker to better support established creative workflows in the community
 * **Safety features**: Only allows you to add things compatible with the engine, so no need to worry about breaking anything
diff --git a/content/docs/hi-IN/guides/ecs/block-components.mdx b/content/docs/hi-IN/guides/ecs/block-components.mdx
new file mode 100644
index 00000000..ca68b38a
--- /dev/null
+++ b/content/docs/hi-IN/guides/ecs/block-components.mdx
@@ -0,0 +1,247 @@
+---
+title: Block Components
+description: Learn how to use the block components.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+  - name: oskarscot
+    link: https://oskar.scot
+---
+
+# Overview
+
+In this guide, you'll learn how to use block components to create a ticking block.
+
+<Callout>
+  For a more complete reference, you may also want to review FarmingSystems.Ticking, as much of the underlying logic is based on its implementation.
+</Callout>
+
+## Steps
+
+### 1. ExampleBlock - holds block behavior
+
+```java
+public class ExampleBlock implements Component<ChunkStore> {
+
+    public static final BuilderCodec CODEC = BuilderCodec.builder(ExampleBlock.class, ExampleBlock::new).build();
+
+    // Components usually require a copy constructor as well but since we don't actually hold any data in this component this is not neccessary
+    public ExampleBlock() { }
+
+    public static ComponentType getComponentType() {
+        return ExamplePlugin.get().getExampleBlockComponentType();
+    }
+
+    @Nullable
+    public Component<ChunkStore> clone() {
+        return new ExampleBlock();
+    }
+}
+```
+
+ExampleBlock is a custom component that stores the behavior and data for your ticking block. Here, it simply places an Ice Block at x + 1 relative to its current position when it ticks.
+
+---
+
+### 2. ExampleInitializer - marks blocks as ticking when placed
+
+```java
+public class ExampleInitializer extends RefSystem {
+
+    @Override
+    public void onEntityAdded(@Nonnull Ref ref, @Nonnull AddReason reason, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+        BlockModule.BlockStateInfo info = (BlockModule.BlockStateInfo) commandBuffer.getComponent(ref, BlockModule.BlockStateInfo.getComponentType());
+        if (info == null) return;
+
+        ExampleBlock generator = (ExampleBlock) commandBuffer.getComponent(ref, ExamplePlugin.get().getExampleBlockComponentType());
+        if (generator != null) {
+            int x = ChunkUtil.xFromBlockInColumn(info.getIndex());
+            int y = ChunkUtil.yFromBlockInColumn(info.getIndex());
+            int z = ChunkUtil.zFromBlockInColumn(info.getIndex());
+
+            WorldChunk worldChunk = (WorldChunk) commandBuffer.getComponent(info.getChunkRef(), WorldChunk.getComponentType());
+            if (worldChunk != null) {
+				worldChunk.setTicking(x, y, z, true);
+            }
+        }
+    }
+
+    @Override
+    public void onEntityRemove(@Nonnull Ref ref, @Nonnull RemoveReason reason, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+    }
+
+    @Override
+    public Query getQuery() {
+        return Query.and(BlockModule.BlockStateInfo.getComponentType(), ExamplePlugin.get().getExampleBlockComponentType());
+    }
+}
+```
+
+ExampleInitializer is a RefSystem that reacts when block entities with the ExampleBlock component are added or removed. This is crucial for marking blocks as ticking when they're first placed.
+
+**Key Points:**
+
+- Tells the game that this block should tick, allowing `ExampleSystem` to process it.
+
+```java
+worldChunk.setTicking(x, y, z, true);
+```
+
+---
+
+### 3. ExampleSystem - handles ticking
+
+```java
+public class ExampleSystem extends EntityTickingSystem {
+
+    public void tick(float dt, int index, @Nonnull ArchetypeChunk archetypeChunk, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+        BlockSection blocks = (BlockSection) archetypeChunk.getComponent(index, BlockSection.getComponentType());
+
+        assert blocks != null;
+
+        if (blocks.getTickingBlocksCountCopy() != 0) {
+            ChunkSection section = (ChunkSection) archetypeChunk.getComponent(index, ChunkSection.getComponentType());
+
+            assert section != null;
+
+            BlockComponentChunk blockComponentChunk = (BlockComponentChunk) commandBuffer.getComponent(section.getChunkColumnReference(), BlockComponentChunk.getComponentType());
+
+            assert blockComponentChunk != null;
+
+            blocks.forEachTicking(blockComponentChunk, commandBuffer, section.getY(), (blockComponentChunk1, commandBuffer1, localX, localY, localZ, blockId) -> {
+                Ref<ChunkStore> blockRef = blockComponentChunk.getEntityReference(ChunkUtil.indexBlockInColumn(localX, localY, localZ));
+                if (blockRef == null) {
+                    return BlockTickStrategy.IGNORED;
+                } else {
+                    ExampleBlock exampleBlock = (ExampleBlock) commandBuffer1.getComponent(blockRef, ExampleBlock.getComponentType());
+                    if (exampleBlock != null) {
+                        WorldChunk worldChunk = (WorldChunk) commandBuffer.getComponent(section.getChunkColumnReference(), WorldChunk.getComponentType());
+                        World world = worldChunk.getWorld();
+
+                        int globalX = localX + (worldChunk.getX() * 32);
+                        int globalZ = localZ + (worldChunk.getZ() * 32);
+
+                        // We need to execute setBlock on the world thread as you cannot call store functions from a system
+                        // This is because of the architecture of the server, depending on your needs you can also use the CommandBuffer
+                        world.execute(() -> {
+                            world.setBlock(globalX + 1, localY, globalZ, "Rock_Ice");
+                        });
+
+                        return BlockTickStrategy.CONTINUE;
+
+                    } else {
+                        return BlockTickStrategy.IGNORED;
+                    }
+                }
+            });
+        }
+    }
+
+    @Nullable
+    public Query getQuery() {
+        return Query.and(BlockSection.getComponentType(), ChunkSection.getComponentType());;
+    }
+}
+```
+
+ExampleSystem is an EntityTickingSystem that runs every tick to execute the logic for all ticking blocks with the ExampleBlock component.
+
+**Key Points:**
+
+- **Get the block component**
+
+```java
+ExampleBlock exampleBlock = (ExampleBlock) commandBuffer.getComponent(blockRef, ExampleBlock.getComponentType());
+```
+
+- **Convert local chunk coordinates to world coordinates**
+
+```java
+int globalX = localX + (worldChunk.getX() * 32);
+int globalZ = localZ + (worldChunk.getZ() * 32);
+```
+
+- **Run the block logic**
+
+```java
+exampleBlock.runBlockAction(globalX, localY, globalZ, worldChunk.getWorld());
+```
+
+- **Keep the block ticking in the next tick**
+
+```java
+return BlockTickStrategy.CONTINUE;
+```
+
+---
+
+### 4. ExamplePlugin - registers components and systems
+
+```java
+public class ExamplePlugin extends JavaPlugin {
+    protected static ExamplePlugin instance;
+    private static final HytaleLogger LOGGER = HytaleLogger.forEnclosingClass();
+    private ComponentType exampleBlockComponentType;
+
+    public static ExamplePlugin get() {
+        return instance;
+    }
+
+    public ExamplePlugin(@Nonnull JavaPluginInit init) {
+        super(init);
+        LOGGER.atInfo().log("Hello from " + this.getName() + " version " + this.getManifest().getVersion().toString());
+    }
+
+    @Override
+    protected void setup() {
+        instance = this;
+        LOGGER.atInfo().log("Setting up plugin " + this.getName());
+        this.exampleBlockComponentType = this.getChunkStoreRegistry().registerComponent(ExampleBlock.class, "ExampleBlock", ExampleBlock.CODEC);
+    }
+	
+	@Override
+	protected void start() {
+		this.getChunkStoreRegistry().registerSystem(new ExampleSystem());
+		this.getChunkStoreRegistry().registerSystem(new ExampleInitializer());
+	}
+
+    public ComponentType getExampleBlockComponentType() {
+        return this.exampleBlockComponentType;
+    }
+}
+```
+
+---
+
+### 5. Configure In-Game
+
+![block-component-1](/assets/guides/block-component-1.png)
+
+![block-component-2](/assets/guides/block-component-2.png)
+
+With this logic, the block will now continuously place an Ice Block at the coordinates x + 1 relative to its current position every time it ticks.
+
+---
+
+## Common Issues
+
+### NullPointerException on Startup
+
+**Error message:**
+
+```java
+java.lang.NullPointerException: Cannot invoke "com.hypixel.hytale.component.query.Query.validateRegistry(com.hypixel.hytale.component.ComponentRegistry)" because "query" is null
+```
+
+**Cause:**
+This error occurs when your module is loaded **before** the required Hytale modules.
+
+**Fix:**
+Add `EntityModule` and `BlockModule` as dependencies in your `manifest.json` to ensure proper load order.
+
+```json
+"Dependencies": {
+  "Hytale:EntityModule": "*",
+  "Hytale:BlockModule": "*"
+}
+```
diff --git a/content/docs/hi-IN/guides/ecs/hytale-ecs-theory.mdx b/content/docs/hi-IN/guides/ecs/hytale-ecs-theory.mdx
index 20c3a94d..52d8b1f5 100644
--- a/content/docs/hi-IN/guides/ecs/hytale-ecs-theory.mdx
+++ b/content/docs/hi-IN/guides/ecs/hytale-ecs-theory.mdx
@@ -29,7 +29,7 @@ for now this is the basic understanding for the `ChunkStore`. You can use it to
 
 ## Holder
 
-A Holder is essentially a blueprint for an entity. Before an entity exists in the Store (and thus in the world), is exists as a `Holder`. It collects and holds all the necessary components (data). You can compare it analogous to shopping cart. You grab all components you need and once you have everything, check out at the store which will take your cart and create a valid entity ID and hand you back a receipt (a Ref).
+A Holder is essentially a blueprint for an entity. Before an entity exists in the Store (and thus in the world), it exists as a `Holder`. It collects and holds all the necessary components (data). You can compare it analogous to shopping cart. You grab all components you need and once you have everything, check out at the store which will take your cart and create a valid entity ID and hand you back a receipt (a Ref).
 
 Let's take a look at an example: initializing players. In `Universe`, the `addPlayer` method demonstrates it perfectly.
 When a player connects, we don't immediately throw them into the ECS. We first construct their data in a Holder.
@@ -167,7 +167,7 @@ MyComponent comp = commandBuffer.getComponent(ref, componentType);
 
 Codecs handle serialization and deserialization of components. Hytale uses them to save and load entity data to and from disk as well as sending component data over the network. When creating a custom component, you must also create a corresponding Codec.
 
-There are mutliple Codec types already implemented in the default Codec Interface:
+There are multiple Codec types already implemented in the default Codec Interface:
 
 - Codec.STRING
 - Codec.BOOLEAN
@@ -215,7 +215,7 @@ This might seem tedious at first but it ensures that your component can be corre
   KeyedCodec<Integer> exampleInt = new KeyedCodec<Integer>("ExampleIntIdForCodec", Codec.INTEGER);
   ```
 
-- **Setter Function**: This is a lambda function that takes an instance of your component and returns the value of the field you want to serialize. For example, if you have a field called `myCustomField` in your custom component, your getter function would look like this:
+- **Setter Function**: This is a lambda function that takes an instance of your component + the value to set and sets the field value on the component. For example, if you have a field called `myCustomField` in your custom component, your setter function would look like this:
   ```java
   (data, value) -> data.myCustomField = value
   ```
@@ -276,7 +276,7 @@ public class PoisonComponent implements Component<EntityStore> {
 
 You can also add validators to your Codec fields to ensure that the data being serialized/deserialized meets certain criteria. For example, if you want to ensure that the `damagePerTick` field is always non-negative or the poison name is never null, you can add a validator like this:
 
-````java
+```java
 .append(
     new KeyedCodec<Float>("DamagePerTick", Codec.FLOAT),
     (data, value) -> data.damagePerTick = value,
@@ -292,14 +292,15 @@ You can also add validators to your Codec fields to ensure that the data being s
 )
 .addValidator(Validators.nonNull())
 .add()
+```
 
 ### Complex Codec Examples
 
-If you want to have a map inside your component, you can use the MapCodec class to build a KeyedCoded for it. Here's an example of how to create a Codec for a Map field:
+If you want to have a map inside your component, you can use the MapCodec class to build a KeyedCodec for it. Here's an example of how to create a Codec for a Map field:
 
 ```java
 var damagePerTick = new KeyedCodec<>("DamagePerTick", new MapCodec<>(Codec.FLOAT, HashMap<String, Float>::new));
-````
+```
 
 <Callout type="info">
   This also works with custom Objects as long as you have a Codec defined for the Object type.
diff --git a/content/docs/hi-IN/guides/java-basics/00-introduction.mdx b/content/docs/hi-IN/guides/java-basics/00-introduction.mdx
index a03ad638..b0130d74 100644
--- a/content/docs/hi-IN/guides/java-basics/00-introduction.mdx
+++ b/content/docs/hi-IN/guides/java-basics/00-introduction.mdx
@@ -7,7 +7,7 @@ Welcome to your journey into Java Programming! This guide is designed to introdu
 
 ## What is Java?
 
-Java is a powerful, object-oriented programming language created in 1995. It's one of the most popular programming languages in the world and is used for everything from mobile apps to enterprise software. Most importantly for us, it's the language Hytale uses for it's servers & modding API.
+Java is a powerful, object-oriented programming language created in 1995. It's one of the most popular programming languages in the world and is used for everything from mobile apps to enterprise software. Most importantly for us, it's the language Hytale uses for its servers & modding API.
 
 ## What You'll Learn
 
diff --git a/content/docs/hi-IN/guides/java-basics/02-operators.mdx b/content/docs/hi-IN/guides/java-basics/02-operators.mdx
index a132b1c0..18634665 100644
--- a/content/docs/hi-IN/guides/java-basics/02-operators.mdx
+++ b/content/docs/hi-IN/guides/java-basics/02-operators.mdx
@@ -119,7 +119,7 @@ String greetingWithName = "Hello, " + name + "!"; // "Hello, Alice!"
 
 ## Operator Precedence
 
-Operator Precendence means which operator gets evaluated first in an line of code. Think of it like BODMAS/PEMDAS in math!
+Operator Precedence means which operator gets evaluated first in an line of code. Think of it like BODMAS/PEMDAS in math!
 
 ```java
 int result = 10 + 5 * 2; // result is 20, not 30
diff --git a/content/docs/hi-IN/guides/java-basics/03-control-flow-if.mdx b/content/docs/hi-IN/guides/java-basics/03-control-flow-if.mdx
index b9d6c479..af2d1c22 100644
--- a/content/docs/hi-IN/guides/java-basics/03-control-flow-if.mdx
+++ b/content/docs/hi-IN/guides/java-basics/03-control-flow-if.mdx
@@ -7,7 +7,7 @@ Programs need to make decisions. If statements let your code choose different pa
 
 ## Basic If Statement
 
-The simplest form checks one condition;
+The simplest form checks one condition:
 
 ```java
 int health = 20;
diff --git a/content/docs/hi-IN/guides/java-basics/08-access-modifiers.mdx b/content/docs/hi-IN/guides/java-basics/08-access-modifiers.mdx
index af560932..da2bf33b 100644
--- a/content/docs/hi-IN/guides/java-basics/08-access-modifiers.mdx
+++ b/content/docs/hi-IN/guides/java-basics/08-access-modifiers.mdx
@@ -484,7 +484,7 @@ class Data {
     // Static member:
     // cannot access to non-static variables
     public static void bar() {
-        x = 100; // Error: non-static variable x cannot be renference from a static context
+        x = 100; // Error: non-static variable x cannot be referenced from a static context
         y = 100; // OK
     }
 }
@@ -504,7 +504,7 @@ Data.x = 1000; // Error: cannot access instanced variables in a static context
 
 ### Static Fields
 
-A static field represents a data member owned by the class type rather then the object. Static fields are also stored in a specific memory location that's been shared between all the object instances that are created.
+A static field represents a data member owned by the class type rather than the object. Static fields are also stored in a specific memory location that's been shared between all the object instances that are created.
 
 It is declared as following:
 
diff --git a/content/docs/hi-IN/guides/plugin/animated-block-textures.mdx b/content/docs/hi-IN/guides/plugin/animated-block-textures.mdx
new file mode 100644
index 00000000..42bfa51f
--- /dev/null
+++ b/content/docs/hi-IN/guides/plugin/animated-block-textures.mdx
@@ -0,0 +1,101 @@
+---
+title: Animated Block Textures
+description: Learn how to attach a .blockyanim to a block
+authors:
+  - name: Burkino
+---
+
+import { File, Folder, Files } from 'fumadocs-ui/components/files';
+
+So, you want to make your blocks feel more alive through animations, do you?\
+Now for the most part this is the exact same as [Creating custom blocks](./creating-block).
+![blue fire gif](/assets/guides/blue_fire.gif)
+
+## Prerequisites
+
+This is NOT a guide on animating or texturing or even using BlockBench, why? Because I don't know how to do that.\
+The only thing we will be doing is taking the fire texture, changing the color, and applying it to our new fire block.
+
+## Setup
+
+To start, you're obviously going to want to grab the `Common/VFX/Fire/Fire.png` file. How you do it is up to you, in the Asset Editor you'll need to switch to the Common tab.\
+I'll assume you know how colorize or change the hue of an image, so go ahead and do that now and save it as `Blue_Fire.png`.
+
+The other assets used in this guide are `Common/VFX/Fire/Fire.blockymodel` and `Common/Blocks/Animations/Fire/Fire_Burn.blockyanim` (both renamed to `Blue_Fire`) but since we won't be changing them it's probably fine to leave them. I will reference the `Blue_Fire` versions as a way to point out what should be custom assets.\
+I will also duplicate `Server/Item/Item/Deco/Deco_Fire.json` and call it `Deco_Blue_Fire.json`.
+
+## Applying the changes
+
+The `Deco_Blue_Fire` block is actually just a particle emitter, however we will not be using particles, so lets start by removing them in `Block > Particles`.\
+Next we want to set the Block Model (called `CustomModel` in JSON) to `VFX/Blue_Fire/Blue_Fire.blockymodel` and Block Model Textures (`CustomModelTexture` in JSON) to
+
+```json
+[
+    {
+        "Texture": "VFX/Blue_Fire/Blue_Fire.png",
+        "Weight": 1
+    }
+]
+```
+
+Finally, we will apply the .blockyanim to our model, this is done through the Block Model Animation property (`CustomModelAnimation` in JSON) and the value should be `Blocks/Animations/Blue_Fire/Blue_Fire_Burn.blockyanim`.
+
+## Final Code
+
+With that your new blue fire should be done. Here is the minimal JSON for our blue fire.\
+There is an additional `Looping` and `RequiresAlphaBlending` property that I have not gone over, however I hope it is self-explanatory.
+
+```json
+{
+  "BlockType": {
+    "DrawType": "Model",
+    "CustomModel": "VFX/Blue_Fire/Blue_Fire.blockymodel",
+    "CustomModelAnimation": "Blocks/Animations/Blue_Fire/Blue_Fire_Burn.blockyanim",
+    "CustomModelTexture": [
+      {
+        "Texture": "VFX/Blue_Fire/Blue_Fire.png",
+        "Weight": 1
+      }
+    ],
+    "Looping": true,
+    "RequiresAlphaBlending": false
+  },
+  "PlayerAnimationsId": "Block"
+}
+```
+
+<Files>
+  <Folder name="resources" defaultOpen>
+    <Folder name="Server" defaultOpen>
+      <Folder name="Item" defaultOpen>
+        <Folder name="Items" defaultOpen>
+          <Folder name="Deco" defaultOpen>
+            <File name="Deco_Blue_Fire.json" />
+          </Folder>
+        </Folder>
+      </Folder>
+    </Folder>
+
+    <Folder name="Common" defaultOpen>
+      <Folder name="Blocks" defaultOpen>
+        <Folder name="Animations" defaultOpen>
+          <Folder name="Blue_Fire" defaultOpen>
+            <File name="Blue_Fire_Burn.blockyanim" />
+          </Folder>
+        </Folder>
+      </Folder>
+
+      <Folder name="VFX" defaultOpen>
+        <Folder name="Blue_Fire" defaultOpen>
+          <File name="Blue_Fire.blockymodel" />
+
+          <File name="Blue_Fire.png" />
+        </Folder>
+      </Folder>
+    </Folder>
+  </Folder>
+</Files>
+
+## Next steps
+
+Now that you know how to attach an animation to a block, try adding it to a block state.
diff --git a/content/docs/hi-IN/guides/plugin/build-and-test.mdx b/content/docs/hi-IN/guides/plugin/build-and-test.mdx
index 0e7fe7eb..f37534c3 100644
--- a/content/docs/hi-IN/guides/plugin/build-and-test.mdx
+++ b/content/docs/hi-IN/guides/plugin/build-and-test.mdx
@@ -9,18 +9,18 @@ If you followed along with the [Setting Up Your Development Environment](./setti
 
 ## Building Your Mod
 
-In our case, we've **Maven** as the build system. Maven is a powerful build automation tool that manages dependencies, compiles your code, and packages everything into a distributable JAR file.
+In our case, we've **Gradle** as the build system. Gradle is a powerful build automation tool that manages dependencies, compiles your code, and packages everything into a distributable JAR file.
 
-### Understanding Maven
+### Understanding Gradle
 
-Maven uses a `pom.xml` file (Project Object Model) to define your project's configuration, dependencies, and build settings. You can learn more about Maven at the [official Apache Maven website](https://maven.apache.org/).
+Gradle can use a `build.gradle.kts` file (Kotlin DSL) to define your project's configuration, dependencies, and build settings. You can learn more about Gradle at the [official Gradle website](https://gradle.org/).
 
-### Building with Maven
+### Building with Gradle
 
 To build your mod, open a terminal in your project directory and run:
 
 ```bash
-mvn package
+./gradlew build
 ```
 
 This command will:
@@ -29,16 +29,35 @@ This command will:
 2. Run any tests (if present)
 3. Package everything into a JAR file
 
+<Callout type="info">
+  If you are using the plugin template from the [Setting Up Your Development Environment](./setting-up-env) guide, then the build script is already set up for you. It includes paths to your Hytale game library and handles the packaging of your mod, managing hytale dependencies and manifest changes.
+
+  If you have a different path to your Hytale installation, you may receive the following error:
+
+  ```bash
+  FAILURE: Build failed with an exception.
+
+  * What went wrong:
+  Failed to find Hytale at the expected location. Please make sure you have installed the game. The expected location can be changed using the hytale.home_path property. Currently looking in 'C:\Path\To\Hytale'
+  ```
+
+  You can change the path by adding a property to your `gradle.properties` file (if it doesn't exist, create it in the root of your project):
+
+  ```properties
+  hytale.home_path=C:\Correct\Path\To\Hytale
+  ```
+</Callout>
+
 ### Build Output
 
-Once the build completes successfully, your mod will be located in the `target` directory and named:
+Once the build completes successfully, your mod will be located in the `build/libs` directory and named:
 
 ```
-ExamplePlugin-1.0-SNAPSHOT.jar
+ExamplePlugin-1.0.jar
 ```
 
 <Callout type="info">
-  The exact name may vary depending on what you configured in your `pom.xml` file. Check the `artifactId` and `version` fields to see what your JAR will be named.
+  The exact name may vary depending on what you configured in your `build.gradle.kts` and `settings.gradle.kts` file. Check the `rootProject.name` and `version` fields to see what your JAR will be named.
 </Callout>
 
 ## Testing Your Mod
@@ -49,11 +68,11 @@ Now that you've built your mod, it's time to test it in Hytale!
 
 First, you need to find Hytale's mods directory:
 
-1. Press **Win + R** on your keyboard
-2. Type `%appdata%` and press Enter
-3. Navigate to: `Hytale\UserData\Mods`
+1. Go to your Hytale installation directory (The default location is usually in your AppData folder)
+   > On Windows, you can access it by clicking `windows + R` and typing `%appdata%`.
+2. Navigate to: `/UserData/Mods`
 
-The full path should look like:
+The default path would look like:
 
 ```
 C:\Users\YourUsername\AppData\Roaming\Hytale\UserData\Mods
@@ -65,7 +84,7 @@ C:\Users\YourUsername\AppData\Roaming\Hytale\UserData\Mods
 
 ### 2. Copy Your Mod
 
-Copy the `ExamplePlugin-1.0-SNAPSHOT.jar` file from your project's `target` directory into the `Mods` folder you just located.
+Copy the `ExamplePlugin-1.0.jar` file from your project's `build/libs` directory into the `Mods` folder you just located.
 
 ### 3. Launch Hytale and Verify
 
@@ -84,7 +103,7 @@ If your mod doesn't appear in the mods list:
 - Make sure the JAR file is in the correct `Mods` folder
 - Check that your `manifest.json` file is properly configured
 - Look for any error messages in the Hytale logs
-- Verify that you're using the correct version of Java and Maven
+- Verify that you're using the correct version of Java and Gradle
 
 ## Next Steps
 
diff --git a/content/docs/hi-IN/guides/plugin/creating-commands.mdx b/content/docs/hi-IN/guides/plugin/creating-commands.mdx
index d33597f3..08572f16 100644
--- a/content/docs/hi-IN/guides/plugin/creating-commands.mdx
+++ b/content/docs/hi-IN/guides/plugin/creating-commands.mdx
@@ -8,6 +8,8 @@ authors:
     url: https://oskar.scot
   - name: jacobwojoski
     url: https://github.com/jacobwojoski
+  - name: Marcel-TO
+    url: https://marcel-to.net
 ---
 
 In this guide, you will learn how to create custom commands for your Hytale mod.
@@ -36,7 +38,7 @@ The most basic command is an `AbstractAsyncCommand`. It has very minimal data av
   `AbstractAsyncCommand` runs on its own background thread. This means its execute is not tied to any world instance and because of this it can not edit any **Stores** or **Refs** without getting the desired world first. To access this data any of the other command types would be preferred and are likely what you will want to use instead.
 </Callout>
 
-The main purpose for a command like this would be for something that can happen everywhere and is not tied to a specific world. For example a `serverRules` command to tell the user thats running the command in chat what the servers rules are nomatter what world they are in.
+The main purpose for a command like this would be for something that can happen everywhere and is not tied to a specific world. For example a `serverRules` command to tell the user that's running the command in chat what the server's rules are no matter what world they are in.
 
 ```java
 // Command that can be run that lists the server rules in chat to the player
@@ -49,7 +51,7 @@ public class ServerRulesCommand extends AbstractAsyncCommand {
     }
 
     // Run the command
-    // conetext - info about who ran the command. Server console?, Some player?
+    // context - info about who ran the command. Server console?, Some player?
     @Override
     protected CompletableFuture<Void> executeAsync(@Nonnull CommandContext context) {
         context.sendMessage(Message.raw("The only rule is there are no rules."));
@@ -134,7 +136,7 @@ Uses a Ray to see what the player is looking at and tries to run the command on
 
 ## Adding Arguments
 
-Arguments are additional fields that the user can input when running a command. The different types of arguments along with small snipits and a large example can be seen below.
+Arguments are additional fields that the user can input when running a command. The different types of arguments along with small snippets and a large example can be seen below.
 
 ### Command Argument Types
 
@@ -163,14 +165,14 @@ this.messageArg = this.withOptionalArg("message", "Message to print while healin
 
 ### Default Arguments
 
-Adding a default argument has two additional arguemnt for the default value and default value description. You need to use `withDefaultArg` method.
+Adding a default argument has two additional argument for the default value and default value description. You need to use `withDefaultArg` method.
 
 ```java
 // args <Command String> <Description> <Default Value> <Desc of default value>
 this.healthArg = this.withDefaultArg("health", "Amount to heal player", ArgTypes.FLOAT, (float)100, "Desc of Default: 100");
 ```
 
-### Flag Arguemnts
+### Flag Arguments
 
 Similar as above but the flags return is either true if it exists or false if it does not. You need to use `withFlagArg` method.
 
@@ -181,20 +183,13 @@ this.debugArg = this.withFlagArg("debug", "Add debug logs");
 
 ### ArgTypes
 
-The following ArgTypes are available (only lists common types):
-
-- `ArgTypes.STRING`
-- `ArgTypes.INTEGER`
-- `ArgTypes.BOOLEAN`
-- `ArgTypes.FLOAT`
-- `ArgTypes.DOUBLE`
-- `ArgTypes.UUID`
+You can find all the available argument types on the [ArgTypes](../../argtypes) page.
 
 ### Example Command Arg Types
 
-Shows all Command arguemnt types with different various input types.
+Shows all Command argument types with different various input types.
 
-**NOTE:** When getting the value of an argument during execute you need to pass the context with `someArg.get(commandContext)`. Where `commandContext` is the first variable in the execute funtion.
+**NOTE:** When getting the value of an argument during execute you need to pass the context with `someArg.get(commandContext)`. Where `commandContext` is the first variable in the execute function.
 
 ```java
 // Example usage: /healplayer --health 50 --message "Feels Good" --debug
@@ -204,7 +199,7 @@ public class HealPlayerCommand extends AbstractTargetPlayerCommand {
     private final FlagArg debugArg;
 
     public HealPlayerCommand() {
-        super("healplayer", "Healing a player for an <input> ammount of HP (default: 100)");
+        super("healplayer", "Healing a player for an <input> amount of HP (default: 100)");
 
         // Abstract TargetPlayerCommand passes the player that ran the command by default and implements
         // the use of `--player <value>` to specify someone else
@@ -213,10 +208,10 @@ public class HealPlayerCommand extends AbstractTargetPlayerCommand {
         this.healthArg = this.withDefaultArg("health", "Amount to heal player", ArgTypes.FLOAT, (float)100, "Desc of Default: 100");
 
         // Or you could do the following making the health value required instead of with a default.
-        //    You would need to change the decleration to RequiredArg<Float>
+        //    You would need to change the declaration to RequiredArg<Float>
         // this.healthArg = this.withRequiredArg("health", "Amount to heal player", ArgTypes.FLOAT);
 
-        // Optional args reguare the user the input `--<key> <value>` so the following would require `--message "Good Luck"`
+// Optional args require the user the input `--<key> <value>` so the following would require `--message "Good Luck"`
         this.messageArg = this.withOptionalArg("message", "Message to print while healing", ArgTypes.STRING);
 
         // No type needed due to being a bool
@@ -230,7 +225,7 @@ public class HealPlayerCommand extends AbstractTargetPlayerCommand {
             commandContext.sendMessage(Message.raw("We are debugging"));
         }
 
-        // Health is stored in a generic stat map to allowing mods/future contect to easily add more stats if desired.
+        // Health is stored in a generic stat map to allowing mods/future content to easily add more stats if desired.
         EntityStatMap stats = store.getComponent(ref, EntityStatMap.getComponentType());
         int healthIdx = DefaultEntityStatTypes.getHealth();
         EntityStatValue health = stats.get(healthIdx);
@@ -252,7 +247,7 @@ public class HealPlayerCommand extends AbstractTargetPlayerCommand {
 
 ## Argument Validators
 
-Argument validators are a way to check the command before the command gets executed. They are added with the `addValidator` method on an argument when calling `withXxxArg`. They provide a nice output to the user when an input value is invalid.
+Argument validators are a way to check the command before the command gets executed. They are added with the `addValidator` method on an argument when calling `withXxxArg`. They provide a nice output to the user when an input value is invalid. There are some common validators provided in the `Validators` class such as `greaterThan`, `lessThan`, and `or`, `max`, `range`, etc.
 
 ```java
 ...
@@ -260,18 +255,59 @@ Argument validators are a way to check the command before the command gets execu
     OptionalArg<Integer> healAmount = withOptionalArg("amount", "Heal Amount", ArgTypes.INTEGER)
         .addValidator(Validators.greaterThan(0))
         .addValidator(Validators.lessThan(1000));
-
-    // Custom check example
-    OptionalArg<Integer> healAmount = withOptionalArg("amount", "Heal Amount", ArgTypes.INTEGER)
-            .addValidator( value -> {
-                if (value != null && value <= 0) {
-                    return ValidationResult.error("ammount argument must be a positive number");
-                }
-                return ValidationResult.success();
-            });
 ...
 ```
 
+### Custom Validators
+
+You can also create custom validators by implementing the `com.hypixel.hytale.codec.validation.Validator` interface. The interfaces forces you to implement the `accept` and `updateSchema` method. The `accept` method takes in the argument value and validates it. If the validation fails, you can use the `fail` method of the `com.hypixel.hytale.codec.validation.ValidationResults` class to return an error message.
+The `updateSchema` method is used to update the schema of the command argument. This is used for commands that have dynamic schemas based on the input value. For example, if you have a command that takes in a player name as an argument, you can use the `updateSchema` method to update the schema to include a list of online players for validation.
+
+Here is an example of a custom validator that checks if a string value is equal to a banned word. In this example, the banned word is "badword". If the input value is "badword", the validator will fail and return an error message.
+
+```java
+import com.hypixel.hytale.codec.schema.SchemaContext;
+import com.hypixel.hytale.codec.schema.config.Schema;
+import com.hypixel.hytale.codec.validation.ValidationResults;
+import com.hypixel.hytale.codec.validation.Validator;
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+
+public class MyCustomValidator implements Validator<String> {
+    @Nonnull
+    private final String value;
+
+    public MyCustomValidator(@Nonnull String value) {
+        this.value = value;
+    }
+
+    @Override
+    public void accept(@Nullable String input, @Nonnull ValidationResults results) {
+        if (this.value.equalsIgnoreCase(input)) {
+            results.fail("The given role has been banned.");
+        }
+    }
+
+    @Override
+    public void updateSchema(SchemaContext context, @Nonnull Schema target) {
+        // This method can be used to update the schema of the command argument. This is useful for commands that have dynamic schemas based on the input value. For example, if you have a command that takes in a player name as an argument, you can use the `updateSchema` method to update the schema to include a list of online players for validation.
+        throw new UnsupportedOperationException("Not implemented yet.");
+    }
+}
+```
+
+After the custom validator is created, you can add it to an argument like the following example. In this example, we add the `MyCustomValidator` to a string argument called "role". If the user inputs "badword" as the role, the command will fail and return the error message defined in the `MyCustomValidator`.
+
+```java
+    ...
+    // Custom validator example
+    String bannedRole = "badword";
+
+    OptionalArg<String> roleArg = withOptionalArg("role", "Role to assign", ArgTypes.STRING)
+        .addValidator(new MyCustomValidator(bannedRole));
+    ...
+```
+
 ---
 
 ## Permissions
@@ -312,7 +348,7 @@ This allows the server to control who has access to specific commands. You add t
 
 If you want variants of the same command without doing argument parsing you can instead use `addUsageVariant(new OtherCommandClass())` in the original commands constructor.
 
-The only difference is in the `OtherCommandClass()` constrcutor you don't pass the command name to the super class.
+The only difference is in the `OtherCommandClass()` constructor you don't pass the command name to the super class.
 
 <Callout type="info">
   You can also use `addAliases("some_alias", "some_other_alias")` as a way to add shorthand or other ways to write the same command.
@@ -387,7 +423,7 @@ public class AdminCommand extends AbstractCommandCollection {
     public AdminCommand () {
         super("admin", "Admin commands");
         addSubCommand(new UserCommandCollection());
-        addSybCommand(new ServerCommandCollection);
+        addSubCommand(new ServerCommandCollection);
     }
 }
 ```
@@ -417,5 +453,5 @@ public class MyPlugin extends JavaPlugin {
 
 ## Video Link
 
-_Special Thanks to [TroubleDev](https://www.youtube.com/@TroubleDEV) for his excelent video guide on all of these features._
+_Special Thanks to [TroubleDev](https://www.youtube.com/@TroubleDEV) for his excellent video guide on all of these features._
 _Video Link: [TroubleDev - Hytale's Command API Explained](https://www.youtube.com/watch?v=KnmhG9MDMgo)_
diff --git a/content/docs/hi-IN/guides/plugin/creating-events.mdx b/content/docs/hi-IN/guides/plugin/creating-events.mdx
index 95863990..d3f0925d 100644
--- a/content/docs/hi-IN/guides/plugin/creating-events.mdx
+++ b/content/docs/hi-IN/guides/plugin/creating-events.mdx
@@ -1,6 +1,6 @@
 ---
-title: Creating Events
-description: Learn how to create custom events for your Hytale mod.
+title: Creating Events Listeners
+description: Learn how to create event listeners for your Hytale mod.
 authors:
   - name: Neil Revin
     url: https://itsneil.dev
@@ -10,7 +10,7 @@ authors:
 
 ## Event Class
 
-You can import a Event class and create a function with the Event as a argument. [Click here](../../server/events) to look at all available events.
+You can import an Event class and create a function with the Event as an argument. [Click here](../../server/events) to look at all available events.
 
 Example plugin when a player is ready (joins a server):
 
diff --git a/content/docs/hi-IN/guides/plugin/item-registry.mdx b/content/docs/hi-IN/guides/plugin/item-registry.mdx
new file mode 100644
index 00000000..9a0fd53a
--- /dev/null
+++ b/content/docs/hi-IN/guides/plugin/item-registry.mdx
@@ -0,0 +1,95 @@
+---
+title: Working with the Item Registry
+description: Learn how to access and query the game's item registry to list all items, check if items exist, and retrieve item properties.
+authors:
+  - name: Denis
+---
+
+In this guide, you'll learn how to work with Hytale's Item Registry system. This is useful when you need to programmatically list all available items, validate item IDs, or retrieve item properties at runtime.
+
+## Prerequisites
+
+Before diving in, you should be familiar with:
+
+- [Setting up your development environment](./setting-up-env)
+- [Creating commands](./creating-commands) (optional, for testing)
+
+## Required Imports
+
+To work with the Item Registry, you'll need the following imports:
+
+```java
+import com.hypixel.hytale.assetstore.map.DefaultAssetMap;
+import com.hypixel.hytale.server.core.asset.type.item.config.Item;
+```
+
+## Getting the Item Registry
+
+The Item Registry is accessed through the `Item.getAssetMap()` method, which returns a `DefaultAssetMap<String, Item>` containing all registered items in the game:
+
+```java
+DefaultAssetMap<String, Item> itemMap = Item.getAssetMap();
+```
+
+## Listing All Items
+
+To iterate through all items in the registry, you can get the underlying map and loop through its entries:
+
+```java
+DefaultAssetMap<String, Item> itemMap = Item.getAssetMap();
+var map = itemMap.getAssetMap();
+
+for (var entry : map.entrySet()) {
+    String itemId = String.valueOf(entry.getKey());
+    Item item = entry.getValue();
+    
+    // Do something with the item
+    LOGGER.atInfo().log("Item ID: " + itemId);
+}
+```
+
+You can also get the total count of registered items:
+
+```java
+int totalItems = map.size();
+```
+
+## Checking if an Item Exists
+
+To check if a specific item exists in the registry, use `getAsset()` and verify the result:
+
+```java
+public boolean itemExists(String itemId) {
+    var assetMap = Item.getAssetMap();
+    if (assetMap != null) {
+        Item item = assetMap.getAsset(itemId);
+        return item != null && item != Item.UNKNOWN;
+    }
+    return false;
+}
+```
+
+<Callout type="info">
+  The `Item.UNKNOWN` constant represents an invalid or unrecognized item. Always check for both `null` and `Item.UNKNOWN` when validating items.
+</Callout>
+
+## Accessing Item Properties
+
+Once you have an `Item` instance, you can access various properties:
+
+```java
+var assetMap = Item.getAssetMap();
+Item item = assetMap.getAsset("Soil_Grass");
+
+if (item != null && item != Item.UNKNOWN) {
+    String id = item.getId(); // Soil_Grass
+    int maxStack = item.getMaxStack(); // 100
+    boolean isBlock = item.hasBlockType(); // true
+    boolean isConsumable = item.isConsumable(); // false
+}
+```
+
+## Related Guides
+
+- [Inventory Management](./inventory-management) - Learn how to add and remove items from player inventories
+- [Create Custom Item and Interaction](./item-interaction) - Learn how to create your own custom items
diff --git a/content/docs/hi-IN/guides/plugin/permission-management.mdx b/content/docs/hi-IN/guides/plugin/permission-management.mdx
index 6b7cfd46..55f06101 100644
--- a/content/docs/hi-IN/guides/plugin/permission-management.mdx
+++ b/content/docs/hi-IN/guides/plugin/permission-management.mdx
@@ -10,132 +10,569 @@ authors:
     link: https://discord.com/users/292656109939064833
   - name: Ivan
     link: https://discord.com/users/505770451218333717
+  - name: ZenithDevHQ
+    link: https://github.com/ZenithDevHQ
 ---
 
-In this guide, you'll learn how to manage permission nodes and groups in your Hytale plugin.
+In this guide, you'll learn how to manage permission nodes and groups in your Hytale plugin. Permissions control what actions players can perform on your server, from basic commands to advanced administrative functions.
 
-## The `PermissionsModule` class
+## What Are Permissions?
 
-The `PermissionsModule` class is responsible for managing permission nodes and groups in your plugin. It provides methods to check, grant and revoke permissions and groups for players. It allows the following operations
+Permissions are string identifiers that control access to features and commands. When a player tries to perform an action (like using a command), the server checks if they have the required permission.
 
-- Add permissions to user
-- Remove permissions from user
-- Add permissions to group (this also creates the group if it doesn't exist)
-- Remove permissions from group
-- Add user to group
-- Remove user from group
-- List all groups for a user
-- Check if a user has a permission (it checks both user and group permissions for the given player UUID)
+**Example permission nodes:**
 
-With this class you cannot:
+- `hytale.command.gamemode` - Permission to use the gamemode command
+- `hytale.editor.brush.use` - Permission to use brush tools
+- `myplugin.teleport.home` - A custom permission for your plugin
 
-- List all defined groups
-- Remove a group
+Permissions follow a hierarchical naming pattern: `namespace.category.action`
 
-### Adding Permission Nodes
+## Key Concepts
 
-You need a `Set<String>` containing all the permission nodes you want to add, these are added on top of the already existing permission nodes the user may have, it is not a replacement.
+Before diving into code, let's understand the core concepts:
+
+| Concept             | Description                                                                |
+| ------------------- | -------------------------------------------------------------------------- |
+| **Permission Node** | A string like `myplugin.feature.use` that represents a specific permission |
+| **Group**           | A named collection of permissions (e.g., "Admin", "VIP", "Default")        |
+| **Provider**        | The backend that stores and retrieves permissions                          |
+| **Wildcard**        | A pattern like `*` or `myplugin.*` that matches multiple permissions       |
+
+### How Permissions Are Checked
+
+When checking if a player has a permission, Hytale follows this order:
+
+1. **User's direct permissions** - Permissions granted directly to the player
+2. **Group permissions** - Permissions from groups the player belongs to
+3. **Virtual groups** - Game-mode-based permissions (e.g., Creative mode grants builder tools)
+4. **Default value** - Falls back to `false` if no match found
+
+<Callout type="info">
+  The first definitive match wins. If a player has a permission granted at the user level, group permissions won't override it.
+</Callout>
+
+---
+
+## The `PermissionsModule` Class
+
+The `PermissionsModule` class is the central hub for managing permissions. Access it using the singleton pattern:
 
 ```java
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.addUserPermission(playerUUID, permissions);
 ```
 
-### Removing Permission Nodes
+### Available Operations
+
+The module supports these operations:
+
+| Operation                     | Method                                          |
+| ----------------------------- | ----------------------------------------------- |
+| Add permissions to user       | `addUserPermission(uuid, permissions)`          |
+| Remove permissions from user  | `removeUserPermission(uuid, permissions)`       |
+| Add permissions to group      | `addGroupPermission(groupName, permissions)`    |
+| Remove permissions from group | `removeGroupPermission(groupName, permissions)` |
+| Add user to group             | `addUserToGroup(uuid, groupName)`               |
+| Remove user from group        | `removeUserFromGroup(uuid, groupName)`          |
+| Get user's groups             | `getGroupsForUser(uuid)`                        |
+| Check permission              | `hasPermission(uuid, permissionNode)`           |
+
+<Callout type="warning">
+  The module does **not** support:
+
+  - Listing all defined groups
+  - Deleting a group entirely
+
+  Groups are implicitly created when you first add permissions to them.
+</Callout>
+
+---
 
-Same as above, we just use the `removeUserPermission` method instead to remove permission nodes.
+## Checking Permissions
+
+The most common operation is checking if a player has a permission.
+
+### Basic Permission Check
+
+```java
+// Returns true if player has the permission, false otherwise
+boolean canUse = PermissionsModule.get().hasPermission(playerUUID, "myplugin.feature.use");
+
+if (canUse) {
+    // Player has permission, allow the action
+} else {
+    // Player lacks permission, deny or show error
+}
+```
+
+### Permission Check with Default Value
+
+You can specify what to return when no permission is explicitly set:
+
+```java
+// Returns true by default if no explicit permission is found
+boolean canUse = PermissionsModule.get().hasPermission(playerUUID, "myplugin.feature.use", true);
+```
+
+This is useful for features that should be enabled by default but can be revoked.
+
+### Using PermissionHolder Interface
+
+Players and command senders implement `PermissionHolder`, allowing direct checks:
+
+```java
+// In a command or event handler where you have access to the player
+if (player.hasPermission("myplugin.admin.manage")) {
+    // Player has admin permission
+}
+```
+
+---
+
+## Managing User Permissions
+
+### Adding Permissions to a User
+
+Permissions are additive - new permissions are added on top of existing ones, not replaced.
+
+```java
+PermissionsModule perms = PermissionsModule.get();
+
+// Add a single permission
+perms.addUserPermission(playerUUID, Set.of("myplugin.vip.chat"));
+
+// Add multiple permissions at once
+Set<String> newPerms = Set.of(
+    "myplugin.vip.chat",
+    "myplugin.vip.fly",
+    "myplugin.vip.kit"
+);
+perms.addUserPermission(playerUUID, newPerms);
+```
+
+### Removing Permissions from a User
 
 ```java
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.removeUserPermission(playerUUID, permissions);
+
+// Remove specific permissions
+Set<String> toRemove = Set.of("myplugin.vip.fly");
+perms.removeUserPermission(playerUUID, toRemove);
 ```
 
-### Add permissions to group
+---
+
+## Managing Groups
+
+Groups let you assign a collection of permissions to multiple players. This is more manageable than assigning permissions individually.
+
+### Adding Permissions to a Group
+
+If the group doesn't exist, it will be created automatically.
 
 ```java
-String groupName = "testGroup";
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.addGroupPermission(groupName, permissions);
+
+// Create/update the "VIP" group with permissions
+Set<String> vipPerms = Set.of(
+    "myplugin.vip.chat",
+    "myplugin.vip.fly",
+    "myplugin.vip.kit"
+);
+perms.addGroupPermission("VIP", vipPerms);
 ```
 
-### Remove permissions from group
+### Removing Permissions from a Group
 
 ```java
-String groupName = "testGroup";
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.removeGroupPermission(groupName, permissions);
+
+// Remove specific permissions from the group
+Set<String> toRemove = Set.of("myplugin.vip.fly");
+perms.removeGroupPermission("VIP", toRemove);
 ```
 
-### Add user to group
+### Adding a User to a Group
 
 ```java
-String groupName = "testGroup";
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.addUserToGroup(playerUUID, groupName);
+
+// Add player to the VIP group - they now have all VIP permissions
+perms.addUserToGroup(playerUUID, "VIP");
 ```
 
-### Remove user from group
+### Removing a User from a Group
 
 ```java
-String groupName = "testGroup";
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.removeUserFromGroup(playerUUID, groupName);
+
+// Remove player from VIP group
+perms.removeUserFromGroup(playerUUID, "VIP");
 ```
 
-### List all groups for a user
+### Getting a User's Groups
 
 ```java
 PermissionsModule perms = PermissionsModule.get();
-perms.getGroupsForUser(playerUUID);
+
+// Get all groups the player belongs to
+Set<String> groups = perms.getGroupsForUser(playerUUID);
+
+for (String group : groups) {
+    System.out.println("Player is in group: " + group);
+}
 ```
 
-### Check Permission Nodes
+---
+
+## Built-in Groups
+
+Hytale includes two default groups:
+
+| Group     | Default Permissions   | Purpose                           |
+| --------- | --------------------- | --------------------------------- |
+| `OP`      | `*` (all permissions) | Server operators with full access |
+| `Default` | None                  | Base group for all players        |
+
+Players without any explicit group assignment are automatically part of the `Default` group.
 
-To check if a player has a specific permission node, you can use the `hasPermission` method.
+---
+
+## Wildcards
+
+Wildcards let you grant or deny multiple permissions with a single pattern.
+
+### Wildcard Patterns
+
+| Pattern             | Meaning                                          |
+| ------------------- | ------------------------------------------------ |
+| `*`                 | Grants **all** permissions                       |
+| `myplugin.*`        | Grants all permissions starting with `myplugin.` |
+| `-*`                | Denies **all** permissions                       |
+| `-myplugin.admin.*` | Denies all admin permissions in your plugin      |
+
+### Example: Admin Group with Wildcards
 
 ```java
-boolean hasPermission = PermissionsModule.hasPermission(playerUUID, "permission.node");
+// Grant all permissions to admins
+perms.addGroupPermission("Admin", Set.of("*"));
+
+// Grant all plugin permissions to moderators
+perms.addGroupPermission("Moderator", Set.of("myplugin.*"));
+
+// Grant all permissions except admin commands
+perms.addGroupPermission("Helper", Set.of(
+    "*",
+    "-myplugin.admin.*"  // Deny admin permissions
+));
 ```
 
-## Additional: Defining your own provider for permissions and groups
+<Callout type="warning">
+  Negation permissions (starting with `-`) take precedence at each level. Use them carefully to avoid accidentally blocking permissions.
+</Callout>
+
+---
+
+## Built-in Permission Nodes
+
+Hytale provides constants for common permissions in the `HytalePermissions` class:
+
+### Command Permissions
+
+```java
+// Generate permission for a command
+String perm = HytalePermissions.fromCommand("gamemode");
+// Result: "hytale.command.gamemode"
+
+// Generate permission for a subcommand
+String perm = HytalePermissions.fromCommand("gamemode", "creative");
+// Result: "hytale.command.gamemode.creative"
+```
+
+### Common Permission Nodes
+
+| Permission                    | Description                  |
+| ----------------------------- | ---------------------------- |
+| `hytale.command.op.add`       | Add players to OP group      |
+| `hytale.command.op.remove`    | Remove players from OP group |
+| `hytale.editor.brush.use`     | Use brush tools              |
+| `hytale.editor.prefab.use`    | Use prefabs                  |
+| `hytale.editor.selection.use` | Use selection tools          |
+| `hytale.editor.history`       | Undo/redo operations         |
+| `hytale.camera.flycam`        | Use fly camera mode          |
+
+---
+
+## Listening to Permission Events
+
+You can react to permission changes using Hytale's event system.
+
+### Available Events
+
+| Event                                            | Triggered When                   |
+| ------------------------------------------------ | -------------------------------- |
+| `PlayerPermissionChangeEvent.PermissionsAdded`   | Permissions added to a user      |
+| `PlayerPermissionChangeEvent.PermissionsRemoved` | Permissions removed from a user  |
+| `PlayerGroupEvent.Added`                         | User added to a group            |
+| `PlayerGroupEvent.Removed`                       | User removed from a group        |
+| `GroupPermissionChangeEvent.Added`               | Permissions added to a group     |
+| `GroupPermissionChangeEvent.Removed`             | Permissions removed from a group |
 
-The PermissionsModule also enables us to define our own PermissionProvider's, this can be useful for:
+### Example: Reacting to Permission Changes
 
-- Cross server permission systems
-- Implementing features missing in the `HytalePermissionsProvider` like permission expiry
+```java
+public class PermissionListener {
+
+    public static void onPermissionsAdded(PlayerPermissionChangeEvent.PermissionsAdded event) {
+        UUID playerUUID = event.getPlayerUuid();
+        Set<String> added = event.getAddedPermissions();
+
+        System.out.println("Permissions added to " + playerUUID + ": " + added);
 
-To implement our PermissionProvider, first we need to define a provider class that implements PermissionProvider:
+        // Maybe notify the player or update cached data
+    }
+
+    public static void onGroupAdded(PlayerGroupEvent.Added event) {
+        UUID playerUUID = event.getPlayerUuid();
+        String groupName = event.getGroupName();
+
+        System.out.println("Player " + playerUUID + " joined group: " + groupName);
+    }
+}
+```
+
+### Registering the Events
 
 ```java
-public class DatabasePermissionProvider implements PermissionProvider
+public class MyPlugin extends JavaPlugin {
+
+    @Override
+    public void setup() {
+        EventRegistry events = this.getEventRegistry();
+
+        events.registerGlobal(
+            PlayerPermissionChangeEvent.PermissionsAdded.class,
+            PermissionListener::onPermissionsAdded
+        );
+
+        events.registerGlobal(
+            PlayerGroupEvent.Added.class,
+            PermissionListener::onGroupAdded
+        );
+    }
+}
 ```
 
-Then we just implement the required methods using a database implementation.
+---
+
+## Creating a Custom Permission Provider
+
+For advanced use cases, you can create your own permission provider. This is useful for:
+
+- Database-backed permissions (MySQL, MongoDB, etc.)
+- Cross-server permission synchronization
+- Custom features like permission expiry or contexts
+
+### Implementing PermissionProvider
+
+```java
+public class DatabasePermissionProvider implements PermissionProvider {
+
+    @Nonnull
+    @Override
+    public String getName() {
+        return "DatabasePermissionProvider";
+    }
+
+    // User permission methods
+    @Override
+    public void addUserPermissions(@Nonnull UUID uuid, @Nonnull Set<String> permissions) {
+        // Save to your database
+    }
+
+    @Override
+    public void removeUserPermissions(@Nonnull UUID uuid, @Nonnull Set<String> permissions) {
+        // Remove from your database
+    }
+
+    @Override
+    public Set<String> getUserPermissions(@Nonnull UUID uuid) {
+        // Query your database
+        return Set.of();
+    }
+
+    // Group permission methods
+    @Override
+    public void addGroupPermissions(@Nonnull String group, @Nonnull Set<String> permissions) {
+        // Save to your database
+    }
+
+    @Override
+    public void removeGroupPermissions(@Nonnull String group, @Nonnull Set<String> permissions) {
+        // Remove from your database
+    }
+
+    @Override
+    public Set<String> getGroupPermissions(@Nonnull String group) {
+        // Query your database
+        return Set.of();
+    }
+
+    // User-group membership methods
+    @Override
+    public void addUserToGroup(@Nonnull UUID uuid, @Nonnull String group) {
+        // Save to your database
+    }
+
+    @Override
+    public void removeUserFromGroup(@Nonnull UUID uuid, @Nonnull String group) {
+        // Remove from your database
+    }
+
+    @Override
+    public Set<String> getGroupsForUser(@Nonnull UUID uuid) {
+        // Query your database
+        return Set.of("Default");
+    }
+}
+```
 
 <Callout type="warning">
-  Hytale will try to use the first available permissions provider to add/remove gamemode groups (i.e. `Creative`, `Adventure`).
+  Hytale automatically assigns players to game-mode groups (like `Creative` or `Adventure`) using the first available provider.
+
+  If your provider throws an error when the group doesn't exist, the player will be disconnected! Always handle missing groups gracefully.
+</Callout>
+
+### Registering Your Provider
 
-  If your provider throws an error (for instance, if the group does not exist) when the server is preparing the player, the player will be disconnected.
+```java
+public class MyPlugin extends JavaPlugin {
+
+    @Override
+    public void setup() {
+        // Add your provider alongside the default one
+        PermissionsModule.get().addProvider(new DatabasePermissionProvider());
+    }
+}
+```
+
+The `PermissionsModule` aggregates permissions from all registered providers. This means:
+
+- Permission checks query all providers
+- Write operations (add/remove) use the **first** provider
+
+### Replacing the Default Provider
+
+If you want full control, you can remove the default provider:
+
+```java
+public class MyPlugin extends JavaPlugin {
+
+    @Override
+    public void setup() {
+        PermissionsModule perms = PermissionsModule.get();
+
+        // Remove the default provider FIRST
+        perms.removeProvider(perms.getFirstPermissionProvider());
+
+        // Then add your provider
+        perms.addProvider(new DatabasePermissionProvider());
+    }
+}
+```
+
+<Callout type="info">
+  When you remove the default provider, the `/op self` command will stop working since it checks for provider tampering.
 </Callout>
 
-We can then register the provider using the built-in permission module:
+---
+
+## Best Practices
+
+### Permission Naming Conventions
+
+Follow the pattern: `namespace.category.action`
 
 ```java
-PermissionsModule.get().addProvider(new DatabasePermissionProvider());
+// Good - clear hierarchy
+"myplugin.admin.ban"
+"myplugin.user.teleport.home"
+"myplugin.vip.chat.color"
+
+// Bad - unclear structure
+"myplugin_ban"
+"teleport"
+"vipChatColor"
 ```
 
-Please note that the `HytalePermissionsProvider` will still be enabled alongside your provider.
-The `PermissionsModule` will aggregate groups and permissions from all available providers.
+### Use Constants for Permissions
 
-If you want to disable the default `HytalePermissionsProvider`, you can use:
+Define your permissions as constants to avoid typos:
 
 ```java
-// put this **before** you add your provider
-PermissionsModule.get().removeProvider(PermissionsModule.get().getFirstPermissionProvider());
+public final class MyPermissions {
+    public static final String ADMIN_BAN = "myplugin.admin.ban";
+    public static final String ADMIN_KICK = "myplugin.admin.kick";
+    public static final String USER_HOME = "myplugin.user.home";
+    public static final String VIP_FLY = "myplugin.vip.fly";
+}
+
+// Usage
+if (player.hasPermission(MyPermissions.ADMIN_BAN)) {
+    // ...
+}
 ```
+
+### Don't Over-Permission
+
+Only create permissions for actions that genuinely need access control. Not everything needs a permission check.
+
+### Thread Safety
+
+If you create a custom provider, ensure it's thread-safe. Permission checks can occur from multiple threads simultaneously. Use `ReadWriteLock` or `ConcurrentHashMap` for your data structures.
+
+---
+
+## In-Game Commands
+
+Hytale provides built-in commands for managing permissions:
+
+### `/op` Command
+
+| Command               | Description                                                        |
+| --------------------- | ------------------------------------------------------------------ |
+| `/op self`            | Toggle your own OP status (singleplayer or with `--allow-op` flag) |
+| `/op add <player>`    | Add a player to the OP group                                       |
+| `/op remove <player>` | Remove a player from the OP group                                  |
+
+### `/perm` Command
+
+Use `/perm --help` in-game for full usage. Common operations:
+
+| Command                                  | Description                   |
+| ---------------------------------------- | ----------------------------- |
+| `/perm user list <uuid>`                 | List user's permissions       |
+| `/perm user add <uuid> <perm>`           | Add permission to user        |
+| `/perm user remove <uuid> <perm>`        | Remove permission from user   |
+| `/perm user group list <uuid>`           | List user's groups            |
+| `/perm user group add <uuid> <group>`    | Add user to group             |
+| `/perm user group remove <uuid> <group>` | Remove user from group        |
+| `/perm group list <group>`               | List group's permissions      |
+| `/perm group add <group> <perm>`         | Add permission to group       |
+| `/perm group remove <group> <perm>`      | Remove permission from group  |
+| `/perm test <perm>`                      | Test if you have a permission |
+
+---
+
+## Summary
+
+You've learned how to:
+
+- **Check permissions** using `PermissionsModule.hasPermission()`
+- **Manage user permissions** with `addUserPermission()` and `removeUserPermission()`
+- **Work with groups** using `addGroupPermission()`, `addUserToGroup()`, etc.
+- **Use wildcards** like `*` and `myplugin.*` for bulk permissions
+- **Listen to events** for permission changes
+- **Create custom providers** for database-backed permissions
+
+For more advanced permission systems with features like inheritance, expiry, and contexts, we're looking into expanding this guide with advanced permission management techniques in the future.
diff --git a/content/docs/hi-IN/guides/plugin/setting-up-env.mdx b/content/docs/hi-IN/guides/plugin/setting-up-env.mdx
index d2718098..5be5e9e0 100644
--- a/content/docs/hi-IN/guides/plugin/setting-up-env.mdx
+++ b/content/docs/hi-IN/guides/plugin/setting-up-env.mdx
@@ -4,6 +4,10 @@ description: Learn how to set up your development environment for modding Hytale
 authors:
   - name: Neil Revin
     link: https://itsneil.dev
+  - name: Marcel-TO
+    url: https://marcel-to.net
+  - name: Ádám Liszkai
+    link: https://adaliszk.dev
 ---
 
 This guide will walk you through setting up a complete development environment for Hytale modding, including all necessary tools and dependencies.
@@ -19,24 +23,73 @@ Before we begin, make sure you have:
 
 ## Required Software
 
-### 1. Java Development Kit (JDK)
+### Integrated Development Environment (IDE)
 
+We recommend IntelliJ IDEA Community Edition for Hytale modding. If you use IntelliJ IDEA, **almost everything is built-in**. You can clone a template, open a new project, and start working right away!
+
+1. Download from [JetBrains website](https://www.jetbrains.com/idea/download/)
+2. Install with default settings
+3. Launch and complete the initial setup wizard
+
+When opening a project, wait for indexing to finish, then start coding.
+Now, IDEA may say "No JDK configured" at the top of the source file you have.
+In that case, you can click Download JDK and choose JetBrains JDK 25.
+
+<Callout type="success">
+  If IDEA opened the project without errors, your environment is ready.
+</Callout>
+
+More details by [JetBrains](https://www.jetbrains.com/help/idea/2026.1/run-for-the-first-time.html)
+help page, where we recommend that you also check the
+[SDK configuration](https://www.jetbrains.com/help/idea/2026.1/sdk.html) guide.
+
+<Callout type="info">
+  We recommened following
+  [TheNullicorn's](https://gist.github.com/TheNullicorn/90a619796c40f20ae1fcf13094c1a57d) guide to ensure
+  you are using the correct `Nonnull` in your projects.
+</Callout>
+
+#### What the IDE Does for You
+
+When opened in IntelliJ IDEA, the project automatically:
+
+- Detects and configures Gradle or Maven
+- Downloads all dependencies
+- Sets up project structure and classpaths
+- Configures run/build tasks
+
+You do **not** need to manually install or configure Maven or Gradle if you stay inside the IDE.
+
+Skip to the [Setting Up Your Workspace](#setting-up-your-workspace).
+
+### Manual Setup: Java Development Kit (JDK)
+
+For any other setup, you will need to install and configure your system to have and load Java.
 Hytale modding requires Java 25 or later. We recommend using OpenJDK.
 
-#### Windows
+#### Windows via Installer
 
 1. Download OpenJDK 25 from [Adoptium](https://adoptium.net/)
 2. Run the installer with default settings
+   - Optionally enable feature `Set or Override JAVA_HOME variable` to resolve version related build issues with your project.
 3. Verify installation by opening Command Prompt and running:
 
+#### Windows via Scoop
+
+1. Install Scoop via PowerShell using [scoop.sh](https://scoop.sh/)
+2. Install OpenJDK 25:
+
 ```bash
-java -version
+scoop bucket add java
+scoop install java/openjdk25
 ```
 
 #### macOS
 
+1. Install Brew via Terminal using [brew.sh](https://brew.sh)
+2. Install JDK via Homebrew:
+
 ```bash
-# Using Homebrew
 brew install openjdk@25
 ```
 
@@ -51,22 +104,41 @@ brew install openjdk@25
 
 #### Linux (Ubuntu/Debian)
 
+1. Install JDK via the built-in package repository:
+
 ```bash
 sudo apt update
 sudo apt install openjdk-25-jdk
 ```
 
-### 2. Integrated Development Environment (IDE)
+### Verify installation:
 
-We recommend IntelliJ IDEA Community Edition for Hytale modding.
+Run the following command to see what version of Java you have:
 
-1. Download from [JetBrains website](https://www.jetbrains.com/idea/download/)
-2. Install with default settings
-3. Launch and complete the initial setup wizard
+```bash
+java -version
+```
+
+### Java Build Tool (Optional)
+
+We recommend using a Gradle Wrapper for managing dependencies and building your Hytale plugins. It provides benefits by eliminating the need for a system-wide Gradle installation and ensuring consistent Gradle versions across different environments. (Alternatively you can use Maven, but this guide focuses on Gradle since it is the default for our plugin template.)
+
+The plugin template in the following sections includes a Gradle Wrapper, so you can skip this step if you plan to use the template.
+
+#### Choosing Gradle (if not using the template)
+
+If you prefer to install Gradle manually, follow these steps:
 
-### 3) Java Build Tool
+1. Visit the official website: https://gradle.org/releases/
+2. Download the newest gradle binary: `gradle-9.3.1-bin.zip` (Binary zip archive)
+3. Unzip it
+4. Add the `gradle-9.3.1/bin/` folder to your PATH
+
+You can now try the command `gradle -version` to verify Gradle is installed correctly. Make sure to do this in a fresh new terminal instead of one you had opened from before!
+
+#### Choosing Maven (if not using the template)
 
-We recommend using Apache Maven for managing dependencies and building your Hytale plugins. (Alternatively you can use Gradle, but this guide focuses on Maven.)
+If you prefer to use Maven instead of Gradle, follow these steps to install Maven:
 
 1. Visit the official website: https://maven.apache.org/download.cgi
 2. Download this file: `apache-maven-3.9.12-bin.zip` (Binary zip archive)
@@ -89,22 +161,61 @@ cd MyFirstMod
 
 If you don't have Git installed, you can download the ZIP file from the repository page and extract it to a folder named `MyFirstMod`.
 
-### 2. Open Plugin in your IDEA
+### 2. Open Plugin in your IDE
 
-1. Open IntelliJ IDEA
+1. Open Your IDE (e.g., IntelliJ IDEA)
 2. Click "Open" and navigate to your `MyFirstMod` directory
-3. IntelliJ will automatically detect it as a Maven project
+3. Most IDEs like IntelliJ will automatically detect it as a Gradle project
 4. Wait for the project to index and dependencies to download
 
-<Callout type="info">
-  We recommened following [this](https://gist.github.com/TheNullicorn/90a619796c40f20ae1fcf13094c1a57d) guide to ensure you are using the correct `Nonnull` in your projects.
-</Callout>
+## Alternate Approach: Hytale Dependency
+
+If you prefer to set up your project from scratch without using the template and importing the hytale dependencies manually, ensure your build configuration includes the Hytale repositories and dependencies:
+
+For Gradle, add the following to your `build.gradle.kts`:
+
+```kotlin
+repositories {
+    mavenCentral()
+    maven {
+        name = "hytale"
+        url = uri("https://maven.hytale.com/release") // Or "hytale-pre-release" for pre-release versions
+    }
+}
+dependencies {
+    // + here means the latest version, but you can hard-wire any known version!
+    implementation("com.hypixel.hytale:Server:+")
+}
+```
+
+For Maven, add the following to your `pom.xml`:
+
+```xml
+<project>
+    <repositories>
+        <repository>
+            <id>hytale-release</id> <!-- Or "hytale-pre-release" for pre-release versions -->
+            <url>https://maven.hytale.com/release</url> <!-- Or "https://maven.hytale.com/pre-release" -->
+        </repository>
+    </repositories>
+
+    <dependencies>
+        <dependency>
+            <groupId>com.hypixel.hytale</groupId>
+            <artifactId>Server</artifactId>
+            <!-- Replace with latest version, Hytale provides jars for the last five releases -->
+            <version>LATEST_VERSION_HERE</version>
+            <scope>provided</scope>
+        </dependency>
+    </dependencies>
+</project>
+```
 
 ## Next Steps
 
 Now that you have your development environment set up with the plugin template:
 
-1. **Customize the template** - Edit the `pom.xml` and `manifest.json` file to change your mod's name and details
+1. **Customize the template** - Edit the `settings.gradle.kts`, `build.gradle.kts` and `manifest.json` file to change your mod's name and details
 2. **Explore the code structure** - Familiarize yourself with the template's organization
 3. **Start modding** - Begin writing your first Hytale plugin!
 
diff --git a/content/docs/hi-IN/guides/plugin/spawning-entities.mdx b/content/docs/hi-IN/guides/plugin/spawning-entities.mdx
index e12c0aea..15be2fb3 100644
--- a/content/docs/hi-IN/guides/plugin/spawning-entities.mdx
+++ b/content/docs/hi-IN/guides/plugin/spawning-entities.mdx
@@ -36,7 +36,7 @@ Store<EntityStore> store = world.getEntityStore().getStore();
 
 ## Creating Entities
 
-Once you have the `EntityStore` instance, you can start to create a entity and give it components. Entities are just instances of `Holder<EntityStore>` with several components attached to them.
+Once you have the `EntityStore` instance, you can start to create an entity and give it components. Entities are just instances of `Holder<EntityStore>` with several components attached to them.
 
 <Callout type="warning">
   To interact with the `World` instance, some methods require you to run the code inside the world's execution context.
@@ -118,3 +118,48 @@ Finally, we can add the entity to the world by calling the `addEntity` method on
 ```java
 store.addEntity(holder, AddReason.SPAWN);
 ```
+
+## Making the entity persist
+
+Hytale automatically saves all entities, but the `NetworkId` component (required for players to be able to see the entity) needs to be manually added every time the entity is loaded.
+
+### Using a system
+
+If you have a component that is unique to your entities, this can be done by creating and registering a custom system as follows:
+
+```java
+public class AddNetworkIdToMyEntitySystem extends HolderSystem<EntityStore> {
+    private final ComponentType<EntityStore, MyEntityComponent> myEntityComponentType = MyEntityComponent.getComponentType();
+    private final ComponentType<EntityStore, NetworkId> networkIdComponentType = NetworkId.getComponentType();
+    private final Query<EntityStore> query = Query.and(this.myEntityComponentType, Query.not(this.networkIdComponentType));
+
+    @Override
+    public void onEntityAdd(@NotNull Holder<EntityStore> holder, @NotNull AddReason reason, @NotNull Store<EntityStore> store) {
+        if (!holder.getArchetype().contains(NetworkId.getComponentType())) {
+            holder.addComponent(NetworkId.getComponentType(), new NetworkId(store.getExternalData().takeNextNetworkId()));
+        }
+    }
+
+    @Override
+    public void onEntityRemoved(@NotNull Holder<EntityStore> holder, @NotNull RemoveReason reason, @NotNull Store<EntityStore> store) {}
+
+    @Override
+    public @Nullable Query<EntityStore> getQuery() {
+        return query;
+    }
+}
+```
+
+In your plugin's `setup()` function
+
+```java
+this.getEntityStoreRegistry().registerSystem(new AddNetworkIdToMyEntitySystem())
+```
+
+### Using PropComponent
+
+Alternatively you can add `PropComponent` to your entity. Hytale adds `PropComponent` to entities spawned with the Entity Tool, and such entities automatically get `NetworkId` and `PrefabCopyableComponent` (which makes the entity work with prefabs).
+
+<Callout type="warning">
+  There is no guarantee, that Hytale will not add some other behavior to this component in the future, which may break your entity, so be careful if you decide to rely on it.
+</Callout>
diff --git a/content/docs/hi-IN/guides/plugin/store-persistent-data.mdx b/content/docs/hi-IN/guides/plugin/store-persistent-data.mdx
new file mode 100644
index 00000000..1071dff3
--- /dev/null
+++ b/content/docs/hi-IN/guides/plugin/store-persistent-data.mdx
@@ -0,0 +1,171 @@
+---
+title: Storing Persistent Data on the Player
+description: Learn how to save and load persistent data using Components
+authors:
+  - name: Neil Revin
+    url: https://itsneil.dev/
+  - name: ArcticDev
+    url: https://github.com/ArcticRaven
+  - name: oskarscot
+    url: https://oskar.scot
+  - name: JammingEng
+    url: https://github.com/JammingEnd
+---
+
+Here is how to store persistent data using a custom component on a Player.
+
+## Build your Component Class
+
+Creating a custom component class leverages the Component system made with the ECS architecture in mind. For more information on Components, check out the [ECS Guide](../ecs/hytale-ecs-theory#components).
+
+Start by creating your custom component class. This will be extremely similar to how regular components are created, however we'll setup a custom Codec so the server can translate this data to BSON, or the server's internal json encoder.
+
+<Callout type="info">
+  Each variable you want to store in your component must have its own Codec field defined in the BuilderCodec.
+  For more information on how to create custom Codecs, check out the [ECS Codec Guide](../ecs/hytale-ecs-theory#codec).
+</Callout>
+
+```java
+public class YourPlayerData implements Component<EntityStore> {
+
+    // define some vars!
+    private int someInteger;
+    private String someString;
+    private Map<String, String> someMap;
+
+    public static final BuilderCodec<YourPlayerData> CODEC =
+            BuilderCodec.builder(YourPlayerData.class, YourPlayerData::new)
+            .append(new KeyedCodec<>("SomeInteger", Codec.INTEGER),
+                    (data, value) -> data.someInteger = value, // setter
+                    data -> data.someInteger) // getter
+            .addValidator(Validators.nonNull())
+            .add()
+            .append(new KeyedCodec<>("SomeString", Codec.STRING),
+                    (data, value) -> data.someString = value, // setter
+                    data -> data.someString) // getter
+            .add()
+            .append(new KeyedCodec<>("SomeMap",
+                            new MapCodec<>(Codec.STRING, HashMap::new, false)),
+                    (data, value) -> data.someMap = value, // setter
+                    data -> data.someMap) // getter
+            .add()
+            .build();
+
+
+
+    // Getters and Setters are for the purpose of this example omitted.
+
+    // constructor
+    public YourPlayerData() {
+        this.someInteger = 0;
+        this.someString = "";
+        this.someMap = new HashMap<>();
+    }
+
+    // copy constructor for cloning
+    public YourPlayerData(YourPlayerData clone) {
+        this.someInteger = clone.someInteger;
+        this.someString = clone.someString;
+        this.someMap = clone.someMap;
+    }
+
+    @Nonnull
+    @Override
+    public Component<EntityStore> clone() {
+        return new YourPlayerData(this);
+    }
+}
+```
+
+## Register your Component
+
+Inside your main class's `setup()` method, register your new Component.
+
+```java
+public class YourPlugin extends JavaPlugin {
+
+    private ComponentType<EntityStore, YourPlayerData> yourPlayerDataComponent;
+
+    public YourPlugin(@Nonnull JavaPluginInit init) {
+        super(init);
+    }
+
+    @Override
+    protected void setup(){
+        this.yourPlayerDataComponent = this.getEntityStoreRegistry().registerComponent(
+            YourPlayerData.class,
+            "YourPlayerDataComponent",
+            YourPlayerData.CODEC
+        );
+    }
+
+    public ComponentType<EntityStore, YourPlayerData> getYourPlayerDataComponent() {
+        return this.yourPlayerDataComponent;
+    }
+}
+```
+
+## Using your Component
+
+To use your newly created component, you can add the Component to a player using the `addComponent` method, although this only adds it temporarily, meaning when the player/entity leaves the world, the component is removed. You can use `putComponent` to ensure the component persists between sessions.
+
+```java
+// You will need the Ref and Store to apply components
+private void someEntryMethod(@Nonnull Ref<EntityStore> ref, @Nonnull Store<EntityStore> store)
+{
+       // Any entity will work, for now we will use the player
+      Player player = (Player) store.getComponent(ref, Player.getComponentType());
+
+      // since we're using putComponent, it could be useful to check if it already exists on the player in case we want to update it
+     if(store.getComponent(ref, YourPlugin.instance().getYourPlayerDataComponent()) != null)
+     {
+          // here we implement logic that updates the component
+         var comp = store.getComponent(ref, YourPlugin.instance().getYourPlayerDataComponent())
+         // declare public fields or methods in the component class
+         comp.SomeString = "An Updated Field";
+     } else {
+          // Here we put the component
+          var myCustomComp = new CustomComponent();
+          // declare public fields or methods in the component class
+          myCustomComp.SomeString = "Edited String";
+
+          // putComponent allows you to insert declared objects
+          store.putComponent(ref, YourPlugin.instance().getYourPlayerDataComponent(), myCustomComp);
+     }
+}
+```
+
+## Using your Data
+
+Your component will be stored within the `Store<EntityStore>` when added to the player. In the provided example,
+we'll fetch this data off the player using the `ensureAndGetComponent()` method, which will add the component to
+the player if it does not exist with the default values.
+
+```java
+public class IncompleteCustomCommand extends AbstractPlayerCommand {
+
+    public IncompleteCustomCommand() {
+        super("nope", "don't use this command");
+    }
+
+    @Override
+    protected void execute(
+        @NonNullDecl CommandContext commandContext,
+        @NonNullDecl Store<EntityStore> store,
+        @NonNullDecl Ref<EntityStore> ref,
+        @NonNullDecl PlayerRef playerRef,
+        @NonNullDecl World world
+    ) {
+        YourPlayerData customData = store.ensureAndGetComponent(ref, YourPlugin.instance().getYourPlayerDataComponent());
+        // ensureAndGetComponent adds the component to the ref, with the default values defined inside your component.
+ 		// use your data
+    }
+}
+```
+
+And that's it! Your data will now be saved and loaded automatically with the player.
+
+Using custom components to store persistent data on players is a powerful way to maintain state across sessions.
+By following the steps outlined above, you can easily create, register, and utilize your own data structures within the Hytale ECS framework.
+This approach ensures that your data is seamlessly integrated with the game's existing systems.
+For more information about Hytale's Entity Component System visit the [Hytale ECS Theory](https://hytalemodding.dev/en/docs/guides/ecs/hytale-ecs-theory) guide.
diff --git a/content/docs/hi-IN/guides/plugin/teleporting-players.mdx b/content/docs/hi-IN/guides/plugin/teleporting-players.mdx
index 57cee77f..32ce0435 100644
--- a/content/docs/hi-IN/guides/plugin/teleporting-players.mdx
+++ b/content/docs/hi-IN/guides/plugin/teleporting-players.mdx
@@ -1,26 +1,32 @@
 ---
 title: Teleporting the player
 description: Learn how to teleport the player.
+authors:
+  - name: oskarscot
+    url: https://oskar.scot
 ---
 
-To teleport players in Hytale, you will need to get a `World` object so we can safely run the teleport on the world thread. The world thread manages all entity updates, so modifying entities off-thread can crash the server or cause inconsistent state.
-Next, we get the entity store and make a `Teleport` object.
-We add a `Teleport` component to the player’s entity reference in the entity store. This triggers the teleportation logic for that player.
+Teleporting players in Hytale works by simply attaching a `Teleport` component to a player with the desired world and transform.
+You can only trigger teleports from a world where the player is currently present.
+Teleport itself is a component but it also provides factory methods to configure the Teleport. Just as with any entity component, an EntityStore and a Ref to the EntityStore is required
+
+We can create a simple teleport utility like this:
 
 ```java
-public static void teleportPlayer(Player player, int x, int y, int z) {
-        World world = player.getWorld();
-        if (world == null) return;
-        world.execute(() -> {
-            if (player.getReference() == null) return;
-            Store<EntityStore> store = player.getReference().getStore();
-            Teleport teleport = Teleport.createForPlayer(world,
-                new Vector3d(x ,y, z), // Target position
-                new Vector3f(0, 0, 0)  // Target rotation (pitch, yaw, roll)
-            );
+public static void teleportPlayer(Ref<EntityStore> ref, Store<EntityStore> store, World targetWorld, double x, double y, double z) {                                                                                       
+    Transform transform = new Transform(x, y, z);                                                                                                                           
+    Teleport teleport = Teleport.createForPlayer(targetWorld, transform);                                                                                                   
+    store.addComponent(ref, Teleport.getComponentType(), teleport);                                                                                                         
+}  
+```
 
-            store.addComponent(player.getReference(), Teleport.getComponentType(), teleport);
-        });
+A `Transform` is a representation of a position Vector3d and rotation Vector3f which works in the following way:
 
-}
+```java
+Transform transform = new Transform(
+    new Vector3d(x, y, z),      // Position
+    new Rotation(yaw, pitch, 0) // Rotation, last value seems to always be 0
+);
+Teleport teleport = Teleport.createForPlayer(targetWorld, transform);
+store.addComponent(ref, Teleport.getComponentType(), teleport);
 ```
diff --git a/content/docs/hi-IN/guides/plugin/tracking-mod-analytics-with-hstats.mdx b/content/docs/hi-IN/guides/plugin/tracking-mod-analytics-with-hstats.mdx
new file mode 100644
index 00000000..45c022e0
--- /dev/null
+++ b/content/docs/hi-IN/guides/plugin/tracking-mod-analytics-with-hstats.mdx
@@ -0,0 +1,65 @@
+---
+title: Tracking Mod Analytics with HStats
+description: Learn how you can track Analytics for your Hytale Mod for Free using hstats.dev
+authors:
+  - name: Al3x
+    url: https://hstats.dev
+---
+
+In this guide, you will learn how to integrate HStats into your Plugin/Mod which will allow you to track how many Servers are using it along with other stats.
+
+<Callout type="info">
+  HStats is a third-party tool and is not affiliated with HytaleModding or Hypixel Studios
+</Callout>
+
+# Step 1: Register your Mod to HStats
+
+Before you touch any code, you will need to add your mod to the HStats website which will give you a UUID for your mod.
+
+- Create or Login to an Account on https://hstats.dev
+- Navigate to the dashboard page (https://hstats.dev/dashboard)
+- On the left, type in your mod's name and click "Add Mod"
+- Keep note of the UUID generated for later.
+
+# Step 2: Add the HStats Class to Your Project
+
+To keep things simple, HStats uses a single Java class file that handles everything for you.
+
+- Download / Copy the File from the GitHub page (https://github.com/hstats-dev/HStatsExamplePlugin/blob/main/src/main/java/com/al3x/HStats.java)
+- Paste into your Project. You should now have a HStats.java file somewhere in your projects directory.
+- Update the package name from com.al3x to whatever fits your project.
+
+# Step 3: Initialize HStats in your code
+
+You only need to add one line of code to your mod's setup method in your main class to start tracking.
+
+`new HStats("YOUR-MOD-UUID", "1.0.0");`
+
+Replace `YOUR-MOD-UUID` with the Mod UUID we made note of earlier and change the `1.0.0` version to whatever version your mod is currently on.
+
+Your setup method should now look something like this:
+
+```java
+@Override
+protected void setup() {
+  super.setup();
+  new HStats("c34a2b2a-afd8-4d6a-821e-7a63e12c5ea6", "1.0.0");
+}
+```
+
+# Extras
+
+Your done! Your mod should now be listed under the Mods page (https://hstats.dev/mods) as well as under your dashboard.
+
+Servers using your mod should now post updates about every minute to HStats which you can view in the Dashboard.
+
+### Embeds
+
+HStats allows you to generate an Embed Card that you can place on your CurseForge or GitHub page. This is useful for server owners to be able to see how many other servers are using your mod.
+
+- In your dashboard, scroll down to the Embed Card section.
+- Customize the appearance (Light/Dark mode, layout, etc).
+- Copy the generated URL to display your "Active Servers" and "Players Online" live on your mod's description page
+
+Heres an example of what they look like:
+![HStats Example](https://api.hstats.dev/api/embed/d52fa672-6966-47b2-b501-1a11bddebac3/card.svg?theme=light\&layout=compact\&size=md\&show_id=true\&dark=false)
diff --git a/content/docs/hi-IN/guides/plugin/world-gen.mdx b/content/docs/hi-IN/guides/plugin/world-gen.mdx
index 4c23b0c9..7b193ffd 100644
--- a/content/docs/hi-IN/guides/plugin/world-gen.mdx
+++ b/content/docs/hi-IN/guides/plugin/world-gen.mdx
@@ -100,7 +100,7 @@ Biome biome = biomeGen.generateBiomeAt(zoneResult, seed, x, z);
 
 ### Zone & Cave Integration
 
-Each zone defines it's own cave patterns:
+Each zone defines its own cave patterns:
 
 ```java
 Zone zone = /* ... */;
diff --git a/content/docs/hi-IN/guides/prefabs.mdx b/content/docs/hi-IN/guides/prefabs.mdx
index 08404b30..b1a55109 100644
--- a/content/docs/hi-IN/guides/prefabs.mdx
+++ b/content/docs/hi-IN/guides/prefabs.mdx
@@ -14,7 +14,7 @@ Prefabs are Hytale's way of creating reusable structures.
 There are a few fundamental concepts to understand about prefabs:
 
 - Users interact with prefabs via a prefab editing world.
-- Prefabs the physical structures in the game world, and are saved as JSON files.
+- Prefabs are the physical structures in the game world, and are saved as JSON files.
 
 ## How to Create a Prefab
 
diff --git a/content/docs/hi-IN/official-documentation/custom-ui/common-styling.mdx b/content/docs/hi-IN/official-documentation/custom-ui/common-styling.mdx
new file mode 100644
index 00000000..c36e3e3a
--- /dev/null
+++ b/content/docs/hi-IN/official-documentation/custom-ui/common-styling.mdx
@@ -0,0 +1,50 @@
+---
+title: Common Styling
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# Common Styling
+
+## Common UI Styling Library
+
+This document describes the shared UI components and styles defined in `Common.ui`.
+
+---
+
+### Styles
+
+We are providing some styles that can be re-used in any custom UI that, provide a cohesive UI experience with the core game UI. These styles are available in the `Common.ui` file.
+
+You can find a list of all the styles defined with live examples by running the `/ui-gallery` command ingame.
+
+<Callout type="warning">
+  This command is not available yet, but will be in a future patch.
+</Callout>
+
+![Gallery](/assets/official-documentation/ui/gallery.png)
+
+### Importing
+
+To use these styles in your UI file:
+
+```
+$Common = "Common.ui";
+
+// Then reference styles and components:
+$Common.@TextButton { @Text = "My Button"; }
+$Common.@Container { ... }
+```
+
+<Callout type="info">
+  The `Common.ui` file is at `Common/UI/Custom/Common.ui` within the Hytale pack. If your custom ui document is in a subfolder of `Common/UI/Custom/`, reference it via relative path traversal:
+
+  ```
+  $Common = "../Common.ui";
+  ```
+
+  You can find more info about paths [here](markup#path).
+</Callout>
diff --git a/content/docs/hi-IN/official-documentation/custom-ui/index.mdx b/content/docs/hi-IN/official-documentation/custom-ui/index.mdx
new file mode 100644
index 00000000..f94c4e88
--- /dev/null
+++ b/content/docs/hi-IN/official-documentation/custom-ui/index.mdx
@@ -0,0 +1,125 @@
+---
+title: Custom UI
+icon: LayoutDashboard
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# Custom UI
+
+## What is Custom UI?
+
+Custom UI is Hytale's framework for creating **custom user interfaces** controlled by the game server. Unlike the built-in Client UI (which is part of the game client and cannot be modified), Server UI allows you to create interactive screens and HUD overlays through Java plugins and asset packs.
+
+As a modder, Custom UI gives you the power to:
+
+- **Create custom interactive pages** - Shop interfaces, quest dialogs, server settings menus, admin panels
+- **Add custom HUD overlays** - Quest trackers, status displays, custom health bars, server information
+- **Design with markup** - Use `.ui` files to define reusable UI templates
+- **Handle user interactions** - Respond to button clicks, form submissions, and other events
+- **Localize your UI** - Support multiple languages using the game's translation system
+
+## How Custom UI Fits Into Hytale's UI
+
+Hytale's user interface is divided into two main categories:
+
+### Client UI (Not Moddable)
+
+Built-in interfaces controlled by the C# game client:
+
+- Main menu and settings
+- Character creation
+- Built-in HUD (health, hotbar, chat)
+- Inventory and crafting screens
+- Development tools
+
+**You cannot modify these** - they are part of the core game client.
+
+### In-Game UI (Moddable via Server)
+
+Server-controlled interfaces that you can create and customize:
+
+#### Custom Pages
+
+Full-screen interactive overlays that appear during gameplay:
+
+- Can be dismissed by the player (ESC key)
+- Capture all input (keyboard and mouse)
+- Support loading states while waiting for server responses
+- Perfect for: shops, dialogs, menus, configuration screens
+
+#### Custom HUDs
+
+Persistent overlay elements drawn on top of the game world:
+
+- Display-only (no user interaction)
+- Always visible during gameplay
+- Lightweight and non-intrusive
+- Perfect for: quest objectives, status indicators, server info panels
+
+## Architecture Overview
+
+Server UI uses a **command-based architecture**:
+
+```
+┌─────────────────────┐         ┌──────────────────────┐
+│   Java Server       │         │    C# Client         │
+│   (Your Plugin)     │         │    (Game)            │
+├─────────────────────┤         ├──────────────────────┤
+│                     │         │                      │
+│ InteractiveCustomUI │         │   CustomPage or      │
+│ Page                │         │   CustomHud          │
+│   ↓ build()         ├────────→│     ↓ Apply          │
+│ UICommandBuilder    │         │   Element Tree       │
+│   - append()        │         │     ↓ Layout         │
+│   - set()           │         │   Rendered UI        │
+│   - clear()         │         │                      │
+│                     │         │                      │
+│ ↓ handleDataEvent() │← Events │   User Interaction   │
+│   Process input     │         │   (click, type, etc) │
+│   sendUpdate()      │         │                      │
+└─────────────────────┘         └──────────────────────┘
+```
+
+**The flow:**
+
+1. Your Java code builds UI using `UICommandBuilder`
+2. Commands are sent to the client as data
+3. Client parses `.ui` markup files and creates visual elements
+4. User interacts with the UI
+5. Events are sent back to your Java code
+6. You process events and send updates back
+
+## Key Principles
+
+### Declarative, Not Imperative
+
+You don't create UI objects directly. Instead, you send **commands** that describe what you want:
+
+- "Append this button template to that container"
+- "Set this label's text to 'Hello World'"
+- "Clear all children from this list"
+
+### Asset-Driven
+
+UI structure is defined in `.ui` markup files (assets), not hardcoded in Java. This enables:
+
+- Designers to modify layouts without touching code
+- Reusable UI components
+- Consistent visual language
+
+### Event-Driven
+
+User interactions trigger events that flow back to your server code. You register event bindings and handle them in `handleDataEvent()`.
+
+### Selector-Based
+
+You target specific UI elements using **selectors:**
+
+- `#MyButton` - Element with ID "MyButton"
+- `#List[0]` - First child of element "List"
+- `#List[0] #Title` - Element with ID "Title" in the first child of element "List"
+- `#Label.TextColor` - The TextColor property of element "Label"
diff --git a/content/docs/hi-IN/official-documentation/custom-ui/layout.mdx b/content/docs/hi-IN/official-documentation/custom-ui/layout.mdx
new file mode 100644
index 00000000..0a24ca09
--- /dev/null
+++ b/content/docs/hi-IN/official-documentation/custom-ui/layout.mdx
@@ -0,0 +1,492 @@
+---
+title: Layout
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# Layout
+
+The layout system determines how UI elements are positioned and sized on screen. Understanding layout is crucial for creating well-structured, responsive interfaces.
+
+## Layout Fundamentals
+
+Every UI element has:
+
+- **Container Rectangle** - The space allocated by the parent
+- **Anchor** - How the element positions/sizes itself within the container
+- **Padding** - Inner spacing that affects child layout
+- **LayoutMode** - How the element arranges its children (if it's a container)
+
+```
+┌─────────────────────────────────────┐
+│  Container Rectangle (from parent)  │
+│  ┌───────────────────────────────┐  │
+│  │  Anchored Rectangle           │  │
+│  │  ┌─────────────────────────┐  │  │
+│  │  │ Padding                 │  │  │
+│  │  │  ┌───────────────────┐  │  │  │
+│  │  │  │  Content Area     │  │  │  │
+│  │  │  └───────────────────┘  │  │  │
+│  │  └─────────────────────────┘  │  │
+│  └───────────────────────────────┘  │
+└─────────────────────────────────────┘
+```
+
+## Anchor
+
+`Anchor` controls how an element positions and sizes itself within its container rectangle.
+
+### Fixed Size
+
+```
+Button {
+    Anchor: (Width: 200, Height: 40);
+}
+```
+
+Creates a 200×40 pixel button.
+
+### Positioning
+
+```
+Label {
+    Anchor: (Top: 10, Left: 20, Width: 100, Height: 30);
+}
+```
+
+- **Top**: 10 pixels from container's top edge
+- **Left**: 20 pixels from container's left edge
+- **Width**: 100 pixels wide
+- **Height**: 30 pixels tall
+
+### Anchoring to Edges
+
+```
+Button {
+    Anchor: (Bottom: 10, Right: 10, Width: 100, Height: 30);
+}
+```
+
+Anchors the button to the bottom-right corner, 10 pixels from each edge.
+
+### Stretching
+
+```
+Group {
+    Anchor: (Top: 0, Bottom: 0, Left: 0, Right: 0);
+}
+```
+
+Stretches to fill the entire container (all edges at 0 pixels).
+
+**Shorthand:**
+
+```
+Group {
+    Anchor: (Full: 0);
+}
+```
+
+### Mixed Anchoring
+
+```
+Panel {
+    Anchor: (Top: 10, Bottom: 10, Left: 20, Width: 300);
+}
+```
+
+- Fixed width of 300 pixels
+- Stretches vertically between top and bottom edges
+- 10 pixels from top and bottom
+- 20 pixels from left
+
+## Padding
+
+`Padding` creates inner spacing, affecting where children are positioned.
+
+### Uniform Padding
+
+```
+Group {
+    Padding: (Full: 20);
+}
+```
+
+20 pixels of padding on all sides.
+
+### Directional Padding
+
+```
+Group {
+    Padding: (Top: 10, Bottom: 20, Left: 15, Right: 15);
+}
+```
+
+Different padding per edge.
+
+### Shorthand
+
+```
+// Horizontal and vertical
+Group {
+    Padding: (Horizontal: 20, Vertical: 10);
+}
+
+// Equivalent to:
+// Top: 10, Bottom: 10, Left: 20, Right: 20
+```
+
+### Effect on Children
+
+```
+Group {
+    Anchor: (Width: 200, Height: 100);
+    Padding: (Full: 10);
+
+    Label {
+        Anchor: (Full: 0);
+    }
+}
+```
+
+The label fills the group, but there's a 10-pixel gap on all sides due to padding.
+
+```
+┌──────────────────────┐
+│ Group (200×100)      │
+│  ┌────────────────┐  │
+│  │ Label          │  │ ← 10px padding all around
+│  │                │  │
+│  └────────────────┘  │
+└──────────────────────┘
+```
+
+## LayoutMode
+
+`LayoutMode` determines how a container arranges its children.
+
+### Top (Vertical Stack)
+
+```
+Group {
+    LayoutMode: Top;
+
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+}
+```
+
+Children stack vertically from top to bottom:
+
+```
+┌──────────┐
+│ Button 1 │
+├──────────┤
+│ Button 2 │
+├──────────┤
+│ Button 3 │
+└──────────┘
+
+
+```
+
+Each child's `Anchor.Bottom` adds spacing between elements:
+
+```
+Button { Anchor: (Height: 30, Bottom: 10); }  // 10px gap after this button
+```
+
+### Bottom (Vertical Stack)
+
+```
+Group {
+    LayoutMode: Bottom;
+
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+}
+```
+
+Children stack vertically from top to bottom but aligned to the bottom edge of the parent:
+
+```
+
+
+
+┌──────────┐
+│ Button 1 │
+├──────────┤
+│ Button 2 │
+├──────────┤
+│ Button 3 │
+└──────────┘
+```
+
+### Left (Horizontal Stack)
+
+```
+Group {
+    LayoutMode: Left;
+
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+}
+```
+
+Children arrange horizontally from left to right:
+
+```
+┌────────┬────────┬────────┐
+│ Button │ Button │ Button │
+│   1    │   2    │   3    │
+└────────┴────────┴────────┘
+```
+
+Use `Anchor.Right` for spacing between elements.
+
+### Right (Horizontal Stack)
+
+```
+Group {
+    LayoutMode: Right;
+
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+}
+```
+
+Children arrange horizontally from left to right but aligned to the right side of the parent:
+
+```
+                                                                 ┌────────┬────────┬────────┐
+                                                                 │ Button │ Button │ Button │
+                                                                 │   1    │   2    │   3    │
+                                                                 └────────┴────────┴────────┘
+```
+
+### Center
+
+```
+Group {
+    LayoutMode: Center;
+
+    Group #Dialog {
+        Anchor: (Width: 400, Height: 300);
+    }
+}
+```
+
+Centers the children horizontally.
+
+### Middle
+
+```
+Group {
+    LayoutMode: Middle;
+
+    Group #Dialog {
+        Anchor: (Width: 400, Height: 300);
+    }
+}
+```
+
+Centers the children vertically.
+
+### CenterMiddle (Horizontal Stack, Fully Centered)
+
+```
+Group {
+    LayoutMode: CenterMiddle;
+
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+}
+```
+
+Children stack horizontally from left to right, centered both horizontally and vertically within the parent:
+
+```
+┌────────────────────────────────────────────┐
+│                                            │
+│                                            │
+│         ┌──────┐ ┌──────┐ ┌──────┐         │
+│         │  B1  │ │  B2  │ │  B3  │         │
+│         └──────┘ └──────┘ └──────┘         │
+│                                            │
+│                                            │
+└────────────────────────────────────────────┘
+```
+
+---
+
+### MiddleCenter (Vertical Stack, Fully Centered)
+
+```
+Group {
+    LayoutMode: MiddleCenter;
+
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+}
+```
+
+Children stack vertically from top to bottom, centered both horizontally and vertically within the parent:
+
+```
+┌────────────────────────────────────────────┐
+│                                            │
+│              ┌──────────┐                  │
+│              │ Button 1 │                  │
+│              ├──────────┤                  │
+│              │ Button 2 │                  │
+│              ├──────────┤                  │
+│              │ Button 3 │                  │
+│              └──────────┘                  │
+│                                            │
+└────────────────────────────────────────────┘
+```
+
+---
+
+### Full
+
+```
+Group {
+    LayoutMode: Full;
+
+    Label {
+        Anchor: (Top: 20, Left: 20, Width: 100, Height: 30);
+    }
+}
+```
+
+Children use absolute positioning via their `Anchor` properties.
+
+### TopScrolling
+
+```
+Group {
+    LayoutMode: TopScrolling;
+    ScrollbarStyle: $Common.@DefaultScrollbar;
+
+    // ... many children
+}
+```
+
+Like `Top`, but adds a scrollbar if content exceeds container height.
+
+Or use `BottomScrolling` for bottom-aligned content.
+
+### LeftScrolling
+
+```
+Group {
+    LayoutMode: LeftScrolling;
+    ScrollbarStyle: $Common.@DefaultScrollbar;
+
+    // ... many children
+}
+```
+
+Like `Left`, but adds a scrollbar for horizontal scrolling.
+
+Or use `RightScrolling` for right-aligned content.
+
+### LeftCenterWrap (Wrapping Horizontal Stack, Horizontally Centered)
+
+```
+Group {
+    LayoutMode: LeftCenterWrap;
+
+    Button { Anchor: (Width: 80, Height: 30); }
+    Button { Anchor: (Width: 80, Height: 30); }
+    Button { Anchor: (Width: 80, Height: 30); }
+    Button { Anchor: (Width: 80, Height: 30); }
+    Button { Anchor: (Width: 80, Height: 30); }
+}
+```
+
+Children flow left to right. When there's no more horizontal space, they wrap to the next row. Each row is horizontally centered within the parent:
+
+```
+┌────────────────────────────────────────────┐
+│                                            │
+│       ┌──────┐ ┌──────┐ ┌──────┐           │
+│       │  B1  │ │  B2  │ │  B3  │           │
+│       └──────┘ └──────┘ └──────┘           │
+│            ┌──────┐ ┌──────┐               │
+│            │  B4  │ │  B5  │               │
+│            └──────┘ └──────┘               │
+│                                            │
+└────────────────────────────────────────────┘
+```
+
+## FlexWeight
+
+`FlexWeight` distributes remaining space among children.
+
+```
+Group {
+    LayoutMode: Left;
+    Anchor: (Width: 400);
+
+    Button {
+        Anchor: (Width: 100);
+    }
+
+    Group {
+        FlexWeight: 1;  // Takes all remaining space
+    }
+
+    Button {
+        Anchor: (Width: 100);
+    }
+}
+```
+
+Result:
+
+- First button: 100px
+- Middle group: 200px (400 - 100 - 100 = 200)
+- Last button: 100px
+
+### Multiple FlexWeights
+
+```
+Group {
+    LayoutMode: Left;
+    Anchor: (Width: 600);
+
+    Group { FlexWeight: 1; }
+    Group { FlexWeight: 2; }
+    Group { FlexWeight: 1; }
+}
+```
+
+Remaining space (600px) is split:
+
+- First group: 600 × (1/4) = 150px
+- Second group: 600 × (2/4) = 300px
+- Third group: 600 × (1/4) = 150px
+
+## Visibility
+
+```
+Button #HiddenButton {
+    Visible: false;
+}
+```
+
+**Effect:**
+
+- Element and its children are not displayed
+- Element is **not included in layout** (doesn't take up space)
diff --git a/content/docs/hi-IN/official-documentation/custom-ui/markup.mdx b/content/docs/hi-IN/official-documentation/custom-ui/markup.mdx
new file mode 100644
index 00000000..564110ed
--- /dev/null
+++ b/content/docs/hi-IN/official-documentation/custom-ui/markup.mdx
@@ -0,0 +1,226 @@
+---
+title: Markup
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# Markup
+
+## Markup
+
+An element is the basic building block of a user interface. There are various types of elements with different properties, which are documented below.
+
+Here's what the syntax looks like:
+
+```
+// Basic declaration of an element
+// with its Anchor property set to attach on all sides of its parent
+// with 10 pixels of margin
+Group { Anchor: (Left: 10, Top: 10, Right: 10, Bottom: 10); }
+
+Group { Anchor: (Full: 10); } // More concise version
+
+// Declaration of a Label with a name
+// (can be used to access the element from game code)
+Label #MyLabel {
+  Style: LabelStyle(FontSize: 16); // or just Style: (FontSize: 16), type can be inferred.
+  Text: "Hi! I am text.";
+}
+
+// Declaration of a Group containing 2 children
+// You can use FlexWeight to distribute any left-over space after explicit widths/heights have been subtracted
+Group {
+  LayoutMode: Left;
+  Label { Text: "Child 1"; FlexWeight: 2; }
+  Label { Text: "Child 2"; FlexWeight: 1; }
+}
+```
+
+### Documents
+
+A UI document (_.ui_ file) contains trees of elements. There can be multiple root elements.
+
+### Named Expressions
+
+Named expressions can be declared at any level of a document (including at the root) and will be scoped to that subtree, though they need to be declared at the top of the block.
+
+```
+// Example of named expressions, declared and used with @ prefix
+@Title = "Hytale";
+@ExtraSpacing = 5;
+
+Label {
+  Text: @Title;
+  Style: (LetterSpacing: 2 + @ExtraSpacing);
+}
+```
+
+You can use the spread operator `...` to reuse a named expression while overriding some of its fields:
+
+```
+@MyBaseStyle = LabelStyle(FontSize: 24, LetterSpacing: 2);
+
+Label {
+  Style: (...@MyBaseStyle, FontSize: 36);
+}
+```
+
+You can even layer multiple named expressions like so:
+
+```
+@TitleStyle = LabelStyle(FontSize: 24, HorizontalAlignment: Center);
+@SpacedTextStyle = LabelStyle(LetterSpacing: 2);
+
+Label {
+  Style: (...@BigTextStyle, ...@SpacedTextStyle);
+}
+```
+
+#### Document references
+
+A document can reference another document and access its named expressions.
+
+```
+// Document references are defined with $ prefix
+$Common = "../Common.ui";
+
+TextButton {
+  Style: $Common.@DefaultButtonStyle;
+}
+```
+
+### Templates
+
+You can declare a reusable bit of interface as a named expression and then instantiate it as many times as you want in the tree while customizing it.
+
+You can override local named expressions as well as insert additional children at any point in the template tree. However, local named expressions must be defined at the very top of the block, before properties and child elements.
+
+```
+// This is the template
+@Row = Group {
+  Anchor: (Height: 50);
+  Label #Label { Anchor: (Left: 0, Width: 100); Text: @LabelText; }
+  Group #Content { Anchor: (Left: 100); }
+};
+
+// Here we'll be using it twice in the document tree
+Group #Rows {
+  LayoutMode: TopScrolling;
+
+  @Row #MyFirstRow {
+    @LabelText = "First row";
+    #Content { TextInput {} }
+  }
+
+  @Row #MySecondRow {
+    @LabelText = "Second row";
+  }
+}
+```
+
+### Property Types
+
+#### Basic Types
+
+- **Boolean**
+  - `Visible: false;`
+  - `Visible: true;`
+- **Int**
+  - `Height: 20;`
+- **Float, Double, Decimal**
+  - `Min: 0.2;`
+- **String**
+  - `Text: "Hi!";`
+- **Char**
+  - `PasswordChar: "*";`
+  - _Note: The syntax is the same as a string, however a value of this type cannot contain more than one character!_
+- **Color**
+  - `Background: #ffffff;`&#x20;
+- **Objects**
+  - `Style: (Background: #ffffff)`
+- **Array**&#x20;
+  - `TextSpans: [(Text: "Hi", IsBold: true)]`
+
+#### Translations
+
+Translation keys can be referenced anywhere in markup where you can provide a string, and they are then converted to a string when an element gets instantiated.
+
+**Example:**
+
+```
+Label {
+  Text: %ui.general.cancel;
+}
+```
+
+#### Colors
+
+A color literal can be written as follows:
+
+- `#rrggbb`: 6-digit hexadecimal representation for red, green, blue (fully opaque)
+- `#rrggbb(a.a)`: 6-digit hexadecimal representation for red, green, blue with alpha between 0 and 1
+- `#rrggbbaa`: 8-digit hexadecimal representation for red, green, blue and alpha
+
+```
+Group {
+  Background: #000000(0.3);
+}
+```
+
+<Callout>
+  The `#rrggbb(a.a)` format is prefered over the `#rrggbbaa` format for
+  readability reasons.
+</Callout>
+
+#### Font Name
+
+Font names can be referenced directly by their string ID. Internally this is using a custom type called `UIFontName`, however strings will be converted automatically to this type in markup.
+
+```
+Label {
+  Text: "Hi";
+  Style: (FontName: "Secondary");
+}
+```
+
+**Available Font Names**
+
+- _Default_ - This is the default font that is used for most text and is always used unless a different option has been specified
+- _Secondary_ - This font is mostly used for headlines or elements that are supposed to stick out
+- _Mono_ - This is only used for development; For things such as profiling or error overlays.
+
+#### Path
+
+We can reference other UI assets with the `UIPath` type. Similar to `UIFontName`_,_ Strings are automatically converted to a `UIPath`. Paths are always relative to the file where they have been declared in. Looking up _MyButton.png_ in _Menu/MyAwesomeMenu.ui_ will result in _Menu/MyButton.png_. If you want to reference a file that is in a parent folder you can go back one directory by writing two dots (_../MyButton.png_).
+
+The markup syntax of a `UIPath` is the same as a String. (e.g. `Path: "Test.png"`)
+
+Here are some more examples:
+
+| UIPath             | .ui File                              | Resulting Path    |
+| ------------------ | ------------------------------------- | ----------------- |
+| MyButton.png       | Menu/MyAwesomeMenu.ui                 | Menu/MyButton.png |
+| ../MyButton.png    | Menu/MyAwesomeMenu.ui                 | MyButton.png      |
+| ../../MyButton.png | Menu/Popup/Templates/MyAwesomeMenu.ui | Menu/MyButton.png |
+
+#### Objects
+
+Objects contain a set of properties. In this example we are assigning an Anchor object to the _Anchor_ property:
+
+```
+Group {
+  Anchor: (
+   Height: 10,
+   Width: 20
+ );
+}
+```
+
+You can find all objects that can be used in markup [here](type-documentation#elements).
+
+## Visual Studio Code Extension
+
+There is an official extension for Visual Studio Code which adds syntax highlighting for .ui files. You can find it [here](https://marketplace.visualstudio.com/items?itemName=HypixelStudiosCanadaInc.vscode-hytaleui).
diff --git a/content/docs/hi-IN/official-documentation/custom-ui/type-documentation/index.mdx b/content/docs/hi-IN/official-documentation/custom-ui/type-documentation/index.mdx
new file mode 100644
index 00000000..69cea406
--- /dev/null
+++ b/content/docs/hi-IN/official-documentation/custom-ui/type-documentation/index.mdx
@@ -0,0 +1,127 @@
+---
+title: Type Documentation
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# Type Documentation
+
+This is a generated list of UI elements accessible by markup. More information about the User Interface framework can be found in the main documentation.
+
+## Elements
+
+- [ActionButton](type-documentation/elements/actionbutton)
+- [AssetImage](type-documentation/elements/assetimage)
+- [BackButton](type-documentation/elements/backbutton)
+- [BlockSelector](type-documentation/elements/blockselector)
+- [Button](type-documentation/elements/button)
+- [CharacterPreviewComponent](type-documentation/elements/characterpreviewcomponent)
+- [CheckBox](type-documentation/elements/checkbox)
+- [CheckBoxContainer](type-documentation/elements/checkboxcontainer)
+- [CircularProgressBar](type-documentation/elements/circularprogressbar)
+- [CodeEditor](type-documentation/elements/codeeditor)
+- [ColorOptionGrid](type-documentation/elements/coloroptiongrid)
+- [ColorPicker](type-documentation/lements/colorpicker)
+- [ColorPickerDropdownBox](type-documentation/elements/colorpickerdropdownbox)
+- [CompactTextField](type-documentation/elements/compacttextfield)
+- [DropdownBox](type-documentation/elements/dropdownbox)
+- [DropdownEntry](type-documentation/elements/dropdownentry)
+- [DynamicPane](type-documentation/elements/dynamicpane)
+- [DynamicPaneContainer](type-documentation/elements/dynamicpanecontainer)
+- [FloatSlider](type-documentation/elements/floatslider)
+- [FloatSliderNumberField](type-documentation/elements/floatslidernumberfield)
+- [Group](type-documentation/elements/group)
+- [HotkeyLabel](type-documentation/elements/hotkeylabel)
+- [ItemGrid](type-documentation/elements/itemgrid)
+- [ItemIcon](type-documentation/elements/itemicon)
+- [ItemPreviewComponent](type-documentation/elements/itempreviewcomponent)
+- [ItemSlot](type-documentation/elements/itemslot)
+- [ItemSlotButton](type-documentation/elements/itemslotbutton)
+- [Label](type-documentation/elements/label)
+- [LabeledCheckBox](type-documentation/elements/labeledcheckbox)
+- [MenuItem](type-documentation/elements/menuitem)
+- [MultilineTextField](type-documentation/elements/multilinetextfield)
+- [NumberField](type-documentation/elements/numberfield)
+- [Panel](type-documentation/elements/panel)
+- [ProgressBar](type-documentation/elements/progressbar)
+- [ReorderableList](type-documentation/elements/reorderablelist)
+- [ReorderableListGrip](type-documentation/elements/reorderablelistgrip)
+- [SceneBlur](type-documentation/elements/sceneblur)
+- [Slider](type-documentation/elements/slider)
+- [SliderNumberField](type-documentation/elements/slidernumberfield)
+- [Sprite](type-documentation/elements/sprite)
+- [TabButton](type-documentation/elements/tabbutton)
+- [TabNavigation](type-documentation/elements/tabnavigation)
+- [TextButton](type-documentation/elements/textbutton)
+- [TextField](type-documentation/elements/textfield)
+- [TimerLabel](type-documentation/elements/timerlabel)
+- [ToggleButton](type-documentation/elements/togglebutton)
+
+## Property Types
+
+- [Anchor](type-documentation/property-types/anchor)
+- [BlockSelectorStyle](type-documentation/property-types/blockselectorstyle)
+- [ButtonSounds](type-documentation/property-types/buttonsounds)
+- [ButtonStyle](type-documentation/property-types/buttonstyle)
+- [ButtonStyleState](type-documentation/property-types/buttonstylestate)
+- [CheckBoxStyle](type-documentation/property-types/checkboxstyle)
+- [CheckBoxStyleState](type-documentation/property-types/checkboxstylestate)
+- [ClientItemStack](type-documentation/property-types/clientitemstack)
+- [ColorOptionGridStyle](type-documentation/property-types/coloroptiongridstyle)
+- [ColorPickerDropdownBoxStateBackground](type-documentation/property-types/colorpickerdropdownboxstatebackground)
+- [ColorPickerDropdownBoxStyle](type-documentation/property-types/colorpickerdropdownboxstyle)
+- [ColorPickerStyle](type-documentation/property-types/colorpickerstyle)
+- [DropdownBoxSearchInputStyle](type-documentation/property-types/dropdownboxsearchinputstyle)
+- [DropdownBoxSounds](type-documentation/property-types/dropdownboxsounds)
+- [DropdownBoxStyle](type-documentation/property-types/dropdownboxstyle)
+- [InputFieldButtonStyle](type-documentation/property-types/inputfieldbuttonstyle)
+- [InputFieldDecorationStyle](type-documentation/property-types/inputfielddecorationstyle)
+- [InputFieldDecorationStyleState](type-documentation/property-types/inputfielddecorationstylestate)
+- [InputFieldIcon](type-documentation/property-types/inputfieldicon)
+- [InputFieldStyle](type-documentation/property-types/inputfieldstyle)
+- [ItemGridSlot](type-documentation/property-types/itemgridslot)
+- [ItemGridStyle](type-documentation/property-types/itemgridstyle)
+- [LabeledCheckBoxStyle](type-documentation/property-types/labeledcheckboxstyle)
+- [LabeledCheckBoxStyleState](type-documentation/property-types/labeledcheckboxstylestate)
+- [LabelSpan](type-documentation/property-types/labelspan)
+- [LabelStyle](type-documentation/property-types/labelstyle)
+- [NumberFieldFormat](type-documentation/property-types/numberfieldformat)
+- [Padding](type-documentation/property-types/padding)
+- [PatchStyle](type-documentation/property-types/patchstyle)
+- [PopupStyle](type-documentation/property-types/popupstyle)
+- [ScrollbarStyle](type-documentation/property-types/scrollbarstyle)
+- [SliderStyle](type-documentation/property-types/sliderstyle)
+- [SoundStyle](type-documentation/property-types/soundstyle)
+- [SpriteFrame](type-documentation/property-types/spriteframe)
+- [SubMenuItemStyle](type-documentation/property-types/submenuitemstyle)
+- [SubMenuItemStyleState](type-documentation/property-types/submenuitemstylestate)
+- [Tab](type-documentation/property-types/tab)
+- [TabNavigationStyle](type-documentation/property-types/tabnavigationstyle)
+- [TabStyle](type-documentation/property-types/tabstyle)
+- [TabStyleState](type-documentation/property-types/tabstylestate)
+- [TextButtonStyle](type-documentation/property-types/textbuttonstyle)
+- [TextButtonStyleState](type-documentation/property-types/textbuttonstylestate)
+- [TextTooltipStyle](type-documentation/property-types/texttooltipstyle)
+- [ToggleButtonStyle](type-documentation/property-types/togglebuttonstyle)
+- [ToggleButtonStyleState](type-documentation/property-types/togglebuttonstylestate)
+
+## Enums
+
+- [ActionButtonAlignment](type-documentation/enums/actionbuttonalignment)
+- [CodeEditorLanguage](type-documentation/enums/codeeditorlanguage)
+- [ColorFormat](type-documentation/enums/colorformat)
+- [DropdownBoxAlign](type-documentation/enums/dropdownboxalign)
+- [InputFieldButtonSide](type-documentation/enums/inputfieldbuttonside)
+- [InputFieldIconSide](type-documentation/enums/inputfieldiconside)
+- [ItemGridInfoDisplayMode](type-documentation/enums/itemgridinfodisplaymode)
+- [LabelAlignment](type-documentation/enums/labelalignment)
+- [LayoutMode](type-documentation/enums/layoutmode)
+- [MouseWheelScrollBehaviourType](type-documentation/enums/mousewheelscrollbehaviourtype)
+- [ProgressBarAlignment](type-documentation/enums/progressbaralignment)
+- [ProgressBarDirection](type-documentation/enums/progressbardirection)
+- [ResizeType](type-documentation/enums/resizetype)
+- [TimerDirection](type-documentation/enums/timerdirection)
+- [TooltipAlignment](type-documentation/enums/tooltipalignment)
diff --git a/content/docs/hi-IN/official-documentation/npc/2-getting-started-with-templates.mdx b/content/docs/hi-IN/official-documentation/npc/2-getting-started-with-templates.mdx
index 91081ca1..99d078e0 100644
--- a/content/docs/hi-IN/official-documentation/npc/2-getting-started-with-templates.mdx
+++ b/content/docs/hi-IN/official-documentation/npc/2-getting-started-with-templates.mdx
@@ -9,7 +9,7 @@ authors:
 
 There are no hard and fast rules for making a start on a template. I like to duplicate **BlankTemplate** and start from there because it already provides the basic structure of the file.
 
-This leaves me with the following template (`Template_Goblin_Ogre.json`): (note: the file could be looking different in the current version of the game)
+This leaves me with the following template (`Template_Goblin_Ogre.json`): (**note: the file could be looking different in the current version of the game**)
 
 ```json
 {
@@ -33,7 +33,7 @@ This leaves me with the following template (`Template_Goblin_Ogre.json`): (note:
     }
   },
   "Appearance": { "Compute": "Appearance" },
-  "DropList": { "Compute": "Droplist" },
+  "DropList": { "Compute": "DropList" },
   "MaxHealth": { "Compute": "MaxHealth" },
   "MotionControllerList": [
     {
@@ -65,10 +65,10 @@ And the following variant (`Goblin_Ogre.json`) next to the template. There's a t
   "Type": "Variant",
   "Reference": "Template_Goblin_Ogre",
   "Modify": {
-    "Appearance": "Goblin_Ogre",
+    "Appearance": "Goblin",
     "MaxHealth": 124
   }
 }
 ```
 
-Our artists have defined the `Goblin_Ogre` appearance already so I'm going to use that.
+Our artists have not yet finished animations for the `Goblin_Ogre`, for that sake of the tutorial I am going to use appearance `Goblin`, because it offers a more complete set of animations that we will need.
diff --git a/content/docs/hi-IN/official-documentation/worldgen/pack-tutorial/asset-packs.mdx b/content/docs/hi-IN/official-documentation/worldgen/pack-tutorial/asset-packs.mdx
index 38809fad..dcf1f3b9 100644
--- a/content/docs/hi-IN/official-documentation/worldgen/pack-tutorial/asset-packs.mdx
+++ b/content/docs/hi-IN/official-documentation/worldgen/pack-tutorial/asset-packs.mdx
@@ -9,13 +9,13 @@ authors:
 
 <OfficialDocumentationNotice />
 
-# How to modify Hytale
+# How to modify Hytale?
 
-## What's an Asset Pack
+## What's an Asset Pack?
 
-Hytales gameplay is driven by assets in the game that can be modified by creators. Asset Packs are our solution to let you override or add features to the base game with your own work. These can in the form of zip files of folders, which contain a custom set of assets. This is not the only way for a creator to change Hytale but this is the most accessible form.;
+Hytales gameplay is driven by assets in the game that can be modified by creators. Asset Packs are our solution to let you override or add features to the base game with your own work. These can be the form of zip files of folders, which contain a custom set of assets. This is not the only way for a creator to change Hytale but this is the most accessible form.;
 
-### How do I make an Asset Pack
+### How do I make an Asset Pack?
 
 <video controls className="my-6 aspect-video w-full rounded-lg border">
   <source src="https://cdn.internal.hytalemodding.dev/guides/official/how-to-asset-pack.mp4" type="video/mp4" />
@@ -48,7 +48,7 @@ An asset pack is typically a zip or folder, with a `manifest.json` inside. This
 }
 ```
 
-### Where are they stored
+### Where are they stored?
 
 Asset Packs are stored with other mods in the Mods folder.
 
@@ -76,7 +76,7 @@ C:\Users\<user>\AppData\Roaming\Hytale\UserData\Saves\New World 5\mods
 
 When you have Asset Packs or Mods installed, these will appear in the New World menu under the Options menu.;
 
-### How do I change an existing asset
+### How do I change an existing asset?
 
 <video controls className="my-6 aspect-video w-full rounded-lg border">
   <source src="https://cdn.internal.hytalemodding.dev/guides/official/how-to-asset.mp4" type="video/mp4" />
diff --git a/content/docs/hi-IN/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx b/content/docs/hi-IN/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx
index 44528376..24e628b5 100644
--- a/content/docs/hi-IN/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx
+++ b/content/docs/hi-IN/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx
@@ -106,7 +106,7 @@ If a BaseHeight is provided, the TopY and BottomY values are relative to the Bas
 
 Applies a Material Provider slot on a set of horizontal stripes of blocks of varying thickness and position. Below is an example image of basalt stripes into a stone cliff.
 
-{/* ![](https://540086904-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F7KAmBkOg6d13nZCkf9ku%2Fuploads%2FbcxO9LpArn8gPCaBwFg5%2Funknown.png?alt=media&token=1c72b67a-8253-4d03-8c64-1ad5f6830050) */}
+![Example of basalt stripes](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/basalt-stripes-example.png)
 
 #### Parameters:
 
diff --git a/content/docs/hi-IN/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx b/content/docs/hi-IN/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx
index 5e34acd4..a4418473 100644
--- a/content/docs/hi-IN/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx
+++ b/content/docs/hi-IN/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx
@@ -294,7 +294,7 @@ Combines all the positions into a single Positioins field.
 
 ---
 
-### SimpleHoritontal
+### SimpleHorizontal
 
 Keeps only the positions that are within the provided range.
 
diff --git a/content/docs/hi-IN/official-documentation/worldgen/worldgen-tutorial/README.mdx b/content/docs/hi-IN/official-documentation/worldgen/worldgen-tutorial/README.mdx
new file mode 100644
index 00000000..5f66d245
--- /dev/null
+++ b/content/docs/hi-IN/official-documentation/worldgen/worldgen-tutorial/README.mdx
@@ -0,0 +1,166 @@
+---
+title: How to edit and create Biomes
+description: Explores where world generation assets can be found and how to edit them.
+---
+
+### Where are the Assets
+
+World generation assets are kept in the HytaleGenerator directory within the assets.
+
+```
+/Server/HytaleGenerator/
+```
+
+<div className="flex flex-row rounded-lg border p-4">
+  <div className="flex-1/2 border-r pr-4">
+    ```
+    /Biomes
+    ```
+
+    Biome assets, with content configurations.
+  </div>
+
+  <div className="flex-1/2 pl-4">
+    ```
+    /WorldStructure
+    ```
+
+    Generator files that define which biomes spawn together.
+  </div>
+</div>
+
+<div className="flex flex-row rounded-lg border p-4">
+  <div className="flex-1/2 border-r pr-4">
+    ```
+    /Density
+    ```
+
+    Density assets that can be referenced by any other assets.
+  </div>
+
+  <div className="flex-1/2 pl-4">
+    ```
+    /Assignments
+    ```
+
+    Prop assets that can be referenced by any Biome assets.
+  </div>
+</div>
+
+***
+
+An example of this structure can be found bellow, packed in an asset pack with the instance configuration.
+
+[https://drive.google.com/file/d/1sIz_CluANIIe3n8vNiOi-4PQdeqCO0qY/view?usp=drive_link](https://drive.google.com/file/d/1sIz_CluANIIe3n8vNiOi-4PQdeqCO0qY/view?usp=drive_link)
+
+<Callout>
+  Ensure you place your asset pack in the correct directory, under Mods.
+</Callout>
+
+### How to visit our worlds
+
+https://drive.google.com/file/d/1BJurxyj-taE-PXWm04bk7Dl6X7ZHTH92/view?usp=sharing
+
+#### Requirements
+
+- You must be an **Operator** in the world.
+  - To do this, run <mark style="color:$danger;">`/op self`</mark>
+- You must be in **Creative mode**.
+  - Press the <mark style="color:$danger;">`O`</mark> key, O for Orange.&#x20;
+
+The generation assets define a set of generators but on their own you cannot visit these. Currently you require an Instance with a generator that will allow you to visit your work.
+
+```
+/Server/Instances/
+```
+
+Instances are separate worlds that players can join using the `/instances` command. Each instance has an `Instance.bson` configuration asset that specifies which generator to use, among other worldly settings.
+
+```json
+{
+  "WorldGen": {
+    "Type": "HytaleGenerator",
+    "WorldStructure": "Basic",
+    "playerSpawn" : {
+      "X" : 123,
+      "Y" : 480,
+      "Z" : 10000,
+      "Pitch" : 0,
+      "Yaw" : 0,
+      "Roll" : 0
+    }
+  }
+}
+```
+
+<Callout>
+  You can create custom instances for different world structures and biomes as you need them.
+</Callout>
+
+### How to edit Biomes
+
+<video>
+  <source src="https://cdn.internal.hytalemodding.dev/guides/official/How-to-edit-Biomes.mp4" type="video/mp4" />
+</video>
+
+We currently use the Hytale Node Editor when editing world generation assets. This can be accessed while in-game from the Content Creation menu when pressing B. The node editor is then found under the asset editor dropdown on the upper left.&#x20;
+
+![Node Editor 1](/assets/official-documentation/worldgen/worldgen-tutorial/biomes/node-editor-1.png)
+
+Once you have the Hytale Node Editor open, through the file menu you can open Biomes by navigating to the Biomes directory and selecting one from your pack.&#x20;
+
+```
+/Server/HytaleGenerator/Biomes/
+```
+
+### Biome Asset Structure
+
+Every Biome has a root Biome node, this node splits into 5 structures. This is covered briefly but more information on each field can be found on the World Generation Concepts page.
+
+![Node Editor 2](/assets/official-documentation/worldgen/worldgen-tutorial/biomes/node-editor-2.png)
+
+<Callout>
+  Each biome is for the most part self contained, meaning it has control over what appears with the biome. The only exception to this are Base Heights.
+</Callout>
+
+<Tabs>
+  <Tab value="Terrain">
+    Mathematical function nodes that calculate the physical shape of the Biome's terrain.
+  </Tab>
+
+  <Tab value="Materials">
+    Logical nodes that determine what materials (blocks) make up a Biome's terrain.
+  </Tab>
+
+  <Tab value="Props">
+    Function nodes that add objects like prefabs and decorations to the terrain.
+  </Tab>
+
+  <Tab value="Environments">
+    Logical nodes that determine the environment asset at a given coordinate within the biome. This asset determines things like weather, NPC spawns, and sounds.
+  </Tab>
+
+  <Tab value="Tints">
+    Logical function nodes that determine a colour code that can be used by certain blocks in the world. Typically this will be grasses and soils.
+  </Tab>
+</Tabs>
+
+### How to preview your work
+
+[https://drive.google.com/file/d/1mNcHn9LhFnWDF0DzWFH6_YllmKAUvUry/view?t=6](https://drive.google.com/file/d/1mNcHn9LhFnWDF0DzWFH6_YllmKAUvUry/view?t=6)
+
+Once you are in an Instance world with the Hytale Generator active you will only be able to see your work by generating new chunks. There are a few ways to do this.
+
+The viewport command selects an area around the Player that will live reload as you make changes to the generator.&#x20;
+
+```
+/viewport --radius 5 
+```
+
+You can also create a new world to show your changes.&#x20;
+
+```
+/instances spawn <instance> 
+```
+
+The last option is to simply fly south, new chunks will generate with the changes made.
diff --git a/content/docs/hi-IN/quick-start.mdx b/content/docs/hi-IN/quick-start.mdx
index 653644f4..249d803a 100644
--- a/content/docs/hi-IN/quick-start.mdx
+++ b/content/docs/hi-IN/quick-start.mdx
@@ -9,3 +9,8 @@ Welcome to the Hytale modding documentation! Here you'll find everything you nee
 * [Setting up your dev environment](./guides/plugin/setting-up-env)
 * [Entity Component System (ECS)](./guides/ecs/entity-component-system)
 * [Publishing your mod](./publishing)
+
+### Useful Links
+
+* [Kaupenjoe's Modding Videos](https://www.youtube.com/@ModdingByKaupenjoe)
+* [TroubleDEV's Modding Videos](https://www.youtube.com/@TroubleDEV)
diff --git a/content/docs/hi-IN/server/argtypes.mdx b/content/docs/hi-IN/server/argtypes.mdx
new file mode 100644
index 00000000..e54a442e
--- /dev/null
+++ b/content/docs/hi-IN/server/argtypes.mdx
@@ -0,0 +1,61 @@
+---
+title: ArgTypes
+description: Available ArgTypes
+icon: List
+full: true
+authors:
+  - name: Valeena
+---
+
+| Name                        | Target Class                           | Description                                                                                                                               |   |
+| :-------------------------- | :------------------------------------- | :---------------------------------------------------------------------------------------------------------------------------------------- | - |
+| Boolean                     | java.lang.Boolean                      | A 'true' or 'false' input                                                                                                                 |   |
+| Integer                     | java.lang.Integer                      | A whole number                                                                                                                            |   |
+| String                      | java.lang.String                       | Words, text, numbers, letters. To input more than one word at a time, you may need to wrap it with double quotes (`"my fancy sentence"`). |   |
+| Float                       | java.lang.Float                        | A floating-pointer number                                                                                                                 |   |
+| Double                      | java.lang.Double                       | A decimal number                                                                                                                          |   |
+| UUID                        | java.util.UUID                         | A UUID (Universally Unique IDentifier)                                                                                                    |   |
+| Player_UUID                 | java.util.UUID                         | A UUID or an online player username                                                                                                       |   |
+| Game_Profile_Lookup_Async   | ProfileServiceClient.PublicGameProfile | A player UUID or username. If not found locally, performs a remote lookup via the Profile Service.                                        |   |
+| Relative_Double_Coord       | Coord                                  | An x, y, or z coordinate as a decimal, optionally relative by specifying a tilde (~) in front of the number                               |   |
+| Relative_Int_Coord          | IntCoord                               | An x, y, or z coordinate as a whole number, optionally relative by specifying a tilde (~) in front of the number                          |   |
+| Relative_Integer            | RelativeInteger                        | A tilde to mark an integer relative to a base                                                                                             |   |
+| Relative_Float              | RelativeFloat                          | A tilde to mark a float relative to a base                                                                                                |   |
+| Player_Ref                  | PlayerRef                              | A UUID or an online player's username                                                                                                     |   |
+| World                       | World                                  | A world folder name                                                                                                                       |   |
+| Model_Asset                 | ModelAsset                             | A reference to an Asset of type Model                                                                                                     |   |
+| Weather_Asset               | Weather                                | A reference to an Asset of type Weather                                                                                                   |   |
+| Interaction_Asset           | Interaction                            | A reference to an Asset of type Interaction                                                                                               |   |
+| Root_Interaction_Asset      | RootInteraction                        | A reference to an Asset of type Root Interaction                                                                                          |   |
+| Effect_Asset                | EntityEffect                           | A refernece to an Asset of type EntityEffect                                                                                              |   |
+| Environment_Asset           | Environment                            | A reference to an Asset of type Environment                                                                                               |   |
+| Item_Asset                  | Item                                   | A reference to an Asset of type Item                                                                                                      |   |
+| Block_Type_Asset            | BlockType                              | A reference to an Asset of type BlockType                                                                                                 |   |
+| Particle_System             | ParticleSystem                         | A reference to an Asset of type ParticleSystem                                                                                            |   |
+| Hitbox_Collision_Config     | HitboxCollisionConfig                  | A reference to an Asset of type HitboxCollisionConfig                                                                                     |   |
+| Repulsion_Config            | RepulsionConfig                        | A reference to an Asset of type RepulsionConfig                                                                                           |   |
+| Sound_Event_Asset           | SoundEvent                             | A reference to an Asset of type SoundEvent                                                                                                |   |
+| Ambiance_Fx_Asset           | AmbianceFX                             | A reference to an Asset of type AmbianceFX                                                                                                |   |
+| Sound_Category              | SoundCategory                          | A sound category (sfx, music, ambient, ui)                                                                                                |   |
+| Entity_ID                   | `ArgWrapper<EntityWrappedArg, UUID>`   | A UUID representing an entity id                                                                                                          |   |
+| Integer_Comparison_Operator | IntegerComparisonOperator              | A mathematical sign for integer comparison                                                                                                |   |
+| Integer_Operation           | IntegerOperation                       | A mathematical sign for performing an operation                                                                                           |   |
+| Int_Range                   | `Pair<Integer, Integer>`               | Two integers representing a minimum and maximum of a range                                                                                |   |
+| Relative_Int_Range          | RelativeIntRange                       | Two integers representing a minimum and maximum of a range                                                                                |   |
+| Vector2I                    | Vector2i                               | Two integers, generally corresponding to x/z axis                                                                                         |   |
+| Vector3I                    | Vector3i                               | Three integers, generally corresponding to x/y/z axis                                                                                     |   |
+| Relative_Vector3I           | RelativeVector3i                       | Three optionally relative integers, generally corresponding to x/y/z axis                                                                 |   |
+| Relative_Block_Position     | RelativeIntPosition                    | A position with three integer coordinates, representing a block's location in world space.                                                |   |
+| Relative_Position           | Relative                               | A position with three decimal coordinates, representing a location in world space.                                                        |   |
+| Relative_Chunk_Position     | RealtiveChunkPosition                  | A position with two integer coordinates (x, z), representing a chunk's location.                                                          |   |
+| Rotation                    | Vector3f                               | A rotation with three coordinates, representing the pitch, yaw, and roll respectively                                                     |   |
+| Block_Type_Key              | String                                 | A block type                                                                                                                              |   |
+| Block_ID                    | Integer                                | A block type, converted to an int id                                                                                                      |   |
+| Color                       | Integer                                | A color value in hex format, hex integer, or decimal integer                                                                              |   |
+| Weighted_Block_Type         | `Pair<Integer, String>`                | A weight corresponding to a blocktype                                                                                                     |   |
+| Weighted_Block_Entry        | String                                 | A block with optional weight prefix                                                                                                       |   |
+| Block_Pattern               | BlockPattern                           | A list of blocks with optional weights                                                                                                    |   |
+| Individual_Block_Mask       | BlockMask                              | Create a block mask using symbols and block names                                                                                         |   |
+| Block_Mask                  | BlockMask                              | A tick rate value (e.g., 30tps, 33ms, or 30)                                                                                              |   |
+| Tick_Rate                   | Integer                                | A list of block masks that combine together                                                                                               |   |
+| Game_Mode                   | GameMode                               | GameMode                                                                                                                                  |   |
diff --git a/content/docs/hi-IN/server/interaction-reference.mdx b/content/docs/hi-IN/server/interaction-reference.mdx
new file mode 100644
index 00000000..6c0d01b3
--- /dev/null
+++ b/content/docs/hi-IN/server/interaction-reference.mdx
@@ -0,0 +1,1586 @@
+---
+title: Interactions
+description: A list of most Interaction types provided by Hypixel, along with the meaning of their fields, and how they fit together.
+icon: List
+authors:
+  - name: Stephen Baynham
+    url: https://github.com/cannibalvox
+---
+
+### The Interaction Base Type
+
+All interactions of every type below are inherited from Interaction and have these fields.
+
+**Interaction Fields**
+
+| Field Name                | Type                                                                 | Required? | Notes                                                                                                                                                                                                                       |
+| ------------------------- | -------------------------------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| ViewDistance              | `Double`<br />(Default: 96.0)                                        | **No**    | Distance in blocks at which other players can see the effects from this interaction.                                                                                                                                        |
+| Effects                   | `InteractionEffects`                                                 | **No**    | Sound, animations, and particle effects that should trigger when this interaction begins executing.                                                                                                                         |
+| HorizontalSpeedMultiplier | `Float`<br />(Default: 1.0)                                          | **No**    | Multiplier applied to the User entity's movement speed while this interaction is executing                                                                                                                                  |
+| RunTime                   | `Float`                                                              | **No**    | If provided, this interaction will continue executing for at least this long before the interaction chain moves onto the next interaction.                                                                                  |
+| CancelOnItemChange        | `Boolean`<br />(Default: true)                                       | **No**    | If true, this interaction will be cancelled if the User entity's held item changes during execution. This can happen either due to the selected hotbar slot changing or the contents of the item's inventory slot changing. |
+| Rules                     | `InteractionRules`                                                   | **Yes**   | If provided, adds additional limitations and cancellation conditions to this interaction.                                                                                                                                   |
+| Settings                  | `Map`<br />(Key Type: `GameMode`, Value Type: `InteractionSettings`) | **No**    | If provided, adds additional per-GameMode settings to the interaction.                                                                                                                                                      |
+| Camera                    | `InteractionCameraSettings`                                          | **No**    | Arrays of camera motion keyframes for cutscenes and reveals.                                                                                                                                                                |
+
+**GameMode Values**
+
+- `Creative`: The game is currently in Creative Mode
+- `Adventure`: The game is currently in Adventure Mode
+
+**InteractionEffects Fields**
+
+| Field Name               | Type                                              | Required? | Notes                                                                                                                                                 |
+| ------------------------ | ------------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Particles                | `Array`<br />(Element Type: `ModelParticle`)      | **No**    | Particle systems to activate when this interaction begins if the player is in third-person mode.                                                      |
+| FirstPersonParticles     | `Array`<br />(Element Type: `ModelParticle`)      | **No**    | Particle systems to activate when this interaction begins if the player is in first-person mode.                                                      |
+| WorldSoundEventId        | `Asset`<br />(Asset Type: `SoundEvent`)           | **No**    | A sound to play in the world at the User entity's location when this interaction begins.<br />**The SoundEvent must be single-channel (mono) sound.** |
+| LocalSoundEventId        | `Asset`<br />(Asset Type: `SoundEvent`)           | **No**    | A 2D sound to play for the User entity when this interaction begins. Ignored if the User entity is not a player.                                      |
+| Trails                   | `Array`<br />(Element Type: `ModelTrail`)         | **No**    | Trail effects to activate on the User entity when this interaction begins.                                                                            |
+| WaitForAnimationToFinish | `Boolean`<br />(Default: false)                   | **No**    | If true, this interaction will continue executing for at least the length of any animations in this InteractionEffects object.                        |
+| ItemPlayerAnimationsId   | `Asset`<br />(Asset Type: `ItemPlayerAnimations`) | **No**    | If provided, the User entity will use this ItemPlayerAnimations set while this interaction is executing.                                              |
+| ItemAnimationId          | `String`                                          | **No**    | Id of an animation to trigger when this interaction begins executing.<br />**This animation id is not validated on server start.**                    |
+| ClearAnimationOnFinish   | `Boolean`<br />(Default: false)                   | **No**    | If true, animations triggered by this interaction will be halted when the interaction completes.                                                      |
+| ClearSoundEventOnFinish  | `Boolean`<br />(Default: false)                   | **No**    | If true, sounds triggered by this interaction will be halted when the interaction completes.                                                          |
+| CameraEffect             | `Asset`<br />(Asset Type: `CameraEffect` )        | **No**    | If provided, the CameraEffect will be applied while this interaction is executing.                                                                    |
+| MovementEffects          | `MovementEffects`                                 | **No**    | If provided, apply the movement effects to the User entity while this interaction is executing.                                                       |
+| StartDelay               | `Float`<br />(Default: 0.0f)                      | **No**    | The interaction will wait this many seconds before triggering the effects in this object.                                                             |
+
+**InteractionRules Fields**
+
+| Field Name          | Type                                                                                                | Required? | Notes                                                                                                                                                                                                                                     |
+| ------------------- | --------------------------------------------------------------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| BlockedBy           | `Array`<br />(Element Type: `InteractionType`)<br />(Default: Based on the chain's InteractionType) | **No**    | If provided, this RootInteraction cannot be executed while interaction chains of the provided types are executing.<br />**This field only functions for rules attached to a RootInteraction. It has no effect on an Interaction.**        |
+| Blocking            | `Array`<br />(Element Type: `InteractionType`)                                                      | **No**    | If provided, interaction chains with the specified InteractionTypes cannot be executed while this interaction is executing.                                                                                                               |
+| InterruptedBy       | `Array`<br />(Element Type: `InteractionType`)                                                      | **No**    | If provided, interaction chains with the specified InteractionTypes will cancel this interaction chain when they execute.<br />**This field only functions for rules attached to a RootInteraction. It has no effect on an Interaction.** |
+| Interrupting        | `Array`<br />(Element Type: `InteractionType`)                                                      | **No**    | If provided, interaction chains with the specified InteractionTypes will be canceled when this interaction begins.                                                                                                                        |
+| BlockedByBypass     | `String`                                                                                            | **No**    | If provided, this RootInteraction cannot be blocked by interaction chains whose RootInteraction has this value as an asset tag.                                                                                                           |
+| BlockingBypass      | `String`                                                                                            | **No**    | If provided, this interaction will not block RootInteractions that have the this value as an asset tag.                                                                                                                                   |
+| InterruptedByBypass | `String`                                                                                            | **No**    | If provided, this RootInteraction cannot be canceled by RootInteractions that have this value as an asset tag.                                                                                                                            |
+| InterruptingBypass  | `String`                                                                                            | **No**    | If provided, this interaction will not cancel interaction chains whose RootInteraction has this value as an asset tag.                                                                                                                    |
+
+**InteractionType Values**
+
+- `Primary`
+- `Secondary`
+- `Ability1`
+- `Ability2`
+- `Ability3`
+- `Use`
+- `Pick`
+- `Pickup`
+- `CollisionEnter`
+- `CollisionLeave`
+- `Collision`
+- `EntityStatEffect`
+- `SwapTo`
+- `SwapFrom`
+- `Death`
+- `Wielding`
+- `ProjectileSpawn`
+- `ProjectileHit`
+- `ProjectileMiss`
+- `ProjectileBounce`
+- `Held`
+- `HeldOffhand`
+- `Equipped`
+- `Dodge`
+- `GameModeSwap`
+
+**InteractionSettings Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                        |
+| ---------------- | ------------------------------- | --------- | -------------------------------------------------------------------------------------------- |
+| AllowSkipOnClick | `Boolean`<br />(Default: false) | **No**    | If true, the user will be able to skip this interaction by clicking shortly after it starts. |
+
+**InteractionCameraSettings Fields**
+
+| Field Name  | Type                                             | Required? | Notes                                                                                                                                                           |
+| ----------- | ------------------------------------------------ | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| FirstPerson | `Array`<br />(Element Type: `InteractionCamera`) | **No**    | A list of camera keyframes to be played if the player is in first-person.<br />**The time of each keyframe must be after the keyframe before it in the array.** |
+| ThirdPerson | `Array`<br />(Element Type: `InteractionCamera`) | **No**    | A list of camera keyframes to be played if the player is in third-person.<br />**The time of each keyframe must be after the keyframe before it in the array.** |
+
+**InteractionCamera Fields**
+
+| Field Name | Type                         | Required? | Notes                                                                                                                                       |
+| ---------- | ---------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------- |
+| Time       | `Float`<br />(Default: 0.1f) | **No**    | How long after the interaction begins executing that the camera should arrive at this keyframe.<br />**Cannot be less than or equal to 0.** |
+| Position   | `Vector3`                    | **Yes**   | Where the camera should be located when it arrives at this keyframe.                                                                        |
+| Rotation   | `Direction`                  | **Yes**   | Where the camera should be pointing when it arrives at this keyframe.                                                                       |
+
+### SimpleInteraction
+
+Most interaction types below are inherited from SimpleInteraction and have these
+fields.  If a type does not have these fields, the documentation will mention it.
+
+The purpose of SimpleInteraction is to facilitate Interaction chaining by taking different paths
+based on whether the Interaction succeeded or failed.  The circumstances under which
+a given Interaction fails are generally type-specific (and described in the documentation
+below), but all interactions will be marked failed if they are cancelled via one of the
+many, many mechanisms for doing so.
+
+It is valid to create an interaction asset of type "Simple", which can be valuable when you want to use the
+interaction fields with no additional functionality.
+
+**SimpleInteraction Fields**
+
+| Field Name | Type                                     | Required? | Notes                                                                                          |
+| ---------- | ---------------------------------------- | --------- | ---------------------------------------------------------------------------------------------- |
+| Next       | `Asset`<br />(Asset Type: `Interaction`) | **No**    | After this Interaction has finished, "Next" will be executed if this Interaction did not fail. |
+| Failed     | `Asset`<br />(Asset Type: `Interaction`) | **No**    | After this Interaction has finished, "Failed" will be executed if this Interaction failed.     |
+
+## Flow Control
+
+These are interaction types used to control the flow of an interaction chain and allow interactions
+to be composed into more complex behaviors.  These interaction types generally do not pertain to
+the game and instead pertain to the interaction system itself.
+
+### Condition
+
+This interaction will fail if one of the fields is provided but does not match the current state.
+
+**Condition Fields**
+
+| Field Name       | Type       | Required? | Notes                                                                                                                                                                                    |
+| ---------------- | ---------- | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| RequiredGameMode | `GameMode` | **No**    | If provided, the interaction will fail if the current GameMode does not match the provided value.                                                                                        |
+| Jumping          | `Boolean`  | **No**    | If provided, the interaction will fail if the player's Jumping state does not match the provided value. (i.e. if True, the player must be jumping, if False, the player must not be)     |
+| Swimming         | `Boolean`  | **No**    | If provided, the interaction will fail if the player's Swimming state does not match the provided value. (i.e. if True, the player must be swimming, if False, the player must not be)   |
+| Crouching        | `Boolean`  | **No**    | If provided, the interaction will fail if the player's Crouching state does not match the provided value. (i.e. if True, the player must be crouching, if False, the player must not be) |
+| Running          | `Boolean`  | **No**    | If provided, the interaction will fail if the player's Running state does not match the provided value. (i.e. if True, the player must be running, if False, the player must not be)     |
+| Flying           | `Boolean`  | **No**    | If provided, the interaction will fail if the player's Flying state does not match the provided value. (i.e. if True, the player must be flying, if False, the player must not be)       |
+
+**GameMode Values**
+
+- `Creative`: The game is currently in Creative Mode
+- `Adventure`: The game is currently in Adventure Mode
+
+### FirstClick
+
+This interaction does not inherit from SimpleInteraction and therefore has no Next or Failed fields.
+
+This interaction has two fields that each contain a reference to an Interaction: Click and Hold.  If the root interaction
+of the chain was initiated by a client button/key press (or simulated NPC input) and the input was a tap, then
+the Click interaction is run. if it was a longer press, then the Hold interaction is run.
+
+As a minor implementation detail, this interaction is internally marked as failed when the Hold path is followed.
+This generally shouldn't matter.  If the interaction was not initiated by a key press at all, the Click path will be followed,
+but it seems risky to rely on that behavior.
+
+**FirstClick Fields**
+
+| Field Name | Type                                     | Required? | Notes                                                                                                                                                    |
+| ---------- | ---------------------------------------- | --------- | -------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Click      | `Asset`<br />(Asset Type: `Interaction`) | **No**    | If provided and the root interaction of the chain was initiated by button/key press, this interaction is executed next if the press was a quick tap.     |
+| Hold       | `Asset`<br />(Asset Type: `Interaction`) | **No**    | If provided and the root interaction of the chain was initiated by a button/key press, this interaction is executed next if the press was a longer hold. |
+
+### Interrupt
+
+This interaction can be used to cancel one or more running interaction chains on an entity and **all forked interaction
+chains those chains have spawned that are still currently running**.  All interaction chains canceled in this manner will be marked as
+Failed, which may have additional implications if the canceled chains are themselves forked from
+other chains that are still running.
+
+**Interrupt Fields**
+
+| Field Name     | Type                                           | Required? | Notes                                                                                                                                                                                               |
+| -------------- | ---------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Entity         | `InteractionTarget`<br />(Default: User)       | **Yes**   | The entity that is the owner of the target interaction chains.  This field can indicate the Owner, User, or Target of this interaction chain.                                                       |
+| InterruptTypes | `Array`<br />(Element Type: `InteractionType`) | **No**    | A set of InteractionTypes that are to be interrupted. Only interactions of these types are affected. If null, all types will be interrupted.<br />**(Note: An empty set will interrupt NO TYPES.)** |
+| RequiredTag    | `String`                                       | **No**    | An asset tag that, if provided, the RootInteraction of the interaction chain must have in order to be canceled.                                                                                     |
+| ExcludedTag    | `String`                                       | **No**    | An asset tag that, if provided, the RootInteraction of the interaction chain must not have in order to be canceled.                                                                                 |
+
+**InteractionTarget Values**
+
+- `User` - The user of this interaction chain. The entity whose actions caused this interaction chain to be executed. This is usually the same as the Owner.
+- `Owner` - The owner of this interaction chain. The entity upon whom this interaction chain is executing.
+- `Target` - The entity target of this interaction chain, if any.  This value is mutable (and can therefore come from many places) but most commonly, it is an entity the User was targeting when this interaction chain began executing.
+
+**InteractionType Values**
+
+- `Primary`
+- `Secondary`
+- `Ability1`
+- `Ability2`
+- `Ability3`
+- `Use`
+- `Pick`
+- `Pickup`
+- `CollisionEnter`
+- `CollisionLeave`
+- `Collision`
+- `EntityStatEffect`
+- `SwapTo`
+- `SwapFrom`
+- `Death`
+- `Wielding`
+- `ProjectileSpawn`
+- `ProjectileHit`
+- `ProjectileMiss`
+- `ProjectileBounce`
+- `Held`
+- `HeldOffhand`
+- `Equipped`
+- `Dodge`
+- `GameModeSwap`
+
+### Parallel
+
+This interaction does not inherit from SimpleInteraction and therefore has no Next or Failed fields.
+
+This interaction has a field `Interactions` that is an array of RootInteraction assets. The list must contain at least
+two RootInteractions.  This interaction will fork all of its children except for the first into their
+own interaction chains and immediately complete. After this interaction completes, this interaction chain will
+execute the first RootInteraction in the `Interactions` list.
+
+This interaction does not have any failure conditions and is indifferent to the fate of the forked interaction chains.
+
+**Parallel Fields**
+
+| Field Name   | Type                                                | Required? | Notes                                                         |
+| ------------ | --------------------------------------------------- | --------- | ------------------------------------------------------------- |
+| Interactions | `AssetArray`<br />(Element Type: `RootInteraction`) | **Yes**   | An array of RootInteractions that will be forked or executed. |
+
+### Repeat
+
+This interaction has a field `ForkInteractions` that is an asset of type RootInteraction. This interaction will fork that
+RootInteraction into its own interaction chain and then wait for it to complete. If the RootInteraction fails, this
+interaction will complete immediately and be marked failed. Otherwise, the RootInteraction will be forked and run again,
+up to a specified total number of times.
+
+**Repeat Fields**
+
+| Field Name       | Type                                                                                   | Required? | Notes                                                                                                                                                                                                              |
+| ---------------- | -------------------------------------------------------------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| ForkInteractions | `Asset`<br />(Asset Type: `RootInteraction`)                                           | **Yes**   | A RootInteraction that will be forked.                                                                                                                                                                             |
+| Repeat           | `Integer`<br />(Default: 1)<br />**Must be -1 or a positive integer. 0 is not valid.** | **No**    | The total number of times to fork ForkInteractions. If -1 is provided, ForkInteractions will continue being forked and executed indefinitely, until this interaction is cancelled or until ForkInteractions fails. |
+
+### Replace
+
+This interaction does not inherit from SimpleInteraction and therefore has no Next or Failed fields.
+
+This interaction uses the InteractionVars system that is avaiable for items. InteractionVars are RootInteractions that
+can be attached to an Item asset with a name.
+
+This interaction specifies a var name, and if this interaction chain was executed through
+an item and that item has an InteractionVar of the same name, then this interaction will immediately execute
+the RootInteraction on the var.  Otherwise, it will execute the default RootInteraction specified in this interaction.
+If no default is specified, then this interaction will be marked as failed.
+
+**Replace Fields**
+
+| Field Name   | Type                                         | Required? | Notes                                                                                                                                                                                                           |
+| ------------ | -------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Var          | `String`                                     | **Yes**   | The name of the InteractionVar to execute.                                                                                                                                                                      |
+| DefaultValue | `Asset`<br />(Asset Type: `RootInteraction`) | **No**    | The RootInteraction to execute if the owning item does not have an InteractionVar by the specified name. If not provided, the interaction will be marked as failed instead.                                     |
+| DefaultOk    | `Boolean`<br />(Default: false)              | **No**    | If false, then an angry message will be printed to the server logs if the owning item does not have an InteractionVar by the specified name.  The functioning of this interaction will be otherwise unaffected. |
+
+### RunRootInteraction
+
+This interaction immediately executes the provided RootInteraction as part of this interaction chain. This interaction
+does not have any failure conditions.
+
+**RunRootInteraction Fields**
+
+| Field Name      | Type                                         | Required? | Notes                           |
+| --------------- | -------------------------------------------- | --------- | ------------------------------- |
+| RootInteraction | `Asset`<br />(Asset Type: `RootInteraction`) | **Yes**   | The RootInteraction to execute. |
+
+### Selector
+
+This interaction will execute a Selector to find entities and/or blocks (depending on the Selector) and fork off an
+interaction chain for each located entity or block. This interaction will not wait for those interaction chains
+to complete and is indifferent to their fate. The forked interaction chains will use the located entity/block as
+their target entity/target block. Each entity or block will only fork one interaction chain over the life of this
+interaction.  The Selector is guaranteed to run once for each execution of this interaction, but some Selectors
+are intended to be run over a period of time and sweep across an area to locate targets. In order to use those Selectors
+properly, you will need to extend the execution time of this interaction using `RunTime` or `WaitForAnimationToFinish`.
+The Selector will be executed repeatedly over the lifetime of the interaction.
+
+If the Selector is configured to locate entities, you can add additional sets of entity matching rules. If a located entity
+matches one of the rules, the matching RootInteraction will be forked instead of the standard `HitEntity` RootInteraction.
+
+Entities located by the Selector will be ignored if they do not have a NetworkId, if they are dead, or if they are invulnerable.
+The only exception to this rule is that players in Creative Mode that are marked to receive hits will not be ignored.
+
+This interaction's failure conditions are configurable via the `FailOn` field. You can configure this interaction to never
+fail, to fail if the Selector does not locate any blocks before this interaction finishes executing, to fail if the
+Selector does not locate any entities before this interaction finishes executing, or to fail in either case.
+
+**Selector Fields**
+
+| Field Name     | Type                                         | Required? | Notes                                                                                                                                                                                                                                     |
+| -------------- | -------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Selector       | `Selector`                                   | **Yes**   | The Selector is executed at least once and may be executed repeatedly to locate blocks and/or entities in an area.                                                                                                                        |
+| HitEntity      | `Asset`<br />(Asset Type: `RootInteraction`) | **No**    | If included and the `Selector` locates an entity that does not match any `HitEntityRules`, this RootInteraction will be forked into a new interaction chain with the located entity as the target entity.                                 |
+| HitEntityRules | `Array`<br />(Element Type: `HitEntity`)     | **No**    | If included, these rules will be matched against any entity located by the `Selector`. If an entity matches a set of rules, the RootInteraction associated with the rules will be forked instead of the standard `HitEntity` interaction. |
+| HitBlock       | `Asset`<br />(Asset Type: `RootInteraction`) | **No**    | If included and the `Selector` locates a block, this RootInteraction will be forked into a new interaction chain with the located block as the block target.                                                                              |
+| FailOn         | `FailOnType`<br />(Default: `Neither`)       | **No**    | Defines under what circumstances this interaction will fail.  It can be marked to fail when it completes without locating any blocks, it can be marked to fail when it completes without locating any entities, both, or neither.         |
+| IgnoreOwner    | `Boolean`<br />(Default: true)               | **No**    | If true, the Selector will not locate the User entity of this interaction.                                                                                                                                                                |
+
+**HitEntity Fields**
+
+| Field Name | Type                                         | Required? | Notes                                                                                                 |
+| ---------- | -------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------- |
+| Matchers   | `Array`<br />(Element Type: `EntityMatcher`) | **Yes**   | A set of rules that an entity must match. An entity must successful match all rules to be considered. |
+| Next       | `Asset`<br />(Asset Type: `RootInteraction`) | **Yes**   | The RootInteraction to fork if an entity matches all rules.                                           |
+
+**EntityMatcher Fields**
+
+| Field Name | Type                            | Required? | Notes                                                                                                     |
+| ---------- | ------------------------------- | --------- | --------------------------------------------------------------------------------------------------------- |
+| Type       | `String`                        | **Yes**   | If provided, specifies a type of EntityMatcher to use. Each matcher type may come with additional fields. |
+| Invert     | `Boolean`<br />(Default: false) | **No**    | If true, an entity must fail this rule for it to be marked as succeeded.                                  |
+
+**EntityMatcher Type: Player**
+
+This EntityMatcher will succesfully match the entity only if they are a player.
+
+**EntityMatcher Type: Vulnerable**
+
+This Entitymatcher will successfully match the entity only if they are not marked as invulnerable.
+
+**FailOnType Values**
+
+- `Neither`
+- `Entity`
+- `Block`
+- `Either`
+
+### Serial
+
+This interaction does not inherit from SimpleInteraction and therefore has no Next or Failed fields.
+
+This interaction has a field `Interactions` which is a list of Interaction assets. This interaction immediately
+completes and the interaction chain continues by executing the interactions in the list one at a time. This
+interaction does not have any failure conditions.
+
+**Serial Fields**
+
+| Field Name   | Type                                            | Required? | Notes                                      |
+| ------------ | ----------------------------------------------- | --------- | ------------------------------------------ |
+| Interactions | `AssetArray`<br />(Element Type: `Interaction`) | **Yes**   | An array of Interaction assets to execute. |
+
+## Cooldowns
+
+RootInteractions interface with a complex cooldown system that can be used for a variety of purposes. Aside from simply
+adding an important aspect of resource management to your game design, cooldowns can be used to ensure that click-activated
+interaction chains don't repeatedly spam if the player holds down the input.
+
+By default, every RootInteraction has a cooldown timer that is keyed to the RootInteraction name, and by default, it
+will launch a cooldown of 0.35 seconds when activated by client input.  Otherwise, no cooldown will be activated.  However,
+by configuring your RootInteraction, you can change the key for the cooldown (so that multiple RootInteractions can share
+a single cooldown), set the cooldown timer to whatever you like, and configure multiple charges that can build up over time
+to allow the entity to activate the RootInteraction multiple times before being forced to pause.
+
+One important concept to keep in mind is the difference between **cooldown** and **charge time**.  The cooldown, if any,
+is activated each time a RootInteraction triggers, even if the player has more available charges. If the RootInteraction
+is configured to use charges, then they will gradually build up over time. In order for a RootInteraction to be activated,
+the cooldown (if any) must be expired, and the RootInteraction must have at least one charge (if it has been
+configured to use charges).
+
+Bear in mind that the entire Cooldown configuration is shared between different RootInteractions with the same cooldown id.
+If you activate an ability with 5 charges and a short cooldown and then another ability with a much longer cooldown and no
+charges, the second ability will use the cooldown properties of the first ability until/unless the first ability finishes
+charging and is cleared from the system.  You should generally only have multiple RootInteractions share a cooldown id
+if they have the same configuration.
+
+The interactions below interact with the cooldown system to allow you to manipulate cooldowns via the interaction system. By
+using these interactions, you can have several interaction chains with different cooldown configurations share cooldowns
+that are checked and activated as part of the interaction chain itself, or have some components of an interaction change
+use a second cooldown separate from the main one.
+
+### CooldownCondition
+
+**CooldownCondition Fields**
+
+This interaction will fail if the specified cooldown id is on cooldown for the User entity.  This interaction will only
+function for players- the interaction will always succeed for NPCs.  In order for this interaction to succeed, the
+cooldown, if any, must have expired and at least one charge, if any, must have filled.
+
+| Field Name | Type     | Required? | Notes                     |
+| ---------- | -------- | --------- | ------------------------- |
+| Id         | `String` | **Yes**   | The cooldown id to check. |
+
+### IncrementCooldown
+
+**IncrementCooldown Fields**
+
+This interaction will modify a cooldown that is currently active on the User entity, allowing charges and remaining
+cooldown to be modified.
+Despite its name, this interaction can be used to reduce a cooldown as well as increase it. If the cooldown is not
+currently active, this interaction will have no effect. The interaction has no special failure conditions.
+
+| Field Name        | Type                        | Required? | Notes                                                                                                                                                                                                                                                                                     |
+| ----------------- | --------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Id                | `String`                    | **No**    | If provided, the cooldown id of the cooldown to be manipulated. If not provided, the cooldown id of the current chain's RootInteraction will be used.                                                                                                                                     |
+| Time              | `Float`<br />(Default: 0.0) | **No**    | The amount to increase the remaining cooldown by. Can be negative. The remaining cooldown time will not be reduced below zero or increased above the maximum cooldown time.                                                                                                               |
+| ChargeTime        | `Float`<br />(Default: 0.0) | **No**    | The amount to increase the remaining time until the next charge is filled by. Can be negative. The remaining charge time cannot be reduced below zero or increased above the maximum cooldown time. **This will not work on abilities that have a maximum of 1 charge, for some reason.** |
+| Charge            | `Integer`<br />(Default: 0) | **No**    | The amount to increase the number of charges by. Can be negative. The number of charges cannot be reduced below 0 or increased above the maximum.                                                                                                                                         |
+| InterruptRecharge | `Boolean`(Default: false)   | **No**    | If true and `Charge` is not 0, will reset the remaining time to the next charge to the maximum value after changing the charge count.                                                                                                                                                     |
+
+### ResetCooldown
+
+This interaction will trigger a cooldown on the User entity with a specified configuration. The charges will be refilled
+but the cooldown will be immediately triggered.  The mechanisms for deciding on the configuration are a little bit complicated.
+You may specify a cooldown configuration via the `Cooldown` field. If you do not include an `Id` field, then the
+interaction chain's RootInteraction will be used for any field not specified in the configuration. If there is an active
+cooldown under the specified `Id` (or under the RootInteraction's cooldown id if none is specified) then the fields
+from that active cooldown will overwrite data in the RootInteraction's cooldown, but not data in your `Cooldown` field.
+
+**ResetCooldown Fields**
+
+| Field Name | Type                  | Required? | Notes                                                        |
+| ---------- | --------------------- | --------- | ------------------------------------------------------------ |
+| Cooldown   | `InteractionCooldown` | **No**    | A cooldown configuration to use for the new, reset cooldown. |
+
+**InteractionCooldown Fields**
+
+| Field Name        | Type                                 | Required? | Notes                                                                                                                                                                                                 |
+| ----------------- | ------------------------------------ | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Id                | `String`                             | **No**    | The cooldown id to use for this cooldown. If not provided, the RootInteraction's cooldown id will be used, if any.                                                                                    |
+| Cooldown          | `Float`<br />(Default: 0.0)          | **No**    | The duration of the cooldown, in seconds.                                                                                                                                                             |
+| Charges           | `Array`<br />(Element Type: `Float`) | **No**    | If provided, a list of how many charges this cooldown can build, and how long each charge takes to build, in seconds.                                                                                 |
+| InterruptRecharge | `Boolean`<br />(Default: false)      | **No**    | If true, the charge time will be reset when the number of charges changes.                                                                                                                            |
+| ClickBypass       | `Boolean`<br />(Default: false)      | **No**    | If true, RootInteractions keyed to this cooldown can still be activated when it is on cooldown provided that the RootInteraction was triggered by a distinct key or mouse button press on the client. |
+
+### TriggerCooldown
+
+This interaction is similar to ResetCooldown, except instead of refilling the cooldown's charges, one charge will be deducted
+as normal.
+
+**TriggerCooldown Fields**
+
+| Field Name | Type                  | Required? | Notes                                                        |
+| ---------- | --------------------- | --------- | ------------------------------------------------------------ |
+| Cooldown   | `InteractionCooldown` | **No**    | A cooldown configuration to use for the new, reset cooldown. |
+
+**InteractionCooldown Fields**
+
+| Field Name        | Type                                 | Required? | Notes                                                                                                                                                                                                 |
+| ----------------- | ------------------------------------ | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Id                | `String`                             | **No**    | The cooldown id to use for this cooldown. If not provided, the RootInteraction's cooldown id will be used, if any.                                                                                    |
+| Cooldown          | `Float`<br />(Default: 0.0)          | **No**    | The duration of the cooldown, in seconds.                                                                                                                                                             |
+| Charges           | `Array`<br />(Element Type: `Float`) | **No**    | If provided, a list of how many charges this cooldown can build, and how long each charge takes to build, in seconds.                                                                                 |
+| InterruptRecharge | `Boolean`<br />(Default: false)      | **No**    | If true, the charge time will be reset when the number of charges changes.                                                                                                                            |
+| ClickBypass       | `Boolean`<br />(Default: false)      | **No**    | If true, RootInteractions keyed to this cooldown can still be activated when it is on cooldown provided that the RootInteraction was triggered by a distinct key or mouse button press on the client. |
+
+## Combo Chains
+
+Hytale additionally comes with a rich "combo chaining" system, which allows several inputs in a row to result in different
+attacks and special moves.  Rather than being attached to the RootInteraction like the cooldown system, these are
+primarily driven by the `Chaining` interaction.
+
+### Chaining
+
+This interaction does not inherit from SimpleInteraction and therefore has no Failed field. Its Next field works differently
+from most interaction types.
+
+Chaining is a type of flow control interaction- each time a Chaining interaction with the same `ChainId` is called, a single
+interaction in the `Next` list is chosen and the others are ignored. The first time the `ChainId` is used, the first
+interaction in the list is chosen, the next time the second, etc. Once the end of the list is reached, the first
+interaction will be chosen again.
+
+Bear in mind: the progress through the Next list is based on the **ChainId**, not the interaction!  That means that two
+different Chaining interactions can share a single combo chain. You could have a pair of daggers that attacks with
+the left when the left mouse button is clicked and with the right when the right mouse button is clicked.  You could give
+both interaction chains a Chaining interaction with the same `ChainId` and three `Next` entries that do a light-light-heavy
+combo.  Each specific hit would occur with either the left or the right knife based on which button you clicked, but
+the combo would be otherwise identical regardless of which you chose.
+
+The Chaining interaction also has a concept called "flags".  It is possible to attach named flags to a `ChainId` by using
+the ChainFlag interaction.  Then, you specify the flag name in Chaining's `Flags` field. If a Flag is active when the
+Chaining interaction is run, the Flag's interaction will be run instead of the appropriate interaction in `Next`.
+Bear in mind: the entity's progress through the `Next` list still advances, the resulting `Next` interaction is just not
+run.  Only one flag can be active at a time.
+
+Lastly, it is possible to cancel the entity's progress through the combo chain and reset them to the first interaction in
+the list. This can be done with the CancelChain interaction, but it will also happen automatically if the player does
+not trigger an interaction with the ChainId for the specified ChainingAllowance.  When either of these happen, all flags will be
+canceled as well.
+
+All of these effects are triggered on the User entity only. Non-players can use the chaining system, but Flags do not currently
+work for non-players.  This interaction has no special failure conditions.
+
+**Chaining Fields**
+
+| Field Name        | Type                                                       | Required? | Notes                                                                                                                                                                                                                       |
+| ----------------- | ---------------------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| ChainId           | `String`                                                   | **No**    | If provided, acts as a key that multiple Chaining interactions can use to share combo chain progress and flags. If not provided, a unique ChainId will be generated for this interaction.                                   |
+| ChainingAllowance | `Double`<br />(Default: 0.0)                               | **No**    | If, at the time this interaction is triggered, it has been this long in seconds since the last time a Chaining interaction with the same ChainId was executed, all state for this ChainId will be cleared before execution. |
+| Next              | `AssetArray`<br />(Element Type: `Interaction`)            | **Yes**   | A list of interactions to cycle between each time this interaction is run.                                                                                                                                                  |
+| Flags             | `Map`<br />(Key Type: `String`, Value Type: `Interaction`) | **No**    | A map of flag names to interactions to run if the flag is active when this interaction executes.                                                                                                                            |
+
+### CancelChain
+
+This interaction resets all progress and flag data on the User entity for the provided `ChainId`.  The next time a Chaining
+interaction is called for the provided `ChainId`, it will begin at the first interaction in the `Next` list. This
+interaction has no special failure conditions.
+
+**CancelChain Fields**
+
+| Field Name | Type     | Required? | Notes                                 |
+| ---------- | -------- | --------- | ------------------------------------- |
+| ChainId    | `String` | **Yes**   | A ChainId whose data should be reset. |
+
+### ChainFlag
+
+This interaction activates a flag on the User entity for the provided `ChainId`, which can be used to change behavior the
+next time a Chaining interaction with this `ChainId` is run. This will overwrite any flag that has
+already been raised. This interaction will have no effect for non-players. This interaction has no special failure
+conditions.
+
+| Field Name | Type     | Required? | Notes                                        |
+| ---------- | -------- | --------- | -------------------------------------------- |
+| ChainId    | `String` | **Yes**   | A ChainId on whom the flag should be raised. |
+| Flag       | `String` | **Yes**   | The name of the flag to raise.               |
+
+## Charging
+
+A unique flow-control interaction that is frequently used is the Charging interaction.  It is a flow-control interaction
+that delays while the input button used to trigger the interaction chain is held.  When it is released (or the interaction
+is forced to end), the interaction chain can continue with a different interaction based on how long the input was held
+for.
+
+These interactions are all related by either being the Charging interaction, or other interaction types that inherit the
+Charging interaction's behavior.
+
+### Charging
+
+This interaction does not inherit from SimpleInteraction and therefore its Next field works different from most interactions.
+This interaction adds its own Failed field which works the same way that SimpleInteraction's does.
+
+This interaction only works properly when its interaction chain was triggered by a client key or button press (or
+NPC-simulated equivalent). This interaction will continue executing for as long as the key or button press is held (with
+some exceptions, covered below) by the User entity.  Like other interactions, it has a `Next` field indicating which interaction to execute
+after this one, but the field is a map from `Float` values to `Interaction` assets. When this interaction ends, either
+due to the input being released or the charge duration completing, this interaction will determine the largest `Float` key that is less
+than the amount of time in seconds that the interaction was executing for.  The Interaction mapped to that key will be
+executed next.
+
+The interaction includes some cancellation conditions that are specific to this interaction. For instance, the interaction
+has a `CancelOnOtherClick` field that matches the field on RootInteraction. If it is active on this interaction but not
+the RootInteraction, then clicking while charging will cancel this interaction (and execute the `Failed` interaction rather
+than any of the `Next` interactions) but otherwise continue the interaction chain.
+
+Another valuable feature Charging has is the `Forks` field.  For input-triggered interactions that are triggered while the
+Charging interaction is executing, you can add an entry for the relevant InteractionType to this field and instead of
+triggering the usual interaction chain based on held item, targeted block, etc. the RootInteraction specified in the
+`Forks` field will be triggered.  This can unlock rich attack modes and behaviors. For instance, having a shield bash attack
+triggered off left click while blocking, or a special attack that triggers when both mouse buttons are pressed at the
+same time.
+
+There are two modes of operation for the Charging interaction. One is to have the ability charge for as long
+as the input is held and only end execution when the entity releases the input.  Bows in the main Hytale game work
+that way.  That is accomplished by setting `AllowIndefiniteHold` to true.  Another mode of operation is to have the
+interaction complete execution when the execution time has surpassed the largest key value in the `Next` field and
+immediately begin executing the Interaction mapped to that key.  Food in the main Hytale game work like this.  It
+is accomplished by setting `AllowIndefiniteHold` to false.
+
+One pitfall to be careful of when setting `AllowIndefiniteHold` to false is the way it interacts with cooldowns.\
+Normally, input-initiated interaction chains start a 0.35s cooldown on the triggered RootInteraction that prevents
+holding the mouse button from immediately spamming a new interaction when the first one completes.  However, if the
+duration of a Charging interaction is longer than 0.35s, then the cooldown will have already completed when the
+interaction chain finishes, which will often result in a new execution beginning immediately before the player can
+stop pressing the mouse button.  One solution for this problem is to add a `Simple` interaction to the end of your
+interaction chain with a `RunTime` of 0.35s to simulate the cooldown.  Alternatively, you can add a longer cooldown
+(the maximum duration of your Charging interaction plus 0.35s) to the RootInteraction. However, the longer cooldown is
+not always desirable, as the interaction may have ended prematurely, resulting in an unusually long lockout between
+executions.
+
+**Charging Fields**
+
+| Field Name                         | Type                                                                    | Required? | Notes                                                                                                                                                                                                                                                                                                                                                                                       |
+| ---------------------------------- | ----------------------------------------------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| FailOnDamage                       | `Boolean`<br />(Default: false)                                         | **No**    | If true, this interaction will fail and end immediately if the User entity takes any damage while it is executing.                                                                                                                                                                                                                                                                          |
+| CancelOnOtherClick                 | `Boolean`<br />(Default: true)                                          | **No**    | If true, this interaction will fail and end immediately if the User entity sends another button or key press while it is executing.                                                                                                                                                                                                                                                         |
+| Forks                              | `Map`<br />(Key Type: `InteractionType`, Value Type: `RootInteraction`) | **No**    | A map of InteractionType to RootInteraction. If entity input triggers the InteractionType while this interaction is executing, the mapped RootInteraction will be forked into its own interaction chain. This will happen instead of the usual handling for that InteractionType.  This fork will occur even if `CancelOnOtherClick` is set to true.                                        |
+| Failed                             | `Asset`<br />(Asset Type: `Interaction`)                                | **No**    | After this Interaction has finished, "Failed" will be executed if this Interaction failed.                                                                                                                                                                                                                                                                                                  |
+| AllowIndefiniteHold                | `Boolean`<br />(Default: false)                                         | **No**    | If true, this interaction will continue executing for as long as the User entity continues to hold the input. If false, execution will end as soon as the execution time in seconds reaches the largest key value in the `Next` map.                                                                                                                                                        |
+| DisplayProgress                    | `Boolean`<br />(Default: true)                                          | **No**    | If true, players executing this interaction will see a progress bar will be displayed below their cursor indicating how close to reaching the highest key value in `Next` they are.                                                                                                                                                                                                         |
+| Next                               | `Map`<br />(Key Type: `Float`, Value Type: `Interaction`)               | **No**    | A map from `Float` to `Interaction`.  When this interaction successfully finishes executing (either because the input was released or because the maximum duration was reached), this interaction will find the `Float` value with the largest duration in seconds that is less than the amount of time this interaction executed for. That key's mapped Interaction will then be executed. |
+| MouseSensitivityAdjustmentTarget   | `Float`<br />(Default: 1.0)                                             | **No**    | While charging, this mouse sensitivity multiplier will gradually be applied.                                                                                                                                                                                                                                                                                                                |
+| MouseSensitivityAdjustmentDuration | `Float`<br />(Default: 1.0)                                             | **No**    | Duration in seconds. After this many seconds, `MouseSensitivityAdjustmentTarget` will be fully applied to the mouse sensitivity.                                                                                                                                                                                                                                                            |
+| Delay                              | `ChargingDelay`                                                         | **No**    | Settings that allow charging progress to be pushed back when the User entity takes damage.                                                                                                                                                                                                                                                                                                  |
+
+**ChargingDelay Fields**
+
+| Field Name    | Type                        | Required? | Notes                                                                                                                                                                                                                                                                     |
+| ------------- | --------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| MinHealth     | `Float`<br />(Default: 0.0) | **No**    | Damage taken as a percentage of entity health (0.0-1.0). If a hit deals less than this much damage, no pushback will be applied.  If a hit deals exactly this much damage, `MinDelay` seconds worth of pushback will be applied.                                          |
+| MaxHealth     | `Float`<br />(Default: 0.0) | **No**    | Damage taken as a percentage of entity health (0.0-1.0). If a hit deals at least this much damage, `MaxDelay` seconds worth of pushback will be applied.                                                                                                                  |
+| MinDelay      | `Float`<br />(Default: 0)   | **No**    | The amount of pushback, in seconds, to apply if the entity takes a hit that deals `MinHealth` damage. The amount of pushback applied by a hit is a gradiant between `MinDelay` and `MaxDelay` based on the amount of damage between `MinHealth` and `MaxHealth`.          |
+| MaxDelay      | `Float`<br />(Default: 0)   | **No**    | The amount of pushback, in seconds, to apply if the entity takes a hit that deals at least `MaxHealth` damage. The amount of pushback applied by a hit is a gradiant between `MinDelay` and `MaxDelay` based on the amount of damage between `MinHealth` and `MaxHealth`. |
+| MaxTotalDelay | `Float`<br />(Deault: 0)    | **No**    | The maximum amount of pushback the entity can receive over the course of a single charge, regardless of how many times they are hit.                                                                                                                                      |
+
+**InteractionType Values**
+
+- `Primary`
+- `Secondary`
+- `Ability1`
+- `Ability2`
+- `Ability3`
+- `Use`
+- `Pick`
+- `Pickup`
+- `CollisionEnter`
+- `CollisionLeave`
+- `Collision`
+- `EntityStatEffect`
+- `SwapTo`
+- `SwapFrom`
+- `Death`
+- `Wielding`
+- `ProjectileSpawn`
+- `ProjectileHit`
+- `ProjectileMiss`
+- `ProjectileBounce`
+- `Held`
+- `HeldOffhand`
+- `Equipped`
+- `Dodge`
+- `GameModeSwap`
+
+### Wielding
+
+This interaction is inherited from Charging rather than SimpleInteraction.  However, its `Failed` and `Next` fields function
+identically to SimpleInteraction.  It does not inherit all fields from Charging, so be sure to pay close attention to
+the field list below.
+
+This interaction drives most blocking behavior in the game. While this interaction is executing, attacks made against
+the Owner entity will (conditionally) trigger effects defined in this interaction.  Unlike the Charging interaction,
+this interaction can always execute indefinitely and will only end when it fails or when the input is released.
+
+One option available in Wielding is `AngledWielding`, which allows damage and knockback modifiers to only be applied
+depending on the direction the attack against the Owner entity is coming from.  The AngledWielding type has a
+field `Angle` which determines which direction the protection points relative to the player (0 is the player's
+front), and `AngleDistance` which determines how wide the cone of protection extends around the player.  Block effects
+from this interaction (such as `BlockedEffects`, `BlockedInteractions`, and `StaminaCost`) will only apply if
+the DamageCause matches `DamageModifiers` OR if the DamageCause matches `AngledWielding.DamageModifiers` and
+the source of the damage matches `Angle` and `AngleDistance`.  It is possible for damage and knockback multipliers
+specified on both this interaction's modifier fields and `AngledWielding`'s modifier fields to stack, if both
+have entries for the same DamageCause.
+
+This interaction will only have an effect on damage taken by one of the DamageCause entries in `DamageModifiers` or
+`AngledWielding.DamageModifiers`.  If a DamageCause is in `DamageModifiers`, then the block effect will be triggered
+and the damage modifier applied regardless of what direction the Owner entity is attacked from.  If a DamageCause is in
+`AngledWielding.DamageModifiers`, then the damage modifier is only applied if the
+
+\*\* Wielding Fields\*\*
+
+| Field Name          | Type                                                                    | Required? | Notes                                                                                                                                                                                                                                                                                                                                                                                                      |
+| ------------------- | ----------------------------------------------------------------------- | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| FailOnDamage        | `Boolean`<br />(Default: false)                                         | **No**    | If true, this interaction will fail and end immediately if the User entity takes any damage while it is executing.                                                                                                                                                                                                                                                                                         |
+| CancelOnOtherClick  | `Boolean`<br />(Default: true)                                          | **No**    | If true, this interaction will fail and end immediately if the User entity sends another button or key press while it is executing.                                                                                                                                                                                                                                                                        |
+| Forks               | `Map`<br />(Key Type: `InteractionType`, Value Type: `RootInteraction`) | **No**    | A map of InteractionType to RootInteraction. If entity input triggers the InteractionType while this interaction is executing, the mapped RootInteraction will be forked into its own interaction chain. This will happen instead of the usual handling for that InteractionType.  This fork will occur even if `CancelOnOtherClick` is set to true (after which this interaction chain will be canceled). |
+| Next                | `Asset`<br />(Asset Type: `Interaction`)                                | **No**    | After this interaction has finished, "Next" will be executed if this interaction did not fail.                                                                                                                                                                                                                                                                                                             |
+| Failed              | `Asset`<br />(Asset Type: `Interaction`)                                | **No**    | After this interaction has finished, "Failed" will be executed if this interaction failed.                                                                                                                                                                                                                                                                                                                 |
+| DamageModifiers     | `Map`<br />(Key Type: `DamageCause`, Value Type: `Float`)               | **No**    | A map from DamageCause to Float, where the Float is multiplied against any damage received from the mapped DamageCause while this interaction is executing.                                                                                                                                                                                                                                                |
+| KnockbackModifiers  | `Map`<br />(Key Type: `DamageCause`, Value Type: `Float`)               | **No**    | A map from DamageCause to Float, where the Float is multiplied against any knockback force received from the mapped DamageCause while this interaction is executing.                                                                                                                                                                                                                                       |
+| AngledWielding      | `AngledWielding`                                                        | **No**    | Configuration to only trigger block effects from certain angles.                                                                                                                                                                                                                                                                                                                                           |
+| StaminaCost         | `StaminaCost`                                                           | **No**    | If the Owner entity receives damage that matches `DamageModifiers` or `AngledWielding` while this interaction is executing, then the entity's stamina will be deducted according to this configuration.                                                                                                                                                                                                    |
+| BlockedEffects      | `DamageEffects`                                                         | **No**    | If the Owner entity receives damage that matches `DamageModifiers` or `AngledWielding` while this interaction is executing, then these effects will be applied to the instance of damage.                                                                                                                                                                                                                  |
+| BlockedInteractions | `Asset`<br />(Asset Type: `RootInteraction`)                            | **No**    | If the Owner entity receives damage that matches `DamageModifiers` or `AngledWielding` while this interaction is executing, then this RootInteraction will be launched as a brand new interaction chain with the Owner entity as both Owner and User, and the attacker as the Target entity.  This new interaction chain is, notably, brand new, **not** forked from the current one.                      |
+
+**AngledWielding Fields**
+
+| Field Name         | Type                                                      | Required? | Notes                                                                                                                                                                                                            |
+| ------------------ | --------------------------------------------------------- | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Angle              | `Float`<br />(Default: 0.0)                               | **No**    | Angle in degrees relative to the Owner entity where the angled protection is centered. 0.0 means pointed towards the front of the Owner entity.                                                                  |
+| AngleDistance      | `Float`<br />(Default: 0.0)                               | **No**    | Angle in degrees indicating how wide the cone of protection is.                                                                                                                                                  |
+| DamageModifiers    | `Map`<br />(Key Type: `DamageCause`, Value Type: `Float`) | **No**    | A map from DamageCause to Float, where the Float is multiplied against any damage received from the mapped DamageCause received from within the cone of protection while this interaction is executing.          |
+| KnockbackModifiers | `Map`<br />(Key Type: `DamageCause`, Value Type: `Float`) | **No**    | A map from DamageCause to Float, where the Float is multiplied against any knockback force received from the mapped DamageCause received from within the cone of protection while this interaction is executing. |
+
+**StaminaCost Fields**
+
+| Field Name | Type                                             | Required? | Notes                                                                                                                                                                                                                                                |
+| ---------- | ------------------------------------------------ | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| CostType   | `CostType`<br />(Default: `MaxHealthPercentage`) | **No**    | How to calculate stamina consumed by blocking from the raw pre-block damage. If `Damage`, then the stamina consumed will be `rawDamage / Value`. If `MaxHealthPercentage`, then the stamina consumed will be `rawDamage / (EntityMaxHealth * Value)` |
+| Value      | `Float`<br />(Default: 0.04)                     | **No**    | The value to use in the `CostType` formula.                                                                                                                                                                                                          |
+
+**DamageEffects Fields**
+
+| Field Name             | Type                                         | Required? | Notes                                                                           |
+| ---------------------- | -------------------------------------------- | --------- | ------------------------------------------------------------------------------- |
+| ModelParticles         | `Array`<br />(Element Type: `ModelParticle`) | **No**    | Particle systems to trigger in the first-person view.                           |
+| WorldParticles         | `Array`<br />(Element Type: `WorldParticle`) | **No**    | Particle systems to trigger in the third-person view.                           |
+| LocalSoundEventId      | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | 2D sound to play locally to the attacking entity if they are a player.          |
+| WorldSoundEventId      | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | Sound to play in the world at the Owner entity's location.                      |
+| PlayerSoundEventId     | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | 2D sound to play locally to the Owner entity if they are a player.              |
+| ViewDistance           | `Double`<br />(Default: 75.0)                | **No**    | Distance at which these effects should play for other players.                  |
+| Knockback              | `Knockback`                                  | **No**    | The properties of the knockback that will be applied.                           |
+| CameraEffect           | `Asset`<br />(Asset Type: `CameraEffect`)    | **No**    | CameraEffect to briefly apply locally to the Owner entity if they are a player. |
+| StaminaDrainMultiplier | `Float`<br />(Default: 1.0)                  | **No**    | This multiplier is applied to the `StaminaCost`, if any.                        |
+
+**Knockback Fields**
+
+| Field Name     | Type                                       | Required? | Notes                                                                                                                      |
+| -------------- | ------------------------------------------ | --------- | -------------------------------------------------------------------------------------------------------------------------- |
+| Type           | `String`                                   | **No**    | If provided, specifies a type of knockback to use. Each knockback type may come with additional fields.                    |
+| Force          | `Double`<br />(Default: 0.0)               | **No**    | The amount of force to apply to the Owner entity.                                                                          |
+| Duration       | `Double`<br />(Default: 0.0)               | **No**    | If 0.0, apply the force as a single impulse.  If more, continuously apply the force over a period of time.                 |
+| VelocityType   | `ChangeVelocityType`<br />(Default: `Add`) | **No**    | How to apply the force, either adding it to the entity's current velocity, or setting the velocity to the knockback force. |
+| VelocityConfig | `VelocityConfig`                           | **No**    | Characteristics of friction as the Owner entity is thrown by this knockback.                                               |
+
+**Knockback Type: Force**
+
+Apply the calculated knockback force along the provided direction.
+
+| Field Name | Type                         | Required? | Notes                                                                                |
+| ---------- | ---------------------------- | --------- | ------------------------------------------------------------------------------------ |
+| Direction  | `Vector3`<br />(Default: Up) | **No**    | Which direction the player should be flung, relative to the direction of the attack. |
+
+**Knockback Type: Point**
+
+Apply the calculated knockback force laterally along the XZ plane, plus provided Y velocity.
+
+| Field Name | Type                        | Required? | Notes                                                                                                   |
+| ---------- | --------------------------- | --------- | ------------------------------------------------------------------------------------------------------- |
+| OffsetX    | `Integer`<br />(Default: 0) | **No**    | Offset the source position of the knockback left or right perpendicular to the direction of the attack. |
+| OffsetZ    | `Integer`<br />(Default: 0) | **No**    | Offset the source position of the knockback, forward or backward along the directon of the attack.      |
+| RotateY    | `Integer`<br />(Default: 0) | **No**    | Rotate the knockback direction around the Y axis, where 0 is the default attack direction.              |
+| VelocityY  | `Float`<br />(Default: 0.0) | **No**    | Add vertical velocity to the knockback force after the direction and force has been calculated.         |
+
+**Knockback Type: Directional**
+
+Apply the calculated knockback force along the attack direction, removing any vertical component and replacing it with a provided Y velocity.
+
+| Field Name | Type                      | Required? | Notes                                                                                                                                            |
+| ---------- | ------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------ |
+| RelativeX  | `Float`<br />(Default: 0) | **No**    | Apply additional force left or right perpendicular to the direction of the attack. The additional force is multiplied by the knockback strength. |
+| RelativeZ  | `Float`<br />(Default: 0) | **No**    | Apply additional force forward or backward along the attack direction. The additional force is multiplied by the knockback strength.             |
+| VelocityY  | `Float`<br />(Default: 0) | **No**    | Replace the vertical velocity of the knockback with this value.  This value is not multiplied by knockback strength.                             |
+
+**VelocityConfig Fields**
+
+| Field Name          | Type                                              | Required? | Notes                                                                                                                                                                                           |
+| ------------------- | ------------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| GroundResistance    | `Float`<br />(Default: 0.82)                      | **No**    | The minimum amount of friction applied when the entity is in contact with the ground.  1.0 = no friction, 0.0 = total friction                                                                  |
+| GroundResistanceMax | `Float`<br />(Default: 0.0)                       | **No**    | The maximum amount of friction applied when the entity is in contact with the ground.  1.0 = no friction, 0.0 = total friction                                                                  |
+| AirResistance       | `Float`<br />(Default: 0.96)                      | **No**    | The minimum amount of friction applied when the entity is in the air. 1.0 = no friction, 0.0 = total friction                                                                                   |
+| AirResistanceMax    | `Float`<br />(Default: 0.0)                       | **No**    | The maximum amount of friction applied when the entity is in the air. 1.0 = no friction, 0.0 = total friction                                                                                   |
+| Threshold           | `Float`<br />(Default: 1.0)                       | **No**    | The speed at which the maximum amount of friction will be applied to the entity. The amount of friction applied will increase from minimum to maximum as the entity moves from 0 to this speed. |
+| Style               | `VelocityThresholdStyle`<br />(Default: `Linear`) | **No**    | The curve that friction follows as the entity's speed increases toward the `Threshold`.                                                                                                         |
+
+**CostType Values**
+
+- `MaxHealthPercentage`
+- `Damage`
+
+**ChangeVelocityType Values**
+
+- `Add`
+- `Set`
+
+**VelocityThresholdStyle Values**
+
+- `Linear`
+- `Exp`
+
+## Blocks
+
+These are interaction types meant to reason about and modify blocks in the world.  The most important concept unique
+to these interactions is the Block Target.  Like the Entity Target, it is mutable and can come from many places.
+However, for interaction chains initiated by the client, the block target will initially be the block that the player's cursor was
+over, if any.
+
+Additionally, for interaction chains initiated by the client, the client will send along which face of the block is targeted,
+which is used by a few block-related interactions.
+It is left up to each interaction type that cares about block faces as to how to handle this behavior for simulated input
+(i.e. NPCs initiating chains that are normally initated by the client).  At the time of this writing, all block-related
+interactions choose the top face where relevant in simulated input.
+
+### BlockCondition
+
+This interaction has a field `Matchers` which specifies certain conditions, such as block type, state, etc.  This
+interaction fails if the current target block does not match all of them.
+
+**BlockCondition Fields**
+
+| Field Name       | Type                                        | Required? | Notes                                                                                                                                                                                                                                                                                                                                   |
+| ---------------- | ------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false)             | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction.                                                                                                                                                                                                       |
+| Matchers         | `Array`<br />(Element Type: `BlockMatcher`) | **Yes**   | A list of conditions that the target block must match or this condition will fail.<br />**Note: This field is technically not required but there is a bug that makes it dangerous to not provide at the time of this writing.**<br />**Note: If no conditions are added to this array, the interaction will fail, counterintuitively.** |
+
+**BlockMatcher Fields**
+
+| Field Name | Type                       | Required? | Notes                                                                          |
+| ---------- | -------------------------- | --------- | ------------------------------------------------------------------------------ |
+| Block      | `BlockIdMatcher`           | **No**    | If provided, requires the block itself match some set of conditions.           |
+| Face       | `BlockFace`                | **No**    | If provided and not 'None', requires a specific block face be targeted.        |
+| StaticFace | `Boolean` (Default: false) | **No**    | If false, the face condition will be adjusted by the block's current rotation. |
+
+**BlockFace Values**
+
+- `Up`
+- `Down`
+- `North`
+- `South`
+- `East`
+- `West`
+- `None`
+
+**BlockIdMatcher Fields**
+
+| Field Name | Type                                   | Required? | Notes                                                                      |
+| ---------- | -------------------------------------- | --------- | -------------------------------------------------------------------------- |
+| Id         | `Asset`<br />(Asset Type: `BlockType`) | **No**    | If provided, the block must match the specified `BlockType`.               |
+| State      | `String`                               | **No**    | If provided, the block's current state must match the provided state name. |
+| Tag        | `String`                               | **No**    | If provided, the block type's asset tags must contain the provided tag.    |
+
+### DestroyCondition
+
+This interaction fails if the current User entity cannot destroy the current target blcok.
+
+**DestroyCondition Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+
+### PlacementCountCondition
+
+This interaction accepts the name of a BlockType that has the TrackedPlacement BlockEntity. The interaction will fail if the number of
+blocks of the provided BlockType in the world do not match the provided condition.
+
+**PlacementCountCondition Fields**
+
+| Field Name | Type                           | Required? | Notes                                                                                                                                                                                                                                                           |
+| ---------- | ------------------------------ | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Block      | `String`                       | **Yes**   | The BlockType to examine. The number of instances of the BlockType in the world will be compared to Value.<br />**Note: The specified BlockType must have the TrackedPlacement BlockEntity. Otherwise, the number of blocks in the world will always be zero.** |
+| Value      | `Integer`<br />(Default: 0)    | **No**    | The value to compare the number of blocks in the world with.                                                                                                                                                                                                    |
+| LessThan   | \`Boolean<br />(Default: true) | **No**    | If true, the interaction will fail if the number of blocks in the world is greater than or equal to Value. If false, the interaction will fail if the number of blocks in the world is less than or equal to Value.                                             |
+
+### BreakBlock
+
+This interaction attempts to break the target block while acting as the User entity. The User entity must be a player. It
+is not guaranteed to work, depending on world settings and the User entity's current state, it may not work.  If it
+fails, it will fail the interaction under some circumstances, but not others.
+
+**Note: In particular, if `Harvest`=false and the player is in Survival mode, the player will simply execute a damage operation
+against the block. Even when the Tool field is specified, the player's currently-held item can impact the results in unintuitive
+ways.**
+
+This interaction will fail if there is no block target, if `Harvest`=true and the
+block is not harvestable, or if the world settings prevent the Harvest/Break operation.
+It will generally not fail otherwise, even if the block was not broken or damaged.
+The block will generally break every time if `Harvest`=true or the player is in
+Creative mode.
+
+**BreakBlock Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                                                                                                                                                                                                  |
+| ---------------- | ------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction.                                                                                                                                                                      |
+| Harvest          | `Boolean` (Default: false)      | **No**    | If true, harvest the block and deposit the drops in the player's inventory. This operation will generally always succeed.  If false, this interaction will effectively perform whatever action would have occurred if the player had left-clicked the block.                                           |
+| Tool             | `String`                        | **No**    | If `Harvest`=true, the player is in Survival mode, and this field is provided, then the break operation will be performed as though with this tool type.<br />**This field mostly doesn't work.  Your held item will be used for most block damage calculations regardless of this field's contents.** |
+| MatchTool        | `Boolean` (Default: false)      | **No**    | If true, `Harvest`=true, the player is in Survival mode, and `Tool` is provided, block breaking will be prevented unless `Tool` is a valid gathering tool for the target block. The interaction will not be failed, even if block breaking is prevented in this manner.                                |
+
+### ChangeBlock
+
+This interaction requires a mapping from one or more current BlockTypes to one or more target BlockTypes.  If the
+target block is one of the key BlockTypes, then it will be changed to the mapped target BlockType.  If the current
+BlockType of the target block does not appear as a key in the Changes field, then this interaction fails.
+
+**ChangeBlock Fields**
+
+| Field Name        | Type                                                        | Required? | Notes                                                                                                                             |
+| ----------------- | ----------------------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget  | `Boolean`<br />(Default: false)                             | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+| Changes           | `Map`<br />(Key Type: `BlockType`, Value Type: `BlockType`) | **No**    | A list of potential block type changes, with each entry having a current and new BlockType id.                                    |
+| WorldSoundEventId | `Asset`<br />(Asset Type: `SoundEvent`)                     | **No**    | If provided, this SoundEvent is played in the world at the position of the block if the block successfully changes.               |
+| RequireNotBroken  | `Boolean`<br />(Default: false)                             | **No**    | If true, this interaction will fail if the player's held item is broken (durability 0), and the block change will not take place. |
+
+### ChangeState
+
+This interaction requires a mapping from one or more current block state names to one or more state names. If the
+target block is in one of the key block states, then it will be changed to the mapped target blocks tate. If the
+current block state of the target block does nto appear as a key in the Changes field, then this interaction fails.
+
+All blocks start out with a null state by default.  This null state can be referenced by the key "default" and the block
+can be returned to that state with the value "default".
+
+**ChangeState Fields**
+
+| Field Name       | Type                                                  | Required? | Notes                                                                                                                                          |
+| ---------------- | ----------------------------------------------------- | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false)                       | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction.              |
+| Changes          | `Map`<br />(Key Type: `String`, Value Type: `String`) | **No**    | A list of potential block state changes, with each entry having a current and new state name.                                                  |
+| UpdateBlockState | `Boolean`<br />(Default: false)                       | **No**    | If true, performs a full refresh of the block's BlockEntity component and notifies nearby players as though a full block type change occurred. |
+
+### CycleBlockGroup
+
+This interaction will attempt to change the target block to the next block type in one of the BlockGroups it belongs to.
+If the block type belongs to multiple BlockGroups, which one is used is effectively arbitrary. The User entity must be
+a player. If the block cannot be changed for any reason (entity not a player, no block target, block does not belong
+to a BlockGroup, etc.). If the block is the only entry in the BlockGroup, this interaction will succeed and the block
+will be considered changed despite nothing happening.  Unlike most other block-changing interactions, this one will
+fail if the world settings prevent players from breaking blocks.
+
+**This interaction always reduces the player's held item's durability by a single 'hit' worth of damage if the block
+changes. There is no way to prevent it. The block type will change and the interaction will succeed even if the player's
+held item is broken, however.**
+
+**CycleBlockGroup Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+
+### DestroyBlock
+
+This interaction destroys the target block without dropping anything.  It will successfully destroy the block if the
+target block exists and this interaction has no failure conditions.
+
+**This interaction has no additional fields.**
+
+### PickBlock
+
+This interaction is effectively equivalent to using the middle mouse button in creative mode. In survival mode, the
+block's item will be moved to the user's current active hotbar slot if it is in the player's inventory.  This
+interaction is performed entirely on the client and cannot be performed by non-players.  It is unclear if this
+interaction has failure conditions.
+
+**PickBlock Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+
+### PlaceBlock
+
+This interaction is effectively identical to a right clicking while holding a block in their hand, with some
+additional options. For one, it can be executed with any LivingEntity as the User entity. For another, it has some
+useful fields.  For the most part, though, it follows the same behaviors and rules as any ordinary block placement
+by a player.
+
+It's not clear under what circumstances this interaction can fail. The server will not fail the interaction under any
+special circumstances (including when there is no target block, or when `BlockTypeToPlace` is not provided and the
+LivingEntity is not holding a block). However, the client is very involved with the function of this interaction and
+its behavior is unknown.
+
+**PlaceBlock Fields**
+
+| Field Name         | Type                                   | Required? | Notes                                                                                                                                                                                                                                                                                                                                                           |
+| ------------------ | -------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| BlockTypeToPlace   | `Asset`<br />(Asset Type: `BlockType`) | **No**    | If provided, the block placed by this interaction will be the specified BlockType. If not provided, the User entity's held item will be used, instead, if it is a block.                                                                                                                                                                                        |
+| RemoveItemInHand   | `Boolean`<br />(Default: True)         | **No**    | If true and the User entity is not a player in Creative mode, the item in the player's hand must match the block being placed and one quantity will be removed for each block placed. If the item does not match, the block cannot be placed.  If false, the player's hand item is ignored entirely.\*\*                                                        |
+| AllowDragPlacement | `Boolean`<br />(Default: True)         | **No**    | If true and the interaction was triggered on the client by a player, then the player can hold the input that was used to activate this interaction chain and move the mouse around in order to execute this interaction repeatedly and place several blocks. The interaction chain will not move onto the next interaction until the player releases the input. |
+
+### RunOnBlockTypes
+
+This interaction retrieves all blocks within a provided radius of the User entity. For each block that matches any of
+the provided BlockSets, a new interaction chain will be forked that uses the matching block as the target block.
+This interaction will continue executing until all forked interaction chains have completed.  The interaction will fail if no
+blocks within the radius match the provided BlockSets or if all of the forked interaction chains fail.
+
+**RunOnBlockTypes Fields**
+
+| Field Name   | Type                                         | Required?        | Notes                                                                                                                                                                                                                                                                                      |
+| ------------ | -------------------------------------------- | ---------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| Range        | `Integer`                                    | **Yes**          | The spherical radius around the User entity to search for blocks. Must be at least 1.                                                                                                                                                                                                      |
+| BlockSets    | `AssetArray`<br />(Element Type: `BlockSet`) | **No**           | A list of BlockSets to match nearby blocks again. Only blocks that match any of the BlockSets will have interaction chains forked for them.                                                                                                                                                |
+| MaxCount     | `Integer`                                    | **Yes**          | The maximum number of blocks that will be located with the search. Further blocks will be ignored. If there are more matching blocks within the radius than this number, the specific set of blocks that will be found is completely arbitrary and may change from execution to execution. |
+| Interactions | `Asset`<br />(Asset Type: `RootInteraction`) | **No, but yes.** | The RootInteraction that will be forked for each matching block.  This interaction will not fail to validate if it is missing, but every execution of this interaction will fail.                                                                                                          |
+
+### UseBlock
+
+If the target block has an interaction for this interaction chain's interaction type, execute it immediately as part of
+this interaction chain. The execution will be wrapped in UseBlockEvent.Pre and UseBlockEvent.Post events, and cancellations
+of the UserBlockEvent.Pre event are respected. The User entity is considered the triggering entity for both events.
+
+If the target block does not have an interaction for this interaction chain's interaction type, this interaction fails.
+
+**This interaction has no additional fields.**
+
+## Items
+
+These are interactions intended to interface with an entity's inventory. There is no concept of an "item target",
+unfortunately, so these generally either interact with the entity's held item or the entity's inventory at a high level.
+
+### AddItem
+
+Adds a specified quantity of a specified item to the User entity's inventory, preferring to add it to the
+entity's hotbar where possible. This interaction will have no effect on User entities that are not LivingEntities.
+This interaction has no failure states.
+
+**Note: This interaction has a bug in its field validators that will cause interactions that reference items declared
+in the same mod to fail validation on startup.  Additionally, this interaction has a bug that will cause it to
+fail and have no effect if the User entity has no block target. Use ModifyInventory instead.**
+
+**AddItem Fields**
+
+| Field Name       | Type                              | Required? | Notes                                                                                                                             |
+| ---------------- | --------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false)   | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+| ItemId           | `Asset`<br />(Asset Type: `Item`) | **Yes**   | The item id of the item to add to the player's inventory.                                                                         |
+| Quantity         | `Integer`<br />(Default: 0)       | **No**    | The quantity of the item to add to the player's inventory.                                                                        |
+
+### CheckUniqueItemUsage
+
+This interaction will check whether it has run once for the User entity with their currently-held item before. If it hasn't,
+it will succeed. If it has, it will fail. It will also fail if the User entity is not a player. The interaction will record
+the item id of the User entity's currently-held item on success, ensuring it cannot be successfully run with that player
+and item id combination again.
+
+**This interaction has no additional fields.**
+
+### ChangeActiveSlot
+
+This interaction does not inherit from SimpleInteraction and therefore has no Next or Failed fields.  The `CancelOnItemChange`
+field is ignored for this interaction and is always treated as false. This interaction will set the User entity's currently-
+active hotbar slot to the specified slot index. If none is specified, the interaction chain's target slot will be used,
+if any. Otherwise, slot 0 will be used.  If a slot is specified and it is already active, then this interaction will
+have no effect, but if no slot is specified and the interaction chain's target slot is already active, the logic in
+the next paragraph will still be executed. This interaction will also have no effect if the User entity is not a
+LivingEntity.
+
+Once the slot has changed, a new SwapTo interaction chain will be forked off for the selected slot.
+If a target slot was specified, then the interaction chain's current target slot will be set to the specified slot, as will
+the forked SwapTo interaction chain. If this interaction chain was initiated by a player swapping an item into or out of
+an occupied active hotbar slot, then the swap will be executed after the slot is changed and before the SwapTo
+interaction is forked. Not running this interaction in the resulting SwapFrom interaction chain is a way for the server
+to cancel players performing these sorts of swap interactions. The default behavior for these swap interactions is that
+the SwapFrom interaction chain will be initiated with the currently-active-slot as the target slot. As a result, the
+target slot will usually not change when this interaction runs, it merely exists as a signal for the server to continue the
+item swap.
+
+**ChangeActiveSlot Fields**
+
+| Field Name | Type      | Required? | Notes                                                                                                                                                                                                     |
+| ---------- | --------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| TargetSlot | `Integer` | **No**    | If not provided, indicates the slot the player's active hotbar slot should be changed to.  Otherwise, the interaction chain's target slot will be used (which is usually the already-active hotbar slot). |
+
+### EquipItem
+
+This interaction will equip the User entity's currently-held item into the appropriate armor slot, if it is armor. The
+interaction will fail if the item is armor but it cannot be equipped for some reason. The interaction will succeed but
+take no action if the User entity cannot equip armor or if the item is not armor.
+
+**This interaction has no additional fields.**
+
+### IncreaseBackpackCapacity
+
+This interaction will increase the User entity's backpack size by the provided amount.  **It will additionally remove one
+quantity from the player's currently-held item. There is no way to prevent this.**  This interaction will have no effect
+if the User entity is not a player.  This interaction has no special failure conditions, even if the User entity
+is not a player, or the player is not currently holding an item.
+
+| Field Name | Type                        | Required? | Notes                                                                                   |
+| ---------- | --------------------------- | --------- | --------------------------------------------------------------------------------------- |
+| Capacity   | `Integer`<br />(Default: 1) | **No**    | The additional backpack capacity to add to the player. **Must be between 1 and 32767.** |
+
+### ModifyInventory
+
+This interaction attempts to perform one or more inventory-modifying actions against the User entity. The User entity must
+be a player. If they are not, no actions will be performed, but the interaction will not fail. Any item removals performed
+by this interaction, either as a result of `ItemToRemove` or `AdjustHeldItemQuantity`, are both atomic (meaning the entire
+quantity must be removed, or none) and required (meaning that the interaction will fail and no further actions taken if
+the removal fails for any reason).  Item additions performed by this interaction, either as a result of `ItemToAdd` or
+`AdjustHeldItemQuantity` will drop excess items on the ground near the player if necesary and continue on.
+
+This interaction first executes the item removal in `ItemToRemove`, if any, then adjusts the held item as specified by
+`AdjustHeldItemQuantity`, if provided, then executes the item addition in `ItemToAdd`, if any, and then finally executes
+the damage/healing of the held item in `AdjustHeldItemDurability`, if provided.
+
+**ModifyDurability Fields**
+
+| Field Name               | Type                            | Required? | Notes                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
+| ------------------------ | ------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| RequiredGameMode         | `GameMode`                      | **No**    | If provided, only execute the inventory-modifying actions if the player is in the provided GameMode. The interaction will not fail if the GameMode doesn't match.                                                                                                                                                                                                                                                                                                                                                                               |
+| ItemToRemove             | `ItemStack`                     | **No**    | If provided, a matching item will be removed in the provided quantity. If there is no matching item in the player inventory in the required quantity, then the interaction will fail and further actions will not be executed.                                                                                                                                                                                                                                                                                                                  |
+| AdjustHeldItemQuantity   | `Integer`<br />(Default: 0)     | **No**    | The player's held item, if any, will have its quantity will be modified by the provided amount- subtracted from if this number is negative or added to if this item is positive.  If the player has no held item, then this field will have no effect regardless of its value and the interaction will NOT fail.  If the player's inventory does not have sufficient quantity of items to support the removal, this interaction will fail and further actions will not be executed. Excess items will be dropped on the ground near the player. |
+| ItemToAdd                | `ItemStack`                     | **No**    | If provided, the ItemStack will be added to the player's inventory. Excess items will be dropped on the ground near the player.                                                                                                                                                                                                                                                                                                                                                                                                                 |
+| AdjustHeldItemDurability | `Double`<br />(Default: 0.0)    | **No**    | The player's held item, if any, will have its durability adjusted by the specified amount.  The durability cannot go below 0 or raise above the item's maximum durability. Invalid durability values in this field will not cause the interaction to fail. Neither will it fail if the player has no held item.                                                                                                                                                                                                                                 |
+| BrokenItem               | `String`                        | **No**    | This field should contain an ItemId, but it is not validated by the server on startup, so be careful.  This field can have the value of "Empty" to specify no item, or an empty hand. If specified and the `AdjustHeldItemDurability` operation reduces the player's held item to 0 durability, the player's held item is changed to this ItemId. If the inventory replacement fails, this interaction will fail.                                                                                                                               |
+| NotifyOnBreak            | `Boolean`<br />(Default: false) | **No**    | If true and the `AdjustHeldItemDurability` operation reduces the player's held item to 0 durability, this interaction will perform the usual audiovisual feedback of a broken tool. It will play the usual tool breaking sound and send the player a text message in chat that their item has broken.                                                                                                                                                                                                                                           |
+| NotifyOnBreakMessage     | `String`                        | **No**    | If provided, and `NotifyOnBreak` is true, when the player is notified of a broken tool by this interaction, the message sent to their chat will instead be the translation key specified by this field. The translation key supports the templating parameter `{itemName}`. See the translation key `server.general.repair.itemBroken_Hoe` for an example.                                                                                                                                                                                      |
+
+**GameMode Values**
+
+- `Creative`: The game is currently in Creative Mode
+- `Adventure`: The game is currently in Adventure Mode
+
+**ItemStack Fields**
+
+| Field Name                   | Type                              | Required? | Notes                                                                                |
+| ---------------------------- | --------------------------------- | --------- | ------------------------------------------------------------------------------------ |
+| Id                           | `Asset`<br />(Asset Type: `Item`) | **Yes**   | The id of the Item asset this stack contains.                                        |
+| Quantity                     | `Integer`<br />(Default: 1)       | **No**    | The number of items in this stack.<br />**Must be greater than 0.**                  |
+| Durability                   | `Double`<br />(Default: 0.0)      | **No**    | The durability of the item stack.<br />**Cannot be negative.**                       |
+| MaxDurability                | `Double`<br />(Default: 0.0)      | **No**    | The maximum durability of the item this stack contains.<br />**Cannot be negative.** |
+| Metadata                     | `Bson Document`                   | **No**    | If provided, applies the bson to the item stack metadata.                            |
+| OverrideDroppedItemAnimation | `Boolean`\*(Default: false)       | **No**    | ???                                                                                  |
+
+### PickupItem
+
+This interaction will attempt to pick up the User entity's current target entity and add it to their inventory. It will
+fail if the User entity is not a player, if they do not have a target entity, or if the target entity is not an item
+located in the world.  It will not fail if the player simply cannot pick up the item.
+
+**This interaction has no additional fields.**
+
+### RefillContainer
+
+This interaction will fail if the User entity is not a player. The interaction will draw a ray from the player's head
+down their look direction until the edge of the player's held item's interaction range or until the first solid block.
+The nearest fluid block of a type listed in this interaction's `States` map will result in the one of the player's
+currently-held items being converted to the fluid's related item state.  If the `States` map indicates a durability
+for the new item state, then the converted item will use that durability. If the item is already in the fluid's related
+item state, then this interaction will fail if the player's held item is already at maximum durability (unless the
+`States` map indicates a durability value greater than the item's maximum, in which case the interaction will succeed
+but the item will not change).  Otherwise, the durability listed for the fluid in the `States` map will be added to the
+item's current durability.
+
+If the interaction has not failed by this point, the fluid block in the world may be transformed to a different type if one is listed
+in the `States` map.
+
+If any part of this process does not proceed for any reason (for instance, if the player is not holding an item),
+then this interaction will fail.
+
+**RefillContainer Fields**
+
+| Field Name | Type                                                       | Required? | Notes                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| ---------- | ---------------------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| States     | `Map`<br />(Key Type: `String`, Value Type: `RefillState`) | **Yes**   | A map from item state names to `RefillState` objects, which contain information such as acceptable fluid block types, durability increases, and what fluid type to convert the targeted fluid block to after refill, if any. If the player targets a fluid block that matches one of the fluid types in the `RefillState`, the item will be converted to the keyed item state and the `RefillState` will be used to decide what happens next. |
+
+**RefillState Fields**
+
+| Field Name     | Type                                  | Required? | Notes                                                                                                                                                                                                                                                                                                                           |
+| -------------- | ------------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| AllowedFluids  | `Array`<br />(Element Type: `String`) | **Yes**   | If any of these fluids are targeted by the player, the player's held item will be converted to the keyed item state and `Durability` and `TransformFluid` will be used.                                                                                                                                                         |
+| Durability     | `Double`<br />(Default: -1.0)         | **No**    | If the player's held item changes item states, this value is the new item's durability, unless it is negative, in which case the item will begin at full durability. If the player's held item is already in the item state, and the item is not already at full durability, this value will be added to the item's durability. |
+| TransformFluid | `String`                              | **No**    | If provided, this field is a fluid id that the targeted fluid block should be transformed to if the player's held item is successfully updated.                                                                                                                                                                                 |
+
+## Entities
+
+### DamageEntity
+
+This interaction does not inherit from SimpleInteraction, but adds its own Next and Failed fields that
+work similarly.
+
+This interaction will cause the User entity to damage the Target entity.  It has the capability to apply different
+damage based on the direction of the attack or what body part was targeted by the User entity, with each possibility
+providing different damage calculations, effects, and Next interaction. If multiple entires match the attack, `TargetedDamage`
+(body part damage) takes highest priority, then the first matching `AngledDamage` in the list, then the default
+damage in the base interaction fields.  It is possible for elements of these different damage priorities to be taken peacemeal if higher-priority
+damage fields do not overwrite lower-priority damage fields. For instance,
+damage calculation could be taken from `TargetedDamage`, the damage effects could be taken from the first matching
+`AngledDamage`, and the Next interaction coming from the default damage field.
+
+If all damage dealt by this interaction is cancelled, then this interaction will fail, and the `Failed` interaction
+will be executed next in the chain. If any damage dealt by this interaction is blocked, then this interaction will
+succeed, but the `Blocked` interaction wil lbe executed next in the chain. Otherwise, the highest-precedent matching
+`Next` interaction that you provide will be executed.  For instance, if you provide `Next` interactions for all
+`TargetedDamage` and `AngledDamage` entries, and one in the interaction's `Next` field, then a headshot could result
+in a unique `Next` interaction being executed, even if there is a matching `AngledDamage` entry. However, if you leave
+the `Next` interaction out of your `TargetedDamage` entries, a special `Next` interaction for backstabs could be
+executed.  Otherwise, the `Next` field in the root of the interaction will be executed instead.
+
+DamageEntity has an unusual relationship with `RunTime`. This interaction always ends immediately after its first tick,
+regardless of the status of `RunTime` or `WaitForAnimationToFinish`.  However, if damage dealt by this interaction is
+calculated as `DamageCalculatorType` `Dps`, then the `RunTime` will be used to determine the precise amount of damage to
+deal. If `RunTime` is 0, then no damage will be dealt.
+
+**DamageEntity Fields**
+
+| Field Name       | Type                                                          | Required?                                                                                                                    | Notes                                                                                                                                                                                                                                                                                                                                                                         |
+| ---------------- | ------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| DamageCalculator | `DamageCalculator`                                            | **No**                                                                                                                       | If provided, describes the damage amounts and types to apply to the Target entity.                                                                                                                                                                                                                                                                                            |
+| DamageEffects    | `DamageEffects`                                               | **No**                                                                                                                       | If provided, describes particles, sounds, knockback, etc. to apply to the target entity on damage.                                                                                                                                                                                                                                                                            |
+| Next             | `Asset`<br />(Asset Type: `Interaction`)                      | **No**  After this interaction has finished, "Next" will be executed if damage was dealt to the target and none was blocked. |                                                                                                                                                                                                                                                                                                                                                                               |
+| AngledDamage     | `Array`<br />(Element Type: `AngledDamage`)                   | **No**                                                                                                                       | If provided, allows alternative `DamageCalculator`, `DamageEffects`, and `Next` entries for attacks that approach the target from certain angles.                                                                                                                                                                                                                             |
+| TargetedDamage   | `Map`<br />(Key Type: `String`, Value Type: `TargetedDamage`) | **Yes**                                                                                                                      | This field must be provided, but is not required to have any entries.  This is a map from body part names to `TargetedDamage` values. Hypixel only uses one body part name: `Head`, and it is not clear whether there are others.  If provided, allows alternative `DamageCalculator`, `DamageEffects`, and `Next` entries for attacks that damage specific enemy body parts. |
+| EntityStatsOnHit | `Array`<br />(Element Type: `EntityStatOnHit`)                | **No**                                                                                                                       | If provided, allows this attack to reduce enemy stats other than health.  Each individual damage application dealt by the same ability will apply stat reductions, at diminishing returns. All damage dealt in interaction chains forked by a Selector interaction will share the number of hits across all targets.                                                          |
+| Failed           | `Asset`<br />(Asset Type: `Interaction`)                      | **No**                                                                                                                       | After this interaction has finished, "Failed" will be executed if no damage hits were applied to the player, or if all damage hits were cancelled.                                                                                                                                                                                                                            |
+| Blocked          | `Asset`<br />(Asset Type: `Interaction`)                      | **No**                                                                                                                       | After this interaction has finished, "Blocked" will be executed if any damage hits were blocked by the target.                                                                                                                                                                                                                                                                |
+
+**DamageCalculator Fields**
+
+| Field Name                | Type                                                      | Required? | Notes                                                                                                                                                                                                                                                 |
+| ------------------------- | --------------------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Type                      | `DamageCalculatorType`<br />(Default: Absolute)           | **No**    | Whether the damage being applied is `Absolute` or \`Dps'.                                                                                                                                                                                             |
+| Class                     | `DamageClass`<br />(Default: Unknown)                     | **No**    | The type of attack producing the damage. Some weapon systems apply equipment modifiers based on this value.                                                                                                                                           |
+| BaseDamage                | `Map`<br />(Key Type: `DamageCause`, Value Type: `Float`) | **No**    | A set of DamageCauses and how much base damage is dealt for each.                                                                                                                                                                                     |
+| SequentialModifierStep    | `Float`<br />(Default: 0.0)                               | **No**    | Value between 0.0-1.0. Each additional hit from a single ability will have its damage reduced by this much as a percentage. All damage dealt in interaction chains forked by a Selector interaction will share the number of hits across all targets. |
+| SequentialModifierMinimum | `Float`<br />(Default: 0.0)                               | **No**    | Value between 0.0-1.0. `SequentialModifierStep` cannot reduce damage below this percentage regardless of the number of hits.                                                                                                                          |
+| RandomPercentageModifier  | `Float`<br />(Default: 0.0)                               | **No**    | A random value between +/- this amount multiplied by the base damage will be added to the base damage.                                                                                                                                                |
+
+**DamageEffects Fields**
+
+| Field Name             | Type                                         | Required? | Notes                                                                                   |
+| ---------------------- | -------------------------------------------- | --------- | --------------------------------------------------------------------------------------- |
+| ModelParticles         | `Array`<br />(Element Type: `ModelParticle`) | **No**    | Particle systems to trigger in the first-person view.                                   |
+| WorldParticles         | `Array`<br />(Element Type: `WorldParticle`) | **No**    | Particle systems to trigger in the third-person view.                                   |
+| LocalSoundEventId      | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | 2D sound to play locally to the attacking entity if they are a player.                  |
+| WorldSoundEventId      | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | Sound to play in the world at the Target entity's location.                             |
+| PlayerSoundEventId     | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | 2D sound to play locally to the Target entity if they are a player.                     |
+| ViewDistance           | `Double`<br />(Default: 75.0)                | **No**    | Distance at which these effects should play for other players.                          |
+| Knockback              | `Knockback`                                  | **No**    | The properties of the knockback that will be applied.                                   |
+| CameraEffect           | `Asset`<br />(Asset Type: `CameraEffect`)    | **No**    | CameraEffect to briefly apply locally to the Target entity if they are a player.        |
+| StaminaDrainMultiplier | `Float`<br />(Default: 1.0)                  | **No**    | This multiplier is applied to the stamina cost incurred by the target blocking, if any. |
+
+**AngledDamage Fields**
+
+| Field Name       | Type                                     | Required? | Notes                                                                                                                                                                                                     |
+| ---------------- | ---------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| AngleDistance    | `Float`<br />(Default: 0)                | **No**    | The width in degrees of the matching arc around the Target entity. If the attack against the Target originates from within the arc, then the properties below will be applied to the attack, if provided. |
+| Angle            | `Float`<br />(Default: 0.0)              | **No**    | The angle in degrees around the Target entity at which the matching arc is centered.                                                                                                                      |
+| DamageCalculator | `DamageCalculator`                       | **No**    | If provided and the attack against the Target entity originates from within the provided arc, this DamageCalculator will override the interaction's `DamageCalculator` field.                             |
+| DamageEffects    | `DamageEffects`                          | **No**    | If provided and the attack against the Target entity originates from within the provided arc, this DamageEffects will override the interaction's `DamageEffects` field.                                   |
+| Next             | `Asset`<br />(Asset Type: `Interaction`) | **No**    | If provided and the attack against the Target entity originates from within the provided arc, this Interaction will override the interaction's `Next` field.                                              |
+
+**TargetedDamage Fields**
+
+| Field Name       | Type                                     | Required? | Notes                                                                                                                                                                                            |
+| ---------------- | ---------------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| DamageCalculator | `DamageCalculator`                       | **No**    | If provided and this TargetedDamage was matched, this DamageCalculator will override the interaction's `DamageCalculator` field and the `DamageCalculator` field of any matching `AngledDamage`. |
+| DamageEffects    | `DamageEffects`                          | **No**    | If provided and this TargetedDamage was matched, this DamageEffects will override the interaction's `DamageEffects` field and the `DamageEffects` field of any matching `AngledDamage`.          |
+| Next             | `Asset`<br />(Asset Type: `Interaction`) | **No**    | If provided and this TargetedDamage was matched, this Interaction will override the interaction's `Next` field and the `Next` field of any matching `AngledDamage`.                              |
+
+**EntityStatOnHit Fields**
+
+| Field Name                  | Type                                                                       | Required? | Notes                                                                                                                                                                                                                                                                                        |
+| --------------------------- | -------------------------------------------------------------------------- | --------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| EntityStatId                | `Asset`<br />(AssetType: `EntityStatType`)                                 | **Yes**   | Which entity stat to affect.                                                                                                                                                                                                                                                                 |
+| Amount                      | `Float`<br />(Default: 0.0)                                                | **No**    | How much of the stat to apply for each damage application. Use negative numbers to reduce stats.                                                                                                                                                                                             |
+| MultipliersPerEntitiesHit   | `Array`<br />(Element Type: `Float`, Default: `[1.0, 0.6, 0.4, 0.2, 0.1]`) | **No**    | The diminishing returns curve to be applied for multiple damage applications by the same ability. Each hit's stat impact will be multiplied by the next value in the list.  If there are more hits than array elements, subsequent hits will be multiplied by `MultiplierPerExtraEntityHit`. |
+| MultiplierPerExtraEntityHit | `Float`<br />(Default: 0.05)                                               | **No**    | If an ability carries out more damage applications than there are elements in the `MultipliersPerEntitiesHit` array, then subsequent stat values will be multiplied by this number.                                                                                                          |
+
+**Knockback Fields**
+
+| Field Name     | Type                                       | Required? | Notes                                                                                                                      |
+| -------------- | ------------------------------------------ | --------- | -------------------------------------------------------------------------------------------------------------------------- |
+| Type           | `String`                                   | **No**    | If provided, specifies a type of knockback to use. Each Target type may come with additional fields.                       |
+| Force          | `Double`<br />(Default: 0.0)               | **No**    | The amount of force to apply to the Owner entity.                                                                          |
+| Duration       | `Double`<br />(Default: 0.0)               | **No**    | If 0.0, apply the force as a single impulse.  If more, continuously apply the force over a period of time.                 |
+| VelocityType   | `ChangeVelocityType`<br />(Default: `Add`) | **No**    | How to apply the force, either adding it to the entity's current velocity, or setting the velocity to the knockback force. |
+| VelocityConfig | `VelocityConfig`                           | **No**    | Characteristics of friction as the Owner entity is thrown by this knockback.                                               |
+
+**Knockback Type: Force**
+
+Apply the calculated knockback force along the provided direction.
+
+| Field Name | Type                         | Required? | Notes                                                                                |
+| ---------- | ---------------------------- | --------- | ------------------------------------------------------------------------------------ |
+| Direction  | `Vector3`<br />(Default: Up) | **No**    | Which direction the entity should be flung, relative to the direction of the attack. |
+
+**Knockback Type: Point**
+
+Apply the calculated knockback force laterally along the XZ plane, plus provided Y velocity.
+
+| Field Name | Type                        | Required? | Notes                                                                                                   |
+| ---------- | --------------------------- | --------- | ------------------------------------------------------------------------------------------------------- |
+| OffsetX    | `Integer`<br />(Default: 0) | **No**    | Offset the source position of the knockback left or right perpendicular to the direction of the attack. |
+| OffsetZ    | `Integer`<br />(Default: 0) | **No**    | Offset the source position of the knockback, forward or backward along the directon of the attack.      |
+| RotateY    | `Integer`<br />(Default: 0) | **No**    | Rotate the knockback direction around the Y axis, where 0 is the default attack direction.              |
+| VelocityY  | `Float`<br />(Default: 0.0) | **No**    | Add vertical velocity to the knockback force after the direction and force has been calculated.         |
+
+**Knockback Type: Directional**
+
+Apply the calculated knockback force along the attack direction, removing any vertical component and replacing it with a provided Y velocity.
+
+| Field Name | Type                      | Required? | Notes                                                                                                                                            |
+| ---------- | ------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------ |
+| RelativeX  | `Float`<br />(Default: 0) | **No**    | Apply additional force left or right perpendicular to the direction of the attack. The additional force is multiplied by the knockback strength. |
+| RelativeZ  | `Float`<br />(Default: 0) | **No**    | Apply additional force forward or backward along the attack direction. The additional force is multiplied by the knockback strength.             |
+| VelocityY  | `Float`<br />(Default: 0) | **No**    | Replace the vertical velocity of the knockback with this value.  This value is not multiplied by knockback strength.                             |
+
+**VelocityConfig Fields**
+
+| Field Name          | Type                                              | Required? | Notes                                                                                                                                                                                           |
+| ------------------- | ------------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| GroundResistance    | `Float`<br />(Default: 0.82)                      | **No**    | The minimum amount of friction applied when the entity is in contact with the ground.  1.0 = no friction, 0.0 = total friction                                                                  |
+| GroundResistanceMax | `Float`<br />(Default: 0.0)                       | **No**    | The maximum amount of friction applied when the entity is in contact with the ground.  1.0 = no friction, 0.0 = total friction                                                                  |
+| AirResistance       | `Float`<br />(Default: 0.96)                      | **No**    | The minimum amount of friction applied when the entity is in the air. 1.0 = no friction, 0.0 = total friction                                                                                   |
+| AirResistanceMax    | `Float`<br />(Default: 0.0)                       | **No**    | The maximum amount of friction applied when the entity is in the air. 1.0 = no friction, 0.0 = total friction                                                                                   |
+| Threshold           | `Float`<br />(Default: 1.0)                       | **No**    | The speed at which the maximum amount of friction will be applied to the entity. The amount of friction applied will increase from minimum to maximum as the entity moves from 0 to this speed. |
+| Style               | `VelocityThresholdStyle`<br />(Default: `Linear`) | **No**    | The curve that friction follows as the entity's speed increases toward the `Threshold`.                                                                                                         |
+
+**DamageCalculatorType Values**
+
+- `Absolute`
+- `Dps`
+
+**DamageClass Values**
+
+- `Unknown`
+- `Light`
+- `Charged`
+- `Signature`
+
+**ChangeVelocityType Values**
+
+- `Add`
+- `Set`
+
+**VelocityThresholdStyle Values**
+
+- `Linear`
+- `Exp`
+
+### LaunchProjectile
+
+This is just a worse version of Projectile and is slated to be removed.  Use Projectile.
+
+### Projectile
+
+This interaction will spawn a new projectile at the User entity's eye position that will travel in its look direction.
+
+| Field Name | Type                                          | Required? | Notes                                                  |
+| ---------- | --------------------------------------------- | --------- | ------------------------------------------------------ |
+| Config     | `Asset`<br />(Asset Type: `ProjectileConfig`) | **No**    | Configuration describing the projectile to be spawned. |
+
+### RemoveEntity
+
+Despawns the specified entity from the world. This interaction will have no effect if the specified entity is a player. This
+interaction has no special failure conditions.
+
+| Field Name | Type                                     | Required? | Notes                  |
+| ---------- | ---------------------------------------- | --------- | ---------------------- |
+| Entity     | `InteractionTarget`<br />(Default: User) | **No**    | The entity to despawn. |
+
+**InteractionTarget Values**
+
+- `User` - The user of this interaction chain. The entity whose actions caused this interaction chain to be executed. This is usually the same as the Owner.
+- `Owner` - The owner of this interaction chain. The entity upon whom this interaction chain is executing.
+- `Target` - The entity target of this interaction chain, if any.  This value is mutable (and can therefore come from many places) but most commonly, it is an entity the User was targeting when this interaction chain began executing.
+
+### SendMessage
+
+This interaction sends a message to the Owner entity if that entity can receive messages.  Otherwise, the message
+is written to the server logs.  If the entity is a player, the message will appear in the player's chat window.
+
+\*\*SendMessage
+
+| Field Name | Type     | Required? | Notes                                                                                                                 |
+| ---------- | -------- | --------- | --------------------------------------------------------------------------------------------------------------------- |
+| Message    | `String` | **No**    | A text message to be sent to the Owner entity.  If this field is not provided, `Key` is used instead.                 |
+| Key        | `String` | **No**    | A translation key for a message to be sent to the Owner entity. If `Message` is provided, then this field is ignored. |
+
+### UseEntity
+
+This interaction is not in use by Hypixel and has some unusual qualities that mean it probably won't do what you want it
+to.  Do not use it.
+
+This interaction will retrieve the entity currently targeted by the client (NOT the interaction chain's current Target
+entity) and execute that entity's RootInteraction for this interaction chain's current interaction type. The
+RootInteraction will be executed as part of this current interaction chain. None of the properties of this interaction
+chain will be modified.
+
+This interaction will fail if the client is not currently targeting an entity, or if no interaction for the current
+interaction type exists on the entity.
+
+## Stats
+
+Hytale's resource system has been written about fairly extensively.  You can use these interactions to modify stats in
+response to actions or use stats as a cost for abilities.
+
+### ChangeStat
+
+This interaction applies a set of raw stat changes to the User entity. It has no special failure conditions.
+
+| Field Name    | Type                                                         | Required? | Notes                                                                                                                                                                                                                      |
+| ------------- | ------------------------------------------------------------ | --------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| StatModifiers | `Map`<br />(Key Type: `EntityStatType`, Value Type: `Float`) | **Yes**   | A set of stats to modify and what value to apply to them.                                                                                                                                                                  |
+| ValueType     | `ValueType`<br />(Default: Absolute)                         | **No**    | Whether the values in the `StatModifiers` map represent flat values to apply to the stat total, or percentages (0.0-100.0). Percentage values are percentage of the difference between the maximum and minimum stat value. |
+| Behaviour     | `ChangeStatBehavior`<br />(Default: Add)                     | **No**    | Whether the values in the `StatModifiers` map represent deltas to add into the User entity's current stat values, or fixed values to set the entity's stats to.                                                            |
+
+**ValueType Values**
+
+- `Absolute`
+- `Percent`
+
+**ChangeStatBehaviour Values**
+
+- `Add`
+- `Set`
+
+### ChangeStatWithModifier
+
+This interaction is like ChangeStat, except an armor stat modifier can be chosen which will apply bonuses and penalties
+to a stat from the User entity's equipped armor before it is applied.
+
+| Field Name            | Type                                                         | Required? | Notes                                                                                                                                                                                                                      |
+| --------------------- | ------------------------------------------------------------ | --------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| StatModifiers         | `Map`<br />(Key Type: `EntityStatType`, Value Type: `Float`) | **Yes**   | A set of stats to modify and what value to apply to them.                                                                                                                                                                  |
+| ValueType             | `ValueType`<br />(Default: Absolute)                         | **No**    | Whether the values in the `StatModifiers` map represent flat values to apply to the stat total, or percentages (0.0-100.0). Percentage values are percentage of the difference between the maximum and minimum stat value. |
+| Behaviour             | `ChangeStatBehavior`<br />(Default: Add)                     | **No**    | Whether the values in the `StatModifiers` map represent deltas to add into the User entity's current stat values, or fixed values to set the entity's stats to.                                                            |
+| InteractionModifierId | `InteractionModifierId`                                      | **Yes**   | The armor interaction modifier to apply bonuses and penalties for.                                                                                                                                                         |
+
+**ValueType Values**
+
+- `Absolute`
+- `Percent`
+
+**ChangeStatBehaviour Values**
+
+- `Add`
+- `Set`
+
+**InteractionModifierId Values**
+
+- `Dodge`
+
+### StatsCondition
+
+This interaction will fail if the User entity cannot afford the specified stats costs, or if it does not have the
+requested stats.
+
+| Field Name | Type                                                         | Required? | Notes                                                                                                                                                                                    |
+| ---------- | ------------------------------------------------------------ | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Costs      | `Map`<br />(Key Type:` EntityStatType`, Value Type: `Float`) | **Yes**   | A set of costs that the User entity needs to be able to afford for this interaction to succeed.                                                                                          |
+| ValueType  | `ValueType`<br />(Default: Absolute)                         | **No**    | Whether the values in the `Costs` map represetn flat values or percentages (0.0-100.0).  Percentage values are percentage of the difference between the maximum and minimum value.       |
+| LessThan   | `Boolean`<br />(Default: false)                              | **No**    | If true, this interaction will fail unless the User entity's current stat values are at or **below** the specified levels.  If false, they must be at or **above** the specified levels. |
+| Lenient    | `Boolean`<br />(Default: false)                              | **No**    | If true and `LessThan` is true, and a player's minimum stat value is below zero, then the player can afford a stat cost if the current value of a stat if above 0.                       |
+
+**ValueType Values**
+
+- `Absolute`
+- `Percent`
+
+### StatsConditionWithModifier
+
+This interaction is like StatsCondition, except an armor stat modifier can be chosen which will apply bonuses and penalties
+to a stat's cost from the User entity's equipped armor before it is compared.
+
+| Field Name            | Type                                                         | Required? | Notes                                                                                                                                                                                    |
+| --------------------- | ------------------------------------------------------------ | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Costs                 | `Map`<br />(Key Type:` EntityStatType`, Value Type: `Float`) | **Yes**   | A set of costs that the User entity needs to be able to afford for this interaction to succeed.                                                                                          |
+| ValueType             | `ValueType`<br />(Default: Absolute)                         | **No**    | Whether the values in the `Costs` map represetn flat values or percentages (0.0-100.0).  Percentage values are percentage of the difference between the maximum and minimum value.       |
+| LessThan              | `Boolean`<br />(Default: false)                              | **No**    | If true, this interaction will fail unless the User entity's current stat values are at or **below** the specified levels.  If false, they must be at or **above** the specified levels. |
+| Lenient               | `Boolean`<br />(Default: false)                              | **No**    | If true and `LessThan` is true, and a player's minimum stat value is below zero, then the player can afford a stat cost if the current value of a stat if above 0.                       |
+| InteractionModifierId | `InteractionModifierId`                                      | **Yes**   | The armor interaction modifier to apply bonuses and penalties for.                                                                                                                       |
+
+**ValueType Values**
+
+- `Absolute`
+- `Percent`
+
+**InteractionModifierId Values**
+
+- `Dodge`
+
+## EntityEffects
+
+EntityEffects are buff or debuff effects that can be applied to a LivingEntity.  These can have a variety of effects from
+movement speed changes to periodic damage.
+
+### EffectCondition
+
+This interaction will fail if the specified entity's EntityEffects do not match the provided conditions.
+
+**EffectCondition Fields**
+
+| Field Name      | Type                                             | Required? | Notes                                                                                                                                                                                                             |
+| --------------- | ------------------------------------------------ | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Entity          | `InteractionTarget`<br />(Default: User)         | **Yes**   | The entity to examine for EntityEffects. This field can indicate the Owner, User, or Target of this interaction chain.                                                                                            |
+| Match           | `Match`<br />(Default: All)                      | **No**    | If `All`, then this interaction will fail if any EntityEffect in the `EntityEffectIds` is not on the specified entity. If `None`, then this interaction will fail if any EntityEffect IS on the specified entity. |
+| EntityEffectIds | `AssetArray`<br />(Element Type: `EntityEffect`) | **Yes**   | The set of EntityEffects to check against the specified entity and `Match`.                                                                                                                                       |
+
+**InteractionTarget Values**
+
+- `User` - The user of this interaction chain. The entity whose actions caused this interaction chain to be executed. This is usually the same as the Owner.
+- `Owner` - The owner of this interaction chain. The entity upon whom this interaction chain is executing.
+- `Target` - The entity target of this interaction chain, if any.  This value is mutable (and can therefore come from many places) but most commonly, it is an entity the User was targeting when this interaction chain began executing.
+
+**Match Values**
+
+- `All` - All EntityEffects must be on the specified entity for this interaction to succeed.
+- `None` - None of the EntityEffects must be on the specified entity for this interaction to succeed.
+
+### ApplyEffect
+
+This interaction will apply the specified EntityEffect to the specified Entity.  It has no special failure conditions.
+
+**ApplyEffect Fields**
+
+| Field Name | Type                                      | Required? | Notes                                                                                                                  |
+| ---------- | ----------------------------------------- | --------- | ---------------------------------------------------------------------------------------------------------------------- |
+| Entity     | `InteractionTarget`<br />(Default: User)  | **Yes**   | The entity to apply the EntityEffect to. This field can indicate the Owner, User, or Target of this interaction chain. |
+| EffectId   | `Asset`<br />(Asset Type: `EntityEffect`) | **Yes**   | The effect to apply.                                                                                                   |
+
+**InteractionTarget Values**
+
+- `User` - The user of this interaction chain. The entity whose actions caused this interaction chain to be executed. This is usually the same as the Owner.
+- `Owner` - The owner of this interaction chain. The entity upon whom this interaction chain is executing.
+- `Target` - The entity target of this interaction chain, if any.  This value is mutable (and can therefore come from many places) but most commonly, it is an entity the User was targeting when this interaction chain began executing.
+
+### ClearEntityEffect
+
+This interaction will remove the specified EntityEffect from the specified Entity. It has no special failure conditions.
+It will not fail if the Entity does not have the EntityEffect.
+
+**ClearEntityEffect Fields**
+
+| Field Name | Type                                      | Required? | Notes                                                                                                                     |
+| ---------- | ----------------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------- |
+| Entity     | `InteractionTarget`<br />(Default: User)  | **Yes**   | The entity to remove the EntityEffect from. This field can indicate the Owner, User, or Target of this interaction chain. |
+| EffectId   | `Asset`<br />(Asset Type: `EntityEffect`) | **Yes**   | The effect to remove.                                                                                                     |
+
+**InteractionTarget Values**
+
+- `User` - The user of this interaction chain. The entity whose actions caused this interaction chain to be executed. This is usually the same as the Owner.
+- `Owner` - The owner of this interaction chain. The entity upon whom this interaction chain is executing.
+- `Target` - The entity target of this interaction chain, if any.  This value is mutable (and can therefore come from many places) but most commonly, it is an entity the User was targeting when this interaction chain began executing.
+
+## Farming
+
+These are interaction types built to support the in-game farming system in Hytale. They are mostly block-related interactions
+with a few exceptions.
+
+### ChangeFarmingStage
+
+If the target block is a farming block, this interaction will attempt to modify the current farming stage in one of
+three ways.  The interaction can optionally specify which StageSet to use for the new stage. If it is not specified,
+the current StageSet will be used. If any part of the the process of changing the growth stage fails, this interaction
+will fail, with the one exception that attempting to set the stage to the crop's existing stage will have no effect but
+still succeed.
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                                                                                                                                                                          |
+| ---------------- | ------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction.                                                                                                                                              |
+| StageSet         | `String`                        | **No**    | If provided, set the block's current stage to one in the provided StageSet. Otherwise, use the crop's current StageSet.                                                                                                                                                        |
+| Increase         | `Integer`                       | **No**    | If provided, increase the current stage by the specified amount. If the specified stage does not exist, the block will be set to the closest extant stage.                                                                                                                     |
+| Decrease         | `Integer`                       | **No**    | If provided and `Increase` is not provided, decrease the current stage by the specified amount. If the specified stage does not exist, the block will be set to the closest extant stage.                                                                                      |
+| Stage            | `Integer`<br />(Default: -1)    | **No**    | If provided and `Increase`/`Decrease` are not provided, set the current stage to the specified stage. If this value is less than 0, set the current stage to the final growth stage. If the specified stage does not exist, the block will be set to the closest extant stage. |
+
+### FertilizeSoil
+
+If the target block is unfertilized tilled soil or a farming block on top of unfertilized tilled soil, fertilizes the soil.
+The interaction will fail otherwise.
+
+**FertilizeSoil Fields**
+
+| Field Name       | Type                                  | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false)       | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+| RefreshModifiers | `Array`<br />(Element Type: `String`) | **No**    | Does nothing.                                                                                                                     |
+
+### HarvestCrop
+
+This interaction will attempt to execute the harvest action on the current block target and add the crop's drops to the User entity's
+inventory.  The block will either be destroyed or set to its post-harvest growth stage, depending on the farming
+configuration of the block.  This will happen (and the player will receive the full harvest drops) regardless of the
+block's current growth stage. This interaction has no special failure conditions, even if the block target isn't a
+farming block or gathering isn't permitted in the current world, but nothing will occur in those cases.
+
+**HarvestCrop Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+
+### UseWateringCan
+
+If the target block is tilled soil or a farming block on top of tilled soil, waters the soil for the specified duration.
+The interaction will fail otherwise.
+
+**UseWateringCan Fields**
+
+| Field Name       | Type                                  | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false)       | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+| Duration         | `Integer`<br />(Default: 0)           | **No**    | The duration in seconds to water the soil for.                                                                                    |
+| RefreshModifiers | `Array`<br />(Element Type: `String`) | **No**    | Does nothing.                                                                                                                     |
diff --git a/content/docs/hu-HU/contributing/pr-guidelines.mdx b/content/docs/hu-HU/contributing/pr-guidelines.mdx
index 7a251032..c226da04 100644
--- a/content/docs/hu-HU/contributing/pr-guidelines.mdx
+++ b/content/docs/hu-HU/contributing/pr-guidelines.mdx
@@ -19,6 +19,8 @@ To ensure a smooth and efficient review process, both contributors and reviewers
 4. **Code Quality**
    - Ensure your code follows the project's coding standards and best practices.
    - Include comments where necessary to explain complex logic.
+   - Always test your changes locally before submitting the PR to catch any issues early.
+   - Format your code using `bun format` to maintain consistency across the codebase.
 5. **Testing**
    - Test your changes thoroughly before submitting the PR.
    - If applicable, include unit tests or integration tests to verify your changes.
diff --git a/content/docs/hu-HU/contributing/translate.mdx b/content/docs/hu-HU/contributing/translate.mdx
new file mode 100644
index 00000000..c62ffdde
--- /dev/null
+++ b/content/docs/hu-HU/contributing/translate.mdx
@@ -0,0 +1,74 @@
+---
+title: Translate
+description: How to translate HytaleModding to your language
+---
+
+# Translating HytaleModding
+
+HytaleModding is translated with the help of the community using **Crowdin**. If you want to help translate or improve existing translations, this is the right place.
+
+## Steps to Translate
+
+All translations are managed **via Crowdin**.
+
+1. Visit [our Crowdin project](https://crowdin.com/project/hytalemodding) and log in if required.
+2. Click on your language.
+3. Click on the file/article you wish to translate. We recommend starting with Official Documentation, and then Server Plugin Documentation.
+4. Start translating!
+5. Approved translations will appear on the website.
+
+### Video Guide
+
+<iframe src="https://www.youtube.com/embed/NHiG1rDRgks" allowFullScreen />
+
+## How to discuss
+
+You can always report issues or discuss specific topics directly on Crowdin, but we recommend using Discord instead of the Crowdin comment system to keep everything organized in one place.
+
+1. Join [our Discord](https://discord.gg/hytalemodding)
+2. Open `#translations` channel. Here you can discuss or ask questions that are not related to a specific language.
+3. If you want to join a thread, you are required to run `/translator <your-language>` command here. The bot will add you to the thread for your language.
+
+## Translation Guidelines
+
+- You need to be confident in what you are translating. You should be able to read the text you just translated and understand the meaning of it very easily.
+- It should use the simplest form of language possible. Use English words if the translation is unknown to the majority in your country.
+- Use your imagination, trust yourself. Feel free to change any context as you wish as long as it can still get the same point across and is understandable.
+- These guidelines are more important than language-specific guidelines, but less important than Hytale terminology and rules.
+
+## What not to translate
+
+We request you all to not translate these specific sections of the website:
+
+### Callout types
+
+Callouts are the boxes that contain important information. We request you to not translate the types as they only work in English.
+
+**Example:**
+
+```mdx
+<Callout type="warning" title="Translate this title!">
+Translate the text inside the callout!
+</Callout>
+```
+
+In this example, please don't translate the word warning, the rest you can translate.
+
+### Icons
+
+Icon names must not be translated.
+They are technical identifiers mapped directly to existing icons. Translating them will break the icon rendering.
+
+```mdx
+icon: Globe
+```
+
+---
+
+{/* 
+For translators who will edit this page:
+
+- You are required to translate the Guidelines as they change.
+- General guidelines should be translated but not edited.
+- Learn how to use Markdown from writing_guides.mdx
+*/}
diff --git a/content/docs/hu-HU/established-information/server/content-categories/art-assets.mdx b/content/docs/hu-HU/established-information/server/content-categories/art-assets.mdx
index 39c2ed37..1e926874 100644
--- a/content/docs/hu-HU/established-information/server/content-categories/art-assets.mdx
+++ b/content/docs/hu-HU/established-information/server/content-categories/art-assets.mdx
@@ -14,7 +14,7 @@ Hytale provides comprehensive support for 3D modeling and texture art creation,
 Hytale uses **Blockbench** as the primary tool for 3D modeling and animation:
 
 * **Official support**: Used for "creating Hytale models, textures, and animations"
-* **Special plugin**: Hytale will have a dedicated Blockbench plugin, to be released ASAP
+* **Special plugin**: Hytale has a dedicated [Blockbench Plugin](https://www.blockbench.net/plugins/hytale_plugin).
 * **Direct compatibility**: The plugin allows creators to "create Hytale-compatible models, textures, and animations directly in Blockbench"
 * **Replaces legacy tools**: Fully replaces the old Hytale Model Maker to better support established creative workflows in the community
 * **Safety features**: Only allows you to add things compatible with the engine, so no need to worry about breaking anything
diff --git a/content/docs/hu-HU/guides/ecs/block-components.mdx b/content/docs/hu-HU/guides/ecs/block-components.mdx
new file mode 100644
index 00000000..ca68b38a
--- /dev/null
+++ b/content/docs/hu-HU/guides/ecs/block-components.mdx
@@ -0,0 +1,247 @@
+---
+title: Block Components
+description: Learn how to use the block components.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+  - name: oskarscot
+    link: https://oskar.scot
+---
+
+# Overview
+
+In this guide, you'll learn how to use block components to create a ticking block.
+
+<Callout>
+  For a more complete reference, you may also want to review FarmingSystems.Ticking, as much of the underlying logic is based on its implementation.
+</Callout>
+
+## Steps
+
+### 1. ExampleBlock - holds block behavior
+
+```java
+public class ExampleBlock implements Component<ChunkStore> {
+
+    public static final BuilderCodec CODEC = BuilderCodec.builder(ExampleBlock.class, ExampleBlock::new).build();
+
+    // Components usually require a copy constructor as well but since we don't actually hold any data in this component this is not neccessary
+    public ExampleBlock() { }
+
+    public static ComponentType getComponentType() {
+        return ExamplePlugin.get().getExampleBlockComponentType();
+    }
+
+    @Nullable
+    public Component<ChunkStore> clone() {
+        return new ExampleBlock();
+    }
+}
+```
+
+ExampleBlock is a custom component that stores the behavior and data for your ticking block. Here, it simply places an Ice Block at x + 1 relative to its current position when it ticks.
+
+---
+
+### 2. ExampleInitializer - marks blocks as ticking when placed
+
+```java
+public class ExampleInitializer extends RefSystem {
+
+    @Override
+    public void onEntityAdded(@Nonnull Ref ref, @Nonnull AddReason reason, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+        BlockModule.BlockStateInfo info = (BlockModule.BlockStateInfo) commandBuffer.getComponent(ref, BlockModule.BlockStateInfo.getComponentType());
+        if (info == null) return;
+
+        ExampleBlock generator = (ExampleBlock) commandBuffer.getComponent(ref, ExamplePlugin.get().getExampleBlockComponentType());
+        if (generator != null) {
+            int x = ChunkUtil.xFromBlockInColumn(info.getIndex());
+            int y = ChunkUtil.yFromBlockInColumn(info.getIndex());
+            int z = ChunkUtil.zFromBlockInColumn(info.getIndex());
+
+            WorldChunk worldChunk = (WorldChunk) commandBuffer.getComponent(info.getChunkRef(), WorldChunk.getComponentType());
+            if (worldChunk != null) {
+				worldChunk.setTicking(x, y, z, true);
+            }
+        }
+    }
+
+    @Override
+    public void onEntityRemove(@Nonnull Ref ref, @Nonnull RemoveReason reason, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+    }
+
+    @Override
+    public Query getQuery() {
+        return Query.and(BlockModule.BlockStateInfo.getComponentType(), ExamplePlugin.get().getExampleBlockComponentType());
+    }
+}
+```
+
+ExampleInitializer is a RefSystem that reacts when block entities with the ExampleBlock component are added or removed. This is crucial for marking blocks as ticking when they're first placed.
+
+**Key Points:**
+
+- Tells the game that this block should tick, allowing `ExampleSystem` to process it.
+
+```java
+worldChunk.setTicking(x, y, z, true);
+```
+
+---
+
+### 3. ExampleSystem - handles ticking
+
+```java
+public class ExampleSystem extends EntityTickingSystem {
+
+    public void tick(float dt, int index, @Nonnull ArchetypeChunk archetypeChunk, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+        BlockSection blocks = (BlockSection) archetypeChunk.getComponent(index, BlockSection.getComponentType());
+
+        assert blocks != null;
+
+        if (blocks.getTickingBlocksCountCopy() != 0) {
+            ChunkSection section = (ChunkSection) archetypeChunk.getComponent(index, ChunkSection.getComponentType());
+
+            assert section != null;
+
+            BlockComponentChunk blockComponentChunk = (BlockComponentChunk) commandBuffer.getComponent(section.getChunkColumnReference(), BlockComponentChunk.getComponentType());
+
+            assert blockComponentChunk != null;
+
+            blocks.forEachTicking(blockComponentChunk, commandBuffer, section.getY(), (blockComponentChunk1, commandBuffer1, localX, localY, localZ, blockId) -> {
+                Ref<ChunkStore> blockRef = blockComponentChunk.getEntityReference(ChunkUtil.indexBlockInColumn(localX, localY, localZ));
+                if (blockRef == null) {
+                    return BlockTickStrategy.IGNORED;
+                } else {
+                    ExampleBlock exampleBlock = (ExampleBlock) commandBuffer1.getComponent(blockRef, ExampleBlock.getComponentType());
+                    if (exampleBlock != null) {
+                        WorldChunk worldChunk = (WorldChunk) commandBuffer.getComponent(section.getChunkColumnReference(), WorldChunk.getComponentType());
+                        World world = worldChunk.getWorld();
+
+                        int globalX = localX + (worldChunk.getX() * 32);
+                        int globalZ = localZ + (worldChunk.getZ() * 32);
+
+                        // We need to execute setBlock on the world thread as you cannot call store functions from a system
+                        // This is because of the architecture of the server, depending on your needs you can also use the CommandBuffer
+                        world.execute(() -> {
+                            world.setBlock(globalX + 1, localY, globalZ, "Rock_Ice");
+                        });
+
+                        return BlockTickStrategy.CONTINUE;
+
+                    } else {
+                        return BlockTickStrategy.IGNORED;
+                    }
+                }
+            });
+        }
+    }
+
+    @Nullable
+    public Query getQuery() {
+        return Query.and(BlockSection.getComponentType(), ChunkSection.getComponentType());;
+    }
+}
+```
+
+ExampleSystem is an EntityTickingSystem that runs every tick to execute the logic for all ticking blocks with the ExampleBlock component.
+
+**Key Points:**
+
+- **Get the block component**
+
+```java
+ExampleBlock exampleBlock = (ExampleBlock) commandBuffer.getComponent(blockRef, ExampleBlock.getComponentType());
+```
+
+- **Convert local chunk coordinates to world coordinates**
+
+```java
+int globalX = localX + (worldChunk.getX() * 32);
+int globalZ = localZ + (worldChunk.getZ() * 32);
+```
+
+- **Run the block logic**
+
+```java
+exampleBlock.runBlockAction(globalX, localY, globalZ, worldChunk.getWorld());
+```
+
+- **Keep the block ticking in the next tick**
+
+```java
+return BlockTickStrategy.CONTINUE;
+```
+
+---
+
+### 4. ExamplePlugin - registers components and systems
+
+```java
+public class ExamplePlugin extends JavaPlugin {
+    protected static ExamplePlugin instance;
+    private static final HytaleLogger LOGGER = HytaleLogger.forEnclosingClass();
+    private ComponentType exampleBlockComponentType;
+
+    public static ExamplePlugin get() {
+        return instance;
+    }
+
+    public ExamplePlugin(@Nonnull JavaPluginInit init) {
+        super(init);
+        LOGGER.atInfo().log("Hello from " + this.getName() + " version " + this.getManifest().getVersion().toString());
+    }
+
+    @Override
+    protected void setup() {
+        instance = this;
+        LOGGER.atInfo().log("Setting up plugin " + this.getName());
+        this.exampleBlockComponentType = this.getChunkStoreRegistry().registerComponent(ExampleBlock.class, "ExampleBlock", ExampleBlock.CODEC);
+    }
+	
+	@Override
+	protected void start() {
+		this.getChunkStoreRegistry().registerSystem(new ExampleSystem());
+		this.getChunkStoreRegistry().registerSystem(new ExampleInitializer());
+	}
+
+    public ComponentType getExampleBlockComponentType() {
+        return this.exampleBlockComponentType;
+    }
+}
+```
+
+---
+
+### 5. Configure In-Game
+
+![block-component-1](/assets/guides/block-component-1.png)
+
+![block-component-2](/assets/guides/block-component-2.png)
+
+With this logic, the block will now continuously place an Ice Block at the coordinates x + 1 relative to its current position every time it ticks.
+
+---
+
+## Common Issues
+
+### NullPointerException on Startup
+
+**Error message:**
+
+```java
+java.lang.NullPointerException: Cannot invoke "com.hypixel.hytale.component.query.Query.validateRegistry(com.hypixel.hytale.component.ComponentRegistry)" because "query" is null
+```
+
+**Cause:**
+This error occurs when your module is loaded **before** the required Hytale modules.
+
+**Fix:**
+Add `EntityModule` and `BlockModule` as dependencies in your `manifest.json` to ensure proper load order.
+
+```json
+"Dependencies": {
+  "Hytale:EntityModule": "*",
+  "Hytale:BlockModule": "*"
+}
+```
diff --git a/content/docs/hu-HU/guides/ecs/hytale-ecs-theory.mdx b/content/docs/hu-HU/guides/ecs/hytale-ecs-theory.mdx
index 20c3a94d..52d8b1f5 100644
--- a/content/docs/hu-HU/guides/ecs/hytale-ecs-theory.mdx
+++ b/content/docs/hu-HU/guides/ecs/hytale-ecs-theory.mdx
@@ -29,7 +29,7 @@ for now this is the basic understanding for the `ChunkStore`. You can use it to
 
 ## Holder
 
-A Holder is essentially a blueprint for an entity. Before an entity exists in the Store (and thus in the world), is exists as a `Holder`. It collects and holds all the necessary components (data). You can compare it analogous to shopping cart. You grab all components you need and once you have everything, check out at the store which will take your cart and create a valid entity ID and hand you back a receipt (a Ref).
+A Holder is essentially a blueprint for an entity. Before an entity exists in the Store (and thus in the world), it exists as a `Holder`. It collects and holds all the necessary components (data). You can compare it analogous to shopping cart. You grab all components you need and once you have everything, check out at the store which will take your cart and create a valid entity ID and hand you back a receipt (a Ref).
 
 Let's take a look at an example: initializing players. In `Universe`, the `addPlayer` method demonstrates it perfectly.
 When a player connects, we don't immediately throw them into the ECS. We first construct their data in a Holder.
@@ -167,7 +167,7 @@ MyComponent comp = commandBuffer.getComponent(ref, componentType);
 
 Codecs handle serialization and deserialization of components. Hytale uses them to save and load entity data to and from disk as well as sending component data over the network. When creating a custom component, you must also create a corresponding Codec.
 
-There are mutliple Codec types already implemented in the default Codec Interface:
+There are multiple Codec types already implemented in the default Codec Interface:
 
 - Codec.STRING
 - Codec.BOOLEAN
@@ -215,7 +215,7 @@ This might seem tedious at first but it ensures that your component can be corre
   KeyedCodec<Integer> exampleInt = new KeyedCodec<Integer>("ExampleIntIdForCodec", Codec.INTEGER);
   ```
 
-- **Setter Function**: This is a lambda function that takes an instance of your component and returns the value of the field you want to serialize. For example, if you have a field called `myCustomField` in your custom component, your getter function would look like this:
+- **Setter Function**: This is a lambda function that takes an instance of your component + the value to set and sets the field value on the component. For example, if you have a field called `myCustomField` in your custom component, your setter function would look like this:
   ```java
   (data, value) -> data.myCustomField = value
   ```
@@ -276,7 +276,7 @@ public class PoisonComponent implements Component<EntityStore> {
 
 You can also add validators to your Codec fields to ensure that the data being serialized/deserialized meets certain criteria. For example, if you want to ensure that the `damagePerTick` field is always non-negative or the poison name is never null, you can add a validator like this:
 
-````java
+```java
 .append(
     new KeyedCodec<Float>("DamagePerTick", Codec.FLOAT),
     (data, value) -> data.damagePerTick = value,
@@ -292,14 +292,15 @@ You can also add validators to your Codec fields to ensure that the data being s
 )
 .addValidator(Validators.nonNull())
 .add()
+```
 
 ### Complex Codec Examples
 
-If you want to have a map inside your component, you can use the MapCodec class to build a KeyedCoded for it. Here's an example of how to create a Codec for a Map field:
+If you want to have a map inside your component, you can use the MapCodec class to build a KeyedCodec for it. Here's an example of how to create a Codec for a Map field:
 
 ```java
 var damagePerTick = new KeyedCodec<>("DamagePerTick", new MapCodec<>(Codec.FLOAT, HashMap<String, Float>::new));
-````
+```
 
 <Callout type="info">
   This also works with custom Objects as long as you have a Codec defined for the Object type.
diff --git a/content/docs/hu-HU/guides/java-basics/00-introduction.mdx b/content/docs/hu-HU/guides/java-basics/00-introduction.mdx
index a03ad638..b0130d74 100644
--- a/content/docs/hu-HU/guides/java-basics/00-introduction.mdx
+++ b/content/docs/hu-HU/guides/java-basics/00-introduction.mdx
@@ -7,7 +7,7 @@ Welcome to your journey into Java Programming! This guide is designed to introdu
 
 ## What is Java?
 
-Java is a powerful, object-oriented programming language created in 1995. It's one of the most popular programming languages in the world and is used for everything from mobile apps to enterprise software. Most importantly for us, it's the language Hytale uses for it's servers & modding API.
+Java is a powerful, object-oriented programming language created in 1995. It's one of the most popular programming languages in the world and is used for everything from mobile apps to enterprise software. Most importantly for us, it's the language Hytale uses for its servers & modding API.
 
 ## What You'll Learn
 
diff --git a/content/docs/hu-HU/guides/java-basics/02-operators.mdx b/content/docs/hu-HU/guides/java-basics/02-operators.mdx
index a132b1c0..18634665 100644
--- a/content/docs/hu-HU/guides/java-basics/02-operators.mdx
+++ b/content/docs/hu-HU/guides/java-basics/02-operators.mdx
@@ -119,7 +119,7 @@ String greetingWithName = "Hello, " + name + "!"; // "Hello, Alice!"
 
 ## Operator Precedence
 
-Operator Precendence means which operator gets evaluated first in an line of code. Think of it like BODMAS/PEMDAS in math!
+Operator Precedence means which operator gets evaluated first in an line of code. Think of it like BODMAS/PEMDAS in math!
 
 ```java
 int result = 10 + 5 * 2; // result is 20, not 30
diff --git a/content/docs/hu-HU/guides/java-basics/03-control-flow-if.mdx b/content/docs/hu-HU/guides/java-basics/03-control-flow-if.mdx
index b9d6c479..af2d1c22 100644
--- a/content/docs/hu-HU/guides/java-basics/03-control-flow-if.mdx
+++ b/content/docs/hu-HU/guides/java-basics/03-control-flow-if.mdx
@@ -7,7 +7,7 @@ Programs need to make decisions. If statements let your code choose different pa
 
 ## Basic If Statement
 
-The simplest form checks one condition;
+The simplest form checks one condition:
 
 ```java
 int health = 20;
diff --git a/content/docs/hu-HU/guides/java-basics/08-access-modifiers.mdx b/content/docs/hu-HU/guides/java-basics/08-access-modifiers.mdx
index af560932..da2bf33b 100644
--- a/content/docs/hu-HU/guides/java-basics/08-access-modifiers.mdx
+++ b/content/docs/hu-HU/guides/java-basics/08-access-modifiers.mdx
@@ -484,7 +484,7 @@ class Data {
     // Static member:
     // cannot access to non-static variables
     public static void bar() {
-        x = 100; // Error: non-static variable x cannot be renference from a static context
+        x = 100; // Error: non-static variable x cannot be referenced from a static context
         y = 100; // OK
     }
 }
@@ -504,7 +504,7 @@ Data.x = 1000; // Error: cannot access instanced variables in a static context
 
 ### Static Fields
 
-A static field represents a data member owned by the class type rather then the object. Static fields are also stored in a specific memory location that's been shared between all the object instances that are created.
+A static field represents a data member owned by the class type rather than the object. Static fields are also stored in a specific memory location that's been shared between all the object instances that are created.
 
 It is declared as following:
 
diff --git a/content/docs/hu-HU/guides/plugin/animated-block-textures.mdx b/content/docs/hu-HU/guides/plugin/animated-block-textures.mdx
new file mode 100644
index 00000000..42bfa51f
--- /dev/null
+++ b/content/docs/hu-HU/guides/plugin/animated-block-textures.mdx
@@ -0,0 +1,101 @@
+---
+title: Animated Block Textures
+description: Learn how to attach a .blockyanim to a block
+authors:
+  - name: Burkino
+---
+
+import { File, Folder, Files } from 'fumadocs-ui/components/files';
+
+So, you want to make your blocks feel more alive through animations, do you?\
+Now for the most part this is the exact same as [Creating custom blocks](./creating-block).
+![blue fire gif](/assets/guides/blue_fire.gif)
+
+## Prerequisites
+
+This is NOT a guide on animating or texturing or even using BlockBench, why? Because I don't know how to do that.\
+The only thing we will be doing is taking the fire texture, changing the color, and applying it to our new fire block.
+
+## Setup
+
+To start, you're obviously going to want to grab the `Common/VFX/Fire/Fire.png` file. How you do it is up to you, in the Asset Editor you'll need to switch to the Common tab.\
+I'll assume you know how colorize or change the hue of an image, so go ahead and do that now and save it as `Blue_Fire.png`.
+
+The other assets used in this guide are `Common/VFX/Fire/Fire.blockymodel` and `Common/Blocks/Animations/Fire/Fire_Burn.blockyanim` (both renamed to `Blue_Fire`) but since we won't be changing them it's probably fine to leave them. I will reference the `Blue_Fire` versions as a way to point out what should be custom assets.\
+I will also duplicate `Server/Item/Item/Deco/Deco_Fire.json` and call it `Deco_Blue_Fire.json`.
+
+## Applying the changes
+
+The `Deco_Blue_Fire` block is actually just a particle emitter, however we will not be using particles, so lets start by removing them in `Block > Particles`.\
+Next we want to set the Block Model (called `CustomModel` in JSON) to `VFX/Blue_Fire/Blue_Fire.blockymodel` and Block Model Textures (`CustomModelTexture` in JSON) to
+
+```json
+[
+    {
+        "Texture": "VFX/Blue_Fire/Blue_Fire.png",
+        "Weight": 1
+    }
+]
+```
+
+Finally, we will apply the .blockyanim to our model, this is done through the Block Model Animation property (`CustomModelAnimation` in JSON) and the value should be `Blocks/Animations/Blue_Fire/Blue_Fire_Burn.blockyanim`.
+
+## Final Code
+
+With that your new blue fire should be done. Here is the minimal JSON for our blue fire.\
+There is an additional `Looping` and `RequiresAlphaBlending` property that I have not gone over, however I hope it is self-explanatory.
+
+```json
+{
+  "BlockType": {
+    "DrawType": "Model",
+    "CustomModel": "VFX/Blue_Fire/Blue_Fire.blockymodel",
+    "CustomModelAnimation": "Blocks/Animations/Blue_Fire/Blue_Fire_Burn.blockyanim",
+    "CustomModelTexture": [
+      {
+        "Texture": "VFX/Blue_Fire/Blue_Fire.png",
+        "Weight": 1
+      }
+    ],
+    "Looping": true,
+    "RequiresAlphaBlending": false
+  },
+  "PlayerAnimationsId": "Block"
+}
+```
+
+<Files>
+  <Folder name="resources" defaultOpen>
+    <Folder name="Server" defaultOpen>
+      <Folder name="Item" defaultOpen>
+        <Folder name="Items" defaultOpen>
+          <Folder name="Deco" defaultOpen>
+            <File name="Deco_Blue_Fire.json" />
+          </Folder>
+        </Folder>
+      </Folder>
+    </Folder>
+
+    <Folder name="Common" defaultOpen>
+      <Folder name="Blocks" defaultOpen>
+        <Folder name="Animations" defaultOpen>
+          <Folder name="Blue_Fire" defaultOpen>
+            <File name="Blue_Fire_Burn.blockyanim" />
+          </Folder>
+        </Folder>
+      </Folder>
+
+      <Folder name="VFX" defaultOpen>
+        <Folder name="Blue_Fire" defaultOpen>
+          <File name="Blue_Fire.blockymodel" />
+
+          <File name="Blue_Fire.png" />
+        </Folder>
+      </Folder>
+    </Folder>
+  </Folder>
+</Files>
+
+## Next steps
+
+Now that you know how to attach an animation to a block, try adding it to a block state.
diff --git a/content/docs/hu-HU/guides/plugin/build-and-test.mdx b/content/docs/hu-HU/guides/plugin/build-and-test.mdx
index 0e7fe7eb..f37534c3 100644
--- a/content/docs/hu-HU/guides/plugin/build-and-test.mdx
+++ b/content/docs/hu-HU/guides/plugin/build-and-test.mdx
@@ -9,18 +9,18 @@ If you followed along with the [Setting Up Your Development Environment](./setti
 
 ## Building Your Mod
 
-In our case, we've **Maven** as the build system. Maven is a powerful build automation tool that manages dependencies, compiles your code, and packages everything into a distributable JAR file.
+In our case, we've **Gradle** as the build system. Gradle is a powerful build automation tool that manages dependencies, compiles your code, and packages everything into a distributable JAR file.
 
-### Understanding Maven
+### Understanding Gradle
 
-Maven uses a `pom.xml` file (Project Object Model) to define your project's configuration, dependencies, and build settings. You can learn more about Maven at the [official Apache Maven website](https://maven.apache.org/).
+Gradle can use a `build.gradle.kts` file (Kotlin DSL) to define your project's configuration, dependencies, and build settings. You can learn more about Gradle at the [official Gradle website](https://gradle.org/).
 
-### Building with Maven
+### Building with Gradle
 
 To build your mod, open a terminal in your project directory and run:
 
 ```bash
-mvn package
+./gradlew build
 ```
 
 This command will:
@@ -29,16 +29,35 @@ This command will:
 2. Run any tests (if present)
 3. Package everything into a JAR file
 
+<Callout type="info">
+  If you are using the plugin template from the [Setting Up Your Development Environment](./setting-up-env) guide, then the build script is already set up for you. It includes paths to your Hytale game library and handles the packaging of your mod, managing hytale dependencies and manifest changes.
+
+  If you have a different path to your Hytale installation, you may receive the following error:
+
+  ```bash
+  FAILURE: Build failed with an exception.
+
+  * What went wrong:
+  Failed to find Hytale at the expected location. Please make sure you have installed the game. The expected location can be changed using the hytale.home_path property. Currently looking in 'C:\Path\To\Hytale'
+  ```
+
+  You can change the path by adding a property to your `gradle.properties` file (if it doesn't exist, create it in the root of your project):
+
+  ```properties
+  hytale.home_path=C:\Correct\Path\To\Hytale
+  ```
+</Callout>
+
 ### Build Output
 
-Once the build completes successfully, your mod will be located in the `target` directory and named:
+Once the build completes successfully, your mod will be located in the `build/libs` directory and named:
 
 ```
-ExamplePlugin-1.0-SNAPSHOT.jar
+ExamplePlugin-1.0.jar
 ```
 
 <Callout type="info">
-  The exact name may vary depending on what you configured in your `pom.xml` file. Check the `artifactId` and `version` fields to see what your JAR will be named.
+  The exact name may vary depending on what you configured in your `build.gradle.kts` and `settings.gradle.kts` file. Check the `rootProject.name` and `version` fields to see what your JAR will be named.
 </Callout>
 
 ## Testing Your Mod
@@ -49,11 +68,11 @@ Now that you've built your mod, it's time to test it in Hytale!
 
 First, you need to find Hytale's mods directory:
 
-1. Press **Win + R** on your keyboard
-2. Type `%appdata%` and press Enter
-3. Navigate to: `Hytale\UserData\Mods`
+1. Go to your Hytale installation directory (The default location is usually in your AppData folder)
+   > On Windows, you can access it by clicking `windows + R` and typing `%appdata%`.
+2. Navigate to: `/UserData/Mods`
 
-The full path should look like:
+The default path would look like:
 
 ```
 C:\Users\YourUsername\AppData\Roaming\Hytale\UserData\Mods
@@ -65,7 +84,7 @@ C:\Users\YourUsername\AppData\Roaming\Hytale\UserData\Mods
 
 ### 2. Copy Your Mod
 
-Copy the `ExamplePlugin-1.0-SNAPSHOT.jar` file from your project's `target` directory into the `Mods` folder you just located.
+Copy the `ExamplePlugin-1.0.jar` file from your project's `build/libs` directory into the `Mods` folder you just located.
 
 ### 3. Launch Hytale and Verify
 
@@ -84,7 +103,7 @@ If your mod doesn't appear in the mods list:
 - Make sure the JAR file is in the correct `Mods` folder
 - Check that your `manifest.json` file is properly configured
 - Look for any error messages in the Hytale logs
-- Verify that you're using the correct version of Java and Maven
+- Verify that you're using the correct version of Java and Gradle
 
 ## Next Steps
 
diff --git a/content/docs/hu-HU/guides/plugin/creating-commands.mdx b/content/docs/hu-HU/guides/plugin/creating-commands.mdx
index d33597f3..08572f16 100644
--- a/content/docs/hu-HU/guides/plugin/creating-commands.mdx
+++ b/content/docs/hu-HU/guides/plugin/creating-commands.mdx
@@ -8,6 +8,8 @@ authors:
     url: https://oskar.scot
   - name: jacobwojoski
     url: https://github.com/jacobwojoski
+  - name: Marcel-TO
+    url: https://marcel-to.net
 ---
 
 In this guide, you will learn how to create custom commands for your Hytale mod.
@@ -36,7 +38,7 @@ The most basic command is an `AbstractAsyncCommand`. It has very minimal data av
   `AbstractAsyncCommand` runs on its own background thread. This means its execute is not tied to any world instance and because of this it can not edit any **Stores** or **Refs** without getting the desired world first. To access this data any of the other command types would be preferred and are likely what you will want to use instead.
 </Callout>
 
-The main purpose for a command like this would be for something that can happen everywhere and is not tied to a specific world. For example a `serverRules` command to tell the user thats running the command in chat what the servers rules are nomatter what world they are in.
+The main purpose for a command like this would be for something that can happen everywhere and is not tied to a specific world. For example a `serverRules` command to tell the user that's running the command in chat what the server's rules are no matter what world they are in.
 
 ```java
 // Command that can be run that lists the server rules in chat to the player
@@ -49,7 +51,7 @@ public class ServerRulesCommand extends AbstractAsyncCommand {
     }
 
     // Run the command
-    // conetext - info about who ran the command. Server console?, Some player?
+    // context - info about who ran the command. Server console?, Some player?
     @Override
     protected CompletableFuture<Void> executeAsync(@Nonnull CommandContext context) {
         context.sendMessage(Message.raw("The only rule is there are no rules."));
@@ -134,7 +136,7 @@ Uses a Ray to see what the player is looking at and tries to run the command on
 
 ## Adding Arguments
 
-Arguments are additional fields that the user can input when running a command. The different types of arguments along with small snipits and a large example can be seen below.
+Arguments are additional fields that the user can input when running a command. The different types of arguments along with small snippets and a large example can be seen below.
 
 ### Command Argument Types
 
@@ -163,14 +165,14 @@ this.messageArg = this.withOptionalArg("message", "Message to print while healin
 
 ### Default Arguments
 
-Adding a default argument has two additional arguemnt for the default value and default value description. You need to use `withDefaultArg` method.
+Adding a default argument has two additional argument for the default value and default value description. You need to use `withDefaultArg` method.
 
 ```java
 // args <Command String> <Description> <Default Value> <Desc of default value>
 this.healthArg = this.withDefaultArg("health", "Amount to heal player", ArgTypes.FLOAT, (float)100, "Desc of Default: 100");
 ```
 
-### Flag Arguemnts
+### Flag Arguments
 
 Similar as above but the flags return is either true if it exists or false if it does not. You need to use `withFlagArg` method.
 
@@ -181,20 +183,13 @@ this.debugArg = this.withFlagArg("debug", "Add debug logs");
 
 ### ArgTypes
 
-The following ArgTypes are available (only lists common types):
-
-- `ArgTypes.STRING`
-- `ArgTypes.INTEGER`
-- `ArgTypes.BOOLEAN`
-- `ArgTypes.FLOAT`
-- `ArgTypes.DOUBLE`
-- `ArgTypes.UUID`
+You can find all the available argument types on the [ArgTypes](../../argtypes) page.
 
 ### Example Command Arg Types
 
-Shows all Command arguemnt types with different various input types.
+Shows all Command argument types with different various input types.
 
-**NOTE:** When getting the value of an argument during execute you need to pass the context with `someArg.get(commandContext)`. Where `commandContext` is the first variable in the execute funtion.
+**NOTE:** When getting the value of an argument during execute you need to pass the context with `someArg.get(commandContext)`. Where `commandContext` is the first variable in the execute function.
 
 ```java
 // Example usage: /healplayer --health 50 --message "Feels Good" --debug
@@ -204,7 +199,7 @@ public class HealPlayerCommand extends AbstractTargetPlayerCommand {
     private final FlagArg debugArg;
 
     public HealPlayerCommand() {
-        super("healplayer", "Healing a player for an <input> ammount of HP (default: 100)");
+        super("healplayer", "Healing a player for an <input> amount of HP (default: 100)");
 
         // Abstract TargetPlayerCommand passes the player that ran the command by default and implements
         // the use of `--player <value>` to specify someone else
@@ -213,10 +208,10 @@ public class HealPlayerCommand extends AbstractTargetPlayerCommand {
         this.healthArg = this.withDefaultArg("health", "Amount to heal player", ArgTypes.FLOAT, (float)100, "Desc of Default: 100");
 
         // Or you could do the following making the health value required instead of with a default.
-        //    You would need to change the decleration to RequiredArg<Float>
+        //    You would need to change the declaration to RequiredArg<Float>
         // this.healthArg = this.withRequiredArg("health", "Amount to heal player", ArgTypes.FLOAT);
 
-        // Optional args reguare the user the input `--<key> <value>` so the following would require `--message "Good Luck"`
+// Optional args require the user the input `--<key> <value>` so the following would require `--message "Good Luck"`
         this.messageArg = this.withOptionalArg("message", "Message to print while healing", ArgTypes.STRING);
 
         // No type needed due to being a bool
@@ -230,7 +225,7 @@ public class HealPlayerCommand extends AbstractTargetPlayerCommand {
             commandContext.sendMessage(Message.raw("We are debugging"));
         }
 
-        // Health is stored in a generic stat map to allowing mods/future contect to easily add more stats if desired.
+        // Health is stored in a generic stat map to allowing mods/future content to easily add more stats if desired.
         EntityStatMap stats = store.getComponent(ref, EntityStatMap.getComponentType());
         int healthIdx = DefaultEntityStatTypes.getHealth();
         EntityStatValue health = stats.get(healthIdx);
@@ -252,7 +247,7 @@ public class HealPlayerCommand extends AbstractTargetPlayerCommand {
 
 ## Argument Validators
 
-Argument validators are a way to check the command before the command gets executed. They are added with the `addValidator` method on an argument when calling `withXxxArg`. They provide a nice output to the user when an input value is invalid.
+Argument validators are a way to check the command before the command gets executed. They are added with the `addValidator` method on an argument when calling `withXxxArg`. They provide a nice output to the user when an input value is invalid. There are some common validators provided in the `Validators` class such as `greaterThan`, `lessThan`, and `or`, `max`, `range`, etc.
 
 ```java
 ...
@@ -260,18 +255,59 @@ Argument validators are a way to check the command before the command gets execu
     OptionalArg<Integer> healAmount = withOptionalArg("amount", "Heal Amount", ArgTypes.INTEGER)
         .addValidator(Validators.greaterThan(0))
         .addValidator(Validators.lessThan(1000));
-
-    // Custom check example
-    OptionalArg<Integer> healAmount = withOptionalArg("amount", "Heal Amount", ArgTypes.INTEGER)
-            .addValidator( value -> {
-                if (value != null && value <= 0) {
-                    return ValidationResult.error("ammount argument must be a positive number");
-                }
-                return ValidationResult.success();
-            });
 ...
 ```
 
+### Custom Validators
+
+You can also create custom validators by implementing the `com.hypixel.hytale.codec.validation.Validator` interface. The interfaces forces you to implement the `accept` and `updateSchema` method. The `accept` method takes in the argument value and validates it. If the validation fails, you can use the `fail` method of the `com.hypixel.hytale.codec.validation.ValidationResults` class to return an error message.
+The `updateSchema` method is used to update the schema of the command argument. This is used for commands that have dynamic schemas based on the input value. For example, if you have a command that takes in a player name as an argument, you can use the `updateSchema` method to update the schema to include a list of online players for validation.
+
+Here is an example of a custom validator that checks if a string value is equal to a banned word. In this example, the banned word is "badword". If the input value is "badword", the validator will fail and return an error message.
+
+```java
+import com.hypixel.hytale.codec.schema.SchemaContext;
+import com.hypixel.hytale.codec.schema.config.Schema;
+import com.hypixel.hytale.codec.validation.ValidationResults;
+import com.hypixel.hytale.codec.validation.Validator;
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+
+public class MyCustomValidator implements Validator<String> {
+    @Nonnull
+    private final String value;
+
+    public MyCustomValidator(@Nonnull String value) {
+        this.value = value;
+    }
+
+    @Override
+    public void accept(@Nullable String input, @Nonnull ValidationResults results) {
+        if (this.value.equalsIgnoreCase(input)) {
+            results.fail("The given role has been banned.");
+        }
+    }
+
+    @Override
+    public void updateSchema(SchemaContext context, @Nonnull Schema target) {
+        // This method can be used to update the schema of the command argument. This is useful for commands that have dynamic schemas based on the input value. For example, if you have a command that takes in a player name as an argument, you can use the `updateSchema` method to update the schema to include a list of online players for validation.
+        throw new UnsupportedOperationException("Not implemented yet.");
+    }
+}
+```
+
+After the custom validator is created, you can add it to an argument like the following example. In this example, we add the `MyCustomValidator` to a string argument called "role". If the user inputs "badword" as the role, the command will fail and return the error message defined in the `MyCustomValidator`.
+
+```java
+    ...
+    // Custom validator example
+    String bannedRole = "badword";
+
+    OptionalArg<String> roleArg = withOptionalArg("role", "Role to assign", ArgTypes.STRING)
+        .addValidator(new MyCustomValidator(bannedRole));
+    ...
+```
+
 ---
 
 ## Permissions
@@ -312,7 +348,7 @@ This allows the server to control who has access to specific commands. You add t
 
 If you want variants of the same command without doing argument parsing you can instead use `addUsageVariant(new OtherCommandClass())` in the original commands constructor.
 
-The only difference is in the `OtherCommandClass()` constrcutor you don't pass the command name to the super class.
+The only difference is in the `OtherCommandClass()` constructor you don't pass the command name to the super class.
 
 <Callout type="info">
   You can also use `addAliases("some_alias", "some_other_alias")` as a way to add shorthand or other ways to write the same command.
@@ -387,7 +423,7 @@ public class AdminCommand extends AbstractCommandCollection {
     public AdminCommand () {
         super("admin", "Admin commands");
         addSubCommand(new UserCommandCollection());
-        addSybCommand(new ServerCommandCollection);
+        addSubCommand(new ServerCommandCollection);
     }
 }
 ```
@@ -417,5 +453,5 @@ public class MyPlugin extends JavaPlugin {
 
 ## Video Link
 
-_Special Thanks to [TroubleDev](https://www.youtube.com/@TroubleDEV) for his excelent video guide on all of these features._
+_Special Thanks to [TroubleDev](https://www.youtube.com/@TroubleDEV) for his excellent video guide on all of these features._
 _Video Link: [TroubleDev - Hytale's Command API Explained](https://www.youtube.com/watch?v=KnmhG9MDMgo)_
diff --git a/content/docs/hu-HU/guides/plugin/creating-events.mdx b/content/docs/hu-HU/guides/plugin/creating-events.mdx
index 95863990..d3f0925d 100644
--- a/content/docs/hu-HU/guides/plugin/creating-events.mdx
+++ b/content/docs/hu-HU/guides/plugin/creating-events.mdx
@@ -1,6 +1,6 @@
 ---
-title: Creating Events
-description: Learn how to create custom events for your Hytale mod.
+title: Creating Events Listeners
+description: Learn how to create event listeners for your Hytale mod.
 authors:
   - name: Neil Revin
     url: https://itsneil.dev
@@ -10,7 +10,7 @@ authors:
 
 ## Event Class
 
-You can import a Event class and create a function with the Event as a argument. [Click here](../../server/events) to look at all available events.
+You can import an Event class and create a function with the Event as an argument. [Click here](../../server/events) to look at all available events.
 
 Example plugin when a player is ready (joins a server):
 
diff --git a/content/docs/hu-HU/guides/plugin/item-registry.mdx b/content/docs/hu-HU/guides/plugin/item-registry.mdx
new file mode 100644
index 00000000..9a0fd53a
--- /dev/null
+++ b/content/docs/hu-HU/guides/plugin/item-registry.mdx
@@ -0,0 +1,95 @@
+---
+title: Working with the Item Registry
+description: Learn how to access and query the game's item registry to list all items, check if items exist, and retrieve item properties.
+authors:
+  - name: Denis
+---
+
+In this guide, you'll learn how to work with Hytale's Item Registry system. This is useful when you need to programmatically list all available items, validate item IDs, or retrieve item properties at runtime.
+
+## Prerequisites
+
+Before diving in, you should be familiar with:
+
+- [Setting up your development environment](./setting-up-env)
+- [Creating commands](./creating-commands) (optional, for testing)
+
+## Required Imports
+
+To work with the Item Registry, you'll need the following imports:
+
+```java
+import com.hypixel.hytale.assetstore.map.DefaultAssetMap;
+import com.hypixel.hytale.server.core.asset.type.item.config.Item;
+```
+
+## Getting the Item Registry
+
+The Item Registry is accessed through the `Item.getAssetMap()` method, which returns a `DefaultAssetMap<String, Item>` containing all registered items in the game:
+
+```java
+DefaultAssetMap<String, Item> itemMap = Item.getAssetMap();
+```
+
+## Listing All Items
+
+To iterate through all items in the registry, you can get the underlying map and loop through its entries:
+
+```java
+DefaultAssetMap<String, Item> itemMap = Item.getAssetMap();
+var map = itemMap.getAssetMap();
+
+for (var entry : map.entrySet()) {
+    String itemId = String.valueOf(entry.getKey());
+    Item item = entry.getValue();
+    
+    // Do something with the item
+    LOGGER.atInfo().log("Item ID: " + itemId);
+}
+```
+
+You can also get the total count of registered items:
+
+```java
+int totalItems = map.size();
+```
+
+## Checking if an Item Exists
+
+To check if a specific item exists in the registry, use `getAsset()` and verify the result:
+
+```java
+public boolean itemExists(String itemId) {
+    var assetMap = Item.getAssetMap();
+    if (assetMap != null) {
+        Item item = assetMap.getAsset(itemId);
+        return item != null && item != Item.UNKNOWN;
+    }
+    return false;
+}
+```
+
+<Callout type="info">
+  The `Item.UNKNOWN` constant represents an invalid or unrecognized item. Always check for both `null` and `Item.UNKNOWN` when validating items.
+</Callout>
+
+## Accessing Item Properties
+
+Once you have an `Item` instance, you can access various properties:
+
+```java
+var assetMap = Item.getAssetMap();
+Item item = assetMap.getAsset("Soil_Grass");
+
+if (item != null && item != Item.UNKNOWN) {
+    String id = item.getId(); // Soil_Grass
+    int maxStack = item.getMaxStack(); // 100
+    boolean isBlock = item.hasBlockType(); // true
+    boolean isConsumable = item.isConsumable(); // false
+}
+```
+
+## Related Guides
+
+- [Inventory Management](./inventory-management) - Learn how to add and remove items from player inventories
+- [Create Custom Item and Interaction](./item-interaction) - Learn how to create your own custom items
diff --git a/content/docs/hu-HU/guides/plugin/permission-management.mdx b/content/docs/hu-HU/guides/plugin/permission-management.mdx
index 6b7cfd46..55f06101 100644
--- a/content/docs/hu-HU/guides/plugin/permission-management.mdx
+++ b/content/docs/hu-HU/guides/plugin/permission-management.mdx
@@ -10,132 +10,569 @@ authors:
     link: https://discord.com/users/292656109939064833
   - name: Ivan
     link: https://discord.com/users/505770451218333717
+  - name: ZenithDevHQ
+    link: https://github.com/ZenithDevHQ
 ---
 
-In this guide, you'll learn how to manage permission nodes and groups in your Hytale plugin.
+In this guide, you'll learn how to manage permission nodes and groups in your Hytale plugin. Permissions control what actions players can perform on your server, from basic commands to advanced administrative functions.
 
-## The `PermissionsModule` class
+## What Are Permissions?
 
-The `PermissionsModule` class is responsible for managing permission nodes and groups in your plugin. It provides methods to check, grant and revoke permissions and groups for players. It allows the following operations
+Permissions are string identifiers that control access to features and commands. When a player tries to perform an action (like using a command), the server checks if they have the required permission.
 
-- Add permissions to user
-- Remove permissions from user
-- Add permissions to group (this also creates the group if it doesn't exist)
-- Remove permissions from group
-- Add user to group
-- Remove user from group
-- List all groups for a user
-- Check if a user has a permission (it checks both user and group permissions for the given player UUID)
+**Example permission nodes:**
 
-With this class you cannot:
+- `hytale.command.gamemode` - Permission to use the gamemode command
+- `hytale.editor.brush.use` - Permission to use brush tools
+- `myplugin.teleport.home` - A custom permission for your plugin
 
-- List all defined groups
-- Remove a group
+Permissions follow a hierarchical naming pattern: `namespace.category.action`
 
-### Adding Permission Nodes
+## Key Concepts
 
-You need a `Set<String>` containing all the permission nodes you want to add, these are added on top of the already existing permission nodes the user may have, it is not a replacement.
+Before diving into code, let's understand the core concepts:
+
+| Concept             | Description                                                                |
+| ------------------- | -------------------------------------------------------------------------- |
+| **Permission Node** | A string like `myplugin.feature.use` that represents a specific permission |
+| **Group**           | A named collection of permissions (e.g., "Admin", "VIP", "Default")        |
+| **Provider**        | The backend that stores and retrieves permissions                          |
+| **Wildcard**        | A pattern like `*` or `myplugin.*` that matches multiple permissions       |
+
+### How Permissions Are Checked
+
+When checking if a player has a permission, Hytale follows this order:
+
+1. **User's direct permissions** - Permissions granted directly to the player
+2. **Group permissions** - Permissions from groups the player belongs to
+3. **Virtual groups** - Game-mode-based permissions (e.g., Creative mode grants builder tools)
+4. **Default value** - Falls back to `false` if no match found
+
+<Callout type="info">
+  The first definitive match wins. If a player has a permission granted at the user level, group permissions won't override it.
+</Callout>
+
+---
+
+## The `PermissionsModule` Class
+
+The `PermissionsModule` class is the central hub for managing permissions. Access it using the singleton pattern:
 
 ```java
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.addUserPermission(playerUUID, permissions);
 ```
 
-### Removing Permission Nodes
+### Available Operations
+
+The module supports these operations:
+
+| Operation                     | Method                                          |
+| ----------------------------- | ----------------------------------------------- |
+| Add permissions to user       | `addUserPermission(uuid, permissions)`          |
+| Remove permissions from user  | `removeUserPermission(uuid, permissions)`       |
+| Add permissions to group      | `addGroupPermission(groupName, permissions)`    |
+| Remove permissions from group | `removeGroupPermission(groupName, permissions)` |
+| Add user to group             | `addUserToGroup(uuid, groupName)`               |
+| Remove user from group        | `removeUserFromGroup(uuid, groupName)`          |
+| Get user's groups             | `getGroupsForUser(uuid)`                        |
+| Check permission              | `hasPermission(uuid, permissionNode)`           |
+
+<Callout type="warning">
+  The module does **not** support:
+
+  - Listing all defined groups
+  - Deleting a group entirely
+
+  Groups are implicitly created when you first add permissions to them.
+</Callout>
+
+---
 
-Same as above, we just use the `removeUserPermission` method instead to remove permission nodes.
+## Checking Permissions
+
+The most common operation is checking if a player has a permission.
+
+### Basic Permission Check
+
+```java
+// Returns true if player has the permission, false otherwise
+boolean canUse = PermissionsModule.get().hasPermission(playerUUID, "myplugin.feature.use");
+
+if (canUse) {
+    // Player has permission, allow the action
+} else {
+    // Player lacks permission, deny or show error
+}
+```
+
+### Permission Check with Default Value
+
+You can specify what to return when no permission is explicitly set:
+
+```java
+// Returns true by default if no explicit permission is found
+boolean canUse = PermissionsModule.get().hasPermission(playerUUID, "myplugin.feature.use", true);
+```
+
+This is useful for features that should be enabled by default but can be revoked.
+
+### Using PermissionHolder Interface
+
+Players and command senders implement `PermissionHolder`, allowing direct checks:
+
+```java
+// In a command or event handler where you have access to the player
+if (player.hasPermission("myplugin.admin.manage")) {
+    // Player has admin permission
+}
+```
+
+---
+
+## Managing User Permissions
+
+### Adding Permissions to a User
+
+Permissions are additive - new permissions are added on top of existing ones, not replaced.
+
+```java
+PermissionsModule perms = PermissionsModule.get();
+
+// Add a single permission
+perms.addUserPermission(playerUUID, Set.of("myplugin.vip.chat"));
+
+// Add multiple permissions at once
+Set<String> newPerms = Set.of(
+    "myplugin.vip.chat",
+    "myplugin.vip.fly",
+    "myplugin.vip.kit"
+);
+perms.addUserPermission(playerUUID, newPerms);
+```
+
+### Removing Permissions from a User
 
 ```java
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.removeUserPermission(playerUUID, permissions);
+
+// Remove specific permissions
+Set<String> toRemove = Set.of("myplugin.vip.fly");
+perms.removeUserPermission(playerUUID, toRemove);
 ```
 
-### Add permissions to group
+---
+
+## Managing Groups
+
+Groups let you assign a collection of permissions to multiple players. This is more manageable than assigning permissions individually.
+
+### Adding Permissions to a Group
+
+If the group doesn't exist, it will be created automatically.
 
 ```java
-String groupName = "testGroup";
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.addGroupPermission(groupName, permissions);
+
+// Create/update the "VIP" group with permissions
+Set<String> vipPerms = Set.of(
+    "myplugin.vip.chat",
+    "myplugin.vip.fly",
+    "myplugin.vip.kit"
+);
+perms.addGroupPermission("VIP", vipPerms);
 ```
 
-### Remove permissions from group
+### Removing Permissions from a Group
 
 ```java
-String groupName = "testGroup";
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.removeGroupPermission(groupName, permissions);
+
+// Remove specific permissions from the group
+Set<String> toRemove = Set.of("myplugin.vip.fly");
+perms.removeGroupPermission("VIP", toRemove);
 ```
 
-### Add user to group
+### Adding a User to a Group
 
 ```java
-String groupName = "testGroup";
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.addUserToGroup(playerUUID, groupName);
+
+// Add player to the VIP group - they now have all VIP permissions
+perms.addUserToGroup(playerUUID, "VIP");
 ```
 
-### Remove user from group
+### Removing a User from a Group
 
 ```java
-String groupName = "testGroup";
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.removeUserFromGroup(playerUUID, groupName);
+
+// Remove player from VIP group
+perms.removeUserFromGroup(playerUUID, "VIP");
 ```
 
-### List all groups for a user
+### Getting a User's Groups
 
 ```java
 PermissionsModule perms = PermissionsModule.get();
-perms.getGroupsForUser(playerUUID);
+
+// Get all groups the player belongs to
+Set<String> groups = perms.getGroupsForUser(playerUUID);
+
+for (String group : groups) {
+    System.out.println("Player is in group: " + group);
+}
 ```
 
-### Check Permission Nodes
+---
+
+## Built-in Groups
+
+Hytale includes two default groups:
+
+| Group     | Default Permissions   | Purpose                           |
+| --------- | --------------------- | --------------------------------- |
+| `OP`      | `*` (all permissions) | Server operators with full access |
+| `Default` | None                  | Base group for all players        |
+
+Players without any explicit group assignment are automatically part of the `Default` group.
 
-To check if a player has a specific permission node, you can use the `hasPermission` method.
+---
+
+## Wildcards
+
+Wildcards let you grant or deny multiple permissions with a single pattern.
+
+### Wildcard Patterns
+
+| Pattern             | Meaning                                          |
+| ------------------- | ------------------------------------------------ |
+| `*`                 | Grants **all** permissions                       |
+| `myplugin.*`        | Grants all permissions starting with `myplugin.` |
+| `-*`                | Denies **all** permissions                       |
+| `-myplugin.admin.*` | Denies all admin permissions in your plugin      |
+
+### Example: Admin Group with Wildcards
 
 ```java
-boolean hasPermission = PermissionsModule.hasPermission(playerUUID, "permission.node");
+// Grant all permissions to admins
+perms.addGroupPermission("Admin", Set.of("*"));
+
+// Grant all plugin permissions to moderators
+perms.addGroupPermission("Moderator", Set.of("myplugin.*"));
+
+// Grant all permissions except admin commands
+perms.addGroupPermission("Helper", Set.of(
+    "*",
+    "-myplugin.admin.*"  // Deny admin permissions
+));
 ```
 
-## Additional: Defining your own provider for permissions and groups
+<Callout type="warning">
+  Negation permissions (starting with `-`) take precedence at each level. Use them carefully to avoid accidentally blocking permissions.
+</Callout>
+
+---
+
+## Built-in Permission Nodes
+
+Hytale provides constants for common permissions in the `HytalePermissions` class:
+
+### Command Permissions
+
+```java
+// Generate permission for a command
+String perm = HytalePermissions.fromCommand("gamemode");
+// Result: "hytale.command.gamemode"
+
+// Generate permission for a subcommand
+String perm = HytalePermissions.fromCommand("gamemode", "creative");
+// Result: "hytale.command.gamemode.creative"
+```
+
+### Common Permission Nodes
+
+| Permission                    | Description                  |
+| ----------------------------- | ---------------------------- |
+| `hytale.command.op.add`       | Add players to OP group      |
+| `hytale.command.op.remove`    | Remove players from OP group |
+| `hytale.editor.brush.use`     | Use brush tools              |
+| `hytale.editor.prefab.use`    | Use prefabs                  |
+| `hytale.editor.selection.use` | Use selection tools          |
+| `hytale.editor.history`       | Undo/redo operations         |
+| `hytale.camera.flycam`        | Use fly camera mode          |
+
+---
+
+## Listening to Permission Events
+
+You can react to permission changes using Hytale's event system.
+
+### Available Events
+
+| Event                                            | Triggered When                   |
+| ------------------------------------------------ | -------------------------------- |
+| `PlayerPermissionChangeEvent.PermissionsAdded`   | Permissions added to a user      |
+| `PlayerPermissionChangeEvent.PermissionsRemoved` | Permissions removed from a user  |
+| `PlayerGroupEvent.Added`                         | User added to a group            |
+| `PlayerGroupEvent.Removed`                       | User removed from a group        |
+| `GroupPermissionChangeEvent.Added`               | Permissions added to a group     |
+| `GroupPermissionChangeEvent.Removed`             | Permissions removed from a group |
 
-The PermissionsModule also enables us to define our own PermissionProvider's, this can be useful for:
+### Example: Reacting to Permission Changes
 
-- Cross server permission systems
-- Implementing features missing in the `HytalePermissionsProvider` like permission expiry
+```java
+public class PermissionListener {
+
+    public static void onPermissionsAdded(PlayerPermissionChangeEvent.PermissionsAdded event) {
+        UUID playerUUID = event.getPlayerUuid();
+        Set<String> added = event.getAddedPermissions();
+
+        System.out.println("Permissions added to " + playerUUID + ": " + added);
 
-To implement our PermissionProvider, first we need to define a provider class that implements PermissionProvider:
+        // Maybe notify the player or update cached data
+    }
+
+    public static void onGroupAdded(PlayerGroupEvent.Added event) {
+        UUID playerUUID = event.getPlayerUuid();
+        String groupName = event.getGroupName();
+
+        System.out.println("Player " + playerUUID + " joined group: " + groupName);
+    }
+}
+```
+
+### Registering the Events
 
 ```java
-public class DatabasePermissionProvider implements PermissionProvider
+public class MyPlugin extends JavaPlugin {
+
+    @Override
+    public void setup() {
+        EventRegistry events = this.getEventRegistry();
+
+        events.registerGlobal(
+            PlayerPermissionChangeEvent.PermissionsAdded.class,
+            PermissionListener::onPermissionsAdded
+        );
+
+        events.registerGlobal(
+            PlayerGroupEvent.Added.class,
+            PermissionListener::onGroupAdded
+        );
+    }
+}
 ```
 
-Then we just implement the required methods using a database implementation.
+---
+
+## Creating a Custom Permission Provider
+
+For advanced use cases, you can create your own permission provider. This is useful for:
+
+- Database-backed permissions (MySQL, MongoDB, etc.)
+- Cross-server permission synchronization
+- Custom features like permission expiry or contexts
+
+### Implementing PermissionProvider
+
+```java
+public class DatabasePermissionProvider implements PermissionProvider {
+
+    @Nonnull
+    @Override
+    public String getName() {
+        return "DatabasePermissionProvider";
+    }
+
+    // User permission methods
+    @Override
+    public void addUserPermissions(@Nonnull UUID uuid, @Nonnull Set<String> permissions) {
+        // Save to your database
+    }
+
+    @Override
+    public void removeUserPermissions(@Nonnull UUID uuid, @Nonnull Set<String> permissions) {
+        // Remove from your database
+    }
+
+    @Override
+    public Set<String> getUserPermissions(@Nonnull UUID uuid) {
+        // Query your database
+        return Set.of();
+    }
+
+    // Group permission methods
+    @Override
+    public void addGroupPermissions(@Nonnull String group, @Nonnull Set<String> permissions) {
+        // Save to your database
+    }
+
+    @Override
+    public void removeGroupPermissions(@Nonnull String group, @Nonnull Set<String> permissions) {
+        // Remove from your database
+    }
+
+    @Override
+    public Set<String> getGroupPermissions(@Nonnull String group) {
+        // Query your database
+        return Set.of();
+    }
+
+    // User-group membership methods
+    @Override
+    public void addUserToGroup(@Nonnull UUID uuid, @Nonnull String group) {
+        // Save to your database
+    }
+
+    @Override
+    public void removeUserFromGroup(@Nonnull UUID uuid, @Nonnull String group) {
+        // Remove from your database
+    }
+
+    @Override
+    public Set<String> getGroupsForUser(@Nonnull UUID uuid) {
+        // Query your database
+        return Set.of("Default");
+    }
+}
+```
 
 <Callout type="warning">
-  Hytale will try to use the first available permissions provider to add/remove gamemode groups (i.e. `Creative`, `Adventure`).
+  Hytale automatically assigns players to game-mode groups (like `Creative` or `Adventure`) using the first available provider.
+
+  If your provider throws an error when the group doesn't exist, the player will be disconnected! Always handle missing groups gracefully.
+</Callout>
+
+### Registering Your Provider
 
-  If your provider throws an error (for instance, if the group does not exist) when the server is preparing the player, the player will be disconnected.
+```java
+public class MyPlugin extends JavaPlugin {
+
+    @Override
+    public void setup() {
+        // Add your provider alongside the default one
+        PermissionsModule.get().addProvider(new DatabasePermissionProvider());
+    }
+}
+```
+
+The `PermissionsModule` aggregates permissions from all registered providers. This means:
+
+- Permission checks query all providers
+- Write operations (add/remove) use the **first** provider
+
+### Replacing the Default Provider
+
+If you want full control, you can remove the default provider:
+
+```java
+public class MyPlugin extends JavaPlugin {
+
+    @Override
+    public void setup() {
+        PermissionsModule perms = PermissionsModule.get();
+
+        // Remove the default provider FIRST
+        perms.removeProvider(perms.getFirstPermissionProvider());
+
+        // Then add your provider
+        perms.addProvider(new DatabasePermissionProvider());
+    }
+}
+```
+
+<Callout type="info">
+  When you remove the default provider, the `/op self` command will stop working since it checks for provider tampering.
 </Callout>
 
-We can then register the provider using the built-in permission module:
+---
+
+## Best Practices
+
+### Permission Naming Conventions
+
+Follow the pattern: `namespace.category.action`
 
 ```java
-PermissionsModule.get().addProvider(new DatabasePermissionProvider());
+// Good - clear hierarchy
+"myplugin.admin.ban"
+"myplugin.user.teleport.home"
+"myplugin.vip.chat.color"
+
+// Bad - unclear structure
+"myplugin_ban"
+"teleport"
+"vipChatColor"
 ```
 
-Please note that the `HytalePermissionsProvider` will still be enabled alongside your provider.
-The `PermissionsModule` will aggregate groups and permissions from all available providers.
+### Use Constants for Permissions
 
-If you want to disable the default `HytalePermissionsProvider`, you can use:
+Define your permissions as constants to avoid typos:
 
 ```java
-// put this **before** you add your provider
-PermissionsModule.get().removeProvider(PermissionsModule.get().getFirstPermissionProvider());
+public final class MyPermissions {
+    public static final String ADMIN_BAN = "myplugin.admin.ban";
+    public static final String ADMIN_KICK = "myplugin.admin.kick";
+    public static final String USER_HOME = "myplugin.user.home";
+    public static final String VIP_FLY = "myplugin.vip.fly";
+}
+
+// Usage
+if (player.hasPermission(MyPermissions.ADMIN_BAN)) {
+    // ...
+}
 ```
+
+### Don't Over-Permission
+
+Only create permissions for actions that genuinely need access control. Not everything needs a permission check.
+
+### Thread Safety
+
+If you create a custom provider, ensure it's thread-safe. Permission checks can occur from multiple threads simultaneously. Use `ReadWriteLock` or `ConcurrentHashMap` for your data structures.
+
+---
+
+## In-Game Commands
+
+Hytale provides built-in commands for managing permissions:
+
+### `/op` Command
+
+| Command               | Description                                                        |
+| --------------------- | ------------------------------------------------------------------ |
+| `/op self`            | Toggle your own OP status (singleplayer or with `--allow-op` flag) |
+| `/op add <player>`    | Add a player to the OP group                                       |
+| `/op remove <player>` | Remove a player from the OP group                                  |
+
+### `/perm` Command
+
+Use `/perm --help` in-game for full usage. Common operations:
+
+| Command                                  | Description                   |
+| ---------------------------------------- | ----------------------------- |
+| `/perm user list <uuid>`                 | List user's permissions       |
+| `/perm user add <uuid> <perm>`           | Add permission to user        |
+| `/perm user remove <uuid> <perm>`        | Remove permission from user   |
+| `/perm user group list <uuid>`           | List user's groups            |
+| `/perm user group add <uuid> <group>`    | Add user to group             |
+| `/perm user group remove <uuid> <group>` | Remove user from group        |
+| `/perm group list <group>`               | List group's permissions      |
+| `/perm group add <group> <perm>`         | Add permission to group       |
+| `/perm group remove <group> <perm>`      | Remove permission from group  |
+| `/perm test <perm>`                      | Test if you have a permission |
+
+---
+
+## Summary
+
+You've learned how to:
+
+- **Check permissions** using `PermissionsModule.hasPermission()`
+- **Manage user permissions** with `addUserPermission()` and `removeUserPermission()`
+- **Work with groups** using `addGroupPermission()`, `addUserToGroup()`, etc.
+- **Use wildcards** like `*` and `myplugin.*` for bulk permissions
+- **Listen to events** for permission changes
+- **Create custom providers** for database-backed permissions
+
+For more advanced permission systems with features like inheritance, expiry, and contexts, we're looking into expanding this guide with advanced permission management techniques in the future.
diff --git a/content/docs/hu-HU/guides/plugin/setting-up-env.mdx b/content/docs/hu-HU/guides/plugin/setting-up-env.mdx
index d2718098..5be5e9e0 100644
--- a/content/docs/hu-HU/guides/plugin/setting-up-env.mdx
+++ b/content/docs/hu-HU/guides/plugin/setting-up-env.mdx
@@ -4,6 +4,10 @@ description: Learn how to set up your development environment for modding Hytale
 authors:
   - name: Neil Revin
     link: https://itsneil.dev
+  - name: Marcel-TO
+    url: https://marcel-to.net
+  - name: Ádám Liszkai
+    link: https://adaliszk.dev
 ---
 
 This guide will walk you through setting up a complete development environment for Hytale modding, including all necessary tools and dependencies.
@@ -19,24 +23,73 @@ Before we begin, make sure you have:
 
 ## Required Software
 
-### 1. Java Development Kit (JDK)
+### Integrated Development Environment (IDE)
 
+We recommend IntelliJ IDEA Community Edition for Hytale modding. If you use IntelliJ IDEA, **almost everything is built-in**. You can clone a template, open a new project, and start working right away!
+
+1. Download from [JetBrains website](https://www.jetbrains.com/idea/download/)
+2. Install with default settings
+3. Launch and complete the initial setup wizard
+
+When opening a project, wait for indexing to finish, then start coding.
+Now, IDEA may say "No JDK configured" at the top of the source file you have.
+In that case, you can click Download JDK and choose JetBrains JDK 25.
+
+<Callout type="success">
+  If IDEA opened the project without errors, your environment is ready.
+</Callout>
+
+More details by [JetBrains](https://www.jetbrains.com/help/idea/2026.1/run-for-the-first-time.html)
+help page, where we recommend that you also check the
+[SDK configuration](https://www.jetbrains.com/help/idea/2026.1/sdk.html) guide.
+
+<Callout type="info">
+  We recommened following
+  [TheNullicorn's](https://gist.github.com/TheNullicorn/90a619796c40f20ae1fcf13094c1a57d) guide to ensure
+  you are using the correct `Nonnull` in your projects.
+</Callout>
+
+#### What the IDE Does for You
+
+When opened in IntelliJ IDEA, the project automatically:
+
+- Detects and configures Gradle or Maven
+- Downloads all dependencies
+- Sets up project structure and classpaths
+- Configures run/build tasks
+
+You do **not** need to manually install or configure Maven or Gradle if you stay inside the IDE.
+
+Skip to the [Setting Up Your Workspace](#setting-up-your-workspace).
+
+### Manual Setup: Java Development Kit (JDK)
+
+For any other setup, you will need to install and configure your system to have and load Java.
 Hytale modding requires Java 25 or later. We recommend using OpenJDK.
 
-#### Windows
+#### Windows via Installer
 
 1. Download OpenJDK 25 from [Adoptium](https://adoptium.net/)
 2. Run the installer with default settings
+   - Optionally enable feature `Set or Override JAVA_HOME variable` to resolve version related build issues with your project.
 3. Verify installation by opening Command Prompt and running:
 
+#### Windows via Scoop
+
+1. Install Scoop via PowerShell using [scoop.sh](https://scoop.sh/)
+2. Install OpenJDK 25:
+
 ```bash
-java -version
+scoop bucket add java
+scoop install java/openjdk25
 ```
 
 #### macOS
 
+1. Install Brew via Terminal using [brew.sh](https://brew.sh)
+2. Install JDK via Homebrew:
+
 ```bash
-# Using Homebrew
 brew install openjdk@25
 ```
 
@@ -51,22 +104,41 @@ brew install openjdk@25
 
 #### Linux (Ubuntu/Debian)
 
+1. Install JDK via the built-in package repository:
+
 ```bash
 sudo apt update
 sudo apt install openjdk-25-jdk
 ```
 
-### 2. Integrated Development Environment (IDE)
+### Verify installation:
 
-We recommend IntelliJ IDEA Community Edition for Hytale modding.
+Run the following command to see what version of Java you have:
 
-1. Download from [JetBrains website](https://www.jetbrains.com/idea/download/)
-2. Install with default settings
-3. Launch and complete the initial setup wizard
+```bash
+java -version
+```
+
+### Java Build Tool (Optional)
+
+We recommend using a Gradle Wrapper for managing dependencies and building your Hytale plugins. It provides benefits by eliminating the need for a system-wide Gradle installation and ensuring consistent Gradle versions across different environments. (Alternatively you can use Maven, but this guide focuses on Gradle since it is the default for our plugin template.)
+
+The plugin template in the following sections includes a Gradle Wrapper, so you can skip this step if you plan to use the template.
+
+#### Choosing Gradle (if not using the template)
+
+If you prefer to install Gradle manually, follow these steps:
 
-### 3) Java Build Tool
+1. Visit the official website: https://gradle.org/releases/
+2. Download the newest gradle binary: `gradle-9.3.1-bin.zip` (Binary zip archive)
+3. Unzip it
+4. Add the `gradle-9.3.1/bin/` folder to your PATH
+
+You can now try the command `gradle -version` to verify Gradle is installed correctly. Make sure to do this in a fresh new terminal instead of one you had opened from before!
+
+#### Choosing Maven (if not using the template)
 
-We recommend using Apache Maven for managing dependencies and building your Hytale plugins. (Alternatively you can use Gradle, but this guide focuses on Maven.)
+If you prefer to use Maven instead of Gradle, follow these steps to install Maven:
 
 1. Visit the official website: https://maven.apache.org/download.cgi
 2. Download this file: `apache-maven-3.9.12-bin.zip` (Binary zip archive)
@@ -89,22 +161,61 @@ cd MyFirstMod
 
 If you don't have Git installed, you can download the ZIP file from the repository page and extract it to a folder named `MyFirstMod`.
 
-### 2. Open Plugin in your IDEA
+### 2. Open Plugin in your IDE
 
-1. Open IntelliJ IDEA
+1. Open Your IDE (e.g., IntelliJ IDEA)
 2. Click "Open" and navigate to your `MyFirstMod` directory
-3. IntelliJ will automatically detect it as a Maven project
+3. Most IDEs like IntelliJ will automatically detect it as a Gradle project
 4. Wait for the project to index and dependencies to download
 
-<Callout type="info">
-  We recommened following [this](https://gist.github.com/TheNullicorn/90a619796c40f20ae1fcf13094c1a57d) guide to ensure you are using the correct `Nonnull` in your projects.
-</Callout>
+## Alternate Approach: Hytale Dependency
+
+If you prefer to set up your project from scratch without using the template and importing the hytale dependencies manually, ensure your build configuration includes the Hytale repositories and dependencies:
+
+For Gradle, add the following to your `build.gradle.kts`:
+
+```kotlin
+repositories {
+    mavenCentral()
+    maven {
+        name = "hytale"
+        url = uri("https://maven.hytale.com/release") // Or "hytale-pre-release" for pre-release versions
+    }
+}
+dependencies {
+    // + here means the latest version, but you can hard-wire any known version!
+    implementation("com.hypixel.hytale:Server:+")
+}
+```
+
+For Maven, add the following to your `pom.xml`:
+
+```xml
+<project>
+    <repositories>
+        <repository>
+            <id>hytale-release</id> <!-- Or "hytale-pre-release" for pre-release versions -->
+            <url>https://maven.hytale.com/release</url> <!-- Or "https://maven.hytale.com/pre-release" -->
+        </repository>
+    </repositories>
+
+    <dependencies>
+        <dependency>
+            <groupId>com.hypixel.hytale</groupId>
+            <artifactId>Server</artifactId>
+            <!-- Replace with latest version, Hytale provides jars for the last five releases -->
+            <version>LATEST_VERSION_HERE</version>
+            <scope>provided</scope>
+        </dependency>
+    </dependencies>
+</project>
+```
 
 ## Next Steps
 
 Now that you have your development environment set up with the plugin template:
 
-1. **Customize the template** - Edit the `pom.xml` and `manifest.json` file to change your mod's name and details
+1. **Customize the template** - Edit the `settings.gradle.kts`, `build.gradle.kts` and `manifest.json` file to change your mod's name and details
 2. **Explore the code structure** - Familiarize yourself with the template's organization
 3. **Start modding** - Begin writing your first Hytale plugin!
 
diff --git a/content/docs/hu-HU/guides/plugin/spawning-entities.mdx b/content/docs/hu-HU/guides/plugin/spawning-entities.mdx
index e12c0aea..15be2fb3 100644
--- a/content/docs/hu-HU/guides/plugin/spawning-entities.mdx
+++ b/content/docs/hu-HU/guides/plugin/spawning-entities.mdx
@@ -36,7 +36,7 @@ Store<EntityStore> store = world.getEntityStore().getStore();
 
 ## Creating Entities
 
-Once you have the `EntityStore` instance, you can start to create a entity and give it components. Entities are just instances of `Holder<EntityStore>` with several components attached to them.
+Once you have the `EntityStore` instance, you can start to create an entity and give it components. Entities are just instances of `Holder<EntityStore>` with several components attached to them.
 
 <Callout type="warning">
   To interact with the `World` instance, some methods require you to run the code inside the world's execution context.
@@ -118,3 +118,48 @@ Finally, we can add the entity to the world by calling the `addEntity` method on
 ```java
 store.addEntity(holder, AddReason.SPAWN);
 ```
+
+## Making the entity persist
+
+Hytale automatically saves all entities, but the `NetworkId` component (required for players to be able to see the entity) needs to be manually added every time the entity is loaded.
+
+### Using a system
+
+If you have a component that is unique to your entities, this can be done by creating and registering a custom system as follows:
+
+```java
+public class AddNetworkIdToMyEntitySystem extends HolderSystem<EntityStore> {
+    private final ComponentType<EntityStore, MyEntityComponent> myEntityComponentType = MyEntityComponent.getComponentType();
+    private final ComponentType<EntityStore, NetworkId> networkIdComponentType = NetworkId.getComponentType();
+    private final Query<EntityStore> query = Query.and(this.myEntityComponentType, Query.not(this.networkIdComponentType));
+
+    @Override
+    public void onEntityAdd(@NotNull Holder<EntityStore> holder, @NotNull AddReason reason, @NotNull Store<EntityStore> store) {
+        if (!holder.getArchetype().contains(NetworkId.getComponentType())) {
+            holder.addComponent(NetworkId.getComponentType(), new NetworkId(store.getExternalData().takeNextNetworkId()));
+        }
+    }
+
+    @Override
+    public void onEntityRemoved(@NotNull Holder<EntityStore> holder, @NotNull RemoveReason reason, @NotNull Store<EntityStore> store) {}
+
+    @Override
+    public @Nullable Query<EntityStore> getQuery() {
+        return query;
+    }
+}
+```
+
+In your plugin's `setup()` function
+
+```java
+this.getEntityStoreRegistry().registerSystem(new AddNetworkIdToMyEntitySystem())
+```
+
+### Using PropComponent
+
+Alternatively you can add `PropComponent` to your entity. Hytale adds `PropComponent` to entities spawned with the Entity Tool, and such entities automatically get `NetworkId` and `PrefabCopyableComponent` (which makes the entity work with prefabs).
+
+<Callout type="warning">
+  There is no guarantee, that Hytale will not add some other behavior to this component in the future, which may break your entity, so be careful if you decide to rely on it.
+</Callout>
diff --git a/content/docs/hu-HU/guides/plugin/store-persistent-data.mdx b/content/docs/hu-HU/guides/plugin/store-persistent-data.mdx
new file mode 100644
index 00000000..1071dff3
--- /dev/null
+++ b/content/docs/hu-HU/guides/plugin/store-persistent-data.mdx
@@ -0,0 +1,171 @@
+---
+title: Storing Persistent Data on the Player
+description: Learn how to save and load persistent data using Components
+authors:
+  - name: Neil Revin
+    url: https://itsneil.dev/
+  - name: ArcticDev
+    url: https://github.com/ArcticRaven
+  - name: oskarscot
+    url: https://oskar.scot
+  - name: JammingEng
+    url: https://github.com/JammingEnd
+---
+
+Here is how to store persistent data using a custom component on a Player.
+
+## Build your Component Class
+
+Creating a custom component class leverages the Component system made with the ECS architecture in mind. For more information on Components, check out the [ECS Guide](../ecs/hytale-ecs-theory#components).
+
+Start by creating your custom component class. This will be extremely similar to how regular components are created, however we'll setup a custom Codec so the server can translate this data to BSON, or the server's internal json encoder.
+
+<Callout type="info">
+  Each variable you want to store in your component must have its own Codec field defined in the BuilderCodec.
+  For more information on how to create custom Codecs, check out the [ECS Codec Guide](../ecs/hytale-ecs-theory#codec).
+</Callout>
+
+```java
+public class YourPlayerData implements Component<EntityStore> {
+
+    // define some vars!
+    private int someInteger;
+    private String someString;
+    private Map<String, String> someMap;
+
+    public static final BuilderCodec<YourPlayerData> CODEC =
+            BuilderCodec.builder(YourPlayerData.class, YourPlayerData::new)
+            .append(new KeyedCodec<>("SomeInteger", Codec.INTEGER),
+                    (data, value) -> data.someInteger = value, // setter
+                    data -> data.someInteger) // getter
+            .addValidator(Validators.nonNull())
+            .add()
+            .append(new KeyedCodec<>("SomeString", Codec.STRING),
+                    (data, value) -> data.someString = value, // setter
+                    data -> data.someString) // getter
+            .add()
+            .append(new KeyedCodec<>("SomeMap",
+                            new MapCodec<>(Codec.STRING, HashMap::new, false)),
+                    (data, value) -> data.someMap = value, // setter
+                    data -> data.someMap) // getter
+            .add()
+            .build();
+
+
+
+    // Getters and Setters are for the purpose of this example omitted.
+
+    // constructor
+    public YourPlayerData() {
+        this.someInteger = 0;
+        this.someString = "";
+        this.someMap = new HashMap<>();
+    }
+
+    // copy constructor for cloning
+    public YourPlayerData(YourPlayerData clone) {
+        this.someInteger = clone.someInteger;
+        this.someString = clone.someString;
+        this.someMap = clone.someMap;
+    }
+
+    @Nonnull
+    @Override
+    public Component<EntityStore> clone() {
+        return new YourPlayerData(this);
+    }
+}
+```
+
+## Register your Component
+
+Inside your main class's `setup()` method, register your new Component.
+
+```java
+public class YourPlugin extends JavaPlugin {
+
+    private ComponentType<EntityStore, YourPlayerData> yourPlayerDataComponent;
+
+    public YourPlugin(@Nonnull JavaPluginInit init) {
+        super(init);
+    }
+
+    @Override
+    protected void setup(){
+        this.yourPlayerDataComponent = this.getEntityStoreRegistry().registerComponent(
+            YourPlayerData.class,
+            "YourPlayerDataComponent",
+            YourPlayerData.CODEC
+        );
+    }
+
+    public ComponentType<EntityStore, YourPlayerData> getYourPlayerDataComponent() {
+        return this.yourPlayerDataComponent;
+    }
+}
+```
+
+## Using your Component
+
+To use your newly created component, you can add the Component to a player using the `addComponent` method, although this only adds it temporarily, meaning when the player/entity leaves the world, the component is removed. You can use `putComponent` to ensure the component persists between sessions.
+
+```java
+// You will need the Ref and Store to apply components
+private void someEntryMethod(@Nonnull Ref<EntityStore> ref, @Nonnull Store<EntityStore> store)
+{
+       // Any entity will work, for now we will use the player
+      Player player = (Player) store.getComponent(ref, Player.getComponentType());
+
+      // since we're using putComponent, it could be useful to check if it already exists on the player in case we want to update it
+     if(store.getComponent(ref, YourPlugin.instance().getYourPlayerDataComponent()) != null)
+     {
+          // here we implement logic that updates the component
+         var comp = store.getComponent(ref, YourPlugin.instance().getYourPlayerDataComponent())
+         // declare public fields or methods in the component class
+         comp.SomeString = "An Updated Field";
+     } else {
+          // Here we put the component
+          var myCustomComp = new CustomComponent();
+          // declare public fields or methods in the component class
+          myCustomComp.SomeString = "Edited String";
+
+          // putComponent allows you to insert declared objects
+          store.putComponent(ref, YourPlugin.instance().getYourPlayerDataComponent(), myCustomComp);
+     }
+}
+```
+
+## Using your Data
+
+Your component will be stored within the `Store<EntityStore>` when added to the player. In the provided example,
+we'll fetch this data off the player using the `ensureAndGetComponent()` method, which will add the component to
+the player if it does not exist with the default values.
+
+```java
+public class IncompleteCustomCommand extends AbstractPlayerCommand {
+
+    public IncompleteCustomCommand() {
+        super("nope", "don't use this command");
+    }
+
+    @Override
+    protected void execute(
+        @NonNullDecl CommandContext commandContext,
+        @NonNullDecl Store<EntityStore> store,
+        @NonNullDecl Ref<EntityStore> ref,
+        @NonNullDecl PlayerRef playerRef,
+        @NonNullDecl World world
+    ) {
+        YourPlayerData customData = store.ensureAndGetComponent(ref, YourPlugin.instance().getYourPlayerDataComponent());
+        // ensureAndGetComponent adds the component to the ref, with the default values defined inside your component.
+ 		// use your data
+    }
+}
+```
+
+And that's it! Your data will now be saved and loaded automatically with the player.
+
+Using custom components to store persistent data on players is a powerful way to maintain state across sessions.
+By following the steps outlined above, you can easily create, register, and utilize your own data structures within the Hytale ECS framework.
+This approach ensures that your data is seamlessly integrated with the game's existing systems.
+For more information about Hytale's Entity Component System visit the [Hytale ECS Theory](https://hytalemodding.dev/en/docs/guides/ecs/hytale-ecs-theory) guide.
diff --git a/content/docs/hu-HU/guides/plugin/teleporting-players.mdx b/content/docs/hu-HU/guides/plugin/teleporting-players.mdx
index 57cee77f..32ce0435 100644
--- a/content/docs/hu-HU/guides/plugin/teleporting-players.mdx
+++ b/content/docs/hu-HU/guides/plugin/teleporting-players.mdx
@@ -1,26 +1,32 @@
 ---
 title: Teleporting the player
 description: Learn how to teleport the player.
+authors:
+  - name: oskarscot
+    url: https://oskar.scot
 ---
 
-To teleport players in Hytale, you will need to get a `World` object so we can safely run the teleport on the world thread. The world thread manages all entity updates, so modifying entities off-thread can crash the server or cause inconsistent state.
-Next, we get the entity store and make a `Teleport` object.
-We add a `Teleport` component to the player’s entity reference in the entity store. This triggers the teleportation logic for that player.
+Teleporting players in Hytale works by simply attaching a `Teleport` component to a player with the desired world and transform.
+You can only trigger teleports from a world where the player is currently present.
+Teleport itself is a component but it also provides factory methods to configure the Teleport. Just as with any entity component, an EntityStore and a Ref to the EntityStore is required
+
+We can create a simple teleport utility like this:
 
 ```java
-public static void teleportPlayer(Player player, int x, int y, int z) {
-        World world = player.getWorld();
-        if (world == null) return;
-        world.execute(() -> {
-            if (player.getReference() == null) return;
-            Store<EntityStore> store = player.getReference().getStore();
-            Teleport teleport = Teleport.createForPlayer(world,
-                new Vector3d(x ,y, z), // Target position
-                new Vector3f(0, 0, 0)  // Target rotation (pitch, yaw, roll)
-            );
+public static void teleportPlayer(Ref<EntityStore> ref, Store<EntityStore> store, World targetWorld, double x, double y, double z) {                                                                                       
+    Transform transform = new Transform(x, y, z);                                                                                                                           
+    Teleport teleport = Teleport.createForPlayer(targetWorld, transform);                                                                                                   
+    store.addComponent(ref, Teleport.getComponentType(), teleport);                                                                                                         
+}  
+```
 
-            store.addComponent(player.getReference(), Teleport.getComponentType(), teleport);
-        });
+A `Transform` is a representation of a position Vector3d and rotation Vector3f which works in the following way:
 
-}
+```java
+Transform transform = new Transform(
+    new Vector3d(x, y, z),      // Position
+    new Rotation(yaw, pitch, 0) // Rotation, last value seems to always be 0
+);
+Teleport teleport = Teleport.createForPlayer(targetWorld, transform);
+store.addComponent(ref, Teleport.getComponentType(), teleport);
 ```
diff --git a/content/docs/hu-HU/guides/plugin/tracking-mod-analytics-with-hstats.mdx b/content/docs/hu-HU/guides/plugin/tracking-mod-analytics-with-hstats.mdx
new file mode 100644
index 00000000..45c022e0
--- /dev/null
+++ b/content/docs/hu-HU/guides/plugin/tracking-mod-analytics-with-hstats.mdx
@@ -0,0 +1,65 @@
+---
+title: Tracking Mod Analytics with HStats
+description: Learn how you can track Analytics for your Hytale Mod for Free using hstats.dev
+authors:
+  - name: Al3x
+    url: https://hstats.dev
+---
+
+In this guide, you will learn how to integrate HStats into your Plugin/Mod which will allow you to track how many Servers are using it along with other stats.
+
+<Callout type="info">
+  HStats is a third-party tool and is not affiliated with HytaleModding or Hypixel Studios
+</Callout>
+
+# Step 1: Register your Mod to HStats
+
+Before you touch any code, you will need to add your mod to the HStats website which will give you a UUID for your mod.
+
+- Create or Login to an Account on https://hstats.dev
+- Navigate to the dashboard page (https://hstats.dev/dashboard)
+- On the left, type in your mod's name and click "Add Mod"
+- Keep note of the UUID generated for later.
+
+# Step 2: Add the HStats Class to Your Project
+
+To keep things simple, HStats uses a single Java class file that handles everything for you.
+
+- Download / Copy the File from the GitHub page (https://github.com/hstats-dev/HStatsExamplePlugin/blob/main/src/main/java/com/al3x/HStats.java)
+- Paste into your Project. You should now have a HStats.java file somewhere in your projects directory.
+- Update the package name from com.al3x to whatever fits your project.
+
+# Step 3: Initialize HStats in your code
+
+You only need to add one line of code to your mod's setup method in your main class to start tracking.
+
+`new HStats("YOUR-MOD-UUID", "1.0.0");`
+
+Replace `YOUR-MOD-UUID` with the Mod UUID we made note of earlier and change the `1.0.0` version to whatever version your mod is currently on.
+
+Your setup method should now look something like this:
+
+```java
+@Override
+protected void setup() {
+  super.setup();
+  new HStats("c34a2b2a-afd8-4d6a-821e-7a63e12c5ea6", "1.0.0");
+}
+```
+
+# Extras
+
+Your done! Your mod should now be listed under the Mods page (https://hstats.dev/mods) as well as under your dashboard.
+
+Servers using your mod should now post updates about every minute to HStats which you can view in the Dashboard.
+
+### Embeds
+
+HStats allows you to generate an Embed Card that you can place on your CurseForge or GitHub page. This is useful for server owners to be able to see how many other servers are using your mod.
+
+- In your dashboard, scroll down to the Embed Card section.
+- Customize the appearance (Light/Dark mode, layout, etc).
+- Copy the generated URL to display your "Active Servers" and "Players Online" live on your mod's description page
+
+Heres an example of what they look like:
+![HStats Example](https://api.hstats.dev/api/embed/d52fa672-6966-47b2-b501-1a11bddebac3/card.svg?theme=light\&layout=compact\&size=md\&show_id=true\&dark=false)
diff --git a/content/docs/hu-HU/guides/plugin/world-gen.mdx b/content/docs/hu-HU/guides/plugin/world-gen.mdx
index 4c23b0c9..7b193ffd 100644
--- a/content/docs/hu-HU/guides/plugin/world-gen.mdx
+++ b/content/docs/hu-HU/guides/plugin/world-gen.mdx
@@ -100,7 +100,7 @@ Biome biome = biomeGen.generateBiomeAt(zoneResult, seed, x, z);
 
 ### Zone & Cave Integration
 
-Each zone defines it's own cave patterns:
+Each zone defines its own cave patterns:
 
 ```java
 Zone zone = /* ... */;
diff --git a/content/docs/hu-HU/guides/prefabs.mdx b/content/docs/hu-HU/guides/prefabs.mdx
index 08404b30..b1a55109 100644
--- a/content/docs/hu-HU/guides/prefabs.mdx
+++ b/content/docs/hu-HU/guides/prefabs.mdx
@@ -14,7 +14,7 @@ Prefabs are Hytale's way of creating reusable structures.
 There are a few fundamental concepts to understand about prefabs:
 
 - Users interact with prefabs via a prefab editing world.
-- Prefabs the physical structures in the game world, and are saved as JSON files.
+- Prefabs are the physical structures in the game world, and are saved as JSON files.
 
 ## How to Create a Prefab
 
diff --git a/content/docs/hu-HU/official-documentation/custom-ui/common-styling.mdx b/content/docs/hu-HU/official-documentation/custom-ui/common-styling.mdx
new file mode 100644
index 00000000..c36e3e3a
--- /dev/null
+++ b/content/docs/hu-HU/official-documentation/custom-ui/common-styling.mdx
@@ -0,0 +1,50 @@
+---
+title: Common Styling
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# Common Styling
+
+## Common UI Styling Library
+
+This document describes the shared UI components and styles defined in `Common.ui`.
+
+---
+
+### Styles
+
+We are providing some styles that can be re-used in any custom UI that, provide a cohesive UI experience with the core game UI. These styles are available in the `Common.ui` file.
+
+You can find a list of all the styles defined with live examples by running the `/ui-gallery` command ingame.
+
+<Callout type="warning">
+  This command is not available yet, but will be in a future patch.
+</Callout>
+
+![Gallery](/assets/official-documentation/ui/gallery.png)
+
+### Importing
+
+To use these styles in your UI file:
+
+```
+$Common = "Common.ui";
+
+// Then reference styles and components:
+$Common.@TextButton { @Text = "My Button"; }
+$Common.@Container { ... }
+```
+
+<Callout type="info">
+  The `Common.ui` file is at `Common/UI/Custom/Common.ui` within the Hytale pack. If your custom ui document is in a subfolder of `Common/UI/Custom/`, reference it via relative path traversal:
+
+  ```
+  $Common = "../Common.ui";
+  ```
+
+  You can find more info about paths [here](markup#path).
+</Callout>
diff --git a/content/docs/hu-HU/official-documentation/custom-ui/index.mdx b/content/docs/hu-HU/official-documentation/custom-ui/index.mdx
new file mode 100644
index 00000000..f94c4e88
--- /dev/null
+++ b/content/docs/hu-HU/official-documentation/custom-ui/index.mdx
@@ -0,0 +1,125 @@
+---
+title: Custom UI
+icon: LayoutDashboard
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# Custom UI
+
+## What is Custom UI?
+
+Custom UI is Hytale's framework for creating **custom user interfaces** controlled by the game server. Unlike the built-in Client UI (which is part of the game client and cannot be modified), Server UI allows you to create interactive screens and HUD overlays through Java plugins and asset packs.
+
+As a modder, Custom UI gives you the power to:
+
+- **Create custom interactive pages** - Shop interfaces, quest dialogs, server settings menus, admin panels
+- **Add custom HUD overlays** - Quest trackers, status displays, custom health bars, server information
+- **Design with markup** - Use `.ui` files to define reusable UI templates
+- **Handle user interactions** - Respond to button clicks, form submissions, and other events
+- **Localize your UI** - Support multiple languages using the game's translation system
+
+## How Custom UI Fits Into Hytale's UI
+
+Hytale's user interface is divided into two main categories:
+
+### Client UI (Not Moddable)
+
+Built-in interfaces controlled by the C# game client:
+
+- Main menu and settings
+- Character creation
+- Built-in HUD (health, hotbar, chat)
+- Inventory and crafting screens
+- Development tools
+
+**You cannot modify these** - they are part of the core game client.
+
+### In-Game UI (Moddable via Server)
+
+Server-controlled interfaces that you can create and customize:
+
+#### Custom Pages
+
+Full-screen interactive overlays that appear during gameplay:
+
+- Can be dismissed by the player (ESC key)
+- Capture all input (keyboard and mouse)
+- Support loading states while waiting for server responses
+- Perfect for: shops, dialogs, menus, configuration screens
+
+#### Custom HUDs
+
+Persistent overlay elements drawn on top of the game world:
+
+- Display-only (no user interaction)
+- Always visible during gameplay
+- Lightweight and non-intrusive
+- Perfect for: quest objectives, status indicators, server info panels
+
+## Architecture Overview
+
+Server UI uses a **command-based architecture**:
+
+```
+┌─────────────────────┐         ┌──────────────────────┐
+│   Java Server       │         │    C# Client         │
+│   (Your Plugin)     │         │    (Game)            │
+├─────────────────────┤         ├──────────────────────┤
+│                     │         │                      │
+│ InteractiveCustomUI │         │   CustomPage or      │
+│ Page                │         │   CustomHud          │
+│   ↓ build()         ├────────→│     ↓ Apply          │
+│ UICommandBuilder    │         │   Element Tree       │
+│   - append()        │         │     ↓ Layout         │
+│   - set()           │         │   Rendered UI        │
+│   - clear()         │         │                      │
+│                     │         │                      │
+│ ↓ handleDataEvent() │← Events │   User Interaction   │
+│   Process input     │         │   (click, type, etc) │
+│   sendUpdate()      │         │                      │
+└─────────────────────┘         └──────────────────────┘
+```
+
+**The flow:**
+
+1. Your Java code builds UI using `UICommandBuilder`
+2. Commands are sent to the client as data
+3. Client parses `.ui` markup files and creates visual elements
+4. User interacts with the UI
+5. Events are sent back to your Java code
+6. You process events and send updates back
+
+## Key Principles
+
+### Declarative, Not Imperative
+
+You don't create UI objects directly. Instead, you send **commands** that describe what you want:
+
+- "Append this button template to that container"
+- "Set this label's text to 'Hello World'"
+- "Clear all children from this list"
+
+### Asset-Driven
+
+UI structure is defined in `.ui` markup files (assets), not hardcoded in Java. This enables:
+
+- Designers to modify layouts without touching code
+- Reusable UI components
+- Consistent visual language
+
+### Event-Driven
+
+User interactions trigger events that flow back to your server code. You register event bindings and handle them in `handleDataEvent()`.
+
+### Selector-Based
+
+You target specific UI elements using **selectors:**
+
+- `#MyButton` - Element with ID "MyButton"
+- `#List[0]` - First child of element "List"
+- `#List[0] #Title` - Element with ID "Title" in the first child of element "List"
+- `#Label.TextColor` - The TextColor property of element "Label"
diff --git a/content/docs/hu-HU/official-documentation/custom-ui/layout.mdx b/content/docs/hu-HU/official-documentation/custom-ui/layout.mdx
new file mode 100644
index 00000000..0a24ca09
--- /dev/null
+++ b/content/docs/hu-HU/official-documentation/custom-ui/layout.mdx
@@ -0,0 +1,492 @@
+---
+title: Layout
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# Layout
+
+The layout system determines how UI elements are positioned and sized on screen. Understanding layout is crucial for creating well-structured, responsive interfaces.
+
+## Layout Fundamentals
+
+Every UI element has:
+
+- **Container Rectangle** - The space allocated by the parent
+- **Anchor** - How the element positions/sizes itself within the container
+- **Padding** - Inner spacing that affects child layout
+- **LayoutMode** - How the element arranges its children (if it's a container)
+
+```
+┌─────────────────────────────────────┐
+│  Container Rectangle (from parent)  │
+│  ┌───────────────────────────────┐  │
+│  │  Anchored Rectangle           │  │
+│  │  ┌─────────────────────────┐  │  │
+│  │  │ Padding                 │  │  │
+│  │  │  ┌───────────────────┐  │  │  │
+│  │  │  │  Content Area     │  │  │  │
+│  │  │  └───────────────────┘  │  │  │
+│  │  └─────────────────────────┘  │  │
+│  └───────────────────────────────┘  │
+└─────────────────────────────────────┘
+```
+
+## Anchor
+
+`Anchor` controls how an element positions and sizes itself within its container rectangle.
+
+### Fixed Size
+
+```
+Button {
+    Anchor: (Width: 200, Height: 40);
+}
+```
+
+Creates a 200×40 pixel button.
+
+### Positioning
+
+```
+Label {
+    Anchor: (Top: 10, Left: 20, Width: 100, Height: 30);
+}
+```
+
+- **Top**: 10 pixels from container's top edge
+- **Left**: 20 pixels from container's left edge
+- **Width**: 100 pixels wide
+- **Height**: 30 pixels tall
+
+### Anchoring to Edges
+
+```
+Button {
+    Anchor: (Bottom: 10, Right: 10, Width: 100, Height: 30);
+}
+```
+
+Anchors the button to the bottom-right corner, 10 pixels from each edge.
+
+### Stretching
+
+```
+Group {
+    Anchor: (Top: 0, Bottom: 0, Left: 0, Right: 0);
+}
+```
+
+Stretches to fill the entire container (all edges at 0 pixels).
+
+**Shorthand:**
+
+```
+Group {
+    Anchor: (Full: 0);
+}
+```
+
+### Mixed Anchoring
+
+```
+Panel {
+    Anchor: (Top: 10, Bottom: 10, Left: 20, Width: 300);
+}
+```
+
+- Fixed width of 300 pixels
+- Stretches vertically between top and bottom edges
+- 10 pixels from top and bottom
+- 20 pixels from left
+
+## Padding
+
+`Padding` creates inner spacing, affecting where children are positioned.
+
+### Uniform Padding
+
+```
+Group {
+    Padding: (Full: 20);
+}
+```
+
+20 pixels of padding on all sides.
+
+### Directional Padding
+
+```
+Group {
+    Padding: (Top: 10, Bottom: 20, Left: 15, Right: 15);
+}
+```
+
+Different padding per edge.
+
+### Shorthand
+
+```
+// Horizontal and vertical
+Group {
+    Padding: (Horizontal: 20, Vertical: 10);
+}
+
+// Equivalent to:
+// Top: 10, Bottom: 10, Left: 20, Right: 20
+```
+
+### Effect on Children
+
+```
+Group {
+    Anchor: (Width: 200, Height: 100);
+    Padding: (Full: 10);
+
+    Label {
+        Anchor: (Full: 0);
+    }
+}
+```
+
+The label fills the group, but there's a 10-pixel gap on all sides due to padding.
+
+```
+┌──────────────────────┐
+│ Group (200×100)      │
+│  ┌────────────────┐  │
+│  │ Label          │  │ ← 10px padding all around
+│  │                │  │
+│  └────────────────┘  │
+└──────────────────────┘
+```
+
+## LayoutMode
+
+`LayoutMode` determines how a container arranges its children.
+
+### Top (Vertical Stack)
+
+```
+Group {
+    LayoutMode: Top;
+
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+}
+```
+
+Children stack vertically from top to bottom:
+
+```
+┌──────────┐
+│ Button 1 │
+├──────────┤
+│ Button 2 │
+├──────────┤
+│ Button 3 │
+└──────────┘
+
+
+```
+
+Each child's `Anchor.Bottom` adds spacing between elements:
+
+```
+Button { Anchor: (Height: 30, Bottom: 10); }  // 10px gap after this button
+```
+
+### Bottom (Vertical Stack)
+
+```
+Group {
+    LayoutMode: Bottom;
+
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+}
+```
+
+Children stack vertically from top to bottom but aligned to the bottom edge of the parent:
+
+```
+
+
+
+┌──────────┐
+│ Button 1 │
+├──────────┤
+│ Button 2 │
+├──────────┤
+│ Button 3 │
+└──────────┘
+```
+
+### Left (Horizontal Stack)
+
+```
+Group {
+    LayoutMode: Left;
+
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+}
+```
+
+Children arrange horizontally from left to right:
+
+```
+┌────────┬────────┬────────┐
+│ Button │ Button │ Button │
+│   1    │   2    │   3    │
+└────────┴────────┴────────┘
+```
+
+Use `Anchor.Right` for spacing between elements.
+
+### Right (Horizontal Stack)
+
+```
+Group {
+    LayoutMode: Right;
+
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+}
+```
+
+Children arrange horizontally from left to right but aligned to the right side of the parent:
+
+```
+                                                                 ┌────────┬────────┬────────┐
+                                                                 │ Button │ Button │ Button │
+                                                                 │   1    │   2    │   3    │
+                                                                 └────────┴────────┴────────┘
+```
+
+### Center
+
+```
+Group {
+    LayoutMode: Center;
+
+    Group #Dialog {
+        Anchor: (Width: 400, Height: 300);
+    }
+}
+```
+
+Centers the children horizontally.
+
+### Middle
+
+```
+Group {
+    LayoutMode: Middle;
+
+    Group #Dialog {
+        Anchor: (Width: 400, Height: 300);
+    }
+}
+```
+
+Centers the children vertically.
+
+### CenterMiddle (Horizontal Stack, Fully Centered)
+
+```
+Group {
+    LayoutMode: CenterMiddle;
+
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+}
+```
+
+Children stack horizontally from left to right, centered both horizontally and vertically within the parent:
+
+```
+┌────────────────────────────────────────────┐
+│                                            │
+│                                            │
+│         ┌──────┐ ┌──────┐ ┌──────┐         │
+│         │  B1  │ │  B2  │ │  B3  │         │
+│         └──────┘ └──────┘ └──────┘         │
+│                                            │
+│                                            │
+└────────────────────────────────────────────┘
+```
+
+---
+
+### MiddleCenter (Vertical Stack, Fully Centered)
+
+```
+Group {
+    LayoutMode: MiddleCenter;
+
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+}
+```
+
+Children stack vertically from top to bottom, centered both horizontally and vertically within the parent:
+
+```
+┌────────────────────────────────────────────┐
+│                                            │
+│              ┌──────────┐                  │
+│              │ Button 1 │                  │
+│              ├──────────┤                  │
+│              │ Button 2 │                  │
+│              ├──────────┤                  │
+│              │ Button 3 │                  │
+│              └──────────┘                  │
+│                                            │
+└────────────────────────────────────────────┘
+```
+
+---
+
+### Full
+
+```
+Group {
+    LayoutMode: Full;
+
+    Label {
+        Anchor: (Top: 20, Left: 20, Width: 100, Height: 30);
+    }
+}
+```
+
+Children use absolute positioning via their `Anchor` properties.
+
+### TopScrolling
+
+```
+Group {
+    LayoutMode: TopScrolling;
+    ScrollbarStyle: $Common.@DefaultScrollbar;
+
+    // ... many children
+}
+```
+
+Like `Top`, but adds a scrollbar if content exceeds container height.
+
+Or use `BottomScrolling` for bottom-aligned content.
+
+### LeftScrolling
+
+```
+Group {
+    LayoutMode: LeftScrolling;
+    ScrollbarStyle: $Common.@DefaultScrollbar;
+
+    // ... many children
+}
+```
+
+Like `Left`, but adds a scrollbar for horizontal scrolling.
+
+Or use `RightScrolling` for right-aligned content.
+
+### LeftCenterWrap (Wrapping Horizontal Stack, Horizontally Centered)
+
+```
+Group {
+    LayoutMode: LeftCenterWrap;
+
+    Button { Anchor: (Width: 80, Height: 30); }
+    Button { Anchor: (Width: 80, Height: 30); }
+    Button { Anchor: (Width: 80, Height: 30); }
+    Button { Anchor: (Width: 80, Height: 30); }
+    Button { Anchor: (Width: 80, Height: 30); }
+}
+```
+
+Children flow left to right. When there's no more horizontal space, they wrap to the next row. Each row is horizontally centered within the parent:
+
+```
+┌────────────────────────────────────────────┐
+│                                            │
+│       ┌──────┐ ┌──────┐ ┌──────┐           │
+│       │  B1  │ │  B2  │ │  B3  │           │
+│       └──────┘ └──────┘ └──────┘           │
+│            ┌──────┐ ┌──────┐               │
+│            │  B4  │ │  B5  │               │
+│            └──────┘ └──────┘               │
+│                                            │
+└────────────────────────────────────────────┘
+```
+
+## FlexWeight
+
+`FlexWeight` distributes remaining space among children.
+
+```
+Group {
+    LayoutMode: Left;
+    Anchor: (Width: 400);
+
+    Button {
+        Anchor: (Width: 100);
+    }
+
+    Group {
+        FlexWeight: 1;  // Takes all remaining space
+    }
+
+    Button {
+        Anchor: (Width: 100);
+    }
+}
+```
+
+Result:
+
+- First button: 100px
+- Middle group: 200px (400 - 100 - 100 = 200)
+- Last button: 100px
+
+### Multiple FlexWeights
+
+```
+Group {
+    LayoutMode: Left;
+    Anchor: (Width: 600);
+
+    Group { FlexWeight: 1; }
+    Group { FlexWeight: 2; }
+    Group { FlexWeight: 1; }
+}
+```
+
+Remaining space (600px) is split:
+
+- First group: 600 × (1/4) = 150px
+- Second group: 600 × (2/4) = 300px
+- Third group: 600 × (1/4) = 150px
+
+## Visibility
+
+```
+Button #HiddenButton {
+    Visible: false;
+}
+```
+
+**Effect:**
+
+- Element and its children are not displayed
+- Element is **not included in layout** (doesn't take up space)
diff --git a/content/docs/hu-HU/official-documentation/custom-ui/markup.mdx b/content/docs/hu-HU/official-documentation/custom-ui/markup.mdx
new file mode 100644
index 00000000..564110ed
--- /dev/null
+++ b/content/docs/hu-HU/official-documentation/custom-ui/markup.mdx
@@ -0,0 +1,226 @@
+---
+title: Markup
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# Markup
+
+## Markup
+
+An element is the basic building block of a user interface. There are various types of elements with different properties, which are documented below.
+
+Here's what the syntax looks like:
+
+```
+// Basic declaration of an element
+// with its Anchor property set to attach on all sides of its parent
+// with 10 pixels of margin
+Group { Anchor: (Left: 10, Top: 10, Right: 10, Bottom: 10); }
+
+Group { Anchor: (Full: 10); } // More concise version
+
+// Declaration of a Label with a name
+// (can be used to access the element from game code)
+Label #MyLabel {
+  Style: LabelStyle(FontSize: 16); // or just Style: (FontSize: 16), type can be inferred.
+  Text: "Hi! I am text.";
+}
+
+// Declaration of a Group containing 2 children
+// You can use FlexWeight to distribute any left-over space after explicit widths/heights have been subtracted
+Group {
+  LayoutMode: Left;
+  Label { Text: "Child 1"; FlexWeight: 2; }
+  Label { Text: "Child 2"; FlexWeight: 1; }
+}
+```
+
+### Documents
+
+A UI document (_.ui_ file) contains trees of elements. There can be multiple root elements.
+
+### Named Expressions
+
+Named expressions can be declared at any level of a document (including at the root) and will be scoped to that subtree, though they need to be declared at the top of the block.
+
+```
+// Example of named expressions, declared and used with @ prefix
+@Title = "Hytale";
+@ExtraSpacing = 5;
+
+Label {
+  Text: @Title;
+  Style: (LetterSpacing: 2 + @ExtraSpacing);
+}
+```
+
+You can use the spread operator `...` to reuse a named expression while overriding some of its fields:
+
+```
+@MyBaseStyle = LabelStyle(FontSize: 24, LetterSpacing: 2);
+
+Label {
+  Style: (...@MyBaseStyle, FontSize: 36);
+}
+```
+
+You can even layer multiple named expressions like so:
+
+```
+@TitleStyle = LabelStyle(FontSize: 24, HorizontalAlignment: Center);
+@SpacedTextStyle = LabelStyle(LetterSpacing: 2);
+
+Label {
+  Style: (...@BigTextStyle, ...@SpacedTextStyle);
+}
+```
+
+#### Document references
+
+A document can reference another document and access its named expressions.
+
+```
+// Document references are defined with $ prefix
+$Common = "../Common.ui";
+
+TextButton {
+  Style: $Common.@DefaultButtonStyle;
+}
+```
+
+### Templates
+
+You can declare a reusable bit of interface as a named expression and then instantiate it as many times as you want in the tree while customizing it.
+
+You can override local named expressions as well as insert additional children at any point in the template tree. However, local named expressions must be defined at the very top of the block, before properties and child elements.
+
+```
+// This is the template
+@Row = Group {
+  Anchor: (Height: 50);
+  Label #Label { Anchor: (Left: 0, Width: 100); Text: @LabelText; }
+  Group #Content { Anchor: (Left: 100); }
+};
+
+// Here we'll be using it twice in the document tree
+Group #Rows {
+  LayoutMode: TopScrolling;
+
+  @Row #MyFirstRow {
+    @LabelText = "First row";
+    #Content { TextInput {} }
+  }
+
+  @Row #MySecondRow {
+    @LabelText = "Second row";
+  }
+}
+```
+
+### Property Types
+
+#### Basic Types
+
+- **Boolean**
+  - `Visible: false;`
+  - `Visible: true;`
+- **Int**
+  - `Height: 20;`
+- **Float, Double, Decimal**
+  - `Min: 0.2;`
+- **String**
+  - `Text: "Hi!";`
+- **Char**
+  - `PasswordChar: "*";`
+  - _Note: The syntax is the same as a string, however a value of this type cannot contain more than one character!_
+- **Color**
+  - `Background: #ffffff;`&#x20;
+- **Objects**
+  - `Style: (Background: #ffffff)`
+- **Array**&#x20;
+  - `TextSpans: [(Text: "Hi", IsBold: true)]`
+
+#### Translations
+
+Translation keys can be referenced anywhere in markup where you can provide a string, and they are then converted to a string when an element gets instantiated.
+
+**Example:**
+
+```
+Label {
+  Text: %ui.general.cancel;
+}
+```
+
+#### Colors
+
+A color literal can be written as follows:
+
+- `#rrggbb`: 6-digit hexadecimal representation for red, green, blue (fully opaque)
+- `#rrggbb(a.a)`: 6-digit hexadecimal representation for red, green, blue with alpha between 0 and 1
+- `#rrggbbaa`: 8-digit hexadecimal representation for red, green, blue and alpha
+
+```
+Group {
+  Background: #000000(0.3);
+}
+```
+
+<Callout>
+  The `#rrggbb(a.a)` format is prefered over the `#rrggbbaa` format for
+  readability reasons.
+</Callout>
+
+#### Font Name
+
+Font names can be referenced directly by their string ID. Internally this is using a custom type called `UIFontName`, however strings will be converted automatically to this type in markup.
+
+```
+Label {
+  Text: "Hi";
+  Style: (FontName: "Secondary");
+}
+```
+
+**Available Font Names**
+
+- _Default_ - This is the default font that is used for most text and is always used unless a different option has been specified
+- _Secondary_ - This font is mostly used for headlines or elements that are supposed to stick out
+- _Mono_ - This is only used for development; For things such as profiling or error overlays.
+
+#### Path
+
+We can reference other UI assets with the `UIPath` type. Similar to `UIFontName`_,_ Strings are automatically converted to a `UIPath`. Paths are always relative to the file where they have been declared in. Looking up _MyButton.png_ in _Menu/MyAwesomeMenu.ui_ will result in _Menu/MyButton.png_. If you want to reference a file that is in a parent folder you can go back one directory by writing two dots (_../MyButton.png_).
+
+The markup syntax of a `UIPath` is the same as a String. (e.g. `Path: "Test.png"`)
+
+Here are some more examples:
+
+| UIPath             | .ui File                              | Resulting Path    |
+| ------------------ | ------------------------------------- | ----------------- |
+| MyButton.png       | Menu/MyAwesomeMenu.ui                 | Menu/MyButton.png |
+| ../MyButton.png    | Menu/MyAwesomeMenu.ui                 | MyButton.png      |
+| ../../MyButton.png | Menu/Popup/Templates/MyAwesomeMenu.ui | Menu/MyButton.png |
+
+#### Objects
+
+Objects contain a set of properties. In this example we are assigning an Anchor object to the _Anchor_ property:
+
+```
+Group {
+  Anchor: (
+   Height: 10,
+   Width: 20
+ );
+}
+```
+
+You can find all objects that can be used in markup [here](type-documentation#elements).
+
+## Visual Studio Code Extension
+
+There is an official extension for Visual Studio Code which adds syntax highlighting for .ui files. You can find it [here](https://marketplace.visualstudio.com/items?itemName=HypixelStudiosCanadaInc.vscode-hytaleui).
diff --git a/content/docs/hu-HU/official-documentation/custom-ui/type-documentation/index.mdx b/content/docs/hu-HU/official-documentation/custom-ui/type-documentation/index.mdx
new file mode 100644
index 00000000..69cea406
--- /dev/null
+++ b/content/docs/hu-HU/official-documentation/custom-ui/type-documentation/index.mdx
@@ -0,0 +1,127 @@
+---
+title: Type Documentation
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# Type Documentation
+
+This is a generated list of UI elements accessible by markup. More information about the User Interface framework can be found in the main documentation.
+
+## Elements
+
+- [ActionButton](type-documentation/elements/actionbutton)
+- [AssetImage](type-documentation/elements/assetimage)
+- [BackButton](type-documentation/elements/backbutton)
+- [BlockSelector](type-documentation/elements/blockselector)
+- [Button](type-documentation/elements/button)
+- [CharacterPreviewComponent](type-documentation/elements/characterpreviewcomponent)
+- [CheckBox](type-documentation/elements/checkbox)
+- [CheckBoxContainer](type-documentation/elements/checkboxcontainer)
+- [CircularProgressBar](type-documentation/elements/circularprogressbar)
+- [CodeEditor](type-documentation/elements/codeeditor)
+- [ColorOptionGrid](type-documentation/elements/coloroptiongrid)
+- [ColorPicker](type-documentation/lements/colorpicker)
+- [ColorPickerDropdownBox](type-documentation/elements/colorpickerdropdownbox)
+- [CompactTextField](type-documentation/elements/compacttextfield)
+- [DropdownBox](type-documentation/elements/dropdownbox)
+- [DropdownEntry](type-documentation/elements/dropdownentry)
+- [DynamicPane](type-documentation/elements/dynamicpane)
+- [DynamicPaneContainer](type-documentation/elements/dynamicpanecontainer)
+- [FloatSlider](type-documentation/elements/floatslider)
+- [FloatSliderNumberField](type-documentation/elements/floatslidernumberfield)
+- [Group](type-documentation/elements/group)
+- [HotkeyLabel](type-documentation/elements/hotkeylabel)
+- [ItemGrid](type-documentation/elements/itemgrid)
+- [ItemIcon](type-documentation/elements/itemicon)
+- [ItemPreviewComponent](type-documentation/elements/itempreviewcomponent)
+- [ItemSlot](type-documentation/elements/itemslot)
+- [ItemSlotButton](type-documentation/elements/itemslotbutton)
+- [Label](type-documentation/elements/label)
+- [LabeledCheckBox](type-documentation/elements/labeledcheckbox)
+- [MenuItem](type-documentation/elements/menuitem)
+- [MultilineTextField](type-documentation/elements/multilinetextfield)
+- [NumberField](type-documentation/elements/numberfield)
+- [Panel](type-documentation/elements/panel)
+- [ProgressBar](type-documentation/elements/progressbar)
+- [ReorderableList](type-documentation/elements/reorderablelist)
+- [ReorderableListGrip](type-documentation/elements/reorderablelistgrip)
+- [SceneBlur](type-documentation/elements/sceneblur)
+- [Slider](type-documentation/elements/slider)
+- [SliderNumberField](type-documentation/elements/slidernumberfield)
+- [Sprite](type-documentation/elements/sprite)
+- [TabButton](type-documentation/elements/tabbutton)
+- [TabNavigation](type-documentation/elements/tabnavigation)
+- [TextButton](type-documentation/elements/textbutton)
+- [TextField](type-documentation/elements/textfield)
+- [TimerLabel](type-documentation/elements/timerlabel)
+- [ToggleButton](type-documentation/elements/togglebutton)
+
+## Property Types
+
+- [Anchor](type-documentation/property-types/anchor)
+- [BlockSelectorStyle](type-documentation/property-types/blockselectorstyle)
+- [ButtonSounds](type-documentation/property-types/buttonsounds)
+- [ButtonStyle](type-documentation/property-types/buttonstyle)
+- [ButtonStyleState](type-documentation/property-types/buttonstylestate)
+- [CheckBoxStyle](type-documentation/property-types/checkboxstyle)
+- [CheckBoxStyleState](type-documentation/property-types/checkboxstylestate)
+- [ClientItemStack](type-documentation/property-types/clientitemstack)
+- [ColorOptionGridStyle](type-documentation/property-types/coloroptiongridstyle)
+- [ColorPickerDropdownBoxStateBackground](type-documentation/property-types/colorpickerdropdownboxstatebackground)
+- [ColorPickerDropdownBoxStyle](type-documentation/property-types/colorpickerdropdownboxstyle)
+- [ColorPickerStyle](type-documentation/property-types/colorpickerstyle)
+- [DropdownBoxSearchInputStyle](type-documentation/property-types/dropdownboxsearchinputstyle)
+- [DropdownBoxSounds](type-documentation/property-types/dropdownboxsounds)
+- [DropdownBoxStyle](type-documentation/property-types/dropdownboxstyle)
+- [InputFieldButtonStyle](type-documentation/property-types/inputfieldbuttonstyle)
+- [InputFieldDecorationStyle](type-documentation/property-types/inputfielddecorationstyle)
+- [InputFieldDecorationStyleState](type-documentation/property-types/inputfielddecorationstylestate)
+- [InputFieldIcon](type-documentation/property-types/inputfieldicon)
+- [InputFieldStyle](type-documentation/property-types/inputfieldstyle)
+- [ItemGridSlot](type-documentation/property-types/itemgridslot)
+- [ItemGridStyle](type-documentation/property-types/itemgridstyle)
+- [LabeledCheckBoxStyle](type-documentation/property-types/labeledcheckboxstyle)
+- [LabeledCheckBoxStyleState](type-documentation/property-types/labeledcheckboxstylestate)
+- [LabelSpan](type-documentation/property-types/labelspan)
+- [LabelStyle](type-documentation/property-types/labelstyle)
+- [NumberFieldFormat](type-documentation/property-types/numberfieldformat)
+- [Padding](type-documentation/property-types/padding)
+- [PatchStyle](type-documentation/property-types/patchstyle)
+- [PopupStyle](type-documentation/property-types/popupstyle)
+- [ScrollbarStyle](type-documentation/property-types/scrollbarstyle)
+- [SliderStyle](type-documentation/property-types/sliderstyle)
+- [SoundStyle](type-documentation/property-types/soundstyle)
+- [SpriteFrame](type-documentation/property-types/spriteframe)
+- [SubMenuItemStyle](type-documentation/property-types/submenuitemstyle)
+- [SubMenuItemStyleState](type-documentation/property-types/submenuitemstylestate)
+- [Tab](type-documentation/property-types/tab)
+- [TabNavigationStyle](type-documentation/property-types/tabnavigationstyle)
+- [TabStyle](type-documentation/property-types/tabstyle)
+- [TabStyleState](type-documentation/property-types/tabstylestate)
+- [TextButtonStyle](type-documentation/property-types/textbuttonstyle)
+- [TextButtonStyleState](type-documentation/property-types/textbuttonstylestate)
+- [TextTooltipStyle](type-documentation/property-types/texttooltipstyle)
+- [ToggleButtonStyle](type-documentation/property-types/togglebuttonstyle)
+- [ToggleButtonStyleState](type-documentation/property-types/togglebuttonstylestate)
+
+## Enums
+
+- [ActionButtonAlignment](type-documentation/enums/actionbuttonalignment)
+- [CodeEditorLanguage](type-documentation/enums/codeeditorlanguage)
+- [ColorFormat](type-documentation/enums/colorformat)
+- [DropdownBoxAlign](type-documentation/enums/dropdownboxalign)
+- [InputFieldButtonSide](type-documentation/enums/inputfieldbuttonside)
+- [InputFieldIconSide](type-documentation/enums/inputfieldiconside)
+- [ItemGridInfoDisplayMode](type-documentation/enums/itemgridinfodisplaymode)
+- [LabelAlignment](type-documentation/enums/labelalignment)
+- [LayoutMode](type-documentation/enums/layoutmode)
+- [MouseWheelScrollBehaviourType](type-documentation/enums/mousewheelscrollbehaviourtype)
+- [ProgressBarAlignment](type-documentation/enums/progressbaralignment)
+- [ProgressBarDirection](type-documentation/enums/progressbardirection)
+- [ResizeType](type-documentation/enums/resizetype)
+- [TimerDirection](type-documentation/enums/timerdirection)
+- [TooltipAlignment](type-documentation/enums/tooltipalignment)
diff --git a/content/docs/hu-HU/official-documentation/npc/2-getting-started-with-templates.mdx b/content/docs/hu-HU/official-documentation/npc/2-getting-started-with-templates.mdx
index 91081ca1..99d078e0 100644
--- a/content/docs/hu-HU/official-documentation/npc/2-getting-started-with-templates.mdx
+++ b/content/docs/hu-HU/official-documentation/npc/2-getting-started-with-templates.mdx
@@ -9,7 +9,7 @@ authors:
 
 There are no hard and fast rules for making a start on a template. I like to duplicate **BlankTemplate** and start from there because it already provides the basic structure of the file.
 
-This leaves me with the following template (`Template_Goblin_Ogre.json`): (note: the file could be looking different in the current version of the game)
+This leaves me with the following template (`Template_Goblin_Ogre.json`): (**note: the file could be looking different in the current version of the game**)
 
 ```json
 {
@@ -33,7 +33,7 @@ This leaves me with the following template (`Template_Goblin_Ogre.json`): (note:
     }
   },
   "Appearance": { "Compute": "Appearance" },
-  "DropList": { "Compute": "Droplist" },
+  "DropList": { "Compute": "DropList" },
   "MaxHealth": { "Compute": "MaxHealth" },
   "MotionControllerList": [
     {
@@ -65,10 +65,10 @@ And the following variant (`Goblin_Ogre.json`) next to the template. There's a t
   "Type": "Variant",
   "Reference": "Template_Goblin_Ogre",
   "Modify": {
-    "Appearance": "Goblin_Ogre",
+    "Appearance": "Goblin",
     "MaxHealth": 124
   }
 }
 ```
 
-Our artists have defined the `Goblin_Ogre` appearance already so I'm going to use that.
+Our artists have not yet finished animations for the `Goblin_Ogre`, for that sake of the tutorial I am going to use appearance `Goblin`, because it offers a more complete set of animations that we will need.
diff --git a/content/docs/hu-HU/official-documentation/worldgen/pack-tutorial/asset-packs.mdx b/content/docs/hu-HU/official-documentation/worldgen/pack-tutorial/asset-packs.mdx
index 38809fad..dcf1f3b9 100644
--- a/content/docs/hu-HU/official-documentation/worldgen/pack-tutorial/asset-packs.mdx
+++ b/content/docs/hu-HU/official-documentation/worldgen/pack-tutorial/asset-packs.mdx
@@ -9,13 +9,13 @@ authors:
 
 <OfficialDocumentationNotice />
 
-# How to modify Hytale
+# How to modify Hytale?
 
-## What's an Asset Pack
+## What's an Asset Pack?
 
-Hytales gameplay is driven by assets in the game that can be modified by creators. Asset Packs are our solution to let you override or add features to the base game with your own work. These can in the form of zip files of folders, which contain a custom set of assets. This is not the only way for a creator to change Hytale but this is the most accessible form.;
+Hytales gameplay is driven by assets in the game that can be modified by creators. Asset Packs are our solution to let you override or add features to the base game with your own work. These can be the form of zip files of folders, which contain a custom set of assets. This is not the only way for a creator to change Hytale but this is the most accessible form.;
 
-### How do I make an Asset Pack
+### How do I make an Asset Pack?
 
 <video controls className="my-6 aspect-video w-full rounded-lg border">
   <source src="https://cdn.internal.hytalemodding.dev/guides/official/how-to-asset-pack.mp4" type="video/mp4" />
@@ -48,7 +48,7 @@ An asset pack is typically a zip or folder, with a `manifest.json` inside. This
 }
 ```
 
-### Where are they stored
+### Where are they stored?
 
 Asset Packs are stored with other mods in the Mods folder.
 
@@ -76,7 +76,7 @@ C:\Users\<user>\AppData\Roaming\Hytale\UserData\Saves\New World 5\mods
 
 When you have Asset Packs or Mods installed, these will appear in the New World menu under the Options menu.;
 
-### How do I change an existing asset
+### How do I change an existing asset?
 
 <video controls className="my-6 aspect-video w-full rounded-lg border">
   <source src="https://cdn.internal.hytalemodding.dev/guides/official/how-to-asset.mp4" type="video/mp4" />
diff --git a/content/docs/hu-HU/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx b/content/docs/hu-HU/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx
index 44528376..24e628b5 100644
--- a/content/docs/hu-HU/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx
+++ b/content/docs/hu-HU/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx
@@ -106,7 +106,7 @@ If a BaseHeight is provided, the TopY and BottomY values are relative to the Bas
 
 Applies a Material Provider slot on a set of horizontal stripes of blocks of varying thickness and position. Below is an example image of basalt stripes into a stone cliff.
 
-{/* ![](https://540086904-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F7KAmBkOg6d13nZCkf9ku%2Fuploads%2FbcxO9LpArn8gPCaBwFg5%2Funknown.png?alt=media&token=1c72b67a-8253-4d03-8c64-1ad5f6830050) */}
+![Example of basalt stripes](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/basalt-stripes-example.png)
 
 #### Parameters:
 
diff --git a/content/docs/hu-HU/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx b/content/docs/hu-HU/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx
index 5e34acd4..a4418473 100644
--- a/content/docs/hu-HU/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx
+++ b/content/docs/hu-HU/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx
@@ -294,7 +294,7 @@ Combines all the positions into a single Positioins field.
 
 ---
 
-### SimpleHoritontal
+### SimpleHorizontal
 
 Keeps only the positions that are within the provided range.
 
diff --git a/content/docs/hu-HU/official-documentation/worldgen/worldgen-tutorial/README.mdx b/content/docs/hu-HU/official-documentation/worldgen/worldgen-tutorial/README.mdx
new file mode 100644
index 00000000..5f66d245
--- /dev/null
+++ b/content/docs/hu-HU/official-documentation/worldgen/worldgen-tutorial/README.mdx
@@ -0,0 +1,166 @@
+---
+title: How to edit and create Biomes
+description: Explores where world generation assets can be found and how to edit them.
+---
+
+### Where are the Assets
+
+World generation assets are kept in the HytaleGenerator directory within the assets.
+
+```
+/Server/HytaleGenerator/
+```
+
+<div className="flex flex-row rounded-lg border p-4">
+  <div className="flex-1/2 border-r pr-4">
+    ```
+    /Biomes
+    ```
+
+    Biome assets, with content configurations.
+  </div>
+
+  <div className="flex-1/2 pl-4">
+    ```
+    /WorldStructure
+    ```
+
+    Generator files that define which biomes spawn together.
+  </div>
+</div>
+
+<div className="flex flex-row rounded-lg border p-4">
+  <div className="flex-1/2 border-r pr-4">
+    ```
+    /Density
+    ```
+
+    Density assets that can be referenced by any other assets.
+  </div>
+
+  <div className="flex-1/2 pl-4">
+    ```
+    /Assignments
+    ```
+
+    Prop assets that can be referenced by any Biome assets.
+  </div>
+</div>
+
+***
+
+An example of this structure can be found bellow, packed in an asset pack with the instance configuration.
+
+[https://drive.google.com/file/d/1sIz_CluANIIe3n8vNiOi-4PQdeqCO0qY/view?usp=drive_link](https://drive.google.com/file/d/1sIz_CluANIIe3n8vNiOi-4PQdeqCO0qY/view?usp=drive_link)
+
+<Callout>
+  Ensure you place your asset pack in the correct directory, under Mods.
+</Callout>
+
+### How to visit our worlds
+
+https://drive.google.com/file/d/1BJurxyj-taE-PXWm04bk7Dl6X7ZHTH92/view?usp=sharing
+
+#### Requirements
+
+- You must be an **Operator** in the world.
+  - To do this, run <mark style="color:$danger;">`/op self`</mark>
+- You must be in **Creative mode**.
+  - Press the <mark style="color:$danger;">`O`</mark> key, O for Orange.&#x20;
+
+The generation assets define a set of generators but on their own you cannot visit these. Currently you require an Instance with a generator that will allow you to visit your work.
+
+```
+/Server/Instances/
+```
+
+Instances are separate worlds that players can join using the `/instances` command. Each instance has an `Instance.bson` configuration asset that specifies which generator to use, among other worldly settings.
+
+```json
+{
+  "WorldGen": {
+    "Type": "HytaleGenerator",
+    "WorldStructure": "Basic",
+    "playerSpawn" : {
+      "X" : 123,
+      "Y" : 480,
+      "Z" : 10000,
+      "Pitch" : 0,
+      "Yaw" : 0,
+      "Roll" : 0
+    }
+  }
+}
+```
+
+<Callout>
+  You can create custom instances for different world structures and biomes as you need them.
+</Callout>
+
+### How to edit Biomes
+
+<video>
+  <source src="https://cdn.internal.hytalemodding.dev/guides/official/How-to-edit-Biomes.mp4" type="video/mp4" />
+</video>
+
+We currently use the Hytale Node Editor when editing world generation assets. This can be accessed while in-game from the Content Creation menu when pressing B. The node editor is then found under the asset editor dropdown on the upper left.&#x20;
+
+![Node Editor 1](/assets/official-documentation/worldgen/worldgen-tutorial/biomes/node-editor-1.png)
+
+Once you have the Hytale Node Editor open, through the file menu you can open Biomes by navigating to the Biomes directory and selecting one from your pack.&#x20;
+
+```
+/Server/HytaleGenerator/Biomes/
+```
+
+### Biome Asset Structure
+
+Every Biome has a root Biome node, this node splits into 5 structures. This is covered briefly but more information on each field can be found on the World Generation Concepts page.
+
+![Node Editor 2](/assets/official-documentation/worldgen/worldgen-tutorial/biomes/node-editor-2.png)
+
+<Callout>
+  Each biome is for the most part self contained, meaning it has control over what appears with the biome. The only exception to this are Base Heights.
+</Callout>
+
+<Tabs>
+  <Tab value="Terrain">
+    Mathematical function nodes that calculate the physical shape of the Biome's terrain.
+  </Tab>
+
+  <Tab value="Materials">
+    Logical nodes that determine what materials (blocks) make up a Biome's terrain.
+  </Tab>
+
+  <Tab value="Props">
+    Function nodes that add objects like prefabs and decorations to the terrain.
+  </Tab>
+
+  <Tab value="Environments">
+    Logical nodes that determine the environment asset at a given coordinate within the biome. This asset determines things like weather, NPC spawns, and sounds.
+  </Tab>
+
+  <Tab value="Tints">
+    Logical function nodes that determine a colour code that can be used by certain blocks in the world. Typically this will be grasses and soils.
+  </Tab>
+</Tabs>
+
+### How to preview your work
+
+[https://drive.google.com/file/d/1mNcHn9LhFnWDF0DzWFH6_YllmKAUvUry/view?t=6](https://drive.google.com/file/d/1mNcHn9LhFnWDF0DzWFH6_YllmKAUvUry/view?t=6)
+
+Once you are in an Instance world with the Hytale Generator active you will only be able to see your work by generating new chunks. There are a few ways to do this.
+
+The viewport command selects an area around the Player that will live reload as you make changes to the generator.&#x20;
+
+```
+/viewport --radius 5 
+```
+
+You can also create a new world to show your changes.&#x20;
+
+```
+/instances spawn <instance> 
+```
+
+The last option is to simply fly south, new chunks will generate with the changes made.
diff --git a/content/docs/hu-HU/quick-start.mdx b/content/docs/hu-HU/quick-start.mdx
index 653644f4..249d803a 100644
--- a/content/docs/hu-HU/quick-start.mdx
+++ b/content/docs/hu-HU/quick-start.mdx
@@ -9,3 +9,8 @@ Welcome to the Hytale modding documentation! Here you'll find everything you nee
 * [Setting up your dev environment](./guides/plugin/setting-up-env)
 * [Entity Component System (ECS)](./guides/ecs/entity-component-system)
 * [Publishing your mod](./publishing)
+
+### Useful Links
+
+* [Kaupenjoe's Modding Videos](https://www.youtube.com/@ModdingByKaupenjoe)
+* [TroubleDEV's Modding Videos](https://www.youtube.com/@TroubleDEV)
diff --git a/content/docs/hu-HU/server/argtypes.mdx b/content/docs/hu-HU/server/argtypes.mdx
new file mode 100644
index 00000000..e54a442e
--- /dev/null
+++ b/content/docs/hu-HU/server/argtypes.mdx
@@ -0,0 +1,61 @@
+---
+title: ArgTypes
+description: Available ArgTypes
+icon: List
+full: true
+authors:
+  - name: Valeena
+---
+
+| Name                        | Target Class                           | Description                                                                                                                               |   |
+| :-------------------------- | :------------------------------------- | :---------------------------------------------------------------------------------------------------------------------------------------- | - |
+| Boolean                     | java.lang.Boolean                      | A 'true' or 'false' input                                                                                                                 |   |
+| Integer                     | java.lang.Integer                      | A whole number                                                                                                                            |   |
+| String                      | java.lang.String                       | Words, text, numbers, letters. To input more than one word at a time, you may need to wrap it with double quotes (`"my fancy sentence"`). |   |
+| Float                       | java.lang.Float                        | A floating-pointer number                                                                                                                 |   |
+| Double                      | java.lang.Double                       | A decimal number                                                                                                                          |   |
+| UUID                        | java.util.UUID                         | A UUID (Universally Unique IDentifier)                                                                                                    |   |
+| Player_UUID                 | java.util.UUID                         | A UUID or an online player username                                                                                                       |   |
+| Game_Profile_Lookup_Async   | ProfileServiceClient.PublicGameProfile | A player UUID or username. If not found locally, performs a remote lookup via the Profile Service.                                        |   |
+| Relative_Double_Coord       | Coord                                  | An x, y, or z coordinate as a decimal, optionally relative by specifying a tilde (~) in front of the number                               |   |
+| Relative_Int_Coord          | IntCoord                               | An x, y, or z coordinate as a whole number, optionally relative by specifying a tilde (~) in front of the number                          |   |
+| Relative_Integer            | RelativeInteger                        | A tilde to mark an integer relative to a base                                                                                             |   |
+| Relative_Float              | RelativeFloat                          | A tilde to mark a float relative to a base                                                                                                |   |
+| Player_Ref                  | PlayerRef                              | A UUID or an online player's username                                                                                                     |   |
+| World                       | World                                  | A world folder name                                                                                                                       |   |
+| Model_Asset                 | ModelAsset                             | A reference to an Asset of type Model                                                                                                     |   |
+| Weather_Asset               | Weather                                | A reference to an Asset of type Weather                                                                                                   |   |
+| Interaction_Asset           | Interaction                            | A reference to an Asset of type Interaction                                                                                               |   |
+| Root_Interaction_Asset      | RootInteraction                        | A reference to an Asset of type Root Interaction                                                                                          |   |
+| Effect_Asset                | EntityEffect                           | A refernece to an Asset of type EntityEffect                                                                                              |   |
+| Environment_Asset           | Environment                            | A reference to an Asset of type Environment                                                                                               |   |
+| Item_Asset                  | Item                                   | A reference to an Asset of type Item                                                                                                      |   |
+| Block_Type_Asset            | BlockType                              | A reference to an Asset of type BlockType                                                                                                 |   |
+| Particle_System             | ParticleSystem                         | A reference to an Asset of type ParticleSystem                                                                                            |   |
+| Hitbox_Collision_Config     | HitboxCollisionConfig                  | A reference to an Asset of type HitboxCollisionConfig                                                                                     |   |
+| Repulsion_Config            | RepulsionConfig                        | A reference to an Asset of type RepulsionConfig                                                                                           |   |
+| Sound_Event_Asset           | SoundEvent                             | A reference to an Asset of type SoundEvent                                                                                                |   |
+| Ambiance_Fx_Asset           | AmbianceFX                             | A reference to an Asset of type AmbianceFX                                                                                                |   |
+| Sound_Category              | SoundCategory                          | A sound category (sfx, music, ambient, ui)                                                                                                |   |
+| Entity_ID                   | `ArgWrapper<EntityWrappedArg, UUID>`   | A UUID representing an entity id                                                                                                          |   |
+| Integer_Comparison_Operator | IntegerComparisonOperator              | A mathematical sign for integer comparison                                                                                                |   |
+| Integer_Operation           | IntegerOperation                       | A mathematical sign for performing an operation                                                                                           |   |
+| Int_Range                   | `Pair<Integer, Integer>`               | Two integers representing a minimum and maximum of a range                                                                                |   |
+| Relative_Int_Range          | RelativeIntRange                       | Two integers representing a minimum and maximum of a range                                                                                |   |
+| Vector2I                    | Vector2i                               | Two integers, generally corresponding to x/z axis                                                                                         |   |
+| Vector3I                    | Vector3i                               | Three integers, generally corresponding to x/y/z axis                                                                                     |   |
+| Relative_Vector3I           | RelativeVector3i                       | Three optionally relative integers, generally corresponding to x/y/z axis                                                                 |   |
+| Relative_Block_Position     | RelativeIntPosition                    | A position with three integer coordinates, representing a block's location in world space.                                                |   |
+| Relative_Position           | Relative                               | A position with three decimal coordinates, representing a location in world space.                                                        |   |
+| Relative_Chunk_Position     | RealtiveChunkPosition                  | A position with two integer coordinates (x, z), representing a chunk's location.                                                          |   |
+| Rotation                    | Vector3f                               | A rotation with three coordinates, representing the pitch, yaw, and roll respectively                                                     |   |
+| Block_Type_Key              | String                                 | A block type                                                                                                                              |   |
+| Block_ID                    | Integer                                | A block type, converted to an int id                                                                                                      |   |
+| Color                       | Integer                                | A color value in hex format, hex integer, or decimal integer                                                                              |   |
+| Weighted_Block_Type         | `Pair<Integer, String>`                | A weight corresponding to a blocktype                                                                                                     |   |
+| Weighted_Block_Entry        | String                                 | A block with optional weight prefix                                                                                                       |   |
+| Block_Pattern               | BlockPattern                           | A list of blocks with optional weights                                                                                                    |   |
+| Individual_Block_Mask       | BlockMask                              | Create a block mask using symbols and block names                                                                                         |   |
+| Block_Mask                  | BlockMask                              | A tick rate value (e.g., 30tps, 33ms, or 30)                                                                                              |   |
+| Tick_Rate                   | Integer                                | A list of block masks that combine together                                                                                               |   |
+| Game_Mode                   | GameMode                               | GameMode                                                                                                                                  |   |
diff --git a/content/docs/hu-HU/server/interaction-reference.mdx b/content/docs/hu-HU/server/interaction-reference.mdx
new file mode 100644
index 00000000..6c0d01b3
--- /dev/null
+++ b/content/docs/hu-HU/server/interaction-reference.mdx
@@ -0,0 +1,1586 @@
+---
+title: Interactions
+description: A list of most Interaction types provided by Hypixel, along with the meaning of their fields, and how they fit together.
+icon: List
+authors:
+  - name: Stephen Baynham
+    url: https://github.com/cannibalvox
+---
+
+### The Interaction Base Type
+
+All interactions of every type below are inherited from Interaction and have these fields.
+
+**Interaction Fields**
+
+| Field Name                | Type                                                                 | Required? | Notes                                                                                                                                                                                                                       |
+| ------------------------- | -------------------------------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| ViewDistance              | `Double`<br />(Default: 96.0)                                        | **No**    | Distance in blocks at which other players can see the effects from this interaction.                                                                                                                                        |
+| Effects                   | `InteractionEffects`                                                 | **No**    | Sound, animations, and particle effects that should trigger when this interaction begins executing.                                                                                                                         |
+| HorizontalSpeedMultiplier | `Float`<br />(Default: 1.0)                                          | **No**    | Multiplier applied to the User entity's movement speed while this interaction is executing                                                                                                                                  |
+| RunTime                   | `Float`                                                              | **No**    | If provided, this interaction will continue executing for at least this long before the interaction chain moves onto the next interaction.                                                                                  |
+| CancelOnItemChange        | `Boolean`<br />(Default: true)                                       | **No**    | If true, this interaction will be cancelled if the User entity's held item changes during execution. This can happen either due to the selected hotbar slot changing or the contents of the item's inventory slot changing. |
+| Rules                     | `InteractionRules`                                                   | **Yes**   | If provided, adds additional limitations and cancellation conditions to this interaction.                                                                                                                                   |
+| Settings                  | `Map`<br />(Key Type: `GameMode`, Value Type: `InteractionSettings`) | **No**    | If provided, adds additional per-GameMode settings to the interaction.                                                                                                                                                      |
+| Camera                    | `InteractionCameraSettings`                                          | **No**    | Arrays of camera motion keyframes for cutscenes and reveals.                                                                                                                                                                |
+
+**GameMode Values**
+
+- `Creative`: The game is currently in Creative Mode
+- `Adventure`: The game is currently in Adventure Mode
+
+**InteractionEffects Fields**
+
+| Field Name               | Type                                              | Required? | Notes                                                                                                                                                 |
+| ------------------------ | ------------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Particles                | `Array`<br />(Element Type: `ModelParticle`)      | **No**    | Particle systems to activate when this interaction begins if the player is in third-person mode.                                                      |
+| FirstPersonParticles     | `Array`<br />(Element Type: `ModelParticle`)      | **No**    | Particle systems to activate when this interaction begins if the player is in first-person mode.                                                      |
+| WorldSoundEventId        | `Asset`<br />(Asset Type: `SoundEvent`)           | **No**    | A sound to play in the world at the User entity's location when this interaction begins.<br />**The SoundEvent must be single-channel (mono) sound.** |
+| LocalSoundEventId        | `Asset`<br />(Asset Type: `SoundEvent`)           | **No**    | A 2D sound to play for the User entity when this interaction begins. Ignored if the User entity is not a player.                                      |
+| Trails                   | `Array`<br />(Element Type: `ModelTrail`)         | **No**    | Trail effects to activate on the User entity when this interaction begins.                                                                            |
+| WaitForAnimationToFinish | `Boolean`<br />(Default: false)                   | **No**    | If true, this interaction will continue executing for at least the length of any animations in this InteractionEffects object.                        |
+| ItemPlayerAnimationsId   | `Asset`<br />(Asset Type: `ItemPlayerAnimations`) | **No**    | If provided, the User entity will use this ItemPlayerAnimations set while this interaction is executing.                                              |
+| ItemAnimationId          | `String`                                          | **No**    | Id of an animation to trigger when this interaction begins executing.<br />**This animation id is not validated on server start.**                    |
+| ClearAnimationOnFinish   | `Boolean`<br />(Default: false)                   | **No**    | If true, animations triggered by this interaction will be halted when the interaction completes.                                                      |
+| ClearSoundEventOnFinish  | `Boolean`<br />(Default: false)                   | **No**    | If true, sounds triggered by this interaction will be halted when the interaction completes.                                                          |
+| CameraEffect             | `Asset`<br />(Asset Type: `CameraEffect` )        | **No**    | If provided, the CameraEffect will be applied while this interaction is executing.                                                                    |
+| MovementEffects          | `MovementEffects`                                 | **No**    | If provided, apply the movement effects to the User entity while this interaction is executing.                                                       |
+| StartDelay               | `Float`<br />(Default: 0.0f)                      | **No**    | The interaction will wait this many seconds before triggering the effects in this object.                                                             |
+
+**InteractionRules Fields**
+
+| Field Name          | Type                                                                                                | Required? | Notes                                                                                                                                                                                                                                     |
+| ------------------- | --------------------------------------------------------------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| BlockedBy           | `Array`<br />(Element Type: `InteractionType`)<br />(Default: Based on the chain's InteractionType) | **No**    | If provided, this RootInteraction cannot be executed while interaction chains of the provided types are executing.<br />**This field only functions for rules attached to a RootInteraction. It has no effect on an Interaction.**        |
+| Blocking            | `Array`<br />(Element Type: `InteractionType`)                                                      | **No**    | If provided, interaction chains with the specified InteractionTypes cannot be executed while this interaction is executing.                                                                                                               |
+| InterruptedBy       | `Array`<br />(Element Type: `InteractionType`)                                                      | **No**    | If provided, interaction chains with the specified InteractionTypes will cancel this interaction chain when they execute.<br />**This field only functions for rules attached to a RootInteraction. It has no effect on an Interaction.** |
+| Interrupting        | `Array`<br />(Element Type: `InteractionType`)                                                      | **No**    | If provided, interaction chains with the specified InteractionTypes will be canceled when this interaction begins.                                                                                                                        |
+| BlockedByBypass     | `String`                                                                                            | **No**    | If provided, this RootInteraction cannot be blocked by interaction chains whose RootInteraction has this value as an asset tag.                                                                                                           |
+| BlockingBypass      | `String`                                                                                            | **No**    | If provided, this interaction will not block RootInteractions that have the this value as an asset tag.                                                                                                                                   |
+| InterruptedByBypass | `String`                                                                                            | **No**    | If provided, this RootInteraction cannot be canceled by RootInteractions that have this value as an asset tag.                                                                                                                            |
+| InterruptingBypass  | `String`                                                                                            | **No**    | If provided, this interaction will not cancel interaction chains whose RootInteraction has this value as an asset tag.                                                                                                                    |
+
+**InteractionType Values**
+
+- `Primary`
+- `Secondary`
+- `Ability1`
+- `Ability2`
+- `Ability3`
+- `Use`
+- `Pick`
+- `Pickup`
+- `CollisionEnter`
+- `CollisionLeave`
+- `Collision`
+- `EntityStatEffect`
+- `SwapTo`
+- `SwapFrom`
+- `Death`
+- `Wielding`
+- `ProjectileSpawn`
+- `ProjectileHit`
+- `ProjectileMiss`
+- `ProjectileBounce`
+- `Held`
+- `HeldOffhand`
+- `Equipped`
+- `Dodge`
+- `GameModeSwap`
+
+**InteractionSettings Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                        |
+| ---------------- | ------------------------------- | --------- | -------------------------------------------------------------------------------------------- |
+| AllowSkipOnClick | `Boolean`<br />(Default: false) | **No**    | If true, the user will be able to skip this interaction by clicking shortly after it starts. |
+
+**InteractionCameraSettings Fields**
+
+| Field Name  | Type                                             | Required? | Notes                                                                                                                                                           |
+| ----------- | ------------------------------------------------ | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| FirstPerson | `Array`<br />(Element Type: `InteractionCamera`) | **No**    | A list of camera keyframes to be played if the player is in first-person.<br />**The time of each keyframe must be after the keyframe before it in the array.** |
+| ThirdPerson | `Array`<br />(Element Type: `InteractionCamera`) | **No**    | A list of camera keyframes to be played if the player is in third-person.<br />**The time of each keyframe must be after the keyframe before it in the array.** |
+
+**InteractionCamera Fields**
+
+| Field Name | Type                         | Required? | Notes                                                                                                                                       |
+| ---------- | ---------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------- |
+| Time       | `Float`<br />(Default: 0.1f) | **No**    | How long after the interaction begins executing that the camera should arrive at this keyframe.<br />**Cannot be less than or equal to 0.** |
+| Position   | `Vector3`                    | **Yes**   | Where the camera should be located when it arrives at this keyframe.                                                                        |
+| Rotation   | `Direction`                  | **Yes**   | Where the camera should be pointing when it arrives at this keyframe.                                                                       |
+
+### SimpleInteraction
+
+Most interaction types below are inherited from SimpleInteraction and have these
+fields.  If a type does not have these fields, the documentation will mention it.
+
+The purpose of SimpleInteraction is to facilitate Interaction chaining by taking different paths
+based on whether the Interaction succeeded or failed.  The circumstances under which
+a given Interaction fails are generally type-specific (and described in the documentation
+below), but all interactions will be marked failed if they are cancelled via one of the
+many, many mechanisms for doing so.
+
+It is valid to create an interaction asset of type "Simple", which can be valuable when you want to use the
+interaction fields with no additional functionality.
+
+**SimpleInteraction Fields**
+
+| Field Name | Type                                     | Required? | Notes                                                                                          |
+| ---------- | ---------------------------------------- | --------- | ---------------------------------------------------------------------------------------------- |
+| Next       | `Asset`<br />(Asset Type: `Interaction`) | **No**    | After this Interaction has finished, "Next" will be executed if this Interaction did not fail. |
+| Failed     | `Asset`<br />(Asset Type: `Interaction`) | **No**    | After this Interaction has finished, "Failed" will be executed if this Interaction failed.     |
+
+## Flow Control
+
+These are interaction types used to control the flow of an interaction chain and allow interactions
+to be composed into more complex behaviors.  These interaction types generally do not pertain to
+the game and instead pertain to the interaction system itself.
+
+### Condition
+
+This interaction will fail if one of the fields is provided but does not match the current state.
+
+**Condition Fields**
+
+| Field Name       | Type       | Required? | Notes                                                                                                                                                                                    |
+| ---------------- | ---------- | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| RequiredGameMode | `GameMode` | **No**    | If provided, the interaction will fail if the current GameMode does not match the provided value.                                                                                        |
+| Jumping          | `Boolean`  | **No**    | If provided, the interaction will fail if the player's Jumping state does not match the provided value. (i.e. if True, the player must be jumping, if False, the player must not be)     |
+| Swimming         | `Boolean`  | **No**    | If provided, the interaction will fail if the player's Swimming state does not match the provided value. (i.e. if True, the player must be swimming, if False, the player must not be)   |
+| Crouching        | `Boolean`  | **No**    | If provided, the interaction will fail if the player's Crouching state does not match the provided value. (i.e. if True, the player must be crouching, if False, the player must not be) |
+| Running          | `Boolean`  | **No**    | If provided, the interaction will fail if the player's Running state does not match the provided value. (i.e. if True, the player must be running, if False, the player must not be)     |
+| Flying           | `Boolean`  | **No**    | If provided, the interaction will fail if the player's Flying state does not match the provided value. (i.e. if True, the player must be flying, if False, the player must not be)       |
+
+**GameMode Values**
+
+- `Creative`: The game is currently in Creative Mode
+- `Adventure`: The game is currently in Adventure Mode
+
+### FirstClick
+
+This interaction does not inherit from SimpleInteraction and therefore has no Next or Failed fields.
+
+This interaction has two fields that each contain a reference to an Interaction: Click and Hold.  If the root interaction
+of the chain was initiated by a client button/key press (or simulated NPC input) and the input was a tap, then
+the Click interaction is run. if it was a longer press, then the Hold interaction is run.
+
+As a minor implementation detail, this interaction is internally marked as failed when the Hold path is followed.
+This generally shouldn't matter.  If the interaction was not initiated by a key press at all, the Click path will be followed,
+but it seems risky to rely on that behavior.
+
+**FirstClick Fields**
+
+| Field Name | Type                                     | Required? | Notes                                                                                                                                                    |
+| ---------- | ---------------------------------------- | --------- | -------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Click      | `Asset`<br />(Asset Type: `Interaction`) | **No**    | If provided and the root interaction of the chain was initiated by button/key press, this interaction is executed next if the press was a quick tap.     |
+| Hold       | `Asset`<br />(Asset Type: `Interaction`) | **No**    | If provided and the root interaction of the chain was initiated by a button/key press, this interaction is executed next if the press was a longer hold. |
+
+### Interrupt
+
+This interaction can be used to cancel one or more running interaction chains on an entity and **all forked interaction
+chains those chains have spawned that are still currently running**.  All interaction chains canceled in this manner will be marked as
+Failed, which may have additional implications if the canceled chains are themselves forked from
+other chains that are still running.
+
+**Interrupt Fields**
+
+| Field Name     | Type                                           | Required? | Notes                                                                                                                                                                                               |
+| -------------- | ---------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Entity         | `InteractionTarget`<br />(Default: User)       | **Yes**   | The entity that is the owner of the target interaction chains.  This field can indicate the Owner, User, or Target of this interaction chain.                                                       |
+| InterruptTypes | `Array`<br />(Element Type: `InteractionType`) | **No**    | A set of InteractionTypes that are to be interrupted. Only interactions of these types are affected. If null, all types will be interrupted.<br />**(Note: An empty set will interrupt NO TYPES.)** |
+| RequiredTag    | `String`                                       | **No**    | An asset tag that, if provided, the RootInteraction of the interaction chain must have in order to be canceled.                                                                                     |
+| ExcludedTag    | `String`                                       | **No**    | An asset tag that, if provided, the RootInteraction of the interaction chain must not have in order to be canceled.                                                                                 |
+
+**InteractionTarget Values**
+
+- `User` - The user of this interaction chain. The entity whose actions caused this interaction chain to be executed. This is usually the same as the Owner.
+- `Owner` - The owner of this interaction chain. The entity upon whom this interaction chain is executing.
+- `Target` - The entity target of this interaction chain, if any.  This value is mutable (and can therefore come from many places) but most commonly, it is an entity the User was targeting when this interaction chain began executing.
+
+**InteractionType Values**
+
+- `Primary`
+- `Secondary`
+- `Ability1`
+- `Ability2`
+- `Ability3`
+- `Use`
+- `Pick`
+- `Pickup`
+- `CollisionEnter`
+- `CollisionLeave`
+- `Collision`
+- `EntityStatEffect`
+- `SwapTo`
+- `SwapFrom`
+- `Death`
+- `Wielding`
+- `ProjectileSpawn`
+- `ProjectileHit`
+- `ProjectileMiss`
+- `ProjectileBounce`
+- `Held`
+- `HeldOffhand`
+- `Equipped`
+- `Dodge`
+- `GameModeSwap`
+
+### Parallel
+
+This interaction does not inherit from SimpleInteraction and therefore has no Next or Failed fields.
+
+This interaction has a field `Interactions` that is an array of RootInteraction assets. The list must contain at least
+two RootInteractions.  This interaction will fork all of its children except for the first into their
+own interaction chains and immediately complete. After this interaction completes, this interaction chain will
+execute the first RootInteraction in the `Interactions` list.
+
+This interaction does not have any failure conditions and is indifferent to the fate of the forked interaction chains.
+
+**Parallel Fields**
+
+| Field Name   | Type                                                | Required? | Notes                                                         |
+| ------------ | --------------------------------------------------- | --------- | ------------------------------------------------------------- |
+| Interactions | `AssetArray`<br />(Element Type: `RootInteraction`) | **Yes**   | An array of RootInteractions that will be forked or executed. |
+
+### Repeat
+
+This interaction has a field `ForkInteractions` that is an asset of type RootInteraction. This interaction will fork that
+RootInteraction into its own interaction chain and then wait for it to complete. If the RootInteraction fails, this
+interaction will complete immediately and be marked failed. Otherwise, the RootInteraction will be forked and run again,
+up to a specified total number of times.
+
+**Repeat Fields**
+
+| Field Name       | Type                                                                                   | Required? | Notes                                                                                                                                                                                                              |
+| ---------------- | -------------------------------------------------------------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| ForkInteractions | `Asset`<br />(Asset Type: `RootInteraction`)                                           | **Yes**   | A RootInteraction that will be forked.                                                                                                                                                                             |
+| Repeat           | `Integer`<br />(Default: 1)<br />**Must be -1 or a positive integer. 0 is not valid.** | **No**    | The total number of times to fork ForkInteractions. If -1 is provided, ForkInteractions will continue being forked and executed indefinitely, until this interaction is cancelled or until ForkInteractions fails. |
+
+### Replace
+
+This interaction does not inherit from SimpleInteraction and therefore has no Next or Failed fields.
+
+This interaction uses the InteractionVars system that is avaiable for items. InteractionVars are RootInteractions that
+can be attached to an Item asset with a name.
+
+This interaction specifies a var name, and if this interaction chain was executed through
+an item and that item has an InteractionVar of the same name, then this interaction will immediately execute
+the RootInteraction on the var.  Otherwise, it will execute the default RootInteraction specified in this interaction.
+If no default is specified, then this interaction will be marked as failed.
+
+**Replace Fields**
+
+| Field Name   | Type                                         | Required? | Notes                                                                                                                                                                                                           |
+| ------------ | -------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Var          | `String`                                     | **Yes**   | The name of the InteractionVar to execute.                                                                                                                                                                      |
+| DefaultValue | `Asset`<br />(Asset Type: `RootInteraction`) | **No**    | The RootInteraction to execute if the owning item does not have an InteractionVar by the specified name. If not provided, the interaction will be marked as failed instead.                                     |
+| DefaultOk    | `Boolean`<br />(Default: false)              | **No**    | If false, then an angry message will be printed to the server logs if the owning item does not have an InteractionVar by the specified name.  The functioning of this interaction will be otherwise unaffected. |
+
+### RunRootInteraction
+
+This interaction immediately executes the provided RootInteraction as part of this interaction chain. This interaction
+does not have any failure conditions.
+
+**RunRootInteraction Fields**
+
+| Field Name      | Type                                         | Required? | Notes                           |
+| --------------- | -------------------------------------------- | --------- | ------------------------------- |
+| RootInteraction | `Asset`<br />(Asset Type: `RootInteraction`) | **Yes**   | The RootInteraction to execute. |
+
+### Selector
+
+This interaction will execute a Selector to find entities and/or blocks (depending on the Selector) and fork off an
+interaction chain for each located entity or block. This interaction will not wait for those interaction chains
+to complete and is indifferent to their fate. The forked interaction chains will use the located entity/block as
+their target entity/target block. Each entity or block will only fork one interaction chain over the life of this
+interaction.  The Selector is guaranteed to run once for each execution of this interaction, but some Selectors
+are intended to be run over a period of time and sweep across an area to locate targets. In order to use those Selectors
+properly, you will need to extend the execution time of this interaction using `RunTime` or `WaitForAnimationToFinish`.
+The Selector will be executed repeatedly over the lifetime of the interaction.
+
+If the Selector is configured to locate entities, you can add additional sets of entity matching rules. If a located entity
+matches one of the rules, the matching RootInteraction will be forked instead of the standard `HitEntity` RootInteraction.
+
+Entities located by the Selector will be ignored if they do not have a NetworkId, if they are dead, or if they are invulnerable.
+The only exception to this rule is that players in Creative Mode that are marked to receive hits will not be ignored.
+
+This interaction's failure conditions are configurable via the `FailOn` field. You can configure this interaction to never
+fail, to fail if the Selector does not locate any blocks before this interaction finishes executing, to fail if the
+Selector does not locate any entities before this interaction finishes executing, or to fail in either case.
+
+**Selector Fields**
+
+| Field Name     | Type                                         | Required? | Notes                                                                                                                                                                                                                                     |
+| -------------- | -------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Selector       | `Selector`                                   | **Yes**   | The Selector is executed at least once and may be executed repeatedly to locate blocks and/or entities in an area.                                                                                                                        |
+| HitEntity      | `Asset`<br />(Asset Type: `RootInteraction`) | **No**    | If included and the `Selector` locates an entity that does not match any `HitEntityRules`, this RootInteraction will be forked into a new interaction chain with the located entity as the target entity.                                 |
+| HitEntityRules | `Array`<br />(Element Type: `HitEntity`)     | **No**    | If included, these rules will be matched against any entity located by the `Selector`. If an entity matches a set of rules, the RootInteraction associated with the rules will be forked instead of the standard `HitEntity` interaction. |
+| HitBlock       | `Asset`<br />(Asset Type: `RootInteraction`) | **No**    | If included and the `Selector` locates a block, this RootInteraction will be forked into a new interaction chain with the located block as the block target.                                                                              |
+| FailOn         | `FailOnType`<br />(Default: `Neither`)       | **No**    | Defines under what circumstances this interaction will fail.  It can be marked to fail when it completes without locating any blocks, it can be marked to fail when it completes without locating any entities, both, or neither.         |
+| IgnoreOwner    | `Boolean`<br />(Default: true)               | **No**    | If true, the Selector will not locate the User entity of this interaction.                                                                                                                                                                |
+
+**HitEntity Fields**
+
+| Field Name | Type                                         | Required? | Notes                                                                                                 |
+| ---------- | -------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------- |
+| Matchers   | `Array`<br />(Element Type: `EntityMatcher`) | **Yes**   | A set of rules that an entity must match. An entity must successful match all rules to be considered. |
+| Next       | `Asset`<br />(Asset Type: `RootInteraction`) | **Yes**   | The RootInteraction to fork if an entity matches all rules.                                           |
+
+**EntityMatcher Fields**
+
+| Field Name | Type                            | Required? | Notes                                                                                                     |
+| ---------- | ------------------------------- | --------- | --------------------------------------------------------------------------------------------------------- |
+| Type       | `String`                        | **Yes**   | If provided, specifies a type of EntityMatcher to use. Each matcher type may come with additional fields. |
+| Invert     | `Boolean`<br />(Default: false) | **No**    | If true, an entity must fail this rule for it to be marked as succeeded.                                  |
+
+**EntityMatcher Type: Player**
+
+This EntityMatcher will succesfully match the entity only if they are a player.
+
+**EntityMatcher Type: Vulnerable**
+
+This Entitymatcher will successfully match the entity only if they are not marked as invulnerable.
+
+**FailOnType Values**
+
+- `Neither`
+- `Entity`
+- `Block`
+- `Either`
+
+### Serial
+
+This interaction does not inherit from SimpleInteraction and therefore has no Next or Failed fields.
+
+This interaction has a field `Interactions` which is a list of Interaction assets. This interaction immediately
+completes and the interaction chain continues by executing the interactions in the list one at a time. This
+interaction does not have any failure conditions.
+
+**Serial Fields**
+
+| Field Name   | Type                                            | Required? | Notes                                      |
+| ------------ | ----------------------------------------------- | --------- | ------------------------------------------ |
+| Interactions | `AssetArray`<br />(Element Type: `Interaction`) | **Yes**   | An array of Interaction assets to execute. |
+
+## Cooldowns
+
+RootInteractions interface with a complex cooldown system that can be used for a variety of purposes. Aside from simply
+adding an important aspect of resource management to your game design, cooldowns can be used to ensure that click-activated
+interaction chains don't repeatedly spam if the player holds down the input.
+
+By default, every RootInteraction has a cooldown timer that is keyed to the RootInteraction name, and by default, it
+will launch a cooldown of 0.35 seconds when activated by client input.  Otherwise, no cooldown will be activated.  However,
+by configuring your RootInteraction, you can change the key for the cooldown (so that multiple RootInteractions can share
+a single cooldown), set the cooldown timer to whatever you like, and configure multiple charges that can build up over time
+to allow the entity to activate the RootInteraction multiple times before being forced to pause.
+
+One important concept to keep in mind is the difference between **cooldown** and **charge time**.  The cooldown, if any,
+is activated each time a RootInteraction triggers, even if the player has more available charges. If the RootInteraction
+is configured to use charges, then they will gradually build up over time. In order for a RootInteraction to be activated,
+the cooldown (if any) must be expired, and the RootInteraction must have at least one charge (if it has been
+configured to use charges).
+
+Bear in mind that the entire Cooldown configuration is shared between different RootInteractions with the same cooldown id.
+If you activate an ability with 5 charges and a short cooldown and then another ability with a much longer cooldown and no
+charges, the second ability will use the cooldown properties of the first ability until/unless the first ability finishes
+charging and is cleared from the system.  You should generally only have multiple RootInteractions share a cooldown id
+if they have the same configuration.
+
+The interactions below interact with the cooldown system to allow you to manipulate cooldowns via the interaction system. By
+using these interactions, you can have several interaction chains with different cooldown configurations share cooldowns
+that are checked and activated as part of the interaction chain itself, or have some components of an interaction change
+use a second cooldown separate from the main one.
+
+### CooldownCondition
+
+**CooldownCondition Fields**
+
+This interaction will fail if the specified cooldown id is on cooldown for the User entity.  This interaction will only
+function for players- the interaction will always succeed for NPCs.  In order for this interaction to succeed, the
+cooldown, if any, must have expired and at least one charge, if any, must have filled.
+
+| Field Name | Type     | Required? | Notes                     |
+| ---------- | -------- | --------- | ------------------------- |
+| Id         | `String` | **Yes**   | The cooldown id to check. |
+
+### IncrementCooldown
+
+**IncrementCooldown Fields**
+
+This interaction will modify a cooldown that is currently active on the User entity, allowing charges and remaining
+cooldown to be modified.
+Despite its name, this interaction can be used to reduce a cooldown as well as increase it. If the cooldown is not
+currently active, this interaction will have no effect. The interaction has no special failure conditions.
+
+| Field Name        | Type                        | Required? | Notes                                                                                                                                                                                                                                                                                     |
+| ----------------- | --------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Id                | `String`                    | **No**    | If provided, the cooldown id of the cooldown to be manipulated. If not provided, the cooldown id of the current chain's RootInteraction will be used.                                                                                                                                     |
+| Time              | `Float`<br />(Default: 0.0) | **No**    | The amount to increase the remaining cooldown by. Can be negative. The remaining cooldown time will not be reduced below zero or increased above the maximum cooldown time.                                                                                                               |
+| ChargeTime        | `Float`<br />(Default: 0.0) | **No**    | The amount to increase the remaining time until the next charge is filled by. Can be negative. The remaining charge time cannot be reduced below zero or increased above the maximum cooldown time. **This will not work on abilities that have a maximum of 1 charge, for some reason.** |
+| Charge            | `Integer`<br />(Default: 0) | **No**    | The amount to increase the number of charges by. Can be negative. The number of charges cannot be reduced below 0 or increased above the maximum.                                                                                                                                         |
+| InterruptRecharge | `Boolean`(Default: false)   | **No**    | If true and `Charge` is not 0, will reset the remaining time to the next charge to the maximum value after changing the charge count.                                                                                                                                                     |
+
+### ResetCooldown
+
+This interaction will trigger a cooldown on the User entity with a specified configuration. The charges will be refilled
+but the cooldown will be immediately triggered.  The mechanisms for deciding on the configuration are a little bit complicated.
+You may specify a cooldown configuration via the `Cooldown` field. If you do not include an `Id` field, then the
+interaction chain's RootInteraction will be used for any field not specified in the configuration. If there is an active
+cooldown under the specified `Id` (or under the RootInteraction's cooldown id if none is specified) then the fields
+from that active cooldown will overwrite data in the RootInteraction's cooldown, but not data in your `Cooldown` field.
+
+**ResetCooldown Fields**
+
+| Field Name | Type                  | Required? | Notes                                                        |
+| ---------- | --------------------- | --------- | ------------------------------------------------------------ |
+| Cooldown   | `InteractionCooldown` | **No**    | A cooldown configuration to use for the new, reset cooldown. |
+
+**InteractionCooldown Fields**
+
+| Field Name        | Type                                 | Required? | Notes                                                                                                                                                                                                 |
+| ----------------- | ------------------------------------ | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Id                | `String`                             | **No**    | The cooldown id to use for this cooldown. If not provided, the RootInteraction's cooldown id will be used, if any.                                                                                    |
+| Cooldown          | `Float`<br />(Default: 0.0)          | **No**    | The duration of the cooldown, in seconds.                                                                                                                                                             |
+| Charges           | `Array`<br />(Element Type: `Float`) | **No**    | If provided, a list of how many charges this cooldown can build, and how long each charge takes to build, in seconds.                                                                                 |
+| InterruptRecharge | `Boolean`<br />(Default: false)      | **No**    | If true, the charge time will be reset when the number of charges changes.                                                                                                                            |
+| ClickBypass       | `Boolean`<br />(Default: false)      | **No**    | If true, RootInteractions keyed to this cooldown can still be activated when it is on cooldown provided that the RootInteraction was triggered by a distinct key or mouse button press on the client. |
+
+### TriggerCooldown
+
+This interaction is similar to ResetCooldown, except instead of refilling the cooldown's charges, one charge will be deducted
+as normal.
+
+**TriggerCooldown Fields**
+
+| Field Name | Type                  | Required? | Notes                                                        |
+| ---------- | --------------------- | --------- | ------------------------------------------------------------ |
+| Cooldown   | `InteractionCooldown` | **No**    | A cooldown configuration to use for the new, reset cooldown. |
+
+**InteractionCooldown Fields**
+
+| Field Name        | Type                                 | Required? | Notes                                                                                                                                                                                                 |
+| ----------------- | ------------------------------------ | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Id                | `String`                             | **No**    | The cooldown id to use for this cooldown. If not provided, the RootInteraction's cooldown id will be used, if any.                                                                                    |
+| Cooldown          | `Float`<br />(Default: 0.0)          | **No**    | The duration of the cooldown, in seconds.                                                                                                                                                             |
+| Charges           | `Array`<br />(Element Type: `Float`) | **No**    | If provided, a list of how many charges this cooldown can build, and how long each charge takes to build, in seconds.                                                                                 |
+| InterruptRecharge | `Boolean`<br />(Default: false)      | **No**    | If true, the charge time will be reset when the number of charges changes.                                                                                                                            |
+| ClickBypass       | `Boolean`<br />(Default: false)      | **No**    | If true, RootInteractions keyed to this cooldown can still be activated when it is on cooldown provided that the RootInteraction was triggered by a distinct key or mouse button press on the client. |
+
+## Combo Chains
+
+Hytale additionally comes with a rich "combo chaining" system, which allows several inputs in a row to result in different
+attacks and special moves.  Rather than being attached to the RootInteraction like the cooldown system, these are
+primarily driven by the `Chaining` interaction.
+
+### Chaining
+
+This interaction does not inherit from SimpleInteraction and therefore has no Failed field. Its Next field works differently
+from most interaction types.
+
+Chaining is a type of flow control interaction- each time a Chaining interaction with the same `ChainId` is called, a single
+interaction in the `Next` list is chosen and the others are ignored. The first time the `ChainId` is used, the first
+interaction in the list is chosen, the next time the second, etc. Once the end of the list is reached, the first
+interaction will be chosen again.
+
+Bear in mind: the progress through the Next list is based on the **ChainId**, not the interaction!  That means that two
+different Chaining interactions can share a single combo chain. You could have a pair of daggers that attacks with
+the left when the left mouse button is clicked and with the right when the right mouse button is clicked.  You could give
+both interaction chains a Chaining interaction with the same `ChainId` and three `Next` entries that do a light-light-heavy
+combo.  Each specific hit would occur with either the left or the right knife based on which button you clicked, but
+the combo would be otherwise identical regardless of which you chose.
+
+The Chaining interaction also has a concept called "flags".  It is possible to attach named flags to a `ChainId` by using
+the ChainFlag interaction.  Then, you specify the flag name in Chaining's `Flags` field. If a Flag is active when the
+Chaining interaction is run, the Flag's interaction will be run instead of the appropriate interaction in `Next`.
+Bear in mind: the entity's progress through the `Next` list still advances, the resulting `Next` interaction is just not
+run.  Only one flag can be active at a time.
+
+Lastly, it is possible to cancel the entity's progress through the combo chain and reset them to the first interaction in
+the list. This can be done with the CancelChain interaction, but it will also happen automatically if the player does
+not trigger an interaction with the ChainId for the specified ChainingAllowance.  When either of these happen, all flags will be
+canceled as well.
+
+All of these effects are triggered on the User entity only. Non-players can use the chaining system, but Flags do not currently
+work for non-players.  This interaction has no special failure conditions.
+
+**Chaining Fields**
+
+| Field Name        | Type                                                       | Required? | Notes                                                                                                                                                                                                                       |
+| ----------------- | ---------------------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| ChainId           | `String`                                                   | **No**    | If provided, acts as a key that multiple Chaining interactions can use to share combo chain progress and flags. If not provided, a unique ChainId will be generated for this interaction.                                   |
+| ChainingAllowance | `Double`<br />(Default: 0.0)                               | **No**    | If, at the time this interaction is triggered, it has been this long in seconds since the last time a Chaining interaction with the same ChainId was executed, all state for this ChainId will be cleared before execution. |
+| Next              | `AssetArray`<br />(Element Type: `Interaction`)            | **Yes**   | A list of interactions to cycle between each time this interaction is run.                                                                                                                                                  |
+| Flags             | `Map`<br />(Key Type: `String`, Value Type: `Interaction`) | **No**    | A map of flag names to interactions to run if the flag is active when this interaction executes.                                                                                                                            |
+
+### CancelChain
+
+This interaction resets all progress and flag data on the User entity for the provided `ChainId`.  The next time a Chaining
+interaction is called for the provided `ChainId`, it will begin at the first interaction in the `Next` list. This
+interaction has no special failure conditions.
+
+**CancelChain Fields**
+
+| Field Name | Type     | Required? | Notes                                 |
+| ---------- | -------- | --------- | ------------------------------------- |
+| ChainId    | `String` | **Yes**   | A ChainId whose data should be reset. |
+
+### ChainFlag
+
+This interaction activates a flag on the User entity for the provided `ChainId`, which can be used to change behavior the
+next time a Chaining interaction with this `ChainId` is run. This will overwrite any flag that has
+already been raised. This interaction will have no effect for non-players. This interaction has no special failure
+conditions.
+
+| Field Name | Type     | Required? | Notes                                        |
+| ---------- | -------- | --------- | -------------------------------------------- |
+| ChainId    | `String` | **Yes**   | A ChainId on whom the flag should be raised. |
+| Flag       | `String` | **Yes**   | The name of the flag to raise.               |
+
+## Charging
+
+A unique flow-control interaction that is frequently used is the Charging interaction.  It is a flow-control interaction
+that delays while the input button used to trigger the interaction chain is held.  When it is released (or the interaction
+is forced to end), the interaction chain can continue with a different interaction based on how long the input was held
+for.
+
+These interactions are all related by either being the Charging interaction, or other interaction types that inherit the
+Charging interaction's behavior.
+
+### Charging
+
+This interaction does not inherit from SimpleInteraction and therefore its Next field works different from most interactions.
+This interaction adds its own Failed field which works the same way that SimpleInteraction's does.
+
+This interaction only works properly when its interaction chain was triggered by a client key or button press (or
+NPC-simulated equivalent). This interaction will continue executing for as long as the key or button press is held (with
+some exceptions, covered below) by the User entity.  Like other interactions, it has a `Next` field indicating which interaction to execute
+after this one, but the field is a map from `Float` values to `Interaction` assets. When this interaction ends, either
+due to the input being released or the charge duration completing, this interaction will determine the largest `Float` key that is less
+than the amount of time in seconds that the interaction was executing for.  The Interaction mapped to that key will be
+executed next.
+
+The interaction includes some cancellation conditions that are specific to this interaction. For instance, the interaction
+has a `CancelOnOtherClick` field that matches the field on RootInteraction. If it is active on this interaction but not
+the RootInteraction, then clicking while charging will cancel this interaction (and execute the `Failed` interaction rather
+than any of the `Next` interactions) but otherwise continue the interaction chain.
+
+Another valuable feature Charging has is the `Forks` field.  For input-triggered interactions that are triggered while the
+Charging interaction is executing, you can add an entry for the relevant InteractionType to this field and instead of
+triggering the usual interaction chain based on held item, targeted block, etc. the RootInteraction specified in the
+`Forks` field will be triggered.  This can unlock rich attack modes and behaviors. For instance, having a shield bash attack
+triggered off left click while blocking, or a special attack that triggers when both mouse buttons are pressed at the
+same time.
+
+There are two modes of operation for the Charging interaction. One is to have the ability charge for as long
+as the input is held and only end execution when the entity releases the input.  Bows in the main Hytale game work
+that way.  That is accomplished by setting `AllowIndefiniteHold` to true.  Another mode of operation is to have the
+interaction complete execution when the execution time has surpassed the largest key value in the `Next` field and
+immediately begin executing the Interaction mapped to that key.  Food in the main Hytale game work like this.  It
+is accomplished by setting `AllowIndefiniteHold` to false.
+
+One pitfall to be careful of when setting `AllowIndefiniteHold` to false is the way it interacts with cooldowns.\
+Normally, input-initiated interaction chains start a 0.35s cooldown on the triggered RootInteraction that prevents
+holding the mouse button from immediately spamming a new interaction when the first one completes.  However, if the
+duration of a Charging interaction is longer than 0.35s, then the cooldown will have already completed when the
+interaction chain finishes, which will often result in a new execution beginning immediately before the player can
+stop pressing the mouse button.  One solution for this problem is to add a `Simple` interaction to the end of your
+interaction chain with a `RunTime` of 0.35s to simulate the cooldown.  Alternatively, you can add a longer cooldown
+(the maximum duration of your Charging interaction plus 0.35s) to the RootInteraction. However, the longer cooldown is
+not always desirable, as the interaction may have ended prematurely, resulting in an unusually long lockout between
+executions.
+
+**Charging Fields**
+
+| Field Name                         | Type                                                                    | Required? | Notes                                                                                                                                                                                                                                                                                                                                                                                       |
+| ---------------------------------- | ----------------------------------------------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| FailOnDamage                       | `Boolean`<br />(Default: false)                                         | **No**    | If true, this interaction will fail and end immediately if the User entity takes any damage while it is executing.                                                                                                                                                                                                                                                                          |
+| CancelOnOtherClick                 | `Boolean`<br />(Default: true)                                          | **No**    | If true, this interaction will fail and end immediately if the User entity sends another button or key press while it is executing.                                                                                                                                                                                                                                                         |
+| Forks                              | `Map`<br />(Key Type: `InteractionType`, Value Type: `RootInteraction`) | **No**    | A map of InteractionType to RootInteraction. If entity input triggers the InteractionType while this interaction is executing, the mapped RootInteraction will be forked into its own interaction chain. This will happen instead of the usual handling for that InteractionType.  This fork will occur even if `CancelOnOtherClick` is set to true.                                        |
+| Failed                             | `Asset`<br />(Asset Type: `Interaction`)                                | **No**    | After this Interaction has finished, "Failed" will be executed if this Interaction failed.                                                                                                                                                                                                                                                                                                  |
+| AllowIndefiniteHold                | `Boolean`<br />(Default: false)                                         | **No**    | If true, this interaction will continue executing for as long as the User entity continues to hold the input. If false, execution will end as soon as the execution time in seconds reaches the largest key value in the `Next` map.                                                                                                                                                        |
+| DisplayProgress                    | `Boolean`<br />(Default: true)                                          | **No**    | If true, players executing this interaction will see a progress bar will be displayed below their cursor indicating how close to reaching the highest key value in `Next` they are.                                                                                                                                                                                                         |
+| Next                               | `Map`<br />(Key Type: `Float`, Value Type: `Interaction`)               | **No**    | A map from `Float` to `Interaction`.  When this interaction successfully finishes executing (either because the input was released or because the maximum duration was reached), this interaction will find the `Float` value with the largest duration in seconds that is less than the amount of time this interaction executed for. That key's mapped Interaction will then be executed. |
+| MouseSensitivityAdjustmentTarget   | `Float`<br />(Default: 1.0)                                             | **No**    | While charging, this mouse sensitivity multiplier will gradually be applied.                                                                                                                                                                                                                                                                                                                |
+| MouseSensitivityAdjustmentDuration | `Float`<br />(Default: 1.0)                                             | **No**    | Duration in seconds. After this many seconds, `MouseSensitivityAdjustmentTarget` will be fully applied to the mouse sensitivity.                                                                                                                                                                                                                                                            |
+| Delay                              | `ChargingDelay`                                                         | **No**    | Settings that allow charging progress to be pushed back when the User entity takes damage.                                                                                                                                                                                                                                                                                                  |
+
+**ChargingDelay Fields**
+
+| Field Name    | Type                        | Required? | Notes                                                                                                                                                                                                                                                                     |
+| ------------- | --------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| MinHealth     | `Float`<br />(Default: 0.0) | **No**    | Damage taken as a percentage of entity health (0.0-1.0). If a hit deals less than this much damage, no pushback will be applied.  If a hit deals exactly this much damage, `MinDelay` seconds worth of pushback will be applied.                                          |
+| MaxHealth     | `Float`<br />(Default: 0.0) | **No**    | Damage taken as a percentage of entity health (0.0-1.0). If a hit deals at least this much damage, `MaxDelay` seconds worth of pushback will be applied.                                                                                                                  |
+| MinDelay      | `Float`<br />(Default: 0)   | **No**    | The amount of pushback, in seconds, to apply if the entity takes a hit that deals `MinHealth` damage. The amount of pushback applied by a hit is a gradiant between `MinDelay` and `MaxDelay` based on the amount of damage between `MinHealth` and `MaxHealth`.          |
+| MaxDelay      | `Float`<br />(Default: 0)   | **No**    | The amount of pushback, in seconds, to apply if the entity takes a hit that deals at least `MaxHealth` damage. The amount of pushback applied by a hit is a gradiant between `MinDelay` and `MaxDelay` based on the amount of damage between `MinHealth` and `MaxHealth`. |
+| MaxTotalDelay | `Float`<br />(Deault: 0)    | **No**    | The maximum amount of pushback the entity can receive over the course of a single charge, regardless of how many times they are hit.                                                                                                                                      |
+
+**InteractionType Values**
+
+- `Primary`
+- `Secondary`
+- `Ability1`
+- `Ability2`
+- `Ability3`
+- `Use`
+- `Pick`
+- `Pickup`
+- `CollisionEnter`
+- `CollisionLeave`
+- `Collision`
+- `EntityStatEffect`
+- `SwapTo`
+- `SwapFrom`
+- `Death`
+- `Wielding`
+- `ProjectileSpawn`
+- `ProjectileHit`
+- `ProjectileMiss`
+- `ProjectileBounce`
+- `Held`
+- `HeldOffhand`
+- `Equipped`
+- `Dodge`
+- `GameModeSwap`
+
+### Wielding
+
+This interaction is inherited from Charging rather than SimpleInteraction.  However, its `Failed` and `Next` fields function
+identically to SimpleInteraction.  It does not inherit all fields from Charging, so be sure to pay close attention to
+the field list below.
+
+This interaction drives most blocking behavior in the game. While this interaction is executing, attacks made against
+the Owner entity will (conditionally) trigger effects defined in this interaction.  Unlike the Charging interaction,
+this interaction can always execute indefinitely and will only end when it fails or when the input is released.
+
+One option available in Wielding is `AngledWielding`, which allows damage and knockback modifiers to only be applied
+depending on the direction the attack against the Owner entity is coming from.  The AngledWielding type has a
+field `Angle` which determines which direction the protection points relative to the player (0 is the player's
+front), and `AngleDistance` which determines how wide the cone of protection extends around the player.  Block effects
+from this interaction (such as `BlockedEffects`, `BlockedInteractions`, and `StaminaCost`) will only apply if
+the DamageCause matches `DamageModifiers` OR if the DamageCause matches `AngledWielding.DamageModifiers` and
+the source of the damage matches `Angle` and `AngleDistance`.  It is possible for damage and knockback multipliers
+specified on both this interaction's modifier fields and `AngledWielding`'s modifier fields to stack, if both
+have entries for the same DamageCause.
+
+This interaction will only have an effect on damage taken by one of the DamageCause entries in `DamageModifiers` or
+`AngledWielding.DamageModifiers`.  If a DamageCause is in `DamageModifiers`, then the block effect will be triggered
+and the damage modifier applied regardless of what direction the Owner entity is attacked from.  If a DamageCause is in
+`AngledWielding.DamageModifiers`, then the damage modifier is only applied if the
+
+\*\* Wielding Fields\*\*
+
+| Field Name          | Type                                                                    | Required? | Notes                                                                                                                                                                                                                                                                                                                                                                                                      |
+| ------------------- | ----------------------------------------------------------------------- | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| FailOnDamage        | `Boolean`<br />(Default: false)                                         | **No**    | If true, this interaction will fail and end immediately if the User entity takes any damage while it is executing.                                                                                                                                                                                                                                                                                         |
+| CancelOnOtherClick  | `Boolean`<br />(Default: true)                                          | **No**    | If true, this interaction will fail and end immediately if the User entity sends another button or key press while it is executing.                                                                                                                                                                                                                                                                        |
+| Forks               | `Map`<br />(Key Type: `InteractionType`, Value Type: `RootInteraction`) | **No**    | A map of InteractionType to RootInteraction. If entity input triggers the InteractionType while this interaction is executing, the mapped RootInteraction will be forked into its own interaction chain. This will happen instead of the usual handling for that InteractionType.  This fork will occur even if `CancelOnOtherClick` is set to true (after which this interaction chain will be canceled). |
+| Next                | `Asset`<br />(Asset Type: `Interaction`)                                | **No**    | After this interaction has finished, "Next" will be executed if this interaction did not fail.                                                                                                                                                                                                                                                                                                             |
+| Failed              | `Asset`<br />(Asset Type: `Interaction`)                                | **No**    | After this interaction has finished, "Failed" will be executed if this interaction failed.                                                                                                                                                                                                                                                                                                                 |
+| DamageModifiers     | `Map`<br />(Key Type: `DamageCause`, Value Type: `Float`)               | **No**    | A map from DamageCause to Float, where the Float is multiplied against any damage received from the mapped DamageCause while this interaction is executing.                                                                                                                                                                                                                                                |
+| KnockbackModifiers  | `Map`<br />(Key Type: `DamageCause`, Value Type: `Float`)               | **No**    | A map from DamageCause to Float, where the Float is multiplied against any knockback force received from the mapped DamageCause while this interaction is executing.                                                                                                                                                                                                                                       |
+| AngledWielding      | `AngledWielding`                                                        | **No**    | Configuration to only trigger block effects from certain angles.                                                                                                                                                                                                                                                                                                                                           |
+| StaminaCost         | `StaminaCost`                                                           | **No**    | If the Owner entity receives damage that matches `DamageModifiers` or `AngledWielding` while this interaction is executing, then the entity's stamina will be deducted according to this configuration.                                                                                                                                                                                                    |
+| BlockedEffects      | `DamageEffects`                                                         | **No**    | If the Owner entity receives damage that matches `DamageModifiers` or `AngledWielding` while this interaction is executing, then these effects will be applied to the instance of damage.                                                                                                                                                                                                                  |
+| BlockedInteractions | `Asset`<br />(Asset Type: `RootInteraction`)                            | **No**    | If the Owner entity receives damage that matches `DamageModifiers` or `AngledWielding` while this interaction is executing, then this RootInteraction will be launched as a brand new interaction chain with the Owner entity as both Owner and User, and the attacker as the Target entity.  This new interaction chain is, notably, brand new, **not** forked from the current one.                      |
+
+**AngledWielding Fields**
+
+| Field Name         | Type                                                      | Required? | Notes                                                                                                                                                                                                            |
+| ------------------ | --------------------------------------------------------- | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Angle              | `Float`<br />(Default: 0.0)                               | **No**    | Angle in degrees relative to the Owner entity where the angled protection is centered. 0.0 means pointed towards the front of the Owner entity.                                                                  |
+| AngleDistance      | `Float`<br />(Default: 0.0)                               | **No**    | Angle in degrees indicating how wide the cone of protection is.                                                                                                                                                  |
+| DamageModifiers    | `Map`<br />(Key Type: `DamageCause`, Value Type: `Float`) | **No**    | A map from DamageCause to Float, where the Float is multiplied against any damage received from the mapped DamageCause received from within the cone of protection while this interaction is executing.          |
+| KnockbackModifiers | `Map`<br />(Key Type: `DamageCause`, Value Type: `Float`) | **No**    | A map from DamageCause to Float, where the Float is multiplied against any knockback force received from the mapped DamageCause received from within the cone of protection while this interaction is executing. |
+
+**StaminaCost Fields**
+
+| Field Name | Type                                             | Required? | Notes                                                                                                                                                                                                                                                |
+| ---------- | ------------------------------------------------ | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| CostType   | `CostType`<br />(Default: `MaxHealthPercentage`) | **No**    | How to calculate stamina consumed by blocking from the raw pre-block damage. If `Damage`, then the stamina consumed will be `rawDamage / Value`. If `MaxHealthPercentage`, then the stamina consumed will be `rawDamage / (EntityMaxHealth * Value)` |
+| Value      | `Float`<br />(Default: 0.04)                     | **No**    | The value to use in the `CostType` formula.                                                                                                                                                                                                          |
+
+**DamageEffects Fields**
+
+| Field Name             | Type                                         | Required? | Notes                                                                           |
+| ---------------------- | -------------------------------------------- | --------- | ------------------------------------------------------------------------------- |
+| ModelParticles         | `Array`<br />(Element Type: `ModelParticle`) | **No**    | Particle systems to trigger in the first-person view.                           |
+| WorldParticles         | `Array`<br />(Element Type: `WorldParticle`) | **No**    | Particle systems to trigger in the third-person view.                           |
+| LocalSoundEventId      | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | 2D sound to play locally to the attacking entity if they are a player.          |
+| WorldSoundEventId      | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | Sound to play in the world at the Owner entity's location.                      |
+| PlayerSoundEventId     | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | 2D sound to play locally to the Owner entity if they are a player.              |
+| ViewDistance           | `Double`<br />(Default: 75.0)                | **No**    | Distance at which these effects should play for other players.                  |
+| Knockback              | `Knockback`                                  | **No**    | The properties of the knockback that will be applied.                           |
+| CameraEffect           | `Asset`<br />(Asset Type: `CameraEffect`)    | **No**    | CameraEffect to briefly apply locally to the Owner entity if they are a player. |
+| StaminaDrainMultiplier | `Float`<br />(Default: 1.0)                  | **No**    | This multiplier is applied to the `StaminaCost`, if any.                        |
+
+**Knockback Fields**
+
+| Field Name     | Type                                       | Required? | Notes                                                                                                                      |
+| -------------- | ------------------------------------------ | --------- | -------------------------------------------------------------------------------------------------------------------------- |
+| Type           | `String`                                   | **No**    | If provided, specifies a type of knockback to use. Each knockback type may come with additional fields.                    |
+| Force          | `Double`<br />(Default: 0.0)               | **No**    | The amount of force to apply to the Owner entity.                                                                          |
+| Duration       | `Double`<br />(Default: 0.0)               | **No**    | If 0.0, apply the force as a single impulse.  If more, continuously apply the force over a period of time.                 |
+| VelocityType   | `ChangeVelocityType`<br />(Default: `Add`) | **No**    | How to apply the force, either adding it to the entity's current velocity, or setting the velocity to the knockback force. |
+| VelocityConfig | `VelocityConfig`                           | **No**    | Characteristics of friction as the Owner entity is thrown by this knockback.                                               |
+
+**Knockback Type: Force**
+
+Apply the calculated knockback force along the provided direction.
+
+| Field Name | Type                         | Required? | Notes                                                                                |
+| ---------- | ---------------------------- | --------- | ------------------------------------------------------------------------------------ |
+| Direction  | `Vector3`<br />(Default: Up) | **No**    | Which direction the player should be flung, relative to the direction of the attack. |
+
+**Knockback Type: Point**
+
+Apply the calculated knockback force laterally along the XZ plane, plus provided Y velocity.
+
+| Field Name | Type                        | Required? | Notes                                                                                                   |
+| ---------- | --------------------------- | --------- | ------------------------------------------------------------------------------------------------------- |
+| OffsetX    | `Integer`<br />(Default: 0) | **No**    | Offset the source position of the knockback left or right perpendicular to the direction of the attack. |
+| OffsetZ    | `Integer`<br />(Default: 0) | **No**    | Offset the source position of the knockback, forward or backward along the directon of the attack.      |
+| RotateY    | `Integer`<br />(Default: 0) | **No**    | Rotate the knockback direction around the Y axis, where 0 is the default attack direction.              |
+| VelocityY  | `Float`<br />(Default: 0.0) | **No**    | Add vertical velocity to the knockback force after the direction and force has been calculated.         |
+
+**Knockback Type: Directional**
+
+Apply the calculated knockback force along the attack direction, removing any vertical component and replacing it with a provided Y velocity.
+
+| Field Name | Type                      | Required? | Notes                                                                                                                                            |
+| ---------- | ------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------ |
+| RelativeX  | `Float`<br />(Default: 0) | **No**    | Apply additional force left or right perpendicular to the direction of the attack. The additional force is multiplied by the knockback strength. |
+| RelativeZ  | `Float`<br />(Default: 0) | **No**    | Apply additional force forward or backward along the attack direction. The additional force is multiplied by the knockback strength.             |
+| VelocityY  | `Float`<br />(Default: 0) | **No**    | Replace the vertical velocity of the knockback with this value.  This value is not multiplied by knockback strength.                             |
+
+**VelocityConfig Fields**
+
+| Field Name          | Type                                              | Required? | Notes                                                                                                                                                                                           |
+| ------------------- | ------------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| GroundResistance    | `Float`<br />(Default: 0.82)                      | **No**    | The minimum amount of friction applied when the entity is in contact with the ground.  1.0 = no friction, 0.0 = total friction                                                                  |
+| GroundResistanceMax | `Float`<br />(Default: 0.0)                       | **No**    | The maximum amount of friction applied when the entity is in contact with the ground.  1.0 = no friction, 0.0 = total friction                                                                  |
+| AirResistance       | `Float`<br />(Default: 0.96)                      | **No**    | The minimum amount of friction applied when the entity is in the air. 1.0 = no friction, 0.0 = total friction                                                                                   |
+| AirResistanceMax    | `Float`<br />(Default: 0.0)                       | **No**    | The maximum amount of friction applied when the entity is in the air. 1.0 = no friction, 0.0 = total friction                                                                                   |
+| Threshold           | `Float`<br />(Default: 1.0)                       | **No**    | The speed at which the maximum amount of friction will be applied to the entity. The amount of friction applied will increase from minimum to maximum as the entity moves from 0 to this speed. |
+| Style               | `VelocityThresholdStyle`<br />(Default: `Linear`) | **No**    | The curve that friction follows as the entity's speed increases toward the `Threshold`.                                                                                                         |
+
+**CostType Values**
+
+- `MaxHealthPercentage`
+- `Damage`
+
+**ChangeVelocityType Values**
+
+- `Add`
+- `Set`
+
+**VelocityThresholdStyle Values**
+
+- `Linear`
+- `Exp`
+
+## Blocks
+
+These are interaction types meant to reason about and modify blocks in the world.  The most important concept unique
+to these interactions is the Block Target.  Like the Entity Target, it is mutable and can come from many places.
+However, for interaction chains initiated by the client, the block target will initially be the block that the player's cursor was
+over, if any.
+
+Additionally, for interaction chains initiated by the client, the client will send along which face of the block is targeted,
+which is used by a few block-related interactions.
+It is left up to each interaction type that cares about block faces as to how to handle this behavior for simulated input
+(i.e. NPCs initiating chains that are normally initated by the client).  At the time of this writing, all block-related
+interactions choose the top face where relevant in simulated input.
+
+### BlockCondition
+
+This interaction has a field `Matchers` which specifies certain conditions, such as block type, state, etc.  This
+interaction fails if the current target block does not match all of them.
+
+**BlockCondition Fields**
+
+| Field Name       | Type                                        | Required? | Notes                                                                                                                                                                                                                                                                                                                                   |
+| ---------------- | ------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false)             | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction.                                                                                                                                                                                                       |
+| Matchers         | `Array`<br />(Element Type: `BlockMatcher`) | **Yes**   | A list of conditions that the target block must match or this condition will fail.<br />**Note: This field is technically not required but there is a bug that makes it dangerous to not provide at the time of this writing.**<br />**Note: If no conditions are added to this array, the interaction will fail, counterintuitively.** |
+
+**BlockMatcher Fields**
+
+| Field Name | Type                       | Required? | Notes                                                                          |
+| ---------- | -------------------------- | --------- | ------------------------------------------------------------------------------ |
+| Block      | `BlockIdMatcher`           | **No**    | If provided, requires the block itself match some set of conditions.           |
+| Face       | `BlockFace`                | **No**    | If provided and not 'None', requires a specific block face be targeted.        |
+| StaticFace | `Boolean` (Default: false) | **No**    | If false, the face condition will be adjusted by the block's current rotation. |
+
+**BlockFace Values**
+
+- `Up`
+- `Down`
+- `North`
+- `South`
+- `East`
+- `West`
+- `None`
+
+**BlockIdMatcher Fields**
+
+| Field Name | Type                                   | Required? | Notes                                                                      |
+| ---------- | -------------------------------------- | --------- | -------------------------------------------------------------------------- |
+| Id         | `Asset`<br />(Asset Type: `BlockType`) | **No**    | If provided, the block must match the specified `BlockType`.               |
+| State      | `String`                               | **No**    | If provided, the block's current state must match the provided state name. |
+| Tag        | `String`                               | **No**    | If provided, the block type's asset tags must contain the provided tag.    |
+
+### DestroyCondition
+
+This interaction fails if the current User entity cannot destroy the current target blcok.
+
+**DestroyCondition Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+
+### PlacementCountCondition
+
+This interaction accepts the name of a BlockType that has the TrackedPlacement BlockEntity. The interaction will fail if the number of
+blocks of the provided BlockType in the world do not match the provided condition.
+
+**PlacementCountCondition Fields**
+
+| Field Name | Type                           | Required? | Notes                                                                                                                                                                                                                                                           |
+| ---------- | ------------------------------ | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Block      | `String`                       | **Yes**   | The BlockType to examine. The number of instances of the BlockType in the world will be compared to Value.<br />**Note: The specified BlockType must have the TrackedPlacement BlockEntity. Otherwise, the number of blocks in the world will always be zero.** |
+| Value      | `Integer`<br />(Default: 0)    | **No**    | The value to compare the number of blocks in the world with.                                                                                                                                                                                                    |
+| LessThan   | \`Boolean<br />(Default: true) | **No**    | If true, the interaction will fail if the number of blocks in the world is greater than or equal to Value. If false, the interaction will fail if the number of blocks in the world is less than or equal to Value.                                             |
+
+### BreakBlock
+
+This interaction attempts to break the target block while acting as the User entity. The User entity must be a player. It
+is not guaranteed to work, depending on world settings and the User entity's current state, it may not work.  If it
+fails, it will fail the interaction under some circumstances, but not others.
+
+**Note: In particular, if `Harvest`=false and the player is in Survival mode, the player will simply execute a damage operation
+against the block. Even when the Tool field is specified, the player's currently-held item can impact the results in unintuitive
+ways.**
+
+This interaction will fail if there is no block target, if `Harvest`=true and the
+block is not harvestable, or if the world settings prevent the Harvest/Break operation.
+It will generally not fail otherwise, even if the block was not broken or damaged.
+The block will generally break every time if `Harvest`=true or the player is in
+Creative mode.
+
+**BreakBlock Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                                                                                                                                                                                                  |
+| ---------------- | ------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction.                                                                                                                                                                      |
+| Harvest          | `Boolean` (Default: false)      | **No**    | If true, harvest the block and deposit the drops in the player's inventory. This operation will generally always succeed.  If false, this interaction will effectively perform whatever action would have occurred if the player had left-clicked the block.                                           |
+| Tool             | `String`                        | **No**    | If `Harvest`=true, the player is in Survival mode, and this field is provided, then the break operation will be performed as though with this tool type.<br />**This field mostly doesn't work.  Your held item will be used for most block damage calculations regardless of this field's contents.** |
+| MatchTool        | `Boolean` (Default: false)      | **No**    | If true, `Harvest`=true, the player is in Survival mode, and `Tool` is provided, block breaking will be prevented unless `Tool` is a valid gathering tool for the target block. The interaction will not be failed, even if block breaking is prevented in this manner.                                |
+
+### ChangeBlock
+
+This interaction requires a mapping from one or more current BlockTypes to one or more target BlockTypes.  If the
+target block is one of the key BlockTypes, then it will be changed to the mapped target BlockType.  If the current
+BlockType of the target block does not appear as a key in the Changes field, then this interaction fails.
+
+**ChangeBlock Fields**
+
+| Field Name        | Type                                                        | Required? | Notes                                                                                                                             |
+| ----------------- | ----------------------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget  | `Boolean`<br />(Default: false)                             | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+| Changes           | `Map`<br />(Key Type: `BlockType`, Value Type: `BlockType`) | **No**    | A list of potential block type changes, with each entry having a current and new BlockType id.                                    |
+| WorldSoundEventId | `Asset`<br />(Asset Type: `SoundEvent`)                     | **No**    | If provided, this SoundEvent is played in the world at the position of the block if the block successfully changes.               |
+| RequireNotBroken  | `Boolean`<br />(Default: false)                             | **No**    | If true, this interaction will fail if the player's held item is broken (durability 0), and the block change will not take place. |
+
+### ChangeState
+
+This interaction requires a mapping from one or more current block state names to one or more state names. If the
+target block is in one of the key block states, then it will be changed to the mapped target blocks tate. If the
+current block state of the target block does nto appear as a key in the Changes field, then this interaction fails.
+
+All blocks start out with a null state by default.  This null state can be referenced by the key "default" and the block
+can be returned to that state with the value "default".
+
+**ChangeState Fields**
+
+| Field Name       | Type                                                  | Required? | Notes                                                                                                                                          |
+| ---------------- | ----------------------------------------------------- | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false)                       | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction.              |
+| Changes          | `Map`<br />(Key Type: `String`, Value Type: `String`) | **No**    | A list of potential block state changes, with each entry having a current and new state name.                                                  |
+| UpdateBlockState | `Boolean`<br />(Default: false)                       | **No**    | If true, performs a full refresh of the block's BlockEntity component and notifies nearby players as though a full block type change occurred. |
+
+### CycleBlockGroup
+
+This interaction will attempt to change the target block to the next block type in one of the BlockGroups it belongs to.
+If the block type belongs to multiple BlockGroups, which one is used is effectively arbitrary. The User entity must be
+a player. If the block cannot be changed for any reason (entity not a player, no block target, block does not belong
+to a BlockGroup, etc.). If the block is the only entry in the BlockGroup, this interaction will succeed and the block
+will be considered changed despite nothing happening.  Unlike most other block-changing interactions, this one will
+fail if the world settings prevent players from breaking blocks.
+
+**This interaction always reduces the player's held item's durability by a single 'hit' worth of damage if the block
+changes. There is no way to prevent it. The block type will change and the interaction will succeed even if the player's
+held item is broken, however.**
+
+**CycleBlockGroup Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+
+### DestroyBlock
+
+This interaction destroys the target block without dropping anything.  It will successfully destroy the block if the
+target block exists and this interaction has no failure conditions.
+
+**This interaction has no additional fields.**
+
+### PickBlock
+
+This interaction is effectively equivalent to using the middle mouse button in creative mode. In survival mode, the
+block's item will be moved to the user's current active hotbar slot if it is in the player's inventory.  This
+interaction is performed entirely on the client and cannot be performed by non-players.  It is unclear if this
+interaction has failure conditions.
+
+**PickBlock Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+
+### PlaceBlock
+
+This interaction is effectively identical to a right clicking while holding a block in their hand, with some
+additional options. For one, it can be executed with any LivingEntity as the User entity. For another, it has some
+useful fields.  For the most part, though, it follows the same behaviors and rules as any ordinary block placement
+by a player.
+
+It's not clear under what circumstances this interaction can fail. The server will not fail the interaction under any
+special circumstances (including when there is no target block, or when `BlockTypeToPlace` is not provided and the
+LivingEntity is not holding a block). However, the client is very involved with the function of this interaction and
+its behavior is unknown.
+
+**PlaceBlock Fields**
+
+| Field Name         | Type                                   | Required? | Notes                                                                                                                                                                                                                                                                                                                                                           |
+| ------------------ | -------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| BlockTypeToPlace   | `Asset`<br />(Asset Type: `BlockType`) | **No**    | If provided, the block placed by this interaction will be the specified BlockType. If not provided, the User entity's held item will be used, instead, if it is a block.                                                                                                                                                                                        |
+| RemoveItemInHand   | `Boolean`<br />(Default: True)         | **No**    | If true and the User entity is not a player in Creative mode, the item in the player's hand must match the block being placed and one quantity will be removed for each block placed. If the item does not match, the block cannot be placed.  If false, the player's hand item is ignored entirely.\*\*                                                        |
+| AllowDragPlacement | `Boolean`<br />(Default: True)         | **No**    | If true and the interaction was triggered on the client by a player, then the player can hold the input that was used to activate this interaction chain and move the mouse around in order to execute this interaction repeatedly and place several blocks. The interaction chain will not move onto the next interaction until the player releases the input. |
+
+### RunOnBlockTypes
+
+This interaction retrieves all blocks within a provided radius of the User entity. For each block that matches any of
+the provided BlockSets, a new interaction chain will be forked that uses the matching block as the target block.
+This interaction will continue executing until all forked interaction chains have completed.  The interaction will fail if no
+blocks within the radius match the provided BlockSets or if all of the forked interaction chains fail.
+
+**RunOnBlockTypes Fields**
+
+| Field Name   | Type                                         | Required?        | Notes                                                                                                                                                                                                                                                                                      |
+| ------------ | -------------------------------------------- | ---------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| Range        | `Integer`                                    | **Yes**          | The spherical radius around the User entity to search for blocks. Must be at least 1.                                                                                                                                                                                                      |
+| BlockSets    | `AssetArray`<br />(Element Type: `BlockSet`) | **No**           | A list of BlockSets to match nearby blocks again. Only blocks that match any of the BlockSets will have interaction chains forked for them.                                                                                                                                                |
+| MaxCount     | `Integer`                                    | **Yes**          | The maximum number of blocks that will be located with the search. Further blocks will be ignored. If there are more matching blocks within the radius than this number, the specific set of blocks that will be found is completely arbitrary and may change from execution to execution. |
+| Interactions | `Asset`<br />(Asset Type: `RootInteraction`) | **No, but yes.** | The RootInteraction that will be forked for each matching block.  This interaction will not fail to validate if it is missing, but every execution of this interaction will fail.                                                                                                          |
+
+### UseBlock
+
+If the target block has an interaction for this interaction chain's interaction type, execute it immediately as part of
+this interaction chain. The execution will be wrapped in UseBlockEvent.Pre and UseBlockEvent.Post events, and cancellations
+of the UserBlockEvent.Pre event are respected. The User entity is considered the triggering entity for both events.
+
+If the target block does not have an interaction for this interaction chain's interaction type, this interaction fails.
+
+**This interaction has no additional fields.**
+
+## Items
+
+These are interactions intended to interface with an entity's inventory. There is no concept of an "item target",
+unfortunately, so these generally either interact with the entity's held item or the entity's inventory at a high level.
+
+### AddItem
+
+Adds a specified quantity of a specified item to the User entity's inventory, preferring to add it to the
+entity's hotbar where possible. This interaction will have no effect on User entities that are not LivingEntities.
+This interaction has no failure states.
+
+**Note: This interaction has a bug in its field validators that will cause interactions that reference items declared
+in the same mod to fail validation on startup.  Additionally, this interaction has a bug that will cause it to
+fail and have no effect if the User entity has no block target. Use ModifyInventory instead.**
+
+**AddItem Fields**
+
+| Field Name       | Type                              | Required? | Notes                                                                                                                             |
+| ---------------- | --------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false)   | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+| ItemId           | `Asset`<br />(Asset Type: `Item`) | **Yes**   | The item id of the item to add to the player's inventory.                                                                         |
+| Quantity         | `Integer`<br />(Default: 0)       | **No**    | The quantity of the item to add to the player's inventory.                                                                        |
+
+### CheckUniqueItemUsage
+
+This interaction will check whether it has run once for the User entity with their currently-held item before. If it hasn't,
+it will succeed. If it has, it will fail. It will also fail if the User entity is not a player. The interaction will record
+the item id of the User entity's currently-held item on success, ensuring it cannot be successfully run with that player
+and item id combination again.
+
+**This interaction has no additional fields.**
+
+### ChangeActiveSlot
+
+This interaction does not inherit from SimpleInteraction and therefore has no Next or Failed fields.  The `CancelOnItemChange`
+field is ignored for this interaction and is always treated as false. This interaction will set the User entity's currently-
+active hotbar slot to the specified slot index. If none is specified, the interaction chain's target slot will be used,
+if any. Otherwise, slot 0 will be used.  If a slot is specified and it is already active, then this interaction will
+have no effect, but if no slot is specified and the interaction chain's target slot is already active, the logic in
+the next paragraph will still be executed. This interaction will also have no effect if the User entity is not a
+LivingEntity.
+
+Once the slot has changed, a new SwapTo interaction chain will be forked off for the selected slot.
+If a target slot was specified, then the interaction chain's current target slot will be set to the specified slot, as will
+the forked SwapTo interaction chain. If this interaction chain was initiated by a player swapping an item into or out of
+an occupied active hotbar slot, then the swap will be executed after the slot is changed and before the SwapTo
+interaction is forked. Not running this interaction in the resulting SwapFrom interaction chain is a way for the server
+to cancel players performing these sorts of swap interactions. The default behavior for these swap interactions is that
+the SwapFrom interaction chain will be initiated with the currently-active-slot as the target slot. As a result, the
+target slot will usually not change when this interaction runs, it merely exists as a signal for the server to continue the
+item swap.
+
+**ChangeActiveSlot Fields**
+
+| Field Name | Type      | Required? | Notes                                                                                                                                                                                                     |
+| ---------- | --------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| TargetSlot | `Integer` | **No**    | If not provided, indicates the slot the player's active hotbar slot should be changed to.  Otherwise, the interaction chain's target slot will be used (which is usually the already-active hotbar slot). |
+
+### EquipItem
+
+This interaction will equip the User entity's currently-held item into the appropriate armor slot, if it is armor. The
+interaction will fail if the item is armor but it cannot be equipped for some reason. The interaction will succeed but
+take no action if the User entity cannot equip armor or if the item is not armor.
+
+**This interaction has no additional fields.**
+
+### IncreaseBackpackCapacity
+
+This interaction will increase the User entity's backpack size by the provided amount.  **It will additionally remove one
+quantity from the player's currently-held item. There is no way to prevent this.**  This interaction will have no effect
+if the User entity is not a player.  This interaction has no special failure conditions, even if the User entity
+is not a player, or the player is not currently holding an item.
+
+| Field Name | Type                        | Required? | Notes                                                                                   |
+| ---------- | --------------------------- | --------- | --------------------------------------------------------------------------------------- |
+| Capacity   | `Integer`<br />(Default: 1) | **No**    | The additional backpack capacity to add to the player. **Must be between 1 and 32767.** |
+
+### ModifyInventory
+
+This interaction attempts to perform one or more inventory-modifying actions against the User entity. The User entity must
+be a player. If they are not, no actions will be performed, but the interaction will not fail. Any item removals performed
+by this interaction, either as a result of `ItemToRemove` or `AdjustHeldItemQuantity`, are both atomic (meaning the entire
+quantity must be removed, or none) and required (meaning that the interaction will fail and no further actions taken if
+the removal fails for any reason).  Item additions performed by this interaction, either as a result of `ItemToAdd` or
+`AdjustHeldItemQuantity` will drop excess items on the ground near the player if necesary and continue on.
+
+This interaction first executes the item removal in `ItemToRemove`, if any, then adjusts the held item as specified by
+`AdjustHeldItemQuantity`, if provided, then executes the item addition in `ItemToAdd`, if any, and then finally executes
+the damage/healing of the held item in `AdjustHeldItemDurability`, if provided.
+
+**ModifyDurability Fields**
+
+| Field Name               | Type                            | Required? | Notes                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
+| ------------------------ | ------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| RequiredGameMode         | `GameMode`                      | **No**    | If provided, only execute the inventory-modifying actions if the player is in the provided GameMode. The interaction will not fail if the GameMode doesn't match.                                                                                                                                                                                                                                                                                                                                                                               |
+| ItemToRemove             | `ItemStack`                     | **No**    | If provided, a matching item will be removed in the provided quantity. If there is no matching item in the player inventory in the required quantity, then the interaction will fail and further actions will not be executed.                                                                                                                                                                                                                                                                                                                  |
+| AdjustHeldItemQuantity   | `Integer`<br />(Default: 0)     | **No**    | The player's held item, if any, will have its quantity will be modified by the provided amount- subtracted from if this number is negative or added to if this item is positive.  If the player has no held item, then this field will have no effect regardless of its value and the interaction will NOT fail.  If the player's inventory does not have sufficient quantity of items to support the removal, this interaction will fail and further actions will not be executed. Excess items will be dropped on the ground near the player. |
+| ItemToAdd                | `ItemStack`                     | **No**    | If provided, the ItemStack will be added to the player's inventory. Excess items will be dropped on the ground near the player.                                                                                                                                                                                                                                                                                                                                                                                                                 |
+| AdjustHeldItemDurability | `Double`<br />(Default: 0.0)    | **No**    | The player's held item, if any, will have its durability adjusted by the specified amount.  The durability cannot go below 0 or raise above the item's maximum durability. Invalid durability values in this field will not cause the interaction to fail. Neither will it fail if the player has no held item.                                                                                                                                                                                                                                 |
+| BrokenItem               | `String`                        | **No**    | This field should contain an ItemId, but it is not validated by the server on startup, so be careful.  This field can have the value of "Empty" to specify no item, or an empty hand. If specified and the `AdjustHeldItemDurability` operation reduces the player's held item to 0 durability, the player's held item is changed to this ItemId. If the inventory replacement fails, this interaction will fail.                                                                                                                               |
+| NotifyOnBreak            | `Boolean`<br />(Default: false) | **No**    | If true and the `AdjustHeldItemDurability` operation reduces the player's held item to 0 durability, this interaction will perform the usual audiovisual feedback of a broken tool. It will play the usual tool breaking sound and send the player a text message in chat that their item has broken.                                                                                                                                                                                                                                           |
+| NotifyOnBreakMessage     | `String`                        | **No**    | If provided, and `NotifyOnBreak` is true, when the player is notified of a broken tool by this interaction, the message sent to their chat will instead be the translation key specified by this field. The translation key supports the templating parameter `{itemName}`. See the translation key `server.general.repair.itemBroken_Hoe` for an example.                                                                                                                                                                                      |
+
+**GameMode Values**
+
+- `Creative`: The game is currently in Creative Mode
+- `Adventure`: The game is currently in Adventure Mode
+
+**ItemStack Fields**
+
+| Field Name                   | Type                              | Required? | Notes                                                                                |
+| ---------------------------- | --------------------------------- | --------- | ------------------------------------------------------------------------------------ |
+| Id                           | `Asset`<br />(Asset Type: `Item`) | **Yes**   | The id of the Item asset this stack contains.                                        |
+| Quantity                     | `Integer`<br />(Default: 1)       | **No**    | The number of items in this stack.<br />**Must be greater than 0.**                  |
+| Durability                   | `Double`<br />(Default: 0.0)      | **No**    | The durability of the item stack.<br />**Cannot be negative.**                       |
+| MaxDurability                | `Double`<br />(Default: 0.0)      | **No**    | The maximum durability of the item this stack contains.<br />**Cannot be negative.** |
+| Metadata                     | `Bson Document`                   | **No**    | If provided, applies the bson to the item stack metadata.                            |
+| OverrideDroppedItemAnimation | `Boolean`\*(Default: false)       | **No**    | ???                                                                                  |
+
+### PickupItem
+
+This interaction will attempt to pick up the User entity's current target entity and add it to their inventory. It will
+fail if the User entity is not a player, if they do not have a target entity, or if the target entity is not an item
+located in the world.  It will not fail if the player simply cannot pick up the item.
+
+**This interaction has no additional fields.**
+
+### RefillContainer
+
+This interaction will fail if the User entity is not a player. The interaction will draw a ray from the player's head
+down their look direction until the edge of the player's held item's interaction range or until the first solid block.
+The nearest fluid block of a type listed in this interaction's `States` map will result in the one of the player's
+currently-held items being converted to the fluid's related item state.  If the `States` map indicates a durability
+for the new item state, then the converted item will use that durability. If the item is already in the fluid's related
+item state, then this interaction will fail if the player's held item is already at maximum durability (unless the
+`States` map indicates a durability value greater than the item's maximum, in which case the interaction will succeed
+but the item will not change).  Otherwise, the durability listed for the fluid in the `States` map will be added to the
+item's current durability.
+
+If the interaction has not failed by this point, the fluid block in the world may be transformed to a different type if one is listed
+in the `States` map.
+
+If any part of this process does not proceed for any reason (for instance, if the player is not holding an item),
+then this interaction will fail.
+
+**RefillContainer Fields**
+
+| Field Name | Type                                                       | Required? | Notes                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| ---------- | ---------------------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| States     | `Map`<br />(Key Type: `String`, Value Type: `RefillState`) | **Yes**   | A map from item state names to `RefillState` objects, which contain information such as acceptable fluid block types, durability increases, and what fluid type to convert the targeted fluid block to after refill, if any. If the player targets a fluid block that matches one of the fluid types in the `RefillState`, the item will be converted to the keyed item state and the `RefillState` will be used to decide what happens next. |
+
+**RefillState Fields**
+
+| Field Name     | Type                                  | Required? | Notes                                                                                                                                                                                                                                                                                                                           |
+| -------------- | ------------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| AllowedFluids  | `Array`<br />(Element Type: `String`) | **Yes**   | If any of these fluids are targeted by the player, the player's held item will be converted to the keyed item state and `Durability` and `TransformFluid` will be used.                                                                                                                                                         |
+| Durability     | `Double`<br />(Default: -1.0)         | **No**    | If the player's held item changes item states, this value is the new item's durability, unless it is negative, in which case the item will begin at full durability. If the player's held item is already in the item state, and the item is not already at full durability, this value will be added to the item's durability. |
+| TransformFluid | `String`                              | **No**    | If provided, this field is a fluid id that the targeted fluid block should be transformed to if the player's held item is successfully updated.                                                                                                                                                                                 |
+
+## Entities
+
+### DamageEntity
+
+This interaction does not inherit from SimpleInteraction, but adds its own Next and Failed fields that
+work similarly.
+
+This interaction will cause the User entity to damage the Target entity.  It has the capability to apply different
+damage based on the direction of the attack or what body part was targeted by the User entity, with each possibility
+providing different damage calculations, effects, and Next interaction. If multiple entires match the attack, `TargetedDamage`
+(body part damage) takes highest priority, then the first matching `AngledDamage` in the list, then the default
+damage in the base interaction fields.  It is possible for elements of these different damage priorities to be taken peacemeal if higher-priority
+damage fields do not overwrite lower-priority damage fields. For instance,
+damage calculation could be taken from `TargetedDamage`, the damage effects could be taken from the first matching
+`AngledDamage`, and the Next interaction coming from the default damage field.
+
+If all damage dealt by this interaction is cancelled, then this interaction will fail, and the `Failed` interaction
+will be executed next in the chain. If any damage dealt by this interaction is blocked, then this interaction will
+succeed, but the `Blocked` interaction wil lbe executed next in the chain. Otherwise, the highest-precedent matching
+`Next` interaction that you provide will be executed.  For instance, if you provide `Next` interactions for all
+`TargetedDamage` and `AngledDamage` entries, and one in the interaction's `Next` field, then a headshot could result
+in a unique `Next` interaction being executed, even if there is a matching `AngledDamage` entry. However, if you leave
+the `Next` interaction out of your `TargetedDamage` entries, a special `Next` interaction for backstabs could be
+executed.  Otherwise, the `Next` field in the root of the interaction will be executed instead.
+
+DamageEntity has an unusual relationship with `RunTime`. This interaction always ends immediately after its first tick,
+regardless of the status of `RunTime` or `WaitForAnimationToFinish`.  However, if damage dealt by this interaction is
+calculated as `DamageCalculatorType` `Dps`, then the `RunTime` will be used to determine the precise amount of damage to
+deal. If `RunTime` is 0, then no damage will be dealt.
+
+**DamageEntity Fields**
+
+| Field Name       | Type                                                          | Required?                                                                                                                    | Notes                                                                                                                                                                                                                                                                                                                                                                         |
+| ---------------- | ------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| DamageCalculator | `DamageCalculator`                                            | **No**                                                                                                                       | If provided, describes the damage amounts and types to apply to the Target entity.                                                                                                                                                                                                                                                                                            |
+| DamageEffects    | `DamageEffects`                                               | **No**                                                                                                                       | If provided, describes particles, sounds, knockback, etc. to apply to the target entity on damage.                                                                                                                                                                                                                                                                            |
+| Next             | `Asset`<br />(Asset Type: `Interaction`)                      | **No**  After this interaction has finished, "Next" will be executed if damage was dealt to the target and none was blocked. |                                                                                                                                                                                                                                                                                                                                                                               |
+| AngledDamage     | `Array`<br />(Element Type: `AngledDamage`)                   | **No**                                                                                                                       | If provided, allows alternative `DamageCalculator`, `DamageEffects`, and `Next` entries for attacks that approach the target from certain angles.                                                                                                                                                                                                                             |
+| TargetedDamage   | `Map`<br />(Key Type: `String`, Value Type: `TargetedDamage`) | **Yes**                                                                                                                      | This field must be provided, but is not required to have any entries.  This is a map from body part names to `TargetedDamage` values. Hypixel only uses one body part name: `Head`, and it is not clear whether there are others.  If provided, allows alternative `DamageCalculator`, `DamageEffects`, and `Next` entries for attacks that damage specific enemy body parts. |
+| EntityStatsOnHit | `Array`<br />(Element Type: `EntityStatOnHit`)                | **No**                                                                                                                       | If provided, allows this attack to reduce enemy stats other than health.  Each individual damage application dealt by the same ability will apply stat reductions, at diminishing returns. All damage dealt in interaction chains forked by a Selector interaction will share the number of hits across all targets.                                                          |
+| Failed           | `Asset`<br />(Asset Type: `Interaction`)                      | **No**                                                                                                                       | After this interaction has finished, "Failed" will be executed if no damage hits were applied to the player, or if all damage hits were cancelled.                                                                                                                                                                                                                            |
+| Blocked          | `Asset`<br />(Asset Type: `Interaction`)                      | **No**                                                                                                                       | After this interaction has finished, "Blocked" will be executed if any damage hits were blocked by the target.                                                                                                                                                                                                                                                                |
+
+**DamageCalculator Fields**
+
+| Field Name                | Type                                                      | Required? | Notes                                                                                                                                                                                                                                                 |
+| ------------------------- | --------------------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Type                      | `DamageCalculatorType`<br />(Default: Absolute)           | **No**    | Whether the damage being applied is `Absolute` or \`Dps'.                                                                                                                                                                                             |
+| Class                     | `DamageClass`<br />(Default: Unknown)                     | **No**    | The type of attack producing the damage. Some weapon systems apply equipment modifiers based on this value.                                                                                                                                           |
+| BaseDamage                | `Map`<br />(Key Type: `DamageCause`, Value Type: `Float`) | **No**    | A set of DamageCauses and how much base damage is dealt for each.                                                                                                                                                                                     |
+| SequentialModifierStep    | `Float`<br />(Default: 0.0)                               | **No**    | Value between 0.0-1.0. Each additional hit from a single ability will have its damage reduced by this much as a percentage. All damage dealt in interaction chains forked by a Selector interaction will share the number of hits across all targets. |
+| SequentialModifierMinimum | `Float`<br />(Default: 0.0)                               | **No**    | Value between 0.0-1.0. `SequentialModifierStep` cannot reduce damage below this percentage regardless of the number of hits.                                                                                                                          |
+| RandomPercentageModifier  | `Float`<br />(Default: 0.0)                               | **No**    | A random value between +/- this amount multiplied by the base damage will be added to the base damage.                                                                                                                                                |
+
+**DamageEffects Fields**
+
+| Field Name             | Type                                         | Required? | Notes                                                                                   |
+| ---------------------- | -------------------------------------------- | --------- | --------------------------------------------------------------------------------------- |
+| ModelParticles         | `Array`<br />(Element Type: `ModelParticle`) | **No**    | Particle systems to trigger in the first-person view.                                   |
+| WorldParticles         | `Array`<br />(Element Type: `WorldParticle`) | **No**    | Particle systems to trigger in the third-person view.                                   |
+| LocalSoundEventId      | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | 2D sound to play locally to the attacking entity if they are a player.                  |
+| WorldSoundEventId      | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | Sound to play in the world at the Target entity's location.                             |
+| PlayerSoundEventId     | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | 2D sound to play locally to the Target entity if they are a player.                     |
+| ViewDistance           | `Double`<br />(Default: 75.0)                | **No**    | Distance at which these effects should play for other players.                          |
+| Knockback              | `Knockback`                                  | **No**    | The properties of the knockback that will be applied.                                   |
+| CameraEffect           | `Asset`<br />(Asset Type: `CameraEffect`)    | **No**    | CameraEffect to briefly apply locally to the Target entity if they are a player.        |
+| StaminaDrainMultiplier | `Float`<br />(Default: 1.0)                  | **No**    | This multiplier is applied to the stamina cost incurred by the target blocking, if any. |
+
+**AngledDamage Fields**
+
+| Field Name       | Type                                     | Required? | Notes                                                                                                                                                                                                     |
+| ---------------- | ---------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| AngleDistance    | `Float`<br />(Default: 0)                | **No**    | The width in degrees of the matching arc around the Target entity. If the attack against the Target originates from within the arc, then the properties below will be applied to the attack, if provided. |
+| Angle            | `Float`<br />(Default: 0.0)              | **No**    | The angle in degrees around the Target entity at which the matching arc is centered.                                                                                                                      |
+| DamageCalculator | `DamageCalculator`                       | **No**    | If provided and the attack against the Target entity originates from within the provided arc, this DamageCalculator will override the interaction's `DamageCalculator` field.                             |
+| DamageEffects    | `DamageEffects`                          | **No**    | If provided and the attack against the Target entity originates from within the provided arc, this DamageEffects will override the interaction's `DamageEffects` field.                                   |
+| Next             | `Asset`<br />(Asset Type: `Interaction`) | **No**    | If provided and the attack against the Target entity originates from within the provided arc, this Interaction will override the interaction's `Next` field.                                              |
+
+**TargetedDamage Fields**
+
+| Field Name       | Type                                     | Required? | Notes                                                                                                                                                                                            |
+| ---------------- | ---------------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| DamageCalculator | `DamageCalculator`                       | **No**    | If provided and this TargetedDamage was matched, this DamageCalculator will override the interaction's `DamageCalculator` field and the `DamageCalculator` field of any matching `AngledDamage`. |
+| DamageEffects    | `DamageEffects`                          | **No**    | If provided and this TargetedDamage was matched, this DamageEffects will override the interaction's `DamageEffects` field and the `DamageEffects` field of any matching `AngledDamage`.          |
+| Next             | `Asset`<br />(Asset Type: `Interaction`) | **No**    | If provided and this TargetedDamage was matched, this Interaction will override the interaction's `Next` field and the `Next` field of any matching `AngledDamage`.                              |
+
+**EntityStatOnHit Fields**
+
+| Field Name                  | Type                                                                       | Required? | Notes                                                                                                                                                                                                                                                                                        |
+| --------------------------- | -------------------------------------------------------------------------- | --------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| EntityStatId                | `Asset`<br />(AssetType: `EntityStatType`)                                 | **Yes**   | Which entity stat to affect.                                                                                                                                                                                                                                                                 |
+| Amount                      | `Float`<br />(Default: 0.0)                                                | **No**    | How much of the stat to apply for each damage application. Use negative numbers to reduce stats.                                                                                                                                                                                             |
+| MultipliersPerEntitiesHit   | `Array`<br />(Element Type: `Float`, Default: `[1.0, 0.6, 0.4, 0.2, 0.1]`) | **No**    | The diminishing returns curve to be applied for multiple damage applications by the same ability. Each hit's stat impact will be multiplied by the next value in the list.  If there are more hits than array elements, subsequent hits will be multiplied by `MultiplierPerExtraEntityHit`. |
+| MultiplierPerExtraEntityHit | `Float`<br />(Default: 0.05)                                               | **No**    | If an ability carries out more damage applications than there are elements in the `MultipliersPerEntitiesHit` array, then subsequent stat values will be multiplied by this number.                                                                                                          |
+
+**Knockback Fields**
+
+| Field Name     | Type                                       | Required? | Notes                                                                                                                      |
+| -------------- | ------------------------------------------ | --------- | -------------------------------------------------------------------------------------------------------------------------- |
+| Type           | `String`                                   | **No**    | If provided, specifies a type of knockback to use. Each Target type may come with additional fields.                       |
+| Force          | `Double`<br />(Default: 0.0)               | **No**    | The amount of force to apply to the Owner entity.                                                                          |
+| Duration       | `Double`<br />(Default: 0.0)               | **No**    | If 0.0, apply the force as a single impulse.  If more, continuously apply the force over a period of time.                 |
+| VelocityType   | `ChangeVelocityType`<br />(Default: `Add`) | **No**    | How to apply the force, either adding it to the entity's current velocity, or setting the velocity to the knockback force. |
+| VelocityConfig | `VelocityConfig`                           | **No**    | Characteristics of friction as the Owner entity is thrown by this knockback.                                               |
+
+**Knockback Type: Force**
+
+Apply the calculated knockback force along the provided direction.
+
+| Field Name | Type                         | Required? | Notes                                                                                |
+| ---------- | ---------------------------- | --------- | ------------------------------------------------------------------------------------ |
+| Direction  | `Vector3`<br />(Default: Up) | **No**    | Which direction the entity should be flung, relative to the direction of the attack. |
+
+**Knockback Type: Point**
+
+Apply the calculated knockback force laterally along the XZ plane, plus provided Y velocity.
+
+| Field Name | Type                        | Required? | Notes                                                                                                   |
+| ---------- | --------------------------- | --------- | ------------------------------------------------------------------------------------------------------- |
+| OffsetX    | `Integer`<br />(Default: 0) | **No**    | Offset the source position of the knockback left or right perpendicular to the direction of the attack. |
+| OffsetZ    | `Integer`<br />(Default: 0) | **No**    | Offset the source position of the knockback, forward or backward along the directon of the attack.      |
+| RotateY    | `Integer`<br />(Default: 0) | **No**    | Rotate the knockback direction around the Y axis, where 0 is the default attack direction.              |
+| VelocityY  | `Float`<br />(Default: 0.0) | **No**    | Add vertical velocity to the knockback force after the direction and force has been calculated.         |
+
+**Knockback Type: Directional**
+
+Apply the calculated knockback force along the attack direction, removing any vertical component and replacing it with a provided Y velocity.
+
+| Field Name | Type                      | Required? | Notes                                                                                                                                            |
+| ---------- | ------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------ |
+| RelativeX  | `Float`<br />(Default: 0) | **No**    | Apply additional force left or right perpendicular to the direction of the attack. The additional force is multiplied by the knockback strength. |
+| RelativeZ  | `Float`<br />(Default: 0) | **No**    | Apply additional force forward or backward along the attack direction. The additional force is multiplied by the knockback strength.             |
+| VelocityY  | `Float`<br />(Default: 0) | **No**    | Replace the vertical velocity of the knockback with this value.  This value is not multiplied by knockback strength.                             |
+
+**VelocityConfig Fields**
+
+| Field Name          | Type                                              | Required? | Notes                                                                                                                                                                                           |
+| ------------------- | ------------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| GroundResistance    | `Float`<br />(Default: 0.82)                      | **No**    | The minimum amount of friction applied when the entity is in contact with the ground.  1.0 = no friction, 0.0 = total friction                                                                  |
+| GroundResistanceMax | `Float`<br />(Default: 0.0)                       | **No**    | The maximum amount of friction applied when the entity is in contact with the ground.  1.0 = no friction, 0.0 = total friction                                                                  |
+| AirResistance       | `Float`<br />(Default: 0.96)                      | **No**    | The minimum amount of friction applied when the entity is in the air. 1.0 = no friction, 0.0 = total friction                                                                                   |
+| AirResistanceMax    | `Float`<br />(Default: 0.0)                       | **No**    | The maximum amount of friction applied when the entity is in the air. 1.0 = no friction, 0.0 = total friction                                                                                   |
+| Threshold           | `Float`<br />(Default: 1.0)                       | **No**    | The speed at which the maximum amount of friction will be applied to the entity. The amount of friction applied will increase from minimum to maximum as the entity moves from 0 to this speed. |
+| Style               | `VelocityThresholdStyle`<br />(Default: `Linear`) | **No**    | The curve that friction follows as the entity's speed increases toward the `Threshold`.                                                                                                         |
+
+**DamageCalculatorType Values**
+
+- `Absolute`
+- `Dps`
+
+**DamageClass Values**
+
+- `Unknown`
+- `Light`
+- `Charged`
+- `Signature`
+
+**ChangeVelocityType Values**
+
+- `Add`
+- `Set`
+
+**VelocityThresholdStyle Values**
+
+- `Linear`
+- `Exp`
+
+### LaunchProjectile
+
+This is just a worse version of Projectile and is slated to be removed.  Use Projectile.
+
+### Projectile
+
+This interaction will spawn a new projectile at the User entity's eye position that will travel in its look direction.
+
+| Field Name | Type                                          | Required? | Notes                                                  |
+| ---------- | --------------------------------------------- | --------- | ------------------------------------------------------ |
+| Config     | `Asset`<br />(Asset Type: `ProjectileConfig`) | **No**    | Configuration describing the projectile to be spawned. |
+
+### RemoveEntity
+
+Despawns the specified entity from the world. This interaction will have no effect if the specified entity is a player. This
+interaction has no special failure conditions.
+
+| Field Name | Type                                     | Required? | Notes                  |
+| ---------- | ---------------------------------------- | --------- | ---------------------- |
+| Entity     | `InteractionTarget`<br />(Default: User) | **No**    | The entity to despawn. |
+
+**InteractionTarget Values**
+
+- `User` - The user of this interaction chain. The entity whose actions caused this interaction chain to be executed. This is usually the same as the Owner.
+- `Owner` - The owner of this interaction chain. The entity upon whom this interaction chain is executing.
+- `Target` - The entity target of this interaction chain, if any.  This value is mutable (and can therefore come from many places) but most commonly, it is an entity the User was targeting when this interaction chain began executing.
+
+### SendMessage
+
+This interaction sends a message to the Owner entity if that entity can receive messages.  Otherwise, the message
+is written to the server logs.  If the entity is a player, the message will appear in the player's chat window.
+
+\*\*SendMessage
+
+| Field Name | Type     | Required? | Notes                                                                                                                 |
+| ---------- | -------- | --------- | --------------------------------------------------------------------------------------------------------------------- |
+| Message    | `String` | **No**    | A text message to be sent to the Owner entity.  If this field is not provided, `Key` is used instead.                 |
+| Key        | `String` | **No**    | A translation key for a message to be sent to the Owner entity. If `Message` is provided, then this field is ignored. |
+
+### UseEntity
+
+This interaction is not in use by Hypixel and has some unusual qualities that mean it probably won't do what you want it
+to.  Do not use it.
+
+This interaction will retrieve the entity currently targeted by the client (NOT the interaction chain's current Target
+entity) and execute that entity's RootInteraction for this interaction chain's current interaction type. The
+RootInteraction will be executed as part of this current interaction chain. None of the properties of this interaction
+chain will be modified.
+
+This interaction will fail if the client is not currently targeting an entity, or if no interaction for the current
+interaction type exists on the entity.
+
+## Stats
+
+Hytale's resource system has been written about fairly extensively.  You can use these interactions to modify stats in
+response to actions or use stats as a cost for abilities.
+
+### ChangeStat
+
+This interaction applies a set of raw stat changes to the User entity. It has no special failure conditions.
+
+| Field Name    | Type                                                         | Required? | Notes                                                                                                                                                                                                                      |
+| ------------- | ------------------------------------------------------------ | --------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| StatModifiers | `Map`<br />(Key Type: `EntityStatType`, Value Type: `Float`) | **Yes**   | A set of stats to modify and what value to apply to them.                                                                                                                                                                  |
+| ValueType     | `ValueType`<br />(Default: Absolute)                         | **No**    | Whether the values in the `StatModifiers` map represent flat values to apply to the stat total, or percentages (0.0-100.0). Percentage values are percentage of the difference between the maximum and minimum stat value. |
+| Behaviour     | `ChangeStatBehavior`<br />(Default: Add)                     | **No**    | Whether the values in the `StatModifiers` map represent deltas to add into the User entity's current stat values, or fixed values to set the entity's stats to.                                                            |
+
+**ValueType Values**
+
+- `Absolute`
+- `Percent`
+
+**ChangeStatBehaviour Values**
+
+- `Add`
+- `Set`
+
+### ChangeStatWithModifier
+
+This interaction is like ChangeStat, except an armor stat modifier can be chosen which will apply bonuses and penalties
+to a stat from the User entity's equipped armor before it is applied.
+
+| Field Name            | Type                                                         | Required? | Notes                                                                                                                                                                                                                      |
+| --------------------- | ------------------------------------------------------------ | --------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| StatModifiers         | `Map`<br />(Key Type: `EntityStatType`, Value Type: `Float`) | **Yes**   | A set of stats to modify and what value to apply to them.                                                                                                                                                                  |
+| ValueType             | `ValueType`<br />(Default: Absolute)                         | **No**    | Whether the values in the `StatModifiers` map represent flat values to apply to the stat total, or percentages (0.0-100.0). Percentage values are percentage of the difference between the maximum and minimum stat value. |
+| Behaviour             | `ChangeStatBehavior`<br />(Default: Add)                     | **No**    | Whether the values in the `StatModifiers` map represent deltas to add into the User entity's current stat values, or fixed values to set the entity's stats to.                                                            |
+| InteractionModifierId | `InteractionModifierId`                                      | **Yes**   | The armor interaction modifier to apply bonuses and penalties for.                                                                                                                                                         |
+
+**ValueType Values**
+
+- `Absolute`
+- `Percent`
+
+**ChangeStatBehaviour Values**
+
+- `Add`
+- `Set`
+
+**InteractionModifierId Values**
+
+- `Dodge`
+
+### StatsCondition
+
+This interaction will fail if the User entity cannot afford the specified stats costs, or if it does not have the
+requested stats.
+
+| Field Name | Type                                                         | Required? | Notes                                                                                                                                                                                    |
+| ---------- | ------------------------------------------------------------ | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Costs      | `Map`<br />(Key Type:` EntityStatType`, Value Type: `Float`) | **Yes**   | A set of costs that the User entity needs to be able to afford for this interaction to succeed.                                                                                          |
+| ValueType  | `ValueType`<br />(Default: Absolute)                         | **No**    | Whether the values in the `Costs` map represetn flat values or percentages (0.0-100.0).  Percentage values are percentage of the difference between the maximum and minimum value.       |
+| LessThan   | `Boolean`<br />(Default: false)                              | **No**    | If true, this interaction will fail unless the User entity's current stat values are at or **below** the specified levels.  If false, they must be at or **above** the specified levels. |
+| Lenient    | `Boolean`<br />(Default: false)                              | **No**    | If true and `LessThan` is true, and a player's minimum stat value is below zero, then the player can afford a stat cost if the current value of a stat if above 0.                       |
+
+**ValueType Values**
+
+- `Absolute`
+- `Percent`
+
+### StatsConditionWithModifier
+
+This interaction is like StatsCondition, except an armor stat modifier can be chosen which will apply bonuses and penalties
+to a stat's cost from the User entity's equipped armor before it is compared.
+
+| Field Name            | Type                                                         | Required? | Notes                                                                                                                                                                                    |
+| --------------------- | ------------------------------------------------------------ | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Costs                 | `Map`<br />(Key Type:` EntityStatType`, Value Type: `Float`) | **Yes**   | A set of costs that the User entity needs to be able to afford for this interaction to succeed.                                                                                          |
+| ValueType             | `ValueType`<br />(Default: Absolute)                         | **No**    | Whether the values in the `Costs` map represetn flat values or percentages (0.0-100.0).  Percentage values are percentage of the difference between the maximum and minimum value.       |
+| LessThan              | `Boolean`<br />(Default: false)                              | **No**    | If true, this interaction will fail unless the User entity's current stat values are at or **below** the specified levels.  If false, they must be at or **above** the specified levels. |
+| Lenient               | `Boolean`<br />(Default: false)                              | **No**    | If true and `LessThan` is true, and a player's minimum stat value is below zero, then the player can afford a stat cost if the current value of a stat if above 0.                       |
+| InteractionModifierId | `InteractionModifierId`                                      | **Yes**   | The armor interaction modifier to apply bonuses and penalties for.                                                                                                                       |
+
+**ValueType Values**
+
+- `Absolute`
+- `Percent`
+
+**InteractionModifierId Values**
+
+- `Dodge`
+
+## EntityEffects
+
+EntityEffects are buff or debuff effects that can be applied to a LivingEntity.  These can have a variety of effects from
+movement speed changes to periodic damage.
+
+### EffectCondition
+
+This interaction will fail if the specified entity's EntityEffects do not match the provided conditions.
+
+**EffectCondition Fields**
+
+| Field Name      | Type                                             | Required? | Notes                                                                                                                                                                                                             |
+| --------------- | ------------------------------------------------ | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Entity          | `InteractionTarget`<br />(Default: User)         | **Yes**   | The entity to examine for EntityEffects. This field can indicate the Owner, User, or Target of this interaction chain.                                                                                            |
+| Match           | `Match`<br />(Default: All)                      | **No**    | If `All`, then this interaction will fail if any EntityEffect in the `EntityEffectIds` is not on the specified entity. If `None`, then this interaction will fail if any EntityEffect IS on the specified entity. |
+| EntityEffectIds | `AssetArray`<br />(Element Type: `EntityEffect`) | **Yes**   | The set of EntityEffects to check against the specified entity and `Match`.                                                                                                                                       |
+
+**InteractionTarget Values**
+
+- `User` - The user of this interaction chain. The entity whose actions caused this interaction chain to be executed. This is usually the same as the Owner.
+- `Owner` - The owner of this interaction chain. The entity upon whom this interaction chain is executing.
+- `Target` - The entity target of this interaction chain, if any.  This value is mutable (and can therefore come from many places) but most commonly, it is an entity the User was targeting when this interaction chain began executing.
+
+**Match Values**
+
+- `All` - All EntityEffects must be on the specified entity for this interaction to succeed.
+- `None` - None of the EntityEffects must be on the specified entity for this interaction to succeed.
+
+### ApplyEffect
+
+This interaction will apply the specified EntityEffect to the specified Entity.  It has no special failure conditions.
+
+**ApplyEffect Fields**
+
+| Field Name | Type                                      | Required? | Notes                                                                                                                  |
+| ---------- | ----------------------------------------- | --------- | ---------------------------------------------------------------------------------------------------------------------- |
+| Entity     | `InteractionTarget`<br />(Default: User)  | **Yes**   | The entity to apply the EntityEffect to. This field can indicate the Owner, User, or Target of this interaction chain. |
+| EffectId   | `Asset`<br />(Asset Type: `EntityEffect`) | **Yes**   | The effect to apply.                                                                                                   |
+
+**InteractionTarget Values**
+
+- `User` - The user of this interaction chain. The entity whose actions caused this interaction chain to be executed. This is usually the same as the Owner.
+- `Owner` - The owner of this interaction chain. The entity upon whom this interaction chain is executing.
+- `Target` - The entity target of this interaction chain, if any.  This value is mutable (and can therefore come from many places) but most commonly, it is an entity the User was targeting when this interaction chain began executing.
+
+### ClearEntityEffect
+
+This interaction will remove the specified EntityEffect from the specified Entity. It has no special failure conditions.
+It will not fail if the Entity does not have the EntityEffect.
+
+**ClearEntityEffect Fields**
+
+| Field Name | Type                                      | Required? | Notes                                                                                                                     |
+| ---------- | ----------------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------- |
+| Entity     | `InteractionTarget`<br />(Default: User)  | **Yes**   | The entity to remove the EntityEffect from. This field can indicate the Owner, User, or Target of this interaction chain. |
+| EffectId   | `Asset`<br />(Asset Type: `EntityEffect`) | **Yes**   | The effect to remove.                                                                                                     |
+
+**InteractionTarget Values**
+
+- `User` - The user of this interaction chain. The entity whose actions caused this interaction chain to be executed. This is usually the same as the Owner.
+- `Owner` - The owner of this interaction chain. The entity upon whom this interaction chain is executing.
+- `Target` - The entity target of this interaction chain, if any.  This value is mutable (and can therefore come from many places) but most commonly, it is an entity the User was targeting when this interaction chain began executing.
+
+## Farming
+
+These are interaction types built to support the in-game farming system in Hytale. They are mostly block-related interactions
+with a few exceptions.
+
+### ChangeFarmingStage
+
+If the target block is a farming block, this interaction will attempt to modify the current farming stage in one of
+three ways.  The interaction can optionally specify which StageSet to use for the new stage. If it is not specified,
+the current StageSet will be used. If any part of the the process of changing the growth stage fails, this interaction
+will fail, with the one exception that attempting to set the stage to the crop's existing stage will have no effect but
+still succeed.
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                                                                                                                                                                          |
+| ---------------- | ------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction.                                                                                                                                              |
+| StageSet         | `String`                        | **No**    | If provided, set the block's current stage to one in the provided StageSet. Otherwise, use the crop's current StageSet.                                                                                                                                                        |
+| Increase         | `Integer`                       | **No**    | If provided, increase the current stage by the specified amount. If the specified stage does not exist, the block will be set to the closest extant stage.                                                                                                                     |
+| Decrease         | `Integer`                       | **No**    | If provided and `Increase` is not provided, decrease the current stage by the specified amount. If the specified stage does not exist, the block will be set to the closest extant stage.                                                                                      |
+| Stage            | `Integer`<br />(Default: -1)    | **No**    | If provided and `Increase`/`Decrease` are not provided, set the current stage to the specified stage. If this value is less than 0, set the current stage to the final growth stage. If the specified stage does not exist, the block will be set to the closest extant stage. |
+
+### FertilizeSoil
+
+If the target block is unfertilized tilled soil or a farming block on top of unfertilized tilled soil, fertilizes the soil.
+The interaction will fail otherwise.
+
+**FertilizeSoil Fields**
+
+| Field Name       | Type                                  | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false)       | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+| RefreshModifiers | `Array`<br />(Element Type: `String`) | **No**    | Does nothing.                                                                                                                     |
+
+### HarvestCrop
+
+This interaction will attempt to execute the harvest action on the current block target and add the crop's drops to the User entity's
+inventory.  The block will either be destroyed or set to its post-harvest growth stage, depending on the farming
+configuration of the block.  This will happen (and the player will receive the full harvest drops) regardless of the
+block's current growth stage. This interaction has no special failure conditions, even if the block target isn't a
+farming block or gathering isn't permitted in the current world, but nothing will occur in those cases.
+
+**HarvestCrop Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+
+### UseWateringCan
+
+If the target block is tilled soil or a farming block on top of tilled soil, waters the soil for the specified duration.
+The interaction will fail otherwise.
+
+**UseWateringCan Fields**
+
+| Field Name       | Type                                  | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false)       | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+| Duration         | `Integer`<br />(Default: 0)           | **No**    | The duration in seconds to water the soil for.                                                                                    |
+| RefreshModifiers | `Array`<br />(Element Type: `String`) | **No**    | Does nothing.                                                                                                                     |
diff --git a/content/docs/id-ID/contributing/pr-guidelines.mdx b/content/docs/id-ID/contributing/pr-guidelines.mdx
index 7a251032..c226da04 100644
--- a/content/docs/id-ID/contributing/pr-guidelines.mdx
+++ b/content/docs/id-ID/contributing/pr-guidelines.mdx
@@ -19,6 +19,8 @@ To ensure a smooth and efficient review process, both contributors and reviewers
 4. **Code Quality**
    - Ensure your code follows the project's coding standards and best practices.
    - Include comments where necessary to explain complex logic.
+   - Always test your changes locally before submitting the PR to catch any issues early.
+   - Format your code using `bun format` to maintain consistency across the codebase.
 5. **Testing**
    - Test your changes thoroughly before submitting the PR.
    - If applicable, include unit tests or integration tests to verify your changes.
diff --git a/content/docs/id-ID/contributing/translate.mdx b/content/docs/id-ID/contributing/translate.mdx
new file mode 100644
index 00000000..c62ffdde
--- /dev/null
+++ b/content/docs/id-ID/contributing/translate.mdx
@@ -0,0 +1,74 @@
+---
+title: Translate
+description: How to translate HytaleModding to your language
+---
+
+# Translating HytaleModding
+
+HytaleModding is translated with the help of the community using **Crowdin**. If you want to help translate or improve existing translations, this is the right place.
+
+## Steps to Translate
+
+All translations are managed **via Crowdin**.
+
+1. Visit [our Crowdin project](https://crowdin.com/project/hytalemodding) and log in if required.
+2. Click on your language.
+3. Click on the file/article you wish to translate. We recommend starting with Official Documentation, and then Server Plugin Documentation.
+4. Start translating!
+5. Approved translations will appear on the website.
+
+### Video Guide
+
+<iframe src="https://www.youtube.com/embed/NHiG1rDRgks" allowFullScreen />
+
+## How to discuss
+
+You can always report issues or discuss specific topics directly on Crowdin, but we recommend using Discord instead of the Crowdin comment system to keep everything organized in one place.
+
+1. Join [our Discord](https://discord.gg/hytalemodding)
+2. Open `#translations` channel. Here you can discuss or ask questions that are not related to a specific language.
+3. If you want to join a thread, you are required to run `/translator <your-language>` command here. The bot will add you to the thread for your language.
+
+## Translation Guidelines
+
+- You need to be confident in what you are translating. You should be able to read the text you just translated and understand the meaning of it very easily.
+- It should use the simplest form of language possible. Use English words if the translation is unknown to the majority in your country.
+- Use your imagination, trust yourself. Feel free to change any context as you wish as long as it can still get the same point across and is understandable.
+- These guidelines are more important than language-specific guidelines, but less important than Hytale terminology and rules.
+
+## What not to translate
+
+We request you all to not translate these specific sections of the website:
+
+### Callout types
+
+Callouts are the boxes that contain important information. We request you to not translate the types as they only work in English.
+
+**Example:**
+
+```mdx
+<Callout type="warning" title="Translate this title!">
+Translate the text inside the callout!
+</Callout>
+```
+
+In this example, please don't translate the word warning, the rest you can translate.
+
+### Icons
+
+Icon names must not be translated.
+They are technical identifiers mapped directly to existing icons. Translating them will break the icon rendering.
+
+```mdx
+icon: Globe
+```
+
+---
+
+{/* 
+For translators who will edit this page:
+
+- You are required to translate the Guidelines as they change.
+- General guidelines should be translated but not edited.
+- Learn how to use Markdown from writing_guides.mdx
+*/}
diff --git a/content/docs/id-ID/established-information/server/content-categories/art-assets.mdx b/content/docs/id-ID/established-information/server/content-categories/art-assets.mdx
index 39c2ed37..1e926874 100644
--- a/content/docs/id-ID/established-information/server/content-categories/art-assets.mdx
+++ b/content/docs/id-ID/established-information/server/content-categories/art-assets.mdx
@@ -14,7 +14,7 @@ Hytale provides comprehensive support for 3D modeling and texture art creation,
 Hytale uses **Blockbench** as the primary tool for 3D modeling and animation:
 
 * **Official support**: Used for "creating Hytale models, textures, and animations"
-* **Special plugin**: Hytale will have a dedicated Blockbench plugin, to be released ASAP
+* **Special plugin**: Hytale has a dedicated [Blockbench Plugin](https://www.blockbench.net/plugins/hytale_plugin).
 * **Direct compatibility**: The plugin allows creators to "create Hytale-compatible models, textures, and animations directly in Blockbench"
 * **Replaces legacy tools**: Fully replaces the old Hytale Model Maker to better support established creative workflows in the community
 * **Safety features**: Only allows you to add things compatible with the engine, so no need to worry about breaking anything
diff --git a/content/docs/id-ID/guides/ecs/block-components.mdx b/content/docs/id-ID/guides/ecs/block-components.mdx
new file mode 100644
index 00000000..ca68b38a
--- /dev/null
+++ b/content/docs/id-ID/guides/ecs/block-components.mdx
@@ -0,0 +1,247 @@
+---
+title: Block Components
+description: Learn how to use the block components.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+  - name: oskarscot
+    link: https://oskar.scot
+---
+
+# Overview
+
+In this guide, you'll learn how to use block components to create a ticking block.
+
+<Callout>
+  For a more complete reference, you may also want to review FarmingSystems.Ticking, as much of the underlying logic is based on its implementation.
+</Callout>
+
+## Steps
+
+### 1. ExampleBlock - holds block behavior
+
+```java
+public class ExampleBlock implements Component<ChunkStore> {
+
+    public static final BuilderCodec CODEC = BuilderCodec.builder(ExampleBlock.class, ExampleBlock::new).build();
+
+    // Components usually require a copy constructor as well but since we don't actually hold any data in this component this is not neccessary
+    public ExampleBlock() { }
+
+    public static ComponentType getComponentType() {
+        return ExamplePlugin.get().getExampleBlockComponentType();
+    }
+
+    @Nullable
+    public Component<ChunkStore> clone() {
+        return new ExampleBlock();
+    }
+}
+```
+
+ExampleBlock is a custom component that stores the behavior and data for your ticking block. Here, it simply places an Ice Block at x + 1 relative to its current position when it ticks.
+
+---
+
+### 2. ExampleInitializer - marks blocks as ticking when placed
+
+```java
+public class ExampleInitializer extends RefSystem {
+
+    @Override
+    public void onEntityAdded(@Nonnull Ref ref, @Nonnull AddReason reason, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+        BlockModule.BlockStateInfo info = (BlockModule.BlockStateInfo) commandBuffer.getComponent(ref, BlockModule.BlockStateInfo.getComponentType());
+        if (info == null) return;
+
+        ExampleBlock generator = (ExampleBlock) commandBuffer.getComponent(ref, ExamplePlugin.get().getExampleBlockComponentType());
+        if (generator != null) {
+            int x = ChunkUtil.xFromBlockInColumn(info.getIndex());
+            int y = ChunkUtil.yFromBlockInColumn(info.getIndex());
+            int z = ChunkUtil.zFromBlockInColumn(info.getIndex());
+
+            WorldChunk worldChunk = (WorldChunk) commandBuffer.getComponent(info.getChunkRef(), WorldChunk.getComponentType());
+            if (worldChunk != null) {
+				worldChunk.setTicking(x, y, z, true);
+            }
+        }
+    }
+
+    @Override
+    public void onEntityRemove(@Nonnull Ref ref, @Nonnull RemoveReason reason, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+    }
+
+    @Override
+    public Query getQuery() {
+        return Query.and(BlockModule.BlockStateInfo.getComponentType(), ExamplePlugin.get().getExampleBlockComponentType());
+    }
+}
+```
+
+ExampleInitializer is a RefSystem that reacts when block entities with the ExampleBlock component are added or removed. This is crucial for marking blocks as ticking when they're first placed.
+
+**Key Points:**
+
+- Tells the game that this block should tick, allowing `ExampleSystem` to process it.
+
+```java
+worldChunk.setTicking(x, y, z, true);
+```
+
+---
+
+### 3. ExampleSystem - handles ticking
+
+```java
+public class ExampleSystem extends EntityTickingSystem {
+
+    public void tick(float dt, int index, @Nonnull ArchetypeChunk archetypeChunk, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+        BlockSection blocks = (BlockSection) archetypeChunk.getComponent(index, BlockSection.getComponentType());
+
+        assert blocks != null;
+
+        if (blocks.getTickingBlocksCountCopy() != 0) {
+            ChunkSection section = (ChunkSection) archetypeChunk.getComponent(index, ChunkSection.getComponentType());
+
+            assert section != null;
+
+            BlockComponentChunk blockComponentChunk = (BlockComponentChunk) commandBuffer.getComponent(section.getChunkColumnReference(), BlockComponentChunk.getComponentType());
+
+            assert blockComponentChunk != null;
+
+            blocks.forEachTicking(blockComponentChunk, commandBuffer, section.getY(), (blockComponentChunk1, commandBuffer1, localX, localY, localZ, blockId) -> {
+                Ref<ChunkStore> blockRef = blockComponentChunk.getEntityReference(ChunkUtil.indexBlockInColumn(localX, localY, localZ));
+                if (blockRef == null) {
+                    return BlockTickStrategy.IGNORED;
+                } else {
+                    ExampleBlock exampleBlock = (ExampleBlock) commandBuffer1.getComponent(blockRef, ExampleBlock.getComponentType());
+                    if (exampleBlock != null) {
+                        WorldChunk worldChunk = (WorldChunk) commandBuffer.getComponent(section.getChunkColumnReference(), WorldChunk.getComponentType());
+                        World world = worldChunk.getWorld();
+
+                        int globalX = localX + (worldChunk.getX() * 32);
+                        int globalZ = localZ + (worldChunk.getZ() * 32);
+
+                        // We need to execute setBlock on the world thread as you cannot call store functions from a system
+                        // This is because of the architecture of the server, depending on your needs you can also use the CommandBuffer
+                        world.execute(() -> {
+                            world.setBlock(globalX + 1, localY, globalZ, "Rock_Ice");
+                        });
+
+                        return BlockTickStrategy.CONTINUE;
+
+                    } else {
+                        return BlockTickStrategy.IGNORED;
+                    }
+                }
+            });
+        }
+    }
+
+    @Nullable
+    public Query getQuery() {
+        return Query.and(BlockSection.getComponentType(), ChunkSection.getComponentType());;
+    }
+}
+```
+
+ExampleSystem is an EntityTickingSystem that runs every tick to execute the logic for all ticking blocks with the ExampleBlock component.
+
+**Key Points:**
+
+- **Get the block component**
+
+```java
+ExampleBlock exampleBlock = (ExampleBlock) commandBuffer.getComponent(blockRef, ExampleBlock.getComponentType());
+```
+
+- **Convert local chunk coordinates to world coordinates**
+
+```java
+int globalX = localX + (worldChunk.getX() * 32);
+int globalZ = localZ + (worldChunk.getZ() * 32);
+```
+
+- **Run the block logic**
+
+```java
+exampleBlock.runBlockAction(globalX, localY, globalZ, worldChunk.getWorld());
+```
+
+- **Keep the block ticking in the next tick**
+
+```java
+return BlockTickStrategy.CONTINUE;
+```
+
+---
+
+### 4. ExamplePlugin - registers components and systems
+
+```java
+public class ExamplePlugin extends JavaPlugin {
+    protected static ExamplePlugin instance;
+    private static final HytaleLogger LOGGER = HytaleLogger.forEnclosingClass();
+    private ComponentType exampleBlockComponentType;
+
+    public static ExamplePlugin get() {
+        return instance;
+    }
+
+    public ExamplePlugin(@Nonnull JavaPluginInit init) {
+        super(init);
+        LOGGER.atInfo().log("Hello from " + this.getName() + " version " + this.getManifest().getVersion().toString());
+    }
+
+    @Override
+    protected void setup() {
+        instance = this;
+        LOGGER.atInfo().log("Setting up plugin " + this.getName());
+        this.exampleBlockComponentType = this.getChunkStoreRegistry().registerComponent(ExampleBlock.class, "ExampleBlock", ExampleBlock.CODEC);
+    }
+	
+	@Override
+	protected void start() {
+		this.getChunkStoreRegistry().registerSystem(new ExampleSystem());
+		this.getChunkStoreRegistry().registerSystem(new ExampleInitializer());
+	}
+
+    public ComponentType getExampleBlockComponentType() {
+        return this.exampleBlockComponentType;
+    }
+}
+```
+
+---
+
+### 5. Configure In-Game
+
+![block-component-1](/assets/guides/block-component-1.png)
+
+![block-component-2](/assets/guides/block-component-2.png)
+
+With this logic, the block will now continuously place an Ice Block at the coordinates x + 1 relative to its current position every time it ticks.
+
+---
+
+## Common Issues
+
+### NullPointerException on Startup
+
+**Error message:**
+
+```java
+java.lang.NullPointerException: Cannot invoke "com.hypixel.hytale.component.query.Query.validateRegistry(com.hypixel.hytale.component.ComponentRegistry)" because "query" is null
+```
+
+**Cause:**
+This error occurs when your module is loaded **before** the required Hytale modules.
+
+**Fix:**
+Add `EntityModule` and `BlockModule` as dependencies in your `manifest.json` to ensure proper load order.
+
+```json
+"Dependencies": {
+  "Hytale:EntityModule": "*",
+  "Hytale:BlockModule": "*"
+}
+```
diff --git a/content/docs/id-ID/guides/ecs/hytale-ecs-theory.mdx b/content/docs/id-ID/guides/ecs/hytale-ecs-theory.mdx
index 20c3a94d..52d8b1f5 100644
--- a/content/docs/id-ID/guides/ecs/hytale-ecs-theory.mdx
+++ b/content/docs/id-ID/guides/ecs/hytale-ecs-theory.mdx
@@ -29,7 +29,7 @@ for now this is the basic understanding for the `ChunkStore`. You can use it to
 
 ## Holder
 
-A Holder is essentially a blueprint for an entity. Before an entity exists in the Store (and thus in the world), is exists as a `Holder`. It collects and holds all the necessary components (data). You can compare it analogous to shopping cart. You grab all components you need and once you have everything, check out at the store which will take your cart and create a valid entity ID and hand you back a receipt (a Ref).
+A Holder is essentially a blueprint for an entity. Before an entity exists in the Store (and thus in the world), it exists as a `Holder`. It collects and holds all the necessary components (data). You can compare it analogous to shopping cart. You grab all components you need and once you have everything, check out at the store which will take your cart and create a valid entity ID and hand you back a receipt (a Ref).
 
 Let's take a look at an example: initializing players. In `Universe`, the `addPlayer` method demonstrates it perfectly.
 When a player connects, we don't immediately throw them into the ECS. We first construct their data in a Holder.
@@ -167,7 +167,7 @@ MyComponent comp = commandBuffer.getComponent(ref, componentType);
 
 Codecs handle serialization and deserialization of components. Hytale uses them to save and load entity data to and from disk as well as sending component data over the network. When creating a custom component, you must also create a corresponding Codec.
 
-There are mutliple Codec types already implemented in the default Codec Interface:
+There are multiple Codec types already implemented in the default Codec Interface:
 
 - Codec.STRING
 - Codec.BOOLEAN
@@ -215,7 +215,7 @@ This might seem tedious at first but it ensures that your component can be corre
   KeyedCodec<Integer> exampleInt = new KeyedCodec<Integer>("ExampleIntIdForCodec", Codec.INTEGER);
   ```
 
-- **Setter Function**: This is a lambda function that takes an instance of your component and returns the value of the field you want to serialize. For example, if you have a field called `myCustomField` in your custom component, your getter function would look like this:
+- **Setter Function**: This is a lambda function that takes an instance of your component + the value to set and sets the field value on the component. For example, if you have a field called `myCustomField` in your custom component, your setter function would look like this:
   ```java
   (data, value) -> data.myCustomField = value
   ```
@@ -276,7 +276,7 @@ public class PoisonComponent implements Component<EntityStore> {
 
 You can also add validators to your Codec fields to ensure that the data being serialized/deserialized meets certain criteria. For example, if you want to ensure that the `damagePerTick` field is always non-negative or the poison name is never null, you can add a validator like this:
 
-````java
+```java
 .append(
     new KeyedCodec<Float>("DamagePerTick", Codec.FLOAT),
     (data, value) -> data.damagePerTick = value,
@@ -292,14 +292,15 @@ You can also add validators to your Codec fields to ensure that the data being s
 )
 .addValidator(Validators.nonNull())
 .add()
+```
 
 ### Complex Codec Examples
 
-If you want to have a map inside your component, you can use the MapCodec class to build a KeyedCoded for it. Here's an example of how to create a Codec for a Map field:
+If you want to have a map inside your component, you can use the MapCodec class to build a KeyedCodec for it. Here's an example of how to create a Codec for a Map field:
 
 ```java
 var damagePerTick = new KeyedCodec<>("DamagePerTick", new MapCodec<>(Codec.FLOAT, HashMap<String, Float>::new));
-````
+```
 
 <Callout type="info">
   This also works with custom Objects as long as you have a Codec defined for the Object type.
diff --git a/content/docs/id-ID/guides/java-basics/00-introduction.mdx b/content/docs/id-ID/guides/java-basics/00-introduction.mdx
index c68ece59..b318d450 100644
--- a/content/docs/id-ID/guides/java-basics/00-introduction.mdx
+++ b/content/docs/id-ID/guides/java-basics/00-introduction.mdx
@@ -7,7 +7,7 @@ Selamat datang dalam perjalananmu belajar Pemrograman Java! Panduan ini dirancan
 
 ## Apa itu Java?
 
-Java adalah bahasa pemrograman berorientasi objek yang kuat dan dibuat pada tahun 1995. Ini adalah salah satu bahasa pemrograman paling populer di dunia dan digunakan untuk segalanya, mulai dari aplikasi seluler hingga perangkat lunak perusahaan. Yang paling penting bagi kita, ini adalah bahasa yang digunakan Hytale untuk server & API modding-nya.
+Java adalah bahasa pemrograman berorientasi objek yang kuat dan dibuat pada tahun 1995. Ini adalah salah satu bahasa pemrograman paling populer di dunia dan digunakan untuk segalanya, mulai dari aplikasi seluler hingga perangkat lunak perusahaan. Most importantly for us, it's the language Hytale uses for its servers & modding API.
 
 ## Apa yang akan kamu pelajari
 
diff --git a/content/docs/id-ID/guides/java-basics/02-operators.mdx b/content/docs/id-ID/guides/java-basics/02-operators.mdx
index bb3c1a53..1ec7c188 100644
--- a/content/docs/id-ID/guides/java-basics/02-operators.mdx
+++ b/content/docs/id-ID/guides/java-basics/02-operators.mdx
@@ -118,7 +118,7 @@ String greetingWithName = "Hello, " + name + "!"; // "Hello, Alice!"
 
 ## Prioritas Operator (Precedence)
 
-Prioritas Operator berarti operator mana yang dievaluasi terlebih dahulu dalam satu baris kode. Anggap saja seperti BODMAS/PEMDAS dalam matematika!
+Operator Precedence means which operator gets evaluated first in an line of code. Anggap saja seperti BODMAS/PEMDAS dalam matematika!
 
 ```java
 int result = 10 + 5 * 2; // hasilnya 20, bukan 30
diff --git a/content/docs/id-ID/guides/java-basics/03-control-flow-if.mdx b/content/docs/id-ID/guides/java-basics/03-control-flow-if.mdx
index bb42a0ea..c5acbf33 100644
--- a/content/docs/id-ID/guides/java-basics/03-control-flow-if.mdx
+++ b/content/docs/id-ID/guides/java-basics/03-control-flow-if.mdx
@@ -7,7 +7,7 @@ Program perlu membuat keputusan. Pernyataan if memungkinkan kodemu memilih jalur
 
 ## Pernyataan If Dasar
 
-Bentuk paling sederhana memeriksa satu kondisi;
+The simplest form checks one condition:
 
 ```java
 int health = 20;
diff --git a/content/docs/id-ID/guides/java-basics/08-access-modifiers.mdx b/content/docs/id-ID/guides/java-basics/08-access-modifiers.mdx
index af560932..da2bf33b 100644
--- a/content/docs/id-ID/guides/java-basics/08-access-modifiers.mdx
+++ b/content/docs/id-ID/guides/java-basics/08-access-modifiers.mdx
@@ -484,7 +484,7 @@ class Data {
     // Static member:
     // cannot access to non-static variables
     public static void bar() {
-        x = 100; // Error: non-static variable x cannot be renference from a static context
+        x = 100; // Error: non-static variable x cannot be referenced from a static context
         y = 100; // OK
     }
 }
@@ -504,7 +504,7 @@ Data.x = 1000; // Error: cannot access instanced variables in a static context
 
 ### Static Fields
 
-A static field represents a data member owned by the class type rather then the object. Static fields are also stored in a specific memory location that's been shared between all the object instances that are created.
+A static field represents a data member owned by the class type rather than the object. Static fields are also stored in a specific memory location that's been shared between all the object instances that are created.
 
 It is declared as following:
 
diff --git a/content/docs/id-ID/guides/plugin/animated-block-textures.mdx b/content/docs/id-ID/guides/plugin/animated-block-textures.mdx
new file mode 100644
index 00000000..42bfa51f
--- /dev/null
+++ b/content/docs/id-ID/guides/plugin/animated-block-textures.mdx
@@ -0,0 +1,101 @@
+---
+title: Animated Block Textures
+description: Learn how to attach a .blockyanim to a block
+authors:
+  - name: Burkino
+---
+
+import { File, Folder, Files } from 'fumadocs-ui/components/files';
+
+So, you want to make your blocks feel more alive through animations, do you?\
+Now for the most part this is the exact same as [Creating custom blocks](./creating-block).
+![blue fire gif](/assets/guides/blue_fire.gif)
+
+## Prerequisites
+
+This is NOT a guide on animating or texturing or even using BlockBench, why? Because I don't know how to do that.\
+The only thing we will be doing is taking the fire texture, changing the color, and applying it to our new fire block.
+
+## Setup
+
+To start, you're obviously going to want to grab the `Common/VFX/Fire/Fire.png` file. How you do it is up to you, in the Asset Editor you'll need to switch to the Common tab.\
+I'll assume you know how colorize or change the hue of an image, so go ahead and do that now and save it as `Blue_Fire.png`.
+
+The other assets used in this guide are `Common/VFX/Fire/Fire.blockymodel` and `Common/Blocks/Animations/Fire/Fire_Burn.blockyanim` (both renamed to `Blue_Fire`) but since we won't be changing them it's probably fine to leave them. I will reference the `Blue_Fire` versions as a way to point out what should be custom assets.\
+I will also duplicate `Server/Item/Item/Deco/Deco_Fire.json` and call it `Deco_Blue_Fire.json`.
+
+## Applying the changes
+
+The `Deco_Blue_Fire` block is actually just a particle emitter, however we will not be using particles, so lets start by removing them in `Block > Particles`.\
+Next we want to set the Block Model (called `CustomModel` in JSON) to `VFX/Blue_Fire/Blue_Fire.blockymodel` and Block Model Textures (`CustomModelTexture` in JSON) to
+
+```json
+[
+    {
+        "Texture": "VFX/Blue_Fire/Blue_Fire.png",
+        "Weight": 1
+    }
+]
+```
+
+Finally, we will apply the .blockyanim to our model, this is done through the Block Model Animation property (`CustomModelAnimation` in JSON) and the value should be `Blocks/Animations/Blue_Fire/Blue_Fire_Burn.blockyanim`.
+
+## Final Code
+
+With that your new blue fire should be done. Here is the minimal JSON for our blue fire.\
+There is an additional `Looping` and `RequiresAlphaBlending` property that I have not gone over, however I hope it is self-explanatory.
+
+```json
+{
+  "BlockType": {
+    "DrawType": "Model",
+    "CustomModel": "VFX/Blue_Fire/Blue_Fire.blockymodel",
+    "CustomModelAnimation": "Blocks/Animations/Blue_Fire/Blue_Fire_Burn.blockyanim",
+    "CustomModelTexture": [
+      {
+        "Texture": "VFX/Blue_Fire/Blue_Fire.png",
+        "Weight": 1
+      }
+    ],
+    "Looping": true,
+    "RequiresAlphaBlending": false
+  },
+  "PlayerAnimationsId": "Block"
+}
+```
+
+<Files>
+  <Folder name="resources" defaultOpen>
+    <Folder name="Server" defaultOpen>
+      <Folder name="Item" defaultOpen>
+        <Folder name="Items" defaultOpen>
+          <Folder name="Deco" defaultOpen>
+            <File name="Deco_Blue_Fire.json" />
+          </Folder>
+        </Folder>
+      </Folder>
+    </Folder>
+
+    <Folder name="Common" defaultOpen>
+      <Folder name="Blocks" defaultOpen>
+        <Folder name="Animations" defaultOpen>
+          <Folder name="Blue_Fire" defaultOpen>
+            <File name="Blue_Fire_Burn.blockyanim" />
+          </Folder>
+        </Folder>
+      </Folder>
+
+      <Folder name="VFX" defaultOpen>
+        <Folder name="Blue_Fire" defaultOpen>
+          <File name="Blue_Fire.blockymodel" />
+
+          <File name="Blue_Fire.png" />
+        </Folder>
+      </Folder>
+    </Folder>
+  </Folder>
+</Files>
+
+## Next steps
+
+Now that you know how to attach an animation to a block, try adding it to a block state.
diff --git a/content/docs/id-ID/guides/plugin/build-and-test.mdx b/content/docs/id-ID/guides/plugin/build-and-test.mdx
index 0e7fe7eb..f37534c3 100644
--- a/content/docs/id-ID/guides/plugin/build-and-test.mdx
+++ b/content/docs/id-ID/guides/plugin/build-and-test.mdx
@@ -9,18 +9,18 @@ If you followed along with the [Setting Up Your Development Environment](./setti
 
 ## Building Your Mod
 
-In our case, we've **Maven** as the build system. Maven is a powerful build automation tool that manages dependencies, compiles your code, and packages everything into a distributable JAR file.
+In our case, we've **Gradle** as the build system. Gradle is a powerful build automation tool that manages dependencies, compiles your code, and packages everything into a distributable JAR file.
 
-### Understanding Maven
+### Understanding Gradle
 
-Maven uses a `pom.xml` file (Project Object Model) to define your project's configuration, dependencies, and build settings. You can learn more about Maven at the [official Apache Maven website](https://maven.apache.org/).
+Gradle can use a `build.gradle.kts` file (Kotlin DSL) to define your project's configuration, dependencies, and build settings. You can learn more about Gradle at the [official Gradle website](https://gradle.org/).
 
-### Building with Maven
+### Building with Gradle
 
 To build your mod, open a terminal in your project directory and run:
 
 ```bash
-mvn package
+./gradlew build
 ```
 
 This command will:
@@ -29,16 +29,35 @@ This command will:
 2. Run any tests (if present)
 3. Package everything into a JAR file
 
+<Callout type="info">
+  If you are using the plugin template from the [Setting Up Your Development Environment](./setting-up-env) guide, then the build script is already set up for you. It includes paths to your Hytale game library and handles the packaging of your mod, managing hytale dependencies and manifest changes.
+
+  If you have a different path to your Hytale installation, you may receive the following error:
+
+  ```bash
+  FAILURE: Build failed with an exception.
+
+  * What went wrong:
+  Failed to find Hytale at the expected location. Please make sure you have installed the game. The expected location can be changed using the hytale.home_path property. Currently looking in 'C:\Path\To\Hytale'
+  ```
+
+  You can change the path by adding a property to your `gradle.properties` file (if it doesn't exist, create it in the root of your project):
+
+  ```properties
+  hytale.home_path=C:\Correct\Path\To\Hytale
+  ```
+</Callout>
+
 ### Build Output
 
-Once the build completes successfully, your mod will be located in the `target` directory and named:
+Once the build completes successfully, your mod will be located in the `build/libs` directory and named:
 
 ```
-ExamplePlugin-1.0-SNAPSHOT.jar
+ExamplePlugin-1.0.jar
 ```
 
 <Callout type="info">
-  The exact name may vary depending on what you configured in your `pom.xml` file. Check the `artifactId` and `version` fields to see what your JAR will be named.
+  The exact name may vary depending on what you configured in your `build.gradle.kts` and `settings.gradle.kts` file. Check the `rootProject.name` and `version` fields to see what your JAR will be named.
 </Callout>
 
 ## Testing Your Mod
@@ -49,11 +68,11 @@ Now that you've built your mod, it's time to test it in Hytale!
 
 First, you need to find Hytale's mods directory:
 
-1. Press **Win + R** on your keyboard
-2. Type `%appdata%` and press Enter
-3. Navigate to: `Hytale\UserData\Mods`
+1. Go to your Hytale installation directory (The default location is usually in your AppData folder)
+   > On Windows, you can access it by clicking `windows + R` and typing `%appdata%`.
+2. Navigate to: `/UserData/Mods`
 
-The full path should look like:
+The default path would look like:
 
 ```
 C:\Users\YourUsername\AppData\Roaming\Hytale\UserData\Mods
@@ -65,7 +84,7 @@ C:\Users\YourUsername\AppData\Roaming\Hytale\UserData\Mods
 
 ### 2. Copy Your Mod
 
-Copy the `ExamplePlugin-1.0-SNAPSHOT.jar` file from your project's `target` directory into the `Mods` folder you just located.
+Copy the `ExamplePlugin-1.0.jar` file from your project's `build/libs` directory into the `Mods` folder you just located.
 
 ### 3. Launch Hytale and Verify
 
@@ -84,7 +103,7 @@ If your mod doesn't appear in the mods list:
 - Make sure the JAR file is in the correct `Mods` folder
 - Check that your `manifest.json` file is properly configured
 - Look for any error messages in the Hytale logs
-- Verify that you're using the correct version of Java and Maven
+- Verify that you're using the correct version of Java and Gradle
 
 ## Next Steps
 
diff --git a/content/docs/id-ID/guides/plugin/creating-commands.mdx b/content/docs/id-ID/guides/plugin/creating-commands.mdx
index d33597f3..08572f16 100644
--- a/content/docs/id-ID/guides/plugin/creating-commands.mdx
+++ b/content/docs/id-ID/guides/plugin/creating-commands.mdx
@@ -8,6 +8,8 @@ authors:
     url: https://oskar.scot
   - name: jacobwojoski
     url: https://github.com/jacobwojoski
+  - name: Marcel-TO
+    url: https://marcel-to.net
 ---
 
 In this guide, you will learn how to create custom commands for your Hytale mod.
@@ -36,7 +38,7 @@ The most basic command is an `AbstractAsyncCommand`. It has very minimal data av
   `AbstractAsyncCommand` runs on its own background thread. This means its execute is not tied to any world instance and because of this it can not edit any **Stores** or **Refs** without getting the desired world first. To access this data any of the other command types would be preferred and are likely what you will want to use instead.
 </Callout>
 
-The main purpose for a command like this would be for something that can happen everywhere and is not tied to a specific world. For example a `serverRules` command to tell the user thats running the command in chat what the servers rules are nomatter what world they are in.
+The main purpose for a command like this would be for something that can happen everywhere and is not tied to a specific world. For example a `serverRules` command to tell the user that's running the command in chat what the server's rules are no matter what world they are in.
 
 ```java
 // Command that can be run that lists the server rules in chat to the player
@@ -49,7 +51,7 @@ public class ServerRulesCommand extends AbstractAsyncCommand {
     }
 
     // Run the command
-    // conetext - info about who ran the command. Server console?, Some player?
+    // context - info about who ran the command. Server console?, Some player?
     @Override
     protected CompletableFuture<Void> executeAsync(@Nonnull CommandContext context) {
         context.sendMessage(Message.raw("The only rule is there are no rules."));
@@ -134,7 +136,7 @@ Uses a Ray to see what the player is looking at and tries to run the command on
 
 ## Adding Arguments
 
-Arguments are additional fields that the user can input when running a command. The different types of arguments along with small snipits and a large example can be seen below.
+Arguments are additional fields that the user can input when running a command. The different types of arguments along with small snippets and a large example can be seen below.
 
 ### Command Argument Types
 
@@ -163,14 +165,14 @@ this.messageArg = this.withOptionalArg("message", "Message to print while healin
 
 ### Default Arguments
 
-Adding a default argument has two additional arguemnt for the default value and default value description. You need to use `withDefaultArg` method.
+Adding a default argument has two additional argument for the default value and default value description. You need to use `withDefaultArg` method.
 
 ```java
 // args <Command String> <Description> <Default Value> <Desc of default value>
 this.healthArg = this.withDefaultArg("health", "Amount to heal player", ArgTypes.FLOAT, (float)100, "Desc of Default: 100");
 ```
 
-### Flag Arguemnts
+### Flag Arguments
 
 Similar as above but the flags return is either true if it exists or false if it does not. You need to use `withFlagArg` method.
 
@@ -181,20 +183,13 @@ this.debugArg = this.withFlagArg("debug", "Add debug logs");
 
 ### ArgTypes
 
-The following ArgTypes are available (only lists common types):
-
-- `ArgTypes.STRING`
-- `ArgTypes.INTEGER`
-- `ArgTypes.BOOLEAN`
-- `ArgTypes.FLOAT`
-- `ArgTypes.DOUBLE`
-- `ArgTypes.UUID`
+You can find all the available argument types on the [ArgTypes](../../argtypes) page.
 
 ### Example Command Arg Types
 
-Shows all Command arguemnt types with different various input types.
+Shows all Command argument types with different various input types.
 
-**NOTE:** When getting the value of an argument during execute you need to pass the context with `someArg.get(commandContext)`. Where `commandContext` is the first variable in the execute funtion.
+**NOTE:** When getting the value of an argument during execute you need to pass the context with `someArg.get(commandContext)`. Where `commandContext` is the first variable in the execute function.
 
 ```java
 // Example usage: /healplayer --health 50 --message "Feels Good" --debug
@@ -204,7 +199,7 @@ public class HealPlayerCommand extends AbstractTargetPlayerCommand {
     private final FlagArg debugArg;
 
     public HealPlayerCommand() {
-        super("healplayer", "Healing a player for an <input> ammount of HP (default: 100)");
+        super("healplayer", "Healing a player for an <input> amount of HP (default: 100)");
 
         // Abstract TargetPlayerCommand passes the player that ran the command by default and implements
         // the use of `--player <value>` to specify someone else
@@ -213,10 +208,10 @@ public class HealPlayerCommand extends AbstractTargetPlayerCommand {
         this.healthArg = this.withDefaultArg("health", "Amount to heal player", ArgTypes.FLOAT, (float)100, "Desc of Default: 100");
 
         // Or you could do the following making the health value required instead of with a default.
-        //    You would need to change the decleration to RequiredArg<Float>
+        //    You would need to change the declaration to RequiredArg<Float>
         // this.healthArg = this.withRequiredArg("health", "Amount to heal player", ArgTypes.FLOAT);
 
-        // Optional args reguare the user the input `--<key> <value>` so the following would require `--message "Good Luck"`
+// Optional args require the user the input `--<key> <value>` so the following would require `--message "Good Luck"`
         this.messageArg = this.withOptionalArg("message", "Message to print while healing", ArgTypes.STRING);
 
         // No type needed due to being a bool
@@ -230,7 +225,7 @@ public class HealPlayerCommand extends AbstractTargetPlayerCommand {
             commandContext.sendMessage(Message.raw("We are debugging"));
         }
 
-        // Health is stored in a generic stat map to allowing mods/future contect to easily add more stats if desired.
+        // Health is stored in a generic stat map to allowing mods/future content to easily add more stats if desired.
         EntityStatMap stats = store.getComponent(ref, EntityStatMap.getComponentType());
         int healthIdx = DefaultEntityStatTypes.getHealth();
         EntityStatValue health = stats.get(healthIdx);
@@ -252,7 +247,7 @@ public class HealPlayerCommand extends AbstractTargetPlayerCommand {
 
 ## Argument Validators
 
-Argument validators are a way to check the command before the command gets executed. They are added with the `addValidator` method on an argument when calling `withXxxArg`. They provide a nice output to the user when an input value is invalid.
+Argument validators are a way to check the command before the command gets executed. They are added with the `addValidator` method on an argument when calling `withXxxArg`. They provide a nice output to the user when an input value is invalid. There are some common validators provided in the `Validators` class such as `greaterThan`, `lessThan`, and `or`, `max`, `range`, etc.
 
 ```java
 ...
@@ -260,18 +255,59 @@ Argument validators are a way to check the command before the command gets execu
     OptionalArg<Integer> healAmount = withOptionalArg("amount", "Heal Amount", ArgTypes.INTEGER)
         .addValidator(Validators.greaterThan(0))
         .addValidator(Validators.lessThan(1000));
-
-    // Custom check example
-    OptionalArg<Integer> healAmount = withOptionalArg("amount", "Heal Amount", ArgTypes.INTEGER)
-            .addValidator( value -> {
-                if (value != null && value <= 0) {
-                    return ValidationResult.error("ammount argument must be a positive number");
-                }
-                return ValidationResult.success();
-            });
 ...
 ```
 
+### Custom Validators
+
+You can also create custom validators by implementing the `com.hypixel.hytale.codec.validation.Validator` interface. The interfaces forces you to implement the `accept` and `updateSchema` method. The `accept` method takes in the argument value and validates it. If the validation fails, you can use the `fail` method of the `com.hypixel.hytale.codec.validation.ValidationResults` class to return an error message.
+The `updateSchema` method is used to update the schema of the command argument. This is used for commands that have dynamic schemas based on the input value. For example, if you have a command that takes in a player name as an argument, you can use the `updateSchema` method to update the schema to include a list of online players for validation.
+
+Here is an example of a custom validator that checks if a string value is equal to a banned word. In this example, the banned word is "badword". If the input value is "badword", the validator will fail and return an error message.
+
+```java
+import com.hypixel.hytale.codec.schema.SchemaContext;
+import com.hypixel.hytale.codec.schema.config.Schema;
+import com.hypixel.hytale.codec.validation.ValidationResults;
+import com.hypixel.hytale.codec.validation.Validator;
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+
+public class MyCustomValidator implements Validator<String> {
+    @Nonnull
+    private final String value;
+
+    public MyCustomValidator(@Nonnull String value) {
+        this.value = value;
+    }
+
+    @Override
+    public void accept(@Nullable String input, @Nonnull ValidationResults results) {
+        if (this.value.equalsIgnoreCase(input)) {
+            results.fail("The given role has been banned.");
+        }
+    }
+
+    @Override
+    public void updateSchema(SchemaContext context, @Nonnull Schema target) {
+        // This method can be used to update the schema of the command argument. This is useful for commands that have dynamic schemas based on the input value. For example, if you have a command that takes in a player name as an argument, you can use the `updateSchema` method to update the schema to include a list of online players for validation.
+        throw new UnsupportedOperationException("Not implemented yet.");
+    }
+}
+```
+
+After the custom validator is created, you can add it to an argument like the following example. In this example, we add the `MyCustomValidator` to a string argument called "role". If the user inputs "badword" as the role, the command will fail and return the error message defined in the `MyCustomValidator`.
+
+```java
+    ...
+    // Custom validator example
+    String bannedRole = "badword";
+
+    OptionalArg<String> roleArg = withOptionalArg("role", "Role to assign", ArgTypes.STRING)
+        .addValidator(new MyCustomValidator(bannedRole));
+    ...
+```
+
 ---
 
 ## Permissions
@@ -312,7 +348,7 @@ This allows the server to control who has access to specific commands. You add t
 
 If you want variants of the same command without doing argument parsing you can instead use `addUsageVariant(new OtherCommandClass())` in the original commands constructor.
 
-The only difference is in the `OtherCommandClass()` constrcutor you don't pass the command name to the super class.
+The only difference is in the `OtherCommandClass()` constructor you don't pass the command name to the super class.
 
 <Callout type="info">
   You can also use `addAliases("some_alias", "some_other_alias")` as a way to add shorthand or other ways to write the same command.
@@ -387,7 +423,7 @@ public class AdminCommand extends AbstractCommandCollection {
     public AdminCommand () {
         super("admin", "Admin commands");
         addSubCommand(new UserCommandCollection());
-        addSybCommand(new ServerCommandCollection);
+        addSubCommand(new ServerCommandCollection);
     }
 }
 ```
@@ -417,5 +453,5 @@ public class MyPlugin extends JavaPlugin {
 
 ## Video Link
 
-_Special Thanks to [TroubleDev](https://www.youtube.com/@TroubleDEV) for his excelent video guide on all of these features._
+_Special Thanks to [TroubleDev](https://www.youtube.com/@TroubleDEV) for his excellent video guide on all of these features._
 _Video Link: [TroubleDev - Hytale's Command API Explained](https://www.youtube.com/watch?v=KnmhG9MDMgo)_
diff --git a/content/docs/id-ID/guides/plugin/creating-events.mdx b/content/docs/id-ID/guides/plugin/creating-events.mdx
index 95863990..d3f0925d 100644
--- a/content/docs/id-ID/guides/plugin/creating-events.mdx
+++ b/content/docs/id-ID/guides/plugin/creating-events.mdx
@@ -1,6 +1,6 @@
 ---
-title: Creating Events
-description: Learn how to create custom events for your Hytale mod.
+title: Creating Events Listeners
+description: Learn how to create event listeners for your Hytale mod.
 authors:
   - name: Neil Revin
     url: https://itsneil.dev
@@ -10,7 +10,7 @@ authors:
 
 ## Event Class
 
-You can import a Event class and create a function with the Event as a argument. [Click here](../../server/events) to look at all available events.
+You can import an Event class and create a function with the Event as an argument. [Click here](../../server/events) to look at all available events.
 
 Example plugin when a player is ready (joins a server):
 
diff --git a/content/docs/id-ID/guides/plugin/item-registry.mdx b/content/docs/id-ID/guides/plugin/item-registry.mdx
new file mode 100644
index 00000000..9a0fd53a
--- /dev/null
+++ b/content/docs/id-ID/guides/plugin/item-registry.mdx
@@ -0,0 +1,95 @@
+---
+title: Working with the Item Registry
+description: Learn how to access and query the game's item registry to list all items, check if items exist, and retrieve item properties.
+authors:
+  - name: Denis
+---
+
+In this guide, you'll learn how to work with Hytale's Item Registry system. This is useful when you need to programmatically list all available items, validate item IDs, or retrieve item properties at runtime.
+
+## Prerequisites
+
+Before diving in, you should be familiar with:
+
+- [Setting up your development environment](./setting-up-env)
+- [Creating commands](./creating-commands) (optional, for testing)
+
+## Required Imports
+
+To work with the Item Registry, you'll need the following imports:
+
+```java
+import com.hypixel.hytale.assetstore.map.DefaultAssetMap;
+import com.hypixel.hytale.server.core.asset.type.item.config.Item;
+```
+
+## Getting the Item Registry
+
+The Item Registry is accessed through the `Item.getAssetMap()` method, which returns a `DefaultAssetMap<String, Item>` containing all registered items in the game:
+
+```java
+DefaultAssetMap<String, Item> itemMap = Item.getAssetMap();
+```
+
+## Listing All Items
+
+To iterate through all items in the registry, you can get the underlying map and loop through its entries:
+
+```java
+DefaultAssetMap<String, Item> itemMap = Item.getAssetMap();
+var map = itemMap.getAssetMap();
+
+for (var entry : map.entrySet()) {
+    String itemId = String.valueOf(entry.getKey());
+    Item item = entry.getValue();
+    
+    // Do something with the item
+    LOGGER.atInfo().log("Item ID: " + itemId);
+}
+```
+
+You can also get the total count of registered items:
+
+```java
+int totalItems = map.size();
+```
+
+## Checking if an Item Exists
+
+To check if a specific item exists in the registry, use `getAsset()` and verify the result:
+
+```java
+public boolean itemExists(String itemId) {
+    var assetMap = Item.getAssetMap();
+    if (assetMap != null) {
+        Item item = assetMap.getAsset(itemId);
+        return item != null && item != Item.UNKNOWN;
+    }
+    return false;
+}
+```
+
+<Callout type="info">
+  The `Item.UNKNOWN` constant represents an invalid or unrecognized item. Always check for both `null` and `Item.UNKNOWN` when validating items.
+</Callout>
+
+## Accessing Item Properties
+
+Once you have an `Item` instance, you can access various properties:
+
+```java
+var assetMap = Item.getAssetMap();
+Item item = assetMap.getAsset("Soil_Grass");
+
+if (item != null && item != Item.UNKNOWN) {
+    String id = item.getId(); // Soil_Grass
+    int maxStack = item.getMaxStack(); // 100
+    boolean isBlock = item.hasBlockType(); // true
+    boolean isConsumable = item.isConsumable(); // false
+}
+```
+
+## Related Guides
+
+- [Inventory Management](./inventory-management) - Learn how to add and remove items from player inventories
+- [Create Custom Item and Interaction](./item-interaction) - Learn how to create your own custom items
diff --git a/content/docs/id-ID/guides/plugin/permission-management.mdx b/content/docs/id-ID/guides/plugin/permission-management.mdx
index 6b7cfd46..55f06101 100644
--- a/content/docs/id-ID/guides/plugin/permission-management.mdx
+++ b/content/docs/id-ID/guides/plugin/permission-management.mdx
@@ -10,132 +10,569 @@ authors:
     link: https://discord.com/users/292656109939064833
   - name: Ivan
     link: https://discord.com/users/505770451218333717
+  - name: ZenithDevHQ
+    link: https://github.com/ZenithDevHQ
 ---
 
-In this guide, you'll learn how to manage permission nodes and groups in your Hytale plugin.
+In this guide, you'll learn how to manage permission nodes and groups in your Hytale plugin. Permissions control what actions players can perform on your server, from basic commands to advanced administrative functions.
 
-## The `PermissionsModule` class
+## What Are Permissions?
 
-The `PermissionsModule` class is responsible for managing permission nodes and groups in your plugin. It provides methods to check, grant and revoke permissions and groups for players. It allows the following operations
+Permissions are string identifiers that control access to features and commands. When a player tries to perform an action (like using a command), the server checks if they have the required permission.
 
-- Add permissions to user
-- Remove permissions from user
-- Add permissions to group (this also creates the group if it doesn't exist)
-- Remove permissions from group
-- Add user to group
-- Remove user from group
-- List all groups for a user
-- Check if a user has a permission (it checks both user and group permissions for the given player UUID)
+**Example permission nodes:**
 
-With this class you cannot:
+- `hytale.command.gamemode` - Permission to use the gamemode command
+- `hytale.editor.brush.use` - Permission to use brush tools
+- `myplugin.teleport.home` - A custom permission for your plugin
 
-- List all defined groups
-- Remove a group
+Permissions follow a hierarchical naming pattern: `namespace.category.action`
 
-### Adding Permission Nodes
+## Key Concepts
 
-You need a `Set<String>` containing all the permission nodes you want to add, these are added on top of the already existing permission nodes the user may have, it is not a replacement.
+Before diving into code, let's understand the core concepts:
+
+| Concept             | Description                                                                |
+| ------------------- | -------------------------------------------------------------------------- |
+| **Permission Node** | A string like `myplugin.feature.use` that represents a specific permission |
+| **Group**           | A named collection of permissions (e.g., "Admin", "VIP", "Default")        |
+| **Provider**        | The backend that stores and retrieves permissions                          |
+| **Wildcard**        | A pattern like `*` or `myplugin.*` that matches multiple permissions       |
+
+### How Permissions Are Checked
+
+When checking if a player has a permission, Hytale follows this order:
+
+1. **User's direct permissions** - Permissions granted directly to the player
+2. **Group permissions** - Permissions from groups the player belongs to
+3. **Virtual groups** - Game-mode-based permissions (e.g., Creative mode grants builder tools)
+4. **Default value** - Falls back to `false` if no match found
+
+<Callout type="info">
+  The first definitive match wins. If a player has a permission granted at the user level, group permissions won't override it.
+</Callout>
+
+---
+
+## The `PermissionsModule` Class
+
+The `PermissionsModule` class is the central hub for managing permissions. Access it using the singleton pattern:
 
 ```java
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.addUserPermission(playerUUID, permissions);
 ```
 
-### Removing Permission Nodes
+### Available Operations
+
+The module supports these operations:
+
+| Operation                     | Method                                          |
+| ----------------------------- | ----------------------------------------------- |
+| Add permissions to user       | `addUserPermission(uuid, permissions)`          |
+| Remove permissions from user  | `removeUserPermission(uuid, permissions)`       |
+| Add permissions to group      | `addGroupPermission(groupName, permissions)`    |
+| Remove permissions from group | `removeGroupPermission(groupName, permissions)` |
+| Add user to group             | `addUserToGroup(uuid, groupName)`               |
+| Remove user from group        | `removeUserFromGroup(uuid, groupName)`          |
+| Get user's groups             | `getGroupsForUser(uuid)`                        |
+| Check permission              | `hasPermission(uuid, permissionNode)`           |
+
+<Callout type="warning">
+  The module does **not** support:
+
+  - Listing all defined groups
+  - Deleting a group entirely
+
+  Groups are implicitly created when you first add permissions to them.
+</Callout>
+
+---
 
-Same as above, we just use the `removeUserPermission` method instead to remove permission nodes.
+## Checking Permissions
+
+The most common operation is checking if a player has a permission.
+
+### Basic Permission Check
+
+```java
+// Returns true if player has the permission, false otherwise
+boolean canUse = PermissionsModule.get().hasPermission(playerUUID, "myplugin.feature.use");
+
+if (canUse) {
+    // Player has permission, allow the action
+} else {
+    // Player lacks permission, deny or show error
+}
+```
+
+### Permission Check with Default Value
+
+You can specify what to return when no permission is explicitly set:
+
+```java
+// Returns true by default if no explicit permission is found
+boolean canUse = PermissionsModule.get().hasPermission(playerUUID, "myplugin.feature.use", true);
+```
+
+This is useful for features that should be enabled by default but can be revoked.
+
+### Using PermissionHolder Interface
+
+Players and command senders implement `PermissionHolder`, allowing direct checks:
+
+```java
+// In a command or event handler where you have access to the player
+if (player.hasPermission("myplugin.admin.manage")) {
+    // Player has admin permission
+}
+```
+
+---
+
+## Managing User Permissions
+
+### Adding Permissions to a User
+
+Permissions are additive - new permissions are added on top of existing ones, not replaced.
+
+```java
+PermissionsModule perms = PermissionsModule.get();
+
+// Add a single permission
+perms.addUserPermission(playerUUID, Set.of("myplugin.vip.chat"));
+
+// Add multiple permissions at once
+Set<String> newPerms = Set.of(
+    "myplugin.vip.chat",
+    "myplugin.vip.fly",
+    "myplugin.vip.kit"
+);
+perms.addUserPermission(playerUUID, newPerms);
+```
+
+### Removing Permissions from a User
 
 ```java
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.removeUserPermission(playerUUID, permissions);
+
+// Remove specific permissions
+Set<String> toRemove = Set.of("myplugin.vip.fly");
+perms.removeUserPermission(playerUUID, toRemove);
 ```
 
-### Add permissions to group
+---
+
+## Managing Groups
+
+Groups let you assign a collection of permissions to multiple players. This is more manageable than assigning permissions individually.
+
+### Adding Permissions to a Group
+
+If the group doesn't exist, it will be created automatically.
 
 ```java
-String groupName = "testGroup";
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.addGroupPermission(groupName, permissions);
+
+// Create/update the "VIP" group with permissions
+Set<String> vipPerms = Set.of(
+    "myplugin.vip.chat",
+    "myplugin.vip.fly",
+    "myplugin.vip.kit"
+);
+perms.addGroupPermission("VIP", vipPerms);
 ```
 
-### Remove permissions from group
+### Removing Permissions from a Group
 
 ```java
-String groupName = "testGroup";
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.removeGroupPermission(groupName, permissions);
+
+// Remove specific permissions from the group
+Set<String> toRemove = Set.of("myplugin.vip.fly");
+perms.removeGroupPermission("VIP", toRemove);
 ```
 
-### Add user to group
+### Adding a User to a Group
 
 ```java
-String groupName = "testGroup";
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.addUserToGroup(playerUUID, groupName);
+
+// Add player to the VIP group - they now have all VIP permissions
+perms.addUserToGroup(playerUUID, "VIP");
 ```
 
-### Remove user from group
+### Removing a User from a Group
 
 ```java
-String groupName = "testGroup";
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.removeUserFromGroup(playerUUID, groupName);
+
+// Remove player from VIP group
+perms.removeUserFromGroup(playerUUID, "VIP");
 ```
 
-### List all groups for a user
+### Getting a User's Groups
 
 ```java
 PermissionsModule perms = PermissionsModule.get();
-perms.getGroupsForUser(playerUUID);
+
+// Get all groups the player belongs to
+Set<String> groups = perms.getGroupsForUser(playerUUID);
+
+for (String group : groups) {
+    System.out.println("Player is in group: " + group);
+}
 ```
 
-### Check Permission Nodes
+---
+
+## Built-in Groups
+
+Hytale includes two default groups:
+
+| Group     | Default Permissions   | Purpose                           |
+| --------- | --------------------- | --------------------------------- |
+| `OP`      | `*` (all permissions) | Server operators with full access |
+| `Default` | None                  | Base group for all players        |
+
+Players without any explicit group assignment are automatically part of the `Default` group.
 
-To check if a player has a specific permission node, you can use the `hasPermission` method.
+---
+
+## Wildcards
+
+Wildcards let you grant or deny multiple permissions with a single pattern.
+
+### Wildcard Patterns
+
+| Pattern             | Meaning                                          |
+| ------------------- | ------------------------------------------------ |
+| `*`                 | Grants **all** permissions                       |
+| `myplugin.*`        | Grants all permissions starting with `myplugin.` |
+| `-*`                | Denies **all** permissions                       |
+| `-myplugin.admin.*` | Denies all admin permissions in your plugin      |
+
+### Example: Admin Group with Wildcards
 
 ```java
-boolean hasPermission = PermissionsModule.hasPermission(playerUUID, "permission.node");
+// Grant all permissions to admins
+perms.addGroupPermission("Admin", Set.of("*"));
+
+// Grant all plugin permissions to moderators
+perms.addGroupPermission("Moderator", Set.of("myplugin.*"));
+
+// Grant all permissions except admin commands
+perms.addGroupPermission("Helper", Set.of(
+    "*",
+    "-myplugin.admin.*"  // Deny admin permissions
+));
 ```
 
-## Additional: Defining your own provider for permissions and groups
+<Callout type="warning">
+  Negation permissions (starting with `-`) take precedence at each level. Use them carefully to avoid accidentally blocking permissions.
+</Callout>
+
+---
+
+## Built-in Permission Nodes
+
+Hytale provides constants for common permissions in the `HytalePermissions` class:
+
+### Command Permissions
+
+```java
+// Generate permission for a command
+String perm = HytalePermissions.fromCommand("gamemode");
+// Result: "hytale.command.gamemode"
+
+// Generate permission for a subcommand
+String perm = HytalePermissions.fromCommand("gamemode", "creative");
+// Result: "hytale.command.gamemode.creative"
+```
+
+### Common Permission Nodes
+
+| Permission                    | Description                  |
+| ----------------------------- | ---------------------------- |
+| `hytale.command.op.add`       | Add players to OP group      |
+| `hytale.command.op.remove`    | Remove players from OP group |
+| `hytale.editor.brush.use`     | Use brush tools              |
+| `hytale.editor.prefab.use`    | Use prefabs                  |
+| `hytale.editor.selection.use` | Use selection tools          |
+| `hytale.editor.history`       | Undo/redo operations         |
+| `hytale.camera.flycam`        | Use fly camera mode          |
+
+---
+
+## Listening to Permission Events
+
+You can react to permission changes using Hytale's event system.
+
+### Available Events
+
+| Event                                            | Triggered When                   |
+| ------------------------------------------------ | -------------------------------- |
+| `PlayerPermissionChangeEvent.PermissionsAdded`   | Permissions added to a user      |
+| `PlayerPermissionChangeEvent.PermissionsRemoved` | Permissions removed from a user  |
+| `PlayerGroupEvent.Added`                         | User added to a group            |
+| `PlayerGroupEvent.Removed`                       | User removed from a group        |
+| `GroupPermissionChangeEvent.Added`               | Permissions added to a group     |
+| `GroupPermissionChangeEvent.Removed`             | Permissions removed from a group |
 
-The PermissionsModule also enables us to define our own PermissionProvider's, this can be useful for:
+### Example: Reacting to Permission Changes
 
-- Cross server permission systems
-- Implementing features missing in the `HytalePermissionsProvider` like permission expiry
+```java
+public class PermissionListener {
+
+    public static void onPermissionsAdded(PlayerPermissionChangeEvent.PermissionsAdded event) {
+        UUID playerUUID = event.getPlayerUuid();
+        Set<String> added = event.getAddedPermissions();
+
+        System.out.println("Permissions added to " + playerUUID + ": " + added);
 
-To implement our PermissionProvider, first we need to define a provider class that implements PermissionProvider:
+        // Maybe notify the player or update cached data
+    }
+
+    public static void onGroupAdded(PlayerGroupEvent.Added event) {
+        UUID playerUUID = event.getPlayerUuid();
+        String groupName = event.getGroupName();
+
+        System.out.println("Player " + playerUUID + " joined group: " + groupName);
+    }
+}
+```
+
+### Registering the Events
 
 ```java
-public class DatabasePermissionProvider implements PermissionProvider
+public class MyPlugin extends JavaPlugin {
+
+    @Override
+    public void setup() {
+        EventRegistry events = this.getEventRegistry();
+
+        events.registerGlobal(
+            PlayerPermissionChangeEvent.PermissionsAdded.class,
+            PermissionListener::onPermissionsAdded
+        );
+
+        events.registerGlobal(
+            PlayerGroupEvent.Added.class,
+            PermissionListener::onGroupAdded
+        );
+    }
+}
 ```
 
-Then we just implement the required methods using a database implementation.
+---
+
+## Creating a Custom Permission Provider
+
+For advanced use cases, you can create your own permission provider. This is useful for:
+
+- Database-backed permissions (MySQL, MongoDB, etc.)
+- Cross-server permission synchronization
+- Custom features like permission expiry or contexts
+
+### Implementing PermissionProvider
+
+```java
+public class DatabasePermissionProvider implements PermissionProvider {
+
+    @Nonnull
+    @Override
+    public String getName() {
+        return "DatabasePermissionProvider";
+    }
+
+    // User permission methods
+    @Override
+    public void addUserPermissions(@Nonnull UUID uuid, @Nonnull Set<String> permissions) {
+        // Save to your database
+    }
+
+    @Override
+    public void removeUserPermissions(@Nonnull UUID uuid, @Nonnull Set<String> permissions) {
+        // Remove from your database
+    }
+
+    @Override
+    public Set<String> getUserPermissions(@Nonnull UUID uuid) {
+        // Query your database
+        return Set.of();
+    }
+
+    // Group permission methods
+    @Override
+    public void addGroupPermissions(@Nonnull String group, @Nonnull Set<String> permissions) {
+        // Save to your database
+    }
+
+    @Override
+    public void removeGroupPermissions(@Nonnull String group, @Nonnull Set<String> permissions) {
+        // Remove from your database
+    }
+
+    @Override
+    public Set<String> getGroupPermissions(@Nonnull String group) {
+        // Query your database
+        return Set.of();
+    }
+
+    // User-group membership methods
+    @Override
+    public void addUserToGroup(@Nonnull UUID uuid, @Nonnull String group) {
+        // Save to your database
+    }
+
+    @Override
+    public void removeUserFromGroup(@Nonnull UUID uuid, @Nonnull String group) {
+        // Remove from your database
+    }
+
+    @Override
+    public Set<String> getGroupsForUser(@Nonnull UUID uuid) {
+        // Query your database
+        return Set.of("Default");
+    }
+}
+```
 
 <Callout type="warning">
-  Hytale will try to use the first available permissions provider to add/remove gamemode groups (i.e. `Creative`, `Adventure`).
+  Hytale automatically assigns players to game-mode groups (like `Creative` or `Adventure`) using the first available provider.
+
+  If your provider throws an error when the group doesn't exist, the player will be disconnected! Always handle missing groups gracefully.
+</Callout>
+
+### Registering Your Provider
 
-  If your provider throws an error (for instance, if the group does not exist) when the server is preparing the player, the player will be disconnected.
+```java
+public class MyPlugin extends JavaPlugin {
+
+    @Override
+    public void setup() {
+        // Add your provider alongside the default one
+        PermissionsModule.get().addProvider(new DatabasePermissionProvider());
+    }
+}
+```
+
+The `PermissionsModule` aggregates permissions from all registered providers. This means:
+
+- Permission checks query all providers
+- Write operations (add/remove) use the **first** provider
+
+### Replacing the Default Provider
+
+If you want full control, you can remove the default provider:
+
+```java
+public class MyPlugin extends JavaPlugin {
+
+    @Override
+    public void setup() {
+        PermissionsModule perms = PermissionsModule.get();
+
+        // Remove the default provider FIRST
+        perms.removeProvider(perms.getFirstPermissionProvider());
+
+        // Then add your provider
+        perms.addProvider(new DatabasePermissionProvider());
+    }
+}
+```
+
+<Callout type="info">
+  When you remove the default provider, the `/op self` command will stop working since it checks for provider tampering.
 </Callout>
 
-We can then register the provider using the built-in permission module:
+---
+
+## Best Practices
+
+### Permission Naming Conventions
+
+Follow the pattern: `namespace.category.action`
 
 ```java
-PermissionsModule.get().addProvider(new DatabasePermissionProvider());
+// Good - clear hierarchy
+"myplugin.admin.ban"
+"myplugin.user.teleport.home"
+"myplugin.vip.chat.color"
+
+// Bad - unclear structure
+"myplugin_ban"
+"teleport"
+"vipChatColor"
 ```
 
-Please note that the `HytalePermissionsProvider` will still be enabled alongside your provider.
-The `PermissionsModule` will aggregate groups and permissions from all available providers.
+### Use Constants for Permissions
 
-If you want to disable the default `HytalePermissionsProvider`, you can use:
+Define your permissions as constants to avoid typos:
 
 ```java
-// put this **before** you add your provider
-PermissionsModule.get().removeProvider(PermissionsModule.get().getFirstPermissionProvider());
+public final class MyPermissions {
+    public static final String ADMIN_BAN = "myplugin.admin.ban";
+    public static final String ADMIN_KICK = "myplugin.admin.kick";
+    public static final String USER_HOME = "myplugin.user.home";
+    public static final String VIP_FLY = "myplugin.vip.fly";
+}
+
+// Usage
+if (player.hasPermission(MyPermissions.ADMIN_BAN)) {
+    // ...
+}
 ```
+
+### Don't Over-Permission
+
+Only create permissions for actions that genuinely need access control. Not everything needs a permission check.
+
+### Thread Safety
+
+If you create a custom provider, ensure it's thread-safe. Permission checks can occur from multiple threads simultaneously. Use `ReadWriteLock` or `ConcurrentHashMap` for your data structures.
+
+---
+
+## In-Game Commands
+
+Hytale provides built-in commands for managing permissions:
+
+### `/op` Command
+
+| Command               | Description                                                        |
+| --------------------- | ------------------------------------------------------------------ |
+| `/op self`            | Toggle your own OP status (singleplayer or with `--allow-op` flag) |
+| `/op add <player>`    | Add a player to the OP group                                       |
+| `/op remove <player>` | Remove a player from the OP group                                  |
+
+### `/perm` Command
+
+Use `/perm --help` in-game for full usage. Common operations:
+
+| Command                                  | Description                   |
+| ---------------------------------------- | ----------------------------- |
+| `/perm user list <uuid>`                 | List user's permissions       |
+| `/perm user add <uuid> <perm>`           | Add permission to user        |
+| `/perm user remove <uuid> <perm>`        | Remove permission from user   |
+| `/perm user group list <uuid>`           | List user's groups            |
+| `/perm user group add <uuid> <group>`    | Add user to group             |
+| `/perm user group remove <uuid> <group>` | Remove user from group        |
+| `/perm group list <group>`               | List group's permissions      |
+| `/perm group add <group> <perm>`         | Add permission to group       |
+| `/perm group remove <group> <perm>`      | Remove permission from group  |
+| `/perm test <perm>`                      | Test if you have a permission |
+
+---
+
+## Summary
+
+You've learned how to:
+
+- **Check permissions** using `PermissionsModule.hasPermission()`
+- **Manage user permissions** with `addUserPermission()` and `removeUserPermission()`
+- **Work with groups** using `addGroupPermission()`, `addUserToGroup()`, etc.
+- **Use wildcards** like `*` and `myplugin.*` for bulk permissions
+- **Listen to events** for permission changes
+- **Create custom providers** for database-backed permissions
+
+For more advanced permission systems with features like inheritance, expiry, and contexts, we're looking into expanding this guide with advanced permission management techniques in the future.
diff --git a/content/docs/id-ID/guides/plugin/setting-up-env.mdx b/content/docs/id-ID/guides/plugin/setting-up-env.mdx
index d2718098..5be5e9e0 100644
--- a/content/docs/id-ID/guides/plugin/setting-up-env.mdx
+++ b/content/docs/id-ID/guides/plugin/setting-up-env.mdx
@@ -4,6 +4,10 @@ description: Learn how to set up your development environment for modding Hytale
 authors:
   - name: Neil Revin
     link: https://itsneil.dev
+  - name: Marcel-TO
+    url: https://marcel-to.net
+  - name: Ádám Liszkai
+    link: https://adaliszk.dev
 ---
 
 This guide will walk you through setting up a complete development environment for Hytale modding, including all necessary tools and dependencies.
@@ -19,24 +23,73 @@ Before we begin, make sure you have:
 
 ## Required Software
 
-### 1. Java Development Kit (JDK)
+### Integrated Development Environment (IDE)
 
+We recommend IntelliJ IDEA Community Edition for Hytale modding. If you use IntelliJ IDEA, **almost everything is built-in**. You can clone a template, open a new project, and start working right away!
+
+1. Download from [JetBrains website](https://www.jetbrains.com/idea/download/)
+2. Install with default settings
+3. Launch and complete the initial setup wizard
+
+When opening a project, wait for indexing to finish, then start coding.
+Now, IDEA may say "No JDK configured" at the top of the source file you have.
+In that case, you can click Download JDK and choose JetBrains JDK 25.
+
+<Callout type="success">
+  If IDEA opened the project without errors, your environment is ready.
+</Callout>
+
+More details by [JetBrains](https://www.jetbrains.com/help/idea/2026.1/run-for-the-first-time.html)
+help page, where we recommend that you also check the
+[SDK configuration](https://www.jetbrains.com/help/idea/2026.1/sdk.html) guide.
+
+<Callout type="info">
+  We recommened following
+  [TheNullicorn's](https://gist.github.com/TheNullicorn/90a619796c40f20ae1fcf13094c1a57d) guide to ensure
+  you are using the correct `Nonnull` in your projects.
+</Callout>
+
+#### What the IDE Does for You
+
+When opened in IntelliJ IDEA, the project automatically:
+
+- Detects and configures Gradle or Maven
+- Downloads all dependencies
+- Sets up project structure and classpaths
+- Configures run/build tasks
+
+You do **not** need to manually install or configure Maven or Gradle if you stay inside the IDE.
+
+Skip to the [Setting Up Your Workspace](#setting-up-your-workspace).
+
+### Manual Setup: Java Development Kit (JDK)
+
+For any other setup, you will need to install and configure your system to have and load Java.
 Hytale modding requires Java 25 or later. We recommend using OpenJDK.
 
-#### Windows
+#### Windows via Installer
 
 1. Download OpenJDK 25 from [Adoptium](https://adoptium.net/)
 2. Run the installer with default settings
+   - Optionally enable feature `Set or Override JAVA_HOME variable` to resolve version related build issues with your project.
 3. Verify installation by opening Command Prompt and running:
 
+#### Windows via Scoop
+
+1. Install Scoop via PowerShell using [scoop.sh](https://scoop.sh/)
+2. Install OpenJDK 25:
+
 ```bash
-java -version
+scoop bucket add java
+scoop install java/openjdk25
 ```
 
 #### macOS
 
+1. Install Brew via Terminal using [brew.sh](https://brew.sh)
+2. Install JDK via Homebrew:
+
 ```bash
-# Using Homebrew
 brew install openjdk@25
 ```
 
@@ -51,22 +104,41 @@ brew install openjdk@25
 
 #### Linux (Ubuntu/Debian)
 
+1. Install JDK via the built-in package repository:
+
 ```bash
 sudo apt update
 sudo apt install openjdk-25-jdk
 ```
 
-### 2. Integrated Development Environment (IDE)
+### Verify installation:
 
-We recommend IntelliJ IDEA Community Edition for Hytale modding.
+Run the following command to see what version of Java you have:
 
-1. Download from [JetBrains website](https://www.jetbrains.com/idea/download/)
-2. Install with default settings
-3. Launch and complete the initial setup wizard
+```bash
+java -version
+```
+
+### Java Build Tool (Optional)
+
+We recommend using a Gradle Wrapper for managing dependencies and building your Hytale plugins. It provides benefits by eliminating the need for a system-wide Gradle installation and ensuring consistent Gradle versions across different environments. (Alternatively you can use Maven, but this guide focuses on Gradle since it is the default for our plugin template.)
+
+The plugin template in the following sections includes a Gradle Wrapper, so you can skip this step if you plan to use the template.
+
+#### Choosing Gradle (if not using the template)
+
+If you prefer to install Gradle manually, follow these steps:
 
-### 3) Java Build Tool
+1. Visit the official website: https://gradle.org/releases/
+2. Download the newest gradle binary: `gradle-9.3.1-bin.zip` (Binary zip archive)
+3. Unzip it
+4. Add the `gradle-9.3.1/bin/` folder to your PATH
+
+You can now try the command `gradle -version` to verify Gradle is installed correctly. Make sure to do this in a fresh new terminal instead of one you had opened from before!
+
+#### Choosing Maven (if not using the template)
 
-We recommend using Apache Maven for managing dependencies and building your Hytale plugins. (Alternatively you can use Gradle, but this guide focuses on Maven.)
+If you prefer to use Maven instead of Gradle, follow these steps to install Maven:
 
 1. Visit the official website: https://maven.apache.org/download.cgi
 2. Download this file: `apache-maven-3.9.12-bin.zip` (Binary zip archive)
@@ -89,22 +161,61 @@ cd MyFirstMod
 
 If you don't have Git installed, you can download the ZIP file from the repository page and extract it to a folder named `MyFirstMod`.
 
-### 2. Open Plugin in your IDEA
+### 2. Open Plugin in your IDE
 
-1. Open IntelliJ IDEA
+1. Open Your IDE (e.g., IntelliJ IDEA)
 2. Click "Open" and navigate to your `MyFirstMod` directory
-3. IntelliJ will automatically detect it as a Maven project
+3. Most IDEs like IntelliJ will automatically detect it as a Gradle project
 4. Wait for the project to index and dependencies to download
 
-<Callout type="info">
-  We recommened following [this](https://gist.github.com/TheNullicorn/90a619796c40f20ae1fcf13094c1a57d) guide to ensure you are using the correct `Nonnull` in your projects.
-</Callout>
+## Alternate Approach: Hytale Dependency
+
+If you prefer to set up your project from scratch without using the template and importing the hytale dependencies manually, ensure your build configuration includes the Hytale repositories and dependencies:
+
+For Gradle, add the following to your `build.gradle.kts`:
+
+```kotlin
+repositories {
+    mavenCentral()
+    maven {
+        name = "hytale"
+        url = uri("https://maven.hytale.com/release") // Or "hytale-pre-release" for pre-release versions
+    }
+}
+dependencies {
+    // + here means the latest version, but you can hard-wire any known version!
+    implementation("com.hypixel.hytale:Server:+")
+}
+```
+
+For Maven, add the following to your `pom.xml`:
+
+```xml
+<project>
+    <repositories>
+        <repository>
+            <id>hytale-release</id> <!-- Or "hytale-pre-release" for pre-release versions -->
+            <url>https://maven.hytale.com/release</url> <!-- Or "https://maven.hytale.com/pre-release" -->
+        </repository>
+    </repositories>
+
+    <dependencies>
+        <dependency>
+            <groupId>com.hypixel.hytale</groupId>
+            <artifactId>Server</artifactId>
+            <!-- Replace with latest version, Hytale provides jars for the last five releases -->
+            <version>LATEST_VERSION_HERE</version>
+            <scope>provided</scope>
+        </dependency>
+    </dependencies>
+</project>
+```
 
 ## Next Steps
 
 Now that you have your development environment set up with the plugin template:
 
-1. **Customize the template** - Edit the `pom.xml` and `manifest.json` file to change your mod's name and details
+1. **Customize the template** - Edit the `settings.gradle.kts`, `build.gradle.kts` and `manifest.json` file to change your mod's name and details
 2. **Explore the code structure** - Familiarize yourself with the template's organization
 3. **Start modding** - Begin writing your first Hytale plugin!
 
diff --git a/content/docs/id-ID/guides/plugin/spawning-entities.mdx b/content/docs/id-ID/guides/plugin/spawning-entities.mdx
index e12c0aea..15be2fb3 100644
--- a/content/docs/id-ID/guides/plugin/spawning-entities.mdx
+++ b/content/docs/id-ID/guides/plugin/spawning-entities.mdx
@@ -36,7 +36,7 @@ Store<EntityStore> store = world.getEntityStore().getStore();
 
 ## Creating Entities
 
-Once you have the `EntityStore` instance, you can start to create a entity and give it components. Entities are just instances of `Holder<EntityStore>` with several components attached to them.
+Once you have the `EntityStore` instance, you can start to create an entity and give it components. Entities are just instances of `Holder<EntityStore>` with several components attached to them.
 
 <Callout type="warning">
   To interact with the `World` instance, some methods require you to run the code inside the world's execution context.
@@ -118,3 +118,48 @@ Finally, we can add the entity to the world by calling the `addEntity` method on
 ```java
 store.addEntity(holder, AddReason.SPAWN);
 ```
+
+## Making the entity persist
+
+Hytale automatically saves all entities, but the `NetworkId` component (required for players to be able to see the entity) needs to be manually added every time the entity is loaded.
+
+### Using a system
+
+If you have a component that is unique to your entities, this can be done by creating and registering a custom system as follows:
+
+```java
+public class AddNetworkIdToMyEntitySystem extends HolderSystem<EntityStore> {
+    private final ComponentType<EntityStore, MyEntityComponent> myEntityComponentType = MyEntityComponent.getComponentType();
+    private final ComponentType<EntityStore, NetworkId> networkIdComponentType = NetworkId.getComponentType();
+    private final Query<EntityStore> query = Query.and(this.myEntityComponentType, Query.not(this.networkIdComponentType));
+
+    @Override
+    public void onEntityAdd(@NotNull Holder<EntityStore> holder, @NotNull AddReason reason, @NotNull Store<EntityStore> store) {
+        if (!holder.getArchetype().contains(NetworkId.getComponentType())) {
+            holder.addComponent(NetworkId.getComponentType(), new NetworkId(store.getExternalData().takeNextNetworkId()));
+        }
+    }
+
+    @Override
+    public void onEntityRemoved(@NotNull Holder<EntityStore> holder, @NotNull RemoveReason reason, @NotNull Store<EntityStore> store) {}
+
+    @Override
+    public @Nullable Query<EntityStore> getQuery() {
+        return query;
+    }
+}
+```
+
+In your plugin's `setup()` function
+
+```java
+this.getEntityStoreRegistry().registerSystem(new AddNetworkIdToMyEntitySystem())
+```
+
+### Using PropComponent
+
+Alternatively you can add `PropComponent` to your entity. Hytale adds `PropComponent` to entities spawned with the Entity Tool, and such entities automatically get `NetworkId` and `PrefabCopyableComponent` (which makes the entity work with prefabs).
+
+<Callout type="warning">
+  There is no guarantee, that Hytale will not add some other behavior to this component in the future, which may break your entity, so be careful if you decide to rely on it.
+</Callout>
diff --git a/content/docs/id-ID/guides/plugin/store-persistent-data.mdx b/content/docs/id-ID/guides/plugin/store-persistent-data.mdx
new file mode 100644
index 00000000..1071dff3
--- /dev/null
+++ b/content/docs/id-ID/guides/plugin/store-persistent-data.mdx
@@ -0,0 +1,171 @@
+---
+title: Storing Persistent Data on the Player
+description: Learn how to save and load persistent data using Components
+authors:
+  - name: Neil Revin
+    url: https://itsneil.dev/
+  - name: ArcticDev
+    url: https://github.com/ArcticRaven
+  - name: oskarscot
+    url: https://oskar.scot
+  - name: JammingEng
+    url: https://github.com/JammingEnd
+---
+
+Here is how to store persistent data using a custom component on a Player.
+
+## Build your Component Class
+
+Creating a custom component class leverages the Component system made with the ECS architecture in mind. For more information on Components, check out the [ECS Guide](../ecs/hytale-ecs-theory#components).
+
+Start by creating your custom component class. This will be extremely similar to how regular components are created, however we'll setup a custom Codec so the server can translate this data to BSON, or the server's internal json encoder.
+
+<Callout type="info">
+  Each variable you want to store in your component must have its own Codec field defined in the BuilderCodec.
+  For more information on how to create custom Codecs, check out the [ECS Codec Guide](../ecs/hytale-ecs-theory#codec).
+</Callout>
+
+```java
+public class YourPlayerData implements Component<EntityStore> {
+
+    // define some vars!
+    private int someInteger;
+    private String someString;
+    private Map<String, String> someMap;
+
+    public static final BuilderCodec<YourPlayerData> CODEC =
+            BuilderCodec.builder(YourPlayerData.class, YourPlayerData::new)
+            .append(new KeyedCodec<>("SomeInteger", Codec.INTEGER),
+                    (data, value) -> data.someInteger = value, // setter
+                    data -> data.someInteger) // getter
+            .addValidator(Validators.nonNull())
+            .add()
+            .append(new KeyedCodec<>("SomeString", Codec.STRING),
+                    (data, value) -> data.someString = value, // setter
+                    data -> data.someString) // getter
+            .add()
+            .append(new KeyedCodec<>("SomeMap",
+                            new MapCodec<>(Codec.STRING, HashMap::new, false)),
+                    (data, value) -> data.someMap = value, // setter
+                    data -> data.someMap) // getter
+            .add()
+            .build();
+
+
+
+    // Getters and Setters are for the purpose of this example omitted.
+
+    // constructor
+    public YourPlayerData() {
+        this.someInteger = 0;
+        this.someString = "";
+        this.someMap = new HashMap<>();
+    }
+
+    // copy constructor for cloning
+    public YourPlayerData(YourPlayerData clone) {
+        this.someInteger = clone.someInteger;
+        this.someString = clone.someString;
+        this.someMap = clone.someMap;
+    }
+
+    @Nonnull
+    @Override
+    public Component<EntityStore> clone() {
+        return new YourPlayerData(this);
+    }
+}
+```
+
+## Register your Component
+
+Inside your main class's `setup()` method, register your new Component.
+
+```java
+public class YourPlugin extends JavaPlugin {
+
+    private ComponentType<EntityStore, YourPlayerData> yourPlayerDataComponent;
+
+    public YourPlugin(@Nonnull JavaPluginInit init) {
+        super(init);
+    }
+
+    @Override
+    protected void setup(){
+        this.yourPlayerDataComponent = this.getEntityStoreRegistry().registerComponent(
+            YourPlayerData.class,
+            "YourPlayerDataComponent",
+            YourPlayerData.CODEC
+        );
+    }
+
+    public ComponentType<EntityStore, YourPlayerData> getYourPlayerDataComponent() {
+        return this.yourPlayerDataComponent;
+    }
+}
+```
+
+## Using your Component
+
+To use your newly created component, you can add the Component to a player using the `addComponent` method, although this only adds it temporarily, meaning when the player/entity leaves the world, the component is removed. You can use `putComponent` to ensure the component persists between sessions.
+
+```java
+// You will need the Ref and Store to apply components
+private void someEntryMethod(@Nonnull Ref<EntityStore> ref, @Nonnull Store<EntityStore> store)
+{
+       // Any entity will work, for now we will use the player
+      Player player = (Player) store.getComponent(ref, Player.getComponentType());
+
+      // since we're using putComponent, it could be useful to check if it already exists on the player in case we want to update it
+     if(store.getComponent(ref, YourPlugin.instance().getYourPlayerDataComponent()) != null)
+     {
+          // here we implement logic that updates the component
+         var comp = store.getComponent(ref, YourPlugin.instance().getYourPlayerDataComponent())
+         // declare public fields or methods in the component class
+         comp.SomeString = "An Updated Field";
+     } else {
+          // Here we put the component
+          var myCustomComp = new CustomComponent();
+          // declare public fields or methods in the component class
+          myCustomComp.SomeString = "Edited String";
+
+          // putComponent allows you to insert declared objects
+          store.putComponent(ref, YourPlugin.instance().getYourPlayerDataComponent(), myCustomComp);
+     }
+}
+```
+
+## Using your Data
+
+Your component will be stored within the `Store<EntityStore>` when added to the player. In the provided example,
+we'll fetch this data off the player using the `ensureAndGetComponent()` method, which will add the component to
+the player if it does not exist with the default values.
+
+```java
+public class IncompleteCustomCommand extends AbstractPlayerCommand {
+
+    public IncompleteCustomCommand() {
+        super("nope", "don't use this command");
+    }
+
+    @Override
+    protected void execute(
+        @NonNullDecl CommandContext commandContext,
+        @NonNullDecl Store<EntityStore> store,
+        @NonNullDecl Ref<EntityStore> ref,
+        @NonNullDecl PlayerRef playerRef,
+        @NonNullDecl World world
+    ) {
+        YourPlayerData customData = store.ensureAndGetComponent(ref, YourPlugin.instance().getYourPlayerDataComponent());
+        // ensureAndGetComponent adds the component to the ref, with the default values defined inside your component.
+ 		// use your data
+    }
+}
+```
+
+And that's it! Your data will now be saved and loaded automatically with the player.
+
+Using custom components to store persistent data on players is a powerful way to maintain state across sessions.
+By following the steps outlined above, you can easily create, register, and utilize your own data structures within the Hytale ECS framework.
+This approach ensures that your data is seamlessly integrated with the game's existing systems.
+For more information about Hytale's Entity Component System visit the [Hytale ECS Theory](https://hytalemodding.dev/en/docs/guides/ecs/hytale-ecs-theory) guide.
diff --git a/content/docs/id-ID/guides/plugin/teleporting-players.mdx b/content/docs/id-ID/guides/plugin/teleporting-players.mdx
index 57cee77f..32ce0435 100644
--- a/content/docs/id-ID/guides/plugin/teleporting-players.mdx
+++ b/content/docs/id-ID/guides/plugin/teleporting-players.mdx
@@ -1,26 +1,32 @@
 ---
 title: Teleporting the player
 description: Learn how to teleport the player.
+authors:
+  - name: oskarscot
+    url: https://oskar.scot
 ---
 
-To teleport players in Hytale, you will need to get a `World` object so we can safely run the teleport on the world thread. The world thread manages all entity updates, so modifying entities off-thread can crash the server or cause inconsistent state.
-Next, we get the entity store and make a `Teleport` object.
-We add a `Teleport` component to the player’s entity reference in the entity store. This triggers the teleportation logic for that player.
+Teleporting players in Hytale works by simply attaching a `Teleport` component to a player with the desired world and transform.
+You can only trigger teleports from a world where the player is currently present.
+Teleport itself is a component but it also provides factory methods to configure the Teleport. Just as with any entity component, an EntityStore and a Ref to the EntityStore is required
+
+We can create a simple teleport utility like this:
 
 ```java
-public static void teleportPlayer(Player player, int x, int y, int z) {
-        World world = player.getWorld();
-        if (world == null) return;
-        world.execute(() -> {
-            if (player.getReference() == null) return;
-            Store<EntityStore> store = player.getReference().getStore();
-            Teleport teleport = Teleport.createForPlayer(world,
-                new Vector3d(x ,y, z), // Target position
-                new Vector3f(0, 0, 0)  // Target rotation (pitch, yaw, roll)
-            );
+public static void teleportPlayer(Ref<EntityStore> ref, Store<EntityStore> store, World targetWorld, double x, double y, double z) {                                                                                       
+    Transform transform = new Transform(x, y, z);                                                                                                                           
+    Teleport teleport = Teleport.createForPlayer(targetWorld, transform);                                                                                                   
+    store.addComponent(ref, Teleport.getComponentType(), teleport);                                                                                                         
+}  
+```
 
-            store.addComponent(player.getReference(), Teleport.getComponentType(), teleport);
-        });
+A `Transform` is a representation of a position Vector3d and rotation Vector3f which works in the following way:
 
-}
+```java
+Transform transform = new Transform(
+    new Vector3d(x, y, z),      // Position
+    new Rotation(yaw, pitch, 0) // Rotation, last value seems to always be 0
+);
+Teleport teleport = Teleport.createForPlayer(targetWorld, transform);
+store.addComponent(ref, Teleport.getComponentType(), teleport);
 ```
diff --git a/content/docs/id-ID/guides/plugin/tracking-mod-analytics-with-hstats.mdx b/content/docs/id-ID/guides/plugin/tracking-mod-analytics-with-hstats.mdx
new file mode 100644
index 00000000..45c022e0
--- /dev/null
+++ b/content/docs/id-ID/guides/plugin/tracking-mod-analytics-with-hstats.mdx
@@ -0,0 +1,65 @@
+---
+title: Tracking Mod Analytics with HStats
+description: Learn how you can track Analytics for your Hytale Mod for Free using hstats.dev
+authors:
+  - name: Al3x
+    url: https://hstats.dev
+---
+
+In this guide, you will learn how to integrate HStats into your Plugin/Mod which will allow you to track how many Servers are using it along with other stats.
+
+<Callout type="info">
+  HStats is a third-party tool and is not affiliated with HytaleModding or Hypixel Studios
+</Callout>
+
+# Step 1: Register your Mod to HStats
+
+Before you touch any code, you will need to add your mod to the HStats website which will give you a UUID for your mod.
+
+- Create or Login to an Account on https://hstats.dev
+- Navigate to the dashboard page (https://hstats.dev/dashboard)
+- On the left, type in your mod's name and click "Add Mod"
+- Keep note of the UUID generated for later.
+
+# Step 2: Add the HStats Class to Your Project
+
+To keep things simple, HStats uses a single Java class file that handles everything for you.
+
+- Download / Copy the File from the GitHub page (https://github.com/hstats-dev/HStatsExamplePlugin/blob/main/src/main/java/com/al3x/HStats.java)
+- Paste into your Project. You should now have a HStats.java file somewhere in your projects directory.
+- Update the package name from com.al3x to whatever fits your project.
+
+# Step 3: Initialize HStats in your code
+
+You only need to add one line of code to your mod's setup method in your main class to start tracking.
+
+`new HStats("YOUR-MOD-UUID", "1.0.0");`
+
+Replace `YOUR-MOD-UUID` with the Mod UUID we made note of earlier and change the `1.0.0` version to whatever version your mod is currently on.
+
+Your setup method should now look something like this:
+
+```java
+@Override
+protected void setup() {
+  super.setup();
+  new HStats("c34a2b2a-afd8-4d6a-821e-7a63e12c5ea6", "1.0.0");
+}
+```
+
+# Extras
+
+Your done! Your mod should now be listed under the Mods page (https://hstats.dev/mods) as well as under your dashboard.
+
+Servers using your mod should now post updates about every minute to HStats which you can view in the Dashboard.
+
+### Embeds
+
+HStats allows you to generate an Embed Card that you can place on your CurseForge or GitHub page. This is useful for server owners to be able to see how many other servers are using your mod.
+
+- In your dashboard, scroll down to the Embed Card section.
+- Customize the appearance (Light/Dark mode, layout, etc).
+- Copy the generated URL to display your "Active Servers" and "Players Online" live on your mod's description page
+
+Heres an example of what they look like:
+![HStats Example](https://api.hstats.dev/api/embed/d52fa672-6966-47b2-b501-1a11bddebac3/card.svg?theme=light\&layout=compact\&size=md\&show_id=true\&dark=false)
diff --git a/content/docs/id-ID/guides/plugin/world-gen.mdx b/content/docs/id-ID/guides/plugin/world-gen.mdx
index 4c23b0c9..7b193ffd 100644
--- a/content/docs/id-ID/guides/plugin/world-gen.mdx
+++ b/content/docs/id-ID/guides/plugin/world-gen.mdx
@@ -100,7 +100,7 @@ Biome biome = biomeGen.generateBiomeAt(zoneResult, seed, x, z);
 
 ### Zone & Cave Integration
 
-Each zone defines it's own cave patterns:
+Each zone defines its own cave patterns:
 
 ```java
 Zone zone = /* ... */;
diff --git a/content/docs/id-ID/guides/prefabs.mdx b/content/docs/id-ID/guides/prefabs.mdx
index 08404b30..b1a55109 100644
--- a/content/docs/id-ID/guides/prefabs.mdx
+++ b/content/docs/id-ID/guides/prefabs.mdx
@@ -14,7 +14,7 @@ Prefabs are Hytale's way of creating reusable structures.
 There are a few fundamental concepts to understand about prefabs:
 
 - Users interact with prefabs via a prefab editing world.
-- Prefabs the physical structures in the game world, and are saved as JSON files.
+- Prefabs are the physical structures in the game world, and are saved as JSON files.
 
 ## How to Create a Prefab
 
diff --git a/content/docs/id-ID/official-documentation/custom-ui/common-styling.mdx b/content/docs/id-ID/official-documentation/custom-ui/common-styling.mdx
new file mode 100644
index 00000000..c36e3e3a
--- /dev/null
+++ b/content/docs/id-ID/official-documentation/custom-ui/common-styling.mdx
@@ -0,0 +1,50 @@
+---
+title: Common Styling
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# Common Styling
+
+## Common UI Styling Library
+
+This document describes the shared UI components and styles defined in `Common.ui`.
+
+---
+
+### Styles
+
+We are providing some styles that can be re-used in any custom UI that, provide a cohesive UI experience with the core game UI. These styles are available in the `Common.ui` file.
+
+You can find a list of all the styles defined with live examples by running the `/ui-gallery` command ingame.
+
+<Callout type="warning">
+  This command is not available yet, but will be in a future patch.
+</Callout>
+
+![Gallery](/assets/official-documentation/ui/gallery.png)
+
+### Importing
+
+To use these styles in your UI file:
+
+```
+$Common = "Common.ui";
+
+// Then reference styles and components:
+$Common.@TextButton { @Text = "My Button"; }
+$Common.@Container { ... }
+```
+
+<Callout type="info">
+  The `Common.ui` file is at `Common/UI/Custom/Common.ui` within the Hytale pack. If your custom ui document is in a subfolder of `Common/UI/Custom/`, reference it via relative path traversal:
+
+  ```
+  $Common = "../Common.ui";
+  ```
+
+  You can find more info about paths [here](markup#path).
+</Callout>
diff --git a/content/docs/id-ID/official-documentation/custom-ui/index.mdx b/content/docs/id-ID/official-documentation/custom-ui/index.mdx
new file mode 100644
index 00000000..f94c4e88
--- /dev/null
+++ b/content/docs/id-ID/official-documentation/custom-ui/index.mdx
@@ -0,0 +1,125 @@
+---
+title: Custom UI
+icon: LayoutDashboard
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# Custom UI
+
+## What is Custom UI?
+
+Custom UI is Hytale's framework for creating **custom user interfaces** controlled by the game server. Unlike the built-in Client UI (which is part of the game client and cannot be modified), Server UI allows you to create interactive screens and HUD overlays through Java plugins and asset packs.
+
+As a modder, Custom UI gives you the power to:
+
+- **Create custom interactive pages** - Shop interfaces, quest dialogs, server settings menus, admin panels
+- **Add custom HUD overlays** - Quest trackers, status displays, custom health bars, server information
+- **Design with markup** - Use `.ui` files to define reusable UI templates
+- **Handle user interactions** - Respond to button clicks, form submissions, and other events
+- **Localize your UI** - Support multiple languages using the game's translation system
+
+## How Custom UI Fits Into Hytale's UI
+
+Hytale's user interface is divided into two main categories:
+
+### Client UI (Not Moddable)
+
+Built-in interfaces controlled by the C# game client:
+
+- Main menu and settings
+- Character creation
+- Built-in HUD (health, hotbar, chat)
+- Inventory and crafting screens
+- Development tools
+
+**You cannot modify these** - they are part of the core game client.
+
+### In-Game UI (Moddable via Server)
+
+Server-controlled interfaces that you can create and customize:
+
+#### Custom Pages
+
+Full-screen interactive overlays that appear during gameplay:
+
+- Can be dismissed by the player (ESC key)
+- Capture all input (keyboard and mouse)
+- Support loading states while waiting for server responses
+- Perfect for: shops, dialogs, menus, configuration screens
+
+#### Custom HUDs
+
+Persistent overlay elements drawn on top of the game world:
+
+- Display-only (no user interaction)
+- Always visible during gameplay
+- Lightweight and non-intrusive
+- Perfect for: quest objectives, status indicators, server info panels
+
+## Architecture Overview
+
+Server UI uses a **command-based architecture**:
+
+```
+┌─────────────────────┐         ┌──────────────────────┐
+│   Java Server       │         │    C# Client         │
+│   (Your Plugin)     │         │    (Game)            │
+├─────────────────────┤         ├──────────────────────┤
+│                     │         │                      │
+│ InteractiveCustomUI │         │   CustomPage or      │
+│ Page                │         │   CustomHud          │
+│   ↓ build()         ├────────→│     ↓ Apply          │
+│ UICommandBuilder    │         │   Element Tree       │
+│   - append()        │         │     ↓ Layout         │
+│   - set()           │         │   Rendered UI        │
+│   - clear()         │         │                      │
+│                     │         │                      │
+│ ↓ handleDataEvent() │← Events │   User Interaction   │
+│   Process input     │         │   (click, type, etc) │
+│   sendUpdate()      │         │                      │
+└─────────────────────┘         └──────────────────────┘
+```
+
+**The flow:**
+
+1. Your Java code builds UI using `UICommandBuilder`
+2. Commands are sent to the client as data
+3. Client parses `.ui` markup files and creates visual elements
+4. User interacts with the UI
+5. Events are sent back to your Java code
+6. You process events and send updates back
+
+## Key Principles
+
+### Declarative, Not Imperative
+
+You don't create UI objects directly. Instead, you send **commands** that describe what you want:
+
+- "Append this button template to that container"
+- "Set this label's text to 'Hello World'"
+- "Clear all children from this list"
+
+### Asset-Driven
+
+UI structure is defined in `.ui` markup files (assets), not hardcoded in Java. This enables:
+
+- Designers to modify layouts without touching code
+- Reusable UI components
+- Consistent visual language
+
+### Event-Driven
+
+User interactions trigger events that flow back to your server code. You register event bindings and handle them in `handleDataEvent()`.
+
+### Selector-Based
+
+You target specific UI elements using **selectors:**
+
+- `#MyButton` - Element with ID "MyButton"
+- `#List[0]` - First child of element "List"
+- `#List[0] #Title` - Element with ID "Title" in the first child of element "List"
+- `#Label.TextColor` - The TextColor property of element "Label"
diff --git a/content/docs/id-ID/official-documentation/custom-ui/layout.mdx b/content/docs/id-ID/official-documentation/custom-ui/layout.mdx
new file mode 100644
index 00000000..0a24ca09
--- /dev/null
+++ b/content/docs/id-ID/official-documentation/custom-ui/layout.mdx
@@ -0,0 +1,492 @@
+---
+title: Layout
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# Layout
+
+The layout system determines how UI elements are positioned and sized on screen. Understanding layout is crucial for creating well-structured, responsive interfaces.
+
+## Layout Fundamentals
+
+Every UI element has:
+
+- **Container Rectangle** - The space allocated by the parent
+- **Anchor** - How the element positions/sizes itself within the container
+- **Padding** - Inner spacing that affects child layout
+- **LayoutMode** - How the element arranges its children (if it's a container)
+
+```
+┌─────────────────────────────────────┐
+│  Container Rectangle (from parent)  │
+│  ┌───────────────────────────────┐  │
+│  │  Anchored Rectangle           │  │
+│  │  ┌─────────────────────────┐  │  │
+│  │  │ Padding                 │  │  │
+│  │  │  ┌───────────────────┐  │  │  │
+│  │  │  │  Content Area     │  │  │  │
+│  │  │  └───────────────────┘  │  │  │
+│  │  └─────────────────────────┘  │  │
+│  └───────────────────────────────┘  │
+└─────────────────────────────────────┘
+```
+
+## Anchor
+
+`Anchor` controls how an element positions and sizes itself within its container rectangle.
+
+### Fixed Size
+
+```
+Button {
+    Anchor: (Width: 200, Height: 40);
+}
+```
+
+Creates a 200×40 pixel button.
+
+### Positioning
+
+```
+Label {
+    Anchor: (Top: 10, Left: 20, Width: 100, Height: 30);
+}
+```
+
+- **Top**: 10 pixels from container's top edge
+- **Left**: 20 pixels from container's left edge
+- **Width**: 100 pixels wide
+- **Height**: 30 pixels tall
+
+### Anchoring to Edges
+
+```
+Button {
+    Anchor: (Bottom: 10, Right: 10, Width: 100, Height: 30);
+}
+```
+
+Anchors the button to the bottom-right corner, 10 pixels from each edge.
+
+### Stretching
+
+```
+Group {
+    Anchor: (Top: 0, Bottom: 0, Left: 0, Right: 0);
+}
+```
+
+Stretches to fill the entire container (all edges at 0 pixels).
+
+**Shorthand:**
+
+```
+Group {
+    Anchor: (Full: 0);
+}
+```
+
+### Mixed Anchoring
+
+```
+Panel {
+    Anchor: (Top: 10, Bottom: 10, Left: 20, Width: 300);
+}
+```
+
+- Fixed width of 300 pixels
+- Stretches vertically between top and bottom edges
+- 10 pixels from top and bottom
+- 20 pixels from left
+
+## Padding
+
+`Padding` creates inner spacing, affecting where children are positioned.
+
+### Uniform Padding
+
+```
+Group {
+    Padding: (Full: 20);
+}
+```
+
+20 pixels of padding on all sides.
+
+### Directional Padding
+
+```
+Group {
+    Padding: (Top: 10, Bottom: 20, Left: 15, Right: 15);
+}
+```
+
+Different padding per edge.
+
+### Shorthand
+
+```
+// Horizontal and vertical
+Group {
+    Padding: (Horizontal: 20, Vertical: 10);
+}
+
+// Equivalent to:
+// Top: 10, Bottom: 10, Left: 20, Right: 20
+```
+
+### Effect on Children
+
+```
+Group {
+    Anchor: (Width: 200, Height: 100);
+    Padding: (Full: 10);
+
+    Label {
+        Anchor: (Full: 0);
+    }
+}
+```
+
+The label fills the group, but there's a 10-pixel gap on all sides due to padding.
+
+```
+┌──────────────────────┐
+│ Group (200×100)      │
+│  ┌────────────────┐  │
+│  │ Label          │  │ ← 10px padding all around
+│  │                │  │
+│  └────────────────┘  │
+└──────────────────────┘
+```
+
+## LayoutMode
+
+`LayoutMode` determines how a container arranges its children.
+
+### Top (Vertical Stack)
+
+```
+Group {
+    LayoutMode: Top;
+
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+}
+```
+
+Children stack vertically from top to bottom:
+
+```
+┌──────────┐
+│ Button 1 │
+├──────────┤
+│ Button 2 │
+├──────────┤
+│ Button 3 │
+└──────────┘
+
+
+```
+
+Each child's `Anchor.Bottom` adds spacing between elements:
+
+```
+Button { Anchor: (Height: 30, Bottom: 10); }  // 10px gap after this button
+```
+
+### Bottom (Vertical Stack)
+
+```
+Group {
+    LayoutMode: Bottom;
+
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+}
+```
+
+Children stack vertically from top to bottom but aligned to the bottom edge of the parent:
+
+```
+
+
+
+┌──────────┐
+│ Button 1 │
+├──────────┤
+│ Button 2 │
+├──────────┤
+│ Button 3 │
+└──────────┘
+```
+
+### Left (Horizontal Stack)
+
+```
+Group {
+    LayoutMode: Left;
+
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+}
+```
+
+Children arrange horizontally from left to right:
+
+```
+┌────────┬────────┬────────┐
+│ Button │ Button │ Button │
+│   1    │   2    │   3    │
+└────────┴────────┴────────┘
+```
+
+Use `Anchor.Right` for spacing between elements.
+
+### Right (Horizontal Stack)
+
+```
+Group {
+    LayoutMode: Right;
+
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+}
+```
+
+Children arrange horizontally from left to right but aligned to the right side of the parent:
+
+```
+                                                                 ┌────────┬────────┬────────┐
+                                                                 │ Button │ Button │ Button │
+                                                                 │   1    │   2    │   3    │
+                                                                 └────────┴────────┴────────┘
+```
+
+### Center
+
+```
+Group {
+    LayoutMode: Center;
+
+    Group #Dialog {
+        Anchor: (Width: 400, Height: 300);
+    }
+}
+```
+
+Centers the children horizontally.
+
+### Middle
+
+```
+Group {
+    LayoutMode: Middle;
+
+    Group #Dialog {
+        Anchor: (Width: 400, Height: 300);
+    }
+}
+```
+
+Centers the children vertically.
+
+### CenterMiddle (Horizontal Stack, Fully Centered)
+
+```
+Group {
+    LayoutMode: CenterMiddle;
+
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+}
+```
+
+Children stack horizontally from left to right, centered both horizontally and vertically within the parent:
+
+```
+┌────────────────────────────────────────────┐
+│                                            │
+│                                            │
+│         ┌──────┐ ┌──────┐ ┌──────┐         │
+│         │  B1  │ │  B2  │ │  B3  │         │
+│         └──────┘ └──────┘ └──────┘         │
+│                                            │
+│                                            │
+└────────────────────────────────────────────┘
+```
+
+---
+
+### MiddleCenter (Vertical Stack, Fully Centered)
+
+```
+Group {
+    LayoutMode: MiddleCenter;
+
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+}
+```
+
+Children stack vertically from top to bottom, centered both horizontally and vertically within the parent:
+
+```
+┌────────────────────────────────────────────┐
+│                                            │
+│              ┌──────────┐                  │
+│              │ Button 1 │                  │
+│              ├──────────┤                  │
+│              │ Button 2 │                  │
+│              ├──────────┤                  │
+│              │ Button 3 │                  │
+│              └──────────┘                  │
+│                                            │
+└────────────────────────────────────────────┘
+```
+
+---
+
+### Full
+
+```
+Group {
+    LayoutMode: Full;
+
+    Label {
+        Anchor: (Top: 20, Left: 20, Width: 100, Height: 30);
+    }
+}
+```
+
+Children use absolute positioning via their `Anchor` properties.
+
+### TopScrolling
+
+```
+Group {
+    LayoutMode: TopScrolling;
+    ScrollbarStyle: $Common.@DefaultScrollbar;
+
+    // ... many children
+}
+```
+
+Like `Top`, but adds a scrollbar if content exceeds container height.
+
+Or use `BottomScrolling` for bottom-aligned content.
+
+### LeftScrolling
+
+```
+Group {
+    LayoutMode: LeftScrolling;
+    ScrollbarStyle: $Common.@DefaultScrollbar;
+
+    // ... many children
+}
+```
+
+Like `Left`, but adds a scrollbar for horizontal scrolling.
+
+Or use `RightScrolling` for right-aligned content.
+
+### LeftCenterWrap (Wrapping Horizontal Stack, Horizontally Centered)
+
+```
+Group {
+    LayoutMode: LeftCenterWrap;
+
+    Button { Anchor: (Width: 80, Height: 30); }
+    Button { Anchor: (Width: 80, Height: 30); }
+    Button { Anchor: (Width: 80, Height: 30); }
+    Button { Anchor: (Width: 80, Height: 30); }
+    Button { Anchor: (Width: 80, Height: 30); }
+}
+```
+
+Children flow left to right. When there's no more horizontal space, they wrap to the next row. Each row is horizontally centered within the parent:
+
+```
+┌────────────────────────────────────────────┐
+│                                            │
+│       ┌──────┐ ┌──────┐ ┌──────┐           │
+│       │  B1  │ │  B2  │ │  B3  │           │
+│       └──────┘ └──────┘ └──────┘           │
+│            ┌──────┐ ┌──────┐               │
+│            │  B4  │ │  B5  │               │
+│            └──────┘ └──────┘               │
+│                                            │
+└────────────────────────────────────────────┘
+```
+
+## FlexWeight
+
+`FlexWeight` distributes remaining space among children.
+
+```
+Group {
+    LayoutMode: Left;
+    Anchor: (Width: 400);
+
+    Button {
+        Anchor: (Width: 100);
+    }
+
+    Group {
+        FlexWeight: 1;  // Takes all remaining space
+    }
+
+    Button {
+        Anchor: (Width: 100);
+    }
+}
+```
+
+Result:
+
+- First button: 100px
+- Middle group: 200px (400 - 100 - 100 = 200)
+- Last button: 100px
+
+### Multiple FlexWeights
+
+```
+Group {
+    LayoutMode: Left;
+    Anchor: (Width: 600);
+
+    Group { FlexWeight: 1; }
+    Group { FlexWeight: 2; }
+    Group { FlexWeight: 1; }
+}
+```
+
+Remaining space (600px) is split:
+
+- First group: 600 × (1/4) = 150px
+- Second group: 600 × (2/4) = 300px
+- Third group: 600 × (1/4) = 150px
+
+## Visibility
+
+```
+Button #HiddenButton {
+    Visible: false;
+}
+```
+
+**Effect:**
+
+- Element and its children are not displayed
+- Element is **not included in layout** (doesn't take up space)
diff --git a/content/docs/id-ID/official-documentation/custom-ui/markup.mdx b/content/docs/id-ID/official-documentation/custom-ui/markup.mdx
new file mode 100644
index 00000000..564110ed
--- /dev/null
+++ b/content/docs/id-ID/official-documentation/custom-ui/markup.mdx
@@ -0,0 +1,226 @@
+---
+title: Markup
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# Markup
+
+## Markup
+
+An element is the basic building block of a user interface. There are various types of elements with different properties, which are documented below.
+
+Here's what the syntax looks like:
+
+```
+// Basic declaration of an element
+// with its Anchor property set to attach on all sides of its parent
+// with 10 pixels of margin
+Group { Anchor: (Left: 10, Top: 10, Right: 10, Bottom: 10); }
+
+Group { Anchor: (Full: 10); } // More concise version
+
+// Declaration of a Label with a name
+// (can be used to access the element from game code)
+Label #MyLabel {
+  Style: LabelStyle(FontSize: 16); // or just Style: (FontSize: 16), type can be inferred.
+  Text: "Hi! I am text.";
+}
+
+// Declaration of a Group containing 2 children
+// You can use FlexWeight to distribute any left-over space after explicit widths/heights have been subtracted
+Group {
+  LayoutMode: Left;
+  Label { Text: "Child 1"; FlexWeight: 2; }
+  Label { Text: "Child 2"; FlexWeight: 1; }
+}
+```
+
+### Documents
+
+A UI document (_.ui_ file) contains trees of elements. There can be multiple root elements.
+
+### Named Expressions
+
+Named expressions can be declared at any level of a document (including at the root) and will be scoped to that subtree, though they need to be declared at the top of the block.
+
+```
+// Example of named expressions, declared and used with @ prefix
+@Title = "Hytale";
+@ExtraSpacing = 5;
+
+Label {
+  Text: @Title;
+  Style: (LetterSpacing: 2 + @ExtraSpacing);
+}
+```
+
+You can use the spread operator `...` to reuse a named expression while overriding some of its fields:
+
+```
+@MyBaseStyle = LabelStyle(FontSize: 24, LetterSpacing: 2);
+
+Label {
+  Style: (...@MyBaseStyle, FontSize: 36);
+}
+```
+
+You can even layer multiple named expressions like so:
+
+```
+@TitleStyle = LabelStyle(FontSize: 24, HorizontalAlignment: Center);
+@SpacedTextStyle = LabelStyle(LetterSpacing: 2);
+
+Label {
+  Style: (...@BigTextStyle, ...@SpacedTextStyle);
+}
+```
+
+#### Document references
+
+A document can reference another document and access its named expressions.
+
+```
+// Document references are defined with $ prefix
+$Common = "../Common.ui";
+
+TextButton {
+  Style: $Common.@DefaultButtonStyle;
+}
+```
+
+### Templates
+
+You can declare a reusable bit of interface as a named expression and then instantiate it as many times as you want in the tree while customizing it.
+
+You can override local named expressions as well as insert additional children at any point in the template tree. However, local named expressions must be defined at the very top of the block, before properties and child elements.
+
+```
+// This is the template
+@Row = Group {
+  Anchor: (Height: 50);
+  Label #Label { Anchor: (Left: 0, Width: 100); Text: @LabelText; }
+  Group #Content { Anchor: (Left: 100); }
+};
+
+// Here we'll be using it twice in the document tree
+Group #Rows {
+  LayoutMode: TopScrolling;
+
+  @Row #MyFirstRow {
+    @LabelText = "First row";
+    #Content { TextInput {} }
+  }
+
+  @Row #MySecondRow {
+    @LabelText = "Second row";
+  }
+}
+```
+
+### Property Types
+
+#### Basic Types
+
+- **Boolean**
+  - `Visible: false;`
+  - `Visible: true;`
+- **Int**
+  - `Height: 20;`
+- **Float, Double, Decimal**
+  - `Min: 0.2;`
+- **String**
+  - `Text: "Hi!";`
+- **Char**
+  - `PasswordChar: "*";`
+  - _Note: The syntax is the same as a string, however a value of this type cannot contain more than one character!_
+- **Color**
+  - `Background: #ffffff;`&#x20;
+- **Objects**
+  - `Style: (Background: #ffffff)`
+- **Array**&#x20;
+  - `TextSpans: [(Text: "Hi", IsBold: true)]`
+
+#### Translations
+
+Translation keys can be referenced anywhere in markup where you can provide a string, and they are then converted to a string when an element gets instantiated.
+
+**Example:**
+
+```
+Label {
+  Text: %ui.general.cancel;
+}
+```
+
+#### Colors
+
+A color literal can be written as follows:
+
+- `#rrggbb`: 6-digit hexadecimal representation for red, green, blue (fully opaque)
+- `#rrggbb(a.a)`: 6-digit hexadecimal representation for red, green, blue with alpha between 0 and 1
+- `#rrggbbaa`: 8-digit hexadecimal representation for red, green, blue and alpha
+
+```
+Group {
+  Background: #000000(0.3);
+}
+```
+
+<Callout>
+  The `#rrggbb(a.a)` format is prefered over the `#rrggbbaa` format for
+  readability reasons.
+</Callout>
+
+#### Font Name
+
+Font names can be referenced directly by their string ID. Internally this is using a custom type called `UIFontName`, however strings will be converted automatically to this type in markup.
+
+```
+Label {
+  Text: "Hi";
+  Style: (FontName: "Secondary");
+}
+```
+
+**Available Font Names**
+
+- _Default_ - This is the default font that is used for most text and is always used unless a different option has been specified
+- _Secondary_ - This font is mostly used for headlines or elements that are supposed to stick out
+- _Mono_ - This is only used for development; For things such as profiling or error overlays.
+
+#### Path
+
+We can reference other UI assets with the `UIPath` type. Similar to `UIFontName`_,_ Strings are automatically converted to a `UIPath`. Paths are always relative to the file where they have been declared in. Looking up _MyButton.png_ in _Menu/MyAwesomeMenu.ui_ will result in _Menu/MyButton.png_. If you want to reference a file that is in a parent folder you can go back one directory by writing two dots (_../MyButton.png_).
+
+The markup syntax of a `UIPath` is the same as a String. (e.g. `Path: "Test.png"`)
+
+Here are some more examples:
+
+| UIPath             | .ui File                              | Resulting Path    |
+| ------------------ | ------------------------------------- | ----------------- |
+| MyButton.png       | Menu/MyAwesomeMenu.ui                 | Menu/MyButton.png |
+| ../MyButton.png    | Menu/MyAwesomeMenu.ui                 | MyButton.png      |
+| ../../MyButton.png | Menu/Popup/Templates/MyAwesomeMenu.ui | Menu/MyButton.png |
+
+#### Objects
+
+Objects contain a set of properties. In this example we are assigning an Anchor object to the _Anchor_ property:
+
+```
+Group {
+  Anchor: (
+   Height: 10,
+   Width: 20
+ );
+}
+```
+
+You can find all objects that can be used in markup [here](type-documentation#elements).
+
+## Visual Studio Code Extension
+
+There is an official extension for Visual Studio Code which adds syntax highlighting for .ui files. You can find it [here](https://marketplace.visualstudio.com/items?itemName=HypixelStudiosCanadaInc.vscode-hytaleui).
diff --git a/content/docs/id-ID/official-documentation/custom-ui/type-documentation/index.mdx b/content/docs/id-ID/official-documentation/custom-ui/type-documentation/index.mdx
new file mode 100644
index 00000000..69cea406
--- /dev/null
+++ b/content/docs/id-ID/official-documentation/custom-ui/type-documentation/index.mdx
@@ -0,0 +1,127 @@
+---
+title: Type Documentation
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# Type Documentation
+
+This is a generated list of UI elements accessible by markup. More information about the User Interface framework can be found in the main documentation.
+
+## Elements
+
+- [ActionButton](type-documentation/elements/actionbutton)
+- [AssetImage](type-documentation/elements/assetimage)
+- [BackButton](type-documentation/elements/backbutton)
+- [BlockSelector](type-documentation/elements/blockselector)
+- [Button](type-documentation/elements/button)
+- [CharacterPreviewComponent](type-documentation/elements/characterpreviewcomponent)
+- [CheckBox](type-documentation/elements/checkbox)
+- [CheckBoxContainer](type-documentation/elements/checkboxcontainer)
+- [CircularProgressBar](type-documentation/elements/circularprogressbar)
+- [CodeEditor](type-documentation/elements/codeeditor)
+- [ColorOptionGrid](type-documentation/elements/coloroptiongrid)
+- [ColorPicker](type-documentation/lements/colorpicker)
+- [ColorPickerDropdownBox](type-documentation/elements/colorpickerdropdownbox)
+- [CompactTextField](type-documentation/elements/compacttextfield)
+- [DropdownBox](type-documentation/elements/dropdownbox)
+- [DropdownEntry](type-documentation/elements/dropdownentry)
+- [DynamicPane](type-documentation/elements/dynamicpane)
+- [DynamicPaneContainer](type-documentation/elements/dynamicpanecontainer)
+- [FloatSlider](type-documentation/elements/floatslider)
+- [FloatSliderNumberField](type-documentation/elements/floatslidernumberfield)
+- [Group](type-documentation/elements/group)
+- [HotkeyLabel](type-documentation/elements/hotkeylabel)
+- [ItemGrid](type-documentation/elements/itemgrid)
+- [ItemIcon](type-documentation/elements/itemicon)
+- [ItemPreviewComponent](type-documentation/elements/itempreviewcomponent)
+- [ItemSlot](type-documentation/elements/itemslot)
+- [ItemSlotButton](type-documentation/elements/itemslotbutton)
+- [Label](type-documentation/elements/label)
+- [LabeledCheckBox](type-documentation/elements/labeledcheckbox)
+- [MenuItem](type-documentation/elements/menuitem)
+- [MultilineTextField](type-documentation/elements/multilinetextfield)
+- [NumberField](type-documentation/elements/numberfield)
+- [Panel](type-documentation/elements/panel)
+- [ProgressBar](type-documentation/elements/progressbar)
+- [ReorderableList](type-documentation/elements/reorderablelist)
+- [ReorderableListGrip](type-documentation/elements/reorderablelistgrip)
+- [SceneBlur](type-documentation/elements/sceneblur)
+- [Slider](type-documentation/elements/slider)
+- [SliderNumberField](type-documentation/elements/slidernumberfield)
+- [Sprite](type-documentation/elements/sprite)
+- [TabButton](type-documentation/elements/tabbutton)
+- [TabNavigation](type-documentation/elements/tabnavigation)
+- [TextButton](type-documentation/elements/textbutton)
+- [TextField](type-documentation/elements/textfield)
+- [TimerLabel](type-documentation/elements/timerlabel)
+- [ToggleButton](type-documentation/elements/togglebutton)
+
+## Property Types
+
+- [Anchor](type-documentation/property-types/anchor)
+- [BlockSelectorStyle](type-documentation/property-types/blockselectorstyle)
+- [ButtonSounds](type-documentation/property-types/buttonsounds)
+- [ButtonStyle](type-documentation/property-types/buttonstyle)
+- [ButtonStyleState](type-documentation/property-types/buttonstylestate)
+- [CheckBoxStyle](type-documentation/property-types/checkboxstyle)
+- [CheckBoxStyleState](type-documentation/property-types/checkboxstylestate)
+- [ClientItemStack](type-documentation/property-types/clientitemstack)
+- [ColorOptionGridStyle](type-documentation/property-types/coloroptiongridstyle)
+- [ColorPickerDropdownBoxStateBackground](type-documentation/property-types/colorpickerdropdownboxstatebackground)
+- [ColorPickerDropdownBoxStyle](type-documentation/property-types/colorpickerdropdownboxstyle)
+- [ColorPickerStyle](type-documentation/property-types/colorpickerstyle)
+- [DropdownBoxSearchInputStyle](type-documentation/property-types/dropdownboxsearchinputstyle)
+- [DropdownBoxSounds](type-documentation/property-types/dropdownboxsounds)
+- [DropdownBoxStyle](type-documentation/property-types/dropdownboxstyle)
+- [InputFieldButtonStyle](type-documentation/property-types/inputfieldbuttonstyle)
+- [InputFieldDecorationStyle](type-documentation/property-types/inputfielddecorationstyle)
+- [InputFieldDecorationStyleState](type-documentation/property-types/inputfielddecorationstylestate)
+- [InputFieldIcon](type-documentation/property-types/inputfieldicon)
+- [InputFieldStyle](type-documentation/property-types/inputfieldstyle)
+- [ItemGridSlot](type-documentation/property-types/itemgridslot)
+- [ItemGridStyle](type-documentation/property-types/itemgridstyle)
+- [LabeledCheckBoxStyle](type-documentation/property-types/labeledcheckboxstyle)
+- [LabeledCheckBoxStyleState](type-documentation/property-types/labeledcheckboxstylestate)
+- [LabelSpan](type-documentation/property-types/labelspan)
+- [LabelStyle](type-documentation/property-types/labelstyle)
+- [NumberFieldFormat](type-documentation/property-types/numberfieldformat)
+- [Padding](type-documentation/property-types/padding)
+- [PatchStyle](type-documentation/property-types/patchstyle)
+- [PopupStyle](type-documentation/property-types/popupstyle)
+- [ScrollbarStyle](type-documentation/property-types/scrollbarstyle)
+- [SliderStyle](type-documentation/property-types/sliderstyle)
+- [SoundStyle](type-documentation/property-types/soundstyle)
+- [SpriteFrame](type-documentation/property-types/spriteframe)
+- [SubMenuItemStyle](type-documentation/property-types/submenuitemstyle)
+- [SubMenuItemStyleState](type-documentation/property-types/submenuitemstylestate)
+- [Tab](type-documentation/property-types/tab)
+- [TabNavigationStyle](type-documentation/property-types/tabnavigationstyle)
+- [TabStyle](type-documentation/property-types/tabstyle)
+- [TabStyleState](type-documentation/property-types/tabstylestate)
+- [TextButtonStyle](type-documentation/property-types/textbuttonstyle)
+- [TextButtonStyleState](type-documentation/property-types/textbuttonstylestate)
+- [TextTooltipStyle](type-documentation/property-types/texttooltipstyle)
+- [ToggleButtonStyle](type-documentation/property-types/togglebuttonstyle)
+- [ToggleButtonStyleState](type-documentation/property-types/togglebuttonstylestate)
+
+## Enums
+
+- [ActionButtonAlignment](type-documentation/enums/actionbuttonalignment)
+- [CodeEditorLanguage](type-documentation/enums/codeeditorlanguage)
+- [ColorFormat](type-documentation/enums/colorformat)
+- [DropdownBoxAlign](type-documentation/enums/dropdownboxalign)
+- [InputFieldButtonSide](type-documentation/enums/inputfieldbuttonside)
+- [InputFieldIconSide](type-documentation/enums/inputfieldiconside)
+- [ItemGridInfoDisplayMode](type-documentation/enums/itemgridinfodisplaymode)
+- [LabelAlignment](type-documentation/enums/labelalignment)
+- [LayoutMode](type-documentation/enums/layoutmode)
+- [MouseWheelScrollBehaviourType](type-documentation/enums/mousewheelscrollbehaviourtype)
+- [ProgressBarAlignment](type-documentation/enums/progressbaralignment)
+- [ProgressBarDirection](type-documentation/enums/progressbardirection)
+- [ResizeType](type-documentation/enums/resizetype)
+- [TimerDirection](type-documentation/enums/timerdirection)
+- [TooltipAlignment](type-documentation/enums/tooltipalignment)
diff --git a/content/docs/id-ID/official-documentation/npc/2-getting-started-with-templates.mdx b/content/docs/id-ID/official-documentation/npc/2-getting-started-with-templates.mdx
index 91081ca1..99d078e0 100644
--- a/content/docs/id-ID/official-documentation/npc/2-getting-started-with-templates.mdx
+++ b/content/docs/id-ID/official-documentation/npc/2-getting-started-with-templates.mdx
@@ -9,7 +9,7 @@ authors:
 
 There are no hard and fast rules for making a start on a template. I like to duplicate **BlankTemplate** and start from there because it already provides the basic structure of the file.
 
-This leaves me with the following template (`Template_Goblin_Ogre.json`): (note: the file could be looking different in the current version of the game)
+This leaves me with the following template (`Template_Goblin_Ogre.json`): (**note: the file could be looking different in the current version of the game**)
 
 ```json
 {
@@ -33,7 +33,7 @@ This leaves me with the following template (`Template_Goblin_Ogre.json`): (note:
     }
   },
   "Appearance": { "Compute": "Appearance" },
-  "DropList": { "Compute": "Droplist" },
+  "DropList": { "Compute": "DropList" },
   "MaxHealth": { "Compute": "MaxHealth" },
   "MotionControllerList": [
     {
@@ -65,10 +65,10 @@ And the following variant (`Goblin_Ogre.json`) next to the template. There's a t
   "Type": "Variant",
   "Reference": "Template_Goblin_Ogre",
   "Modify": {
-    "Appearance": "Goblin_Ogre",
+    "Appearance": "Goblin",
     "MaxHealth": 124
   }
 }
 ```
 
-Our artists have defined the `Goblin_Ogre` appearance already so I'm going to use that.
+Our artists have not yet finished animations for the `Goblin_Ogre`, for that sake of the tutorial I am going to use appearance `Goblin`, because it offers a more complete set of animations that we will need.
diff --git a/content/docs/id-ID/official-documentation/worldgen/pack-tutorial/asset-packs.mdx b/content/docs/id-ID/official-documentation/worldgen/pack-tutorial/asset-packs.mdx
index 38809fad..dcf1f3b9 100644
--- a/content/docs/id-ID/official-documentation/worldgen/pack-tutorial/asset-packs.mdx
+++ b/content/docs/id-ID/official-documentation/worldgen/pack-tutorial/asset-packs.mdx
@@ -9,13 +9,13 @@ authors:
 
 <OfficialDocumentationNotice />
 
-# How to modify Hytale
+# How to modify Hytale?
 
-## What's an Asset Pack
+## What's an Asset Pack?
 
-Hytales gameplay is driven by assets in the game that can be modified by creators. Asset Packs are our solution to let you override or add features to the base game with your own work. These can in the form of zip files of folders, which contain a custom set of assets. This is not the only way for a creator to change Hytale but this is the most accessible form.;
+Hytales gameplay is driven by assets in the game that can be modified by creators. Asset Packs are our solution to let you override or add features to the base game with your own work. These can be the form of zip files of folders, which contain a custom set of assets. This is not the only way for a creator to change Hytale but this is the most accessible form.;
 
-### How do I make an Asset Pack
+### How do I make an Asset Pack?
 
 <video controls className="my-6 aspect-video w-full rounded-lg border">
   <source src="https://cdn.internal.hytalemodding.dev/guides/official/how-to-asset-pack.mp4" type="video/mp4" />
@@ -48,7 +48,7 @@ An asset pack is typically a zip or folder, with a `manifest.json` inside. This
 }
 ```
 
-### Where are they stored
+### Where are they stored?
 
 Asset Packs are stored with other mods in the Mods folder.
 
@@ -76,7 +76,7 @@ C:\Users\<user>\AppData\Roaming\Hytale\UserData\Saves\New World 5\mods
 
 When you have Asset Packs or Mods installed, these will appear in the New World menu under the Options menu.;
 
-### How do I change an existing asset
+### How do I change an existing asset?
 
 <video controls className="my-6 aspect-video w-full rounded-lg border">
   <source src="https://cdn.internal.hytalemodding.dev/guides/official/how-to-asset.mp4" type="video/mp4" />
diff --git a/content/docs/id-ID/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx b/content/docs/id-ID/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx
index 44528376..24e628b5 100644
--- a/content/docs/id-ID/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx
+++ b/content/docs/id-ID/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx
@@ -106,7 +106,7 @@ If a BaseHeight is provided, the TopY and BottomY values are relative to the Bas
 
 Applies a Material Provider slot on a set of horizontal stripes of blocks of varying thickness and position. Below is an example image of basalt stripes into a stone cliff.
 
-{/* ![](https://540086904-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F7KAmBkOg6d13nZCkf9ku%2Fuploads%2FbcxO9LpArn8gPCaBwFg5%2Funknown.png?alt=media&token=1c72b67a-8253-4d03-8c64-1ad5f6830050) */}
+![Example of basalt stripes](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/basalt-stripes-example.png)
 
 #### Parameters:
 
diff --git a/content/docs/id-ID/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx b/content/docs/id-ID/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx
index 5e34acd4..a4418473 100644
--- a/content/docs/id-ID/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx
+++ b/content/docs/id-ID/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx
@@ -294,7 +294,7 @@ Combines all the positions into a single Positioins field.
 
 ---
 
-### SimpleHoritontal
+### SimpleHorizontal
 
 Keeps only the positions that are within the provided range.
 
diff --git a/content/docs/id-ID/official-documentation/worldgen/worldgen-tutorial/README.mdx b/content/docs/id-ID/official-documentation/worldgen/worldgen-tutorial/README.mdx
new file mode 100644
index 00000000..5f66d245
--- /dev/null
+++ b/content/docs/id-ID/official-documentation/worldgen/worldgen-tutorial/README.mdx
@@ -0,0 +1,166 @@
+---
+title: How to edit and create Biomes
+description: Explores where world generation assets can be found and how to edit them.
+---
+
+### Where are the Assets
+
+World generation assets are kept in the HytaleGenerator directory within the assets.
+
+```
+/Server/HytaleGenerator/
+```
+
+<div className="flex flex-row rounded-lg border p-4">
+  <div className="flex-1/2 border-r pr-4">
+    ```
+    /Biomes
+    ```
+
+    Biome assets, with content configurations.
+  </div>
+
+  <div className="flex-1/2 pl-4">
+    ```
+    /WorldStructure
+    ```
+
+    Generator files that define which biomes spawn together.
+  </div>
+</div>
+
+<div className="flex flex-row rounded-lg border p-4">
+  <div className="flex-1/2 border-r pr-4">
+    ```
+    /Density
+    ```
+
+    Density assets that can be referenced by any other assets.
+  </div>
+
+  <div className="flex-1/2 pl-4">
+    ```
+    /Assignments
+    ```
+
+    Prop assets that can be referenced by any Biome assets.
+  </div>
+</div>
+
+***
+
+An example of this structure can be found bellow, packed in an asset pack with the instance configuration.
+
+[https://drive.google.com/file/d/1sIz_CluANIIe3n8vNiOi-4PQdeqCO0qY/view?usp=drive_link](https://drive.google.com/file/d/1sIz_CluANIIe3n8vNiOi-4PQdeqCO0qY/view?usp=drive_link)
+
+<Callout>
+  Ensure you place your asset pack in the correct directory, under Mods.
+</Callout>
+
+### How to visit our worlds
+
+https://drive.google.com/file/d/1BJurxyj-taE-PXWm04bk7Dl6X7ZHTH92/view?usp=sharing
+
+#### Requirements
+
+- You must be an **Operator** in the world.
+  - To do this, run <mark style="color:$danger;">`/op self`</mark>
+- You must be in **Creative mode**.
+  - Press the <mark style="color:$danger;">`O`</mark> key, O for Orange.&#x20;
+
+The generation assets define a set of generators but on their own you cannot visit these. Currently you require an Instance with a generator that will allow you to visit your work.
+
+```
+/Server/Instances/
+```
+
+Instances are separate worlds that players can join using the `/instances` command. Each instance has an `Instance.bson` configuration asset that specifies which generator to use, among other worldly settings.
+
+```json
+{
+  "WorldGen": {
+    "Type": "HytaleGenerator",
+    "WorldStructure": "Basic",
+    "playerSpawn" : {
+      "X" : 123,
+      "Y" : 480,
+      "Z" : 10000,
+      "Pitch" : 0,
+      "Yaw" : 0,
+      "Roll" : 0
+    }
+  }
+}
+```
+
+<Callout>
+  You can create custom instances for different world structures and biomes as you need them.
+</Callout>
+
+### How to edit Biomes
+
+<video>
+  <source src="https://cdn.internal.hytalemodding.dev/guides/official/How-to-edit-Biomes.mp4" type="video/mp4" />
+</video>
+
+We currently use the Hytale Node Editor when editing world generation assets. This can be accessed while in-game from the Content Creation menu when pressing B. The node editor is then found under the asset editor dropdown on the upper left.&#x20;
+
+![Node Editor 1](/assets/official-documentation/worldgen/worldgen-tutorial/biomes/node-editor-1.png)
+
+Once you have the Hytale Node Editor open, through the file menu you can open Biomes by navigating to the Biomes directory and selecting one from your pack.&#x20;
+
+```
+/Server/HytaleGenerator/Biomes/
+```
+
+### Biome Asset Structure
+
+Every Biome has a root Biome node, this node splits into 5 structures. This is covered briefly but more information on each field can be found on the World Generation Concepts page.
+
+![Node Editor 2](/assets/official-documentation/worldgen/worldgen-tutorial/biomes/node-editor-2.png)
+
+<Callout>
+  Each biome is for the most part self contained, meaning it has control over what appears with the biome. The only exception to this are Base Heights.
+</Callout>
+
+<Tabs>
+  <Tab value="Terrain">
+    Mathematical function nodes that calculate the physical shape of the Biome's terrain.
+  </Tab>
+
+  <Tab value="Materials">
+    Logical nodes that determine what materials (blocks) make up a Biome's terrain.
+  </Tab>
+
+  <Tab value="Props">
+    Function nodes that add objects like prefabs and decorations to the terrain.
+  </Tab>
+
+  <Tab value="Environments">
+    Logical nodes that determine the environment asset at a given coordinate within the biome. This asset determines things like weather, NPC spawns, and sounds.
+  </Tab>
+
+  <Tab value="Tints">
+    Logical function nodes that determine a colour code that can be used by certain blocks in the world. Typically this will be grasses and soils.
+  </Tab>
+</Tabs>
+
+### How to preview your work
+
+[https://drive.google.com/file/d/1mNcHn9LhFnWDF0DzWFH6_YllmKAUvUry/view?t=6](https://drive.google.com/file/d/1mNcHn9LhFnWDF0DzWFH6_YllmKAUvUry/view?t=6)
+
+Once you are in an Instance world with the Hytale Generator active you will only be able to see your work by generating new chunks. There are a few ways to do this.
+
+The viewport command selects an area around the Player that will live reload as you make changes to the generator.&#x20;
+
+```
+/viewport --radius 5 
+```
+
+You can also create a new world to show your changes.&#x20;
+
+```
+/instances spawn <instance> 
+```
+
+The last option is to simply fly south, new chunks will generate with the changes made.
diff --git a/content/docs/id-ID/quick-start.mdx b/content/docs/id-ID/quick-start.mdx
index 653644f4..249d803a 100644
--- a/content/docs/id-ID/quick-start.mdx
+++ b/content/docs/id-ID/quick-start.mdx
@@ -9,3 +9,8 @@ Welcome to the Hytale modding documentation! Here you'll find everything you nee
 * [Setting up your dev environment](./guides/plugin/setting-up-env)
 * [Entity Component System (ECS)](./guides/ecs/entity-component-system)
 * [Publishing your mod](./publishing)
+
+### Useful Links
+
+* [Kaupenjoe's Modding Videos](https://www.youtube.com/@ModdingByKaupenjoe)
+* [TroubleDEV's Modding Videos](https://www.youtube.com/@TroubleDEV)
diff --git a/content/docs/id-ID/server/argtypes.mdx b/content/docs/id-ID/server/argtypes.mdx
new file mode 100644
index 00000000..e54a442e
--- /dev/null
+++ b/content/docs/id-ID/server/argtypes.mdx
@@ -0,0 +1,61 @@
+---
+title: ArgTypes
+description: Available ArgTypes
+icon: List
+full: true
+authors:
+  - name: Valeena
+---
+
+| Name                        | Target Class                           | Description                                                                                                                               |   |
+| :-------------------------- | :------------------------------------- | :---------------------------------------------------------------------------------------------------------------------------------------- | - |
+| Boolean                     | java.lang.Boolean                      | A 'true' or 'false' input                                                                                                                 |   |
+| Integer                     | java.lang.Integer                      | A whole number                                                                                                                            |   |
+| String                      | java.lang.String                       | Words, text, numbers, letters. To input more than one word at a time, you may need to wrap it with double quotes (`"my fancy sentence"`). |   |
+| Float                       | java.lang.Float                        | A floating-pointer number                                                                                                                 |   |
+| Double                      | java.lang.Double                       | A decimal number                                                                                                                          |   |
+| UUID                        | java.util.UUID                         | A UUID (Universally Unique IDentifier)                                                                                                    |   |
+| Player_UUID                 | java.util.UUID                         | A UUID or an online player username                                                                                                       |   |
+| Game_Profile_Lookup_Async   | ProfileServiceClient.PublicGameProfile | A player UUID or username. If not found locally, performs a remote lookup via the Profile Service.                                        |   |
+| Relative_Double_Coord       | Coord                                  | An x, y, or z coordinate as a decimal, optionally relative by specifying a tilde (~) in front of the number                               |   |
+| Relative_Int_Coord          | IntCoord                               | An x, y, or z coordinate as a whole number, optionally relative by specifying a tilde (~) in front of the number                          |   |
+| Relative_Integer            | RelativeInteger                        | A tilde to mark an integer relative to a base                                                                                             |   |
+| Relative_Float              | RelativeFloat                          | A tilde to mark a float relative to a base                                                                                                |   |
+| Player_Ref                  | PlayerRef                              | A UUID or an online player's username                                                                                                     |   |
+| World                       | World                                  | A world folder name                                                                                                                       |   |
+| Model_Asset                 | ModelAsset                             | A reference to an Asset of type Model                                                                                                     |   |
+| Weather_Asset               | Weather                                | A reference to an Asset of type Weather                                                                                                   |   |
+| Interaction_Asset           | Interaction                            | A reference to an Asset of type Interaction                                                                                               |   |
+| Root_Interaction_Asset      | RootInteraction                        | A reference to an Asset of type Root Interaction                                                                                          |   |
+| Effect_Asset                | EntityEffect                           | A refernece to an Asset of type EntityEffect                                                                                              |   |
+| Environment_Asset           | Environment                            | A reference to an Asset of type Environment                                                                                               |   |
+| Item_Asset                  | Item                                   | A reference to an Asset of type Item                                                                                                      |   |
+| Block_Type_Asset            | BlockType                              | A reference to an Asset of type BlockType                                                                                                 |   |
+| Particle_System             | ParticleSystem                         | A reference to an Asset of type ParticleSystem                                                                                            |   |
+| Hitbox_Collision_Config     | HitboxCollisionConfig                  | A reference to an Asset of type HitboxCollisionConfig                                                                                     |   |
+| Repulsion_Config            | RepulsionConfig                        | A reference to an Asset of type RepulsionConfig                                                                                           |   |
+| Sound_Event_Asset           | SoundEvent                             | A reference to an Asset of type SoundEvent                                                                                                |   |
+| Ambiance_Fx_Asset           | AmbianceFX                             | A reference to an Asset of type AmbianceFX                                                                                                |   |
+| Sound_Category              | SoundCategory                          | A sound category (sfx, music, ambient, ui)                                                                                                |   |
+| Entity_ID                   | `ArgWrapper<EntityWrappedArg, UUID>`   | A UUID representing an entity id                                                                                                          |   |
+| Integer_Comparison_Operator | IntegerComparisonOperator              | A mathematical sign for integer comparison                                                                                                |   |
+| Integer_Operation           | IntegerOperation                       | A mathematical sign for performing an operation                                                                                           |   |
+| Int_Range                   | `Pair<Integer, Integer>`               | Two integers representing a minimum and maximum of a range                                                                                |   |
+| Relative_Int_Range          | RelativeIntRange                       | Two integers representing a minimum and maximum of a range                                                                                |   |
+| Vector2I                    | Vector2i                               | Two integers, generally corresponding to x/z axis                                                                                         |   |
+| Vector3I                    | Vector3i                               | Three integers, generally corresponding to x/y/z axis                                                                                     |   |
+| Relative_Vector3I           | RelativeVector3i                       | Three optionally relative integers, generally corresponding to x/y/z axis                                                                 |   |
+| Relative_Block_Position     | RelativeIntPosition                    | A position with three integer coordinates, representing a block's location in world space.                                                |   |
+| Relative_Position           | Relative                               | A position with three decimal coordinates, representing a location in world space.                                                        |   |
+| Relative_Chunk_Position     | RealtiveChunkPosition                  | A position with two integer coordinates (x, z), representing a chunk's location.                                                          |   |
+| Rotation                    | Vector3f                               | A rotation with three coordinates, representing the pitch, yaw, and roll respectively                                                     |   |
+| Block_Type_Key              | String                                 | A block type                                                                                                                              |   |
+| Block_ID                    | Integer                                | A block type, converted to an int id                                                                                                      |   |
+| Color                       | Integer                                | A color value in hex format, hex integer, or decimal integer                                                                              |   |
+| Weighted_Block_Type         | `Pair<Integer, String>`                | A weight corresponding to a blocktype                                                                                                     |   |
+| Weighted_Block_Entry        | String                                 | A block with optional weight prefix                                                                                                       |   |
+| Block_Pattern               | BlockPattern                           | A list of blocks with optional weights                                                                                                    |   |
+| Individual_Block_Mask       | BlockMask                              | Create a block mask using symbols and block names                                                                                         |   |
+| Block_Mask                  | BlockMask                              | A tick rate value (e.g., 30tps, 33ms, or 30)                                                                                              |   |
+| Tick_Rate                   | Integer                                | A list of block masks that combine together                                                                                               |   |
+| Game_Mode                   | GameMode                               | GameMode                                                                                                                                  |   |
diff --git a/content/docs/id-ID/server/interaction-reference.mdx b/content/docs/id-ID/server/interaction-reference.mdx
new file mode 100644
index 00000000..6c0d01b3
--- /dev/null
+++ b/content/docs/id-ID/server/interaction-reference.mdx
@@ -0,0 +1,1586 @@
+---
+title: Interactions
+description: A list of most Interaction types provided by Hypixel, along with the meaning of their fields, and how they fit together.
+icon: List
+authors:
+  - name: Stephen Baynham
+    url: https://github.com/cannibalvox
+---
+
+### The Interaction Base Type
+
+All interactions of every type below are inherited from Interaction and have these fields.
+
+**Interaction Fields**
+
+| Field Name                | Type                                                                 | Required? | Notes                                                                                                                                                                                                                       |
+| ------------------------- | -------------------------------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| ViewDistance              | `Double`<br />(Default: 96.0)                                        | **No**    | Distance in blocks at which other players can see the effects from this interaction.                                                                                                                                        |
+| Effects                   | `InteractionEffects`                                                 | **No**    | Sound, animations, and particle effects that should trigger when this interaction begins executing.                                                                                                                         |
+| HorizontalSpeedMultiplier | `Float`<br />(Default: 1.0)                                          | **No**    | Multiplier applied to the User entity's movement speed while this interaction is executing                                                                                                                                  |
+| RunTime                   | `Float`                                                              | **No**    | If provided, this interaction will continue executing for at least this long before the interaction chain moves onto the next interaction.                                                                                  |
+| CancelOnItemChange        | `Boolean`<br />(Default: true)                                       | **No**    | If true, this interaction will be cancelled if the User entity's held item changes during execution. This can happen either due to the selected hotbar slot changing or the contents of the item's inventory slot changing. |
+| Rules                     | `InteractionRules`                                                   | **Yes**   | If provided, adds additional limitations and cancellation conditions to this interaction.                                                                                                                                   |
+| Settings                  | `Map`<br />(Key Type: `GameMode`, Value Type: `InteractionSettings`) | **No**    | If provided, adds additional per-GameMode settings to the interaction.                                                                                                                                                      |
+| Camera                    | `InteractionCameraSettings`                                          | **No**    | Arrays of camera motion keyframes for cutscenes and reveals.                                                                                                                                                                |
+
+**GameMode Values**
+
+- `Creative`: The game is currently in Creative Mode
+- `Adventure`: The game is currently in Adventure Mode
+
+**InteractionEffects Fields**
+
+| Field Name               | Type                                              | Required? | Notes                                                                                                                                                 |
+| ------------------------ | ------------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Particles                | `Array`<br />(Element Type: `ModelParticle`)      | **No**    | Particle systems to activate when this interaction begins if the player is in third-person mode.                                                      |
+| FirstPersonParticles     | `Array`<br />(Element Type: `ModelParticle`)      | **No**    | Particle systems to activate when this interaction begins if the player is in first-person mode.                                                      |
+| WorldSoundEventId        | `Asset`<br />(Asset Type: `SoundEvent`)           | **No**    | A sound to play in the world at the User entity's location when this interaction begins.<br />**The SoundEvent must be single-channel (mono) sound.** |
+| LocalSoundEventId        | `Asset`<br />(Asset Type: `SoundEvent`)           | **No**    | A 2D sound to play for the User entity when this interaction begins. Ignored if the User entity is not a player.                                      |
+| Trails                   | `Array`<br />(Element Type: `ModelTrail`)         | **No**    | Trail effects to activate on the User entity when this interaction begins.                                                                            |
+| WaitForAnimationToFinish | `Boolean`<br />(Default: false)                   | **No**    | If true, this interaction will continue executing for at least the length of any animations in this InteractionEffects object.                        |
+| ItemPlayerAnimationsId   | `Asset`<br />(Asset Type: `ItemPlayerAnimations`) | **No**    | If provided, the User entity will use this ItemPlayerAnimations set while this interaction is executing.                                              |
+| ItemAnimationId          | `String`                                          | **No**    | Id of an animation to trigger when this interaction begins executing.<br />**This animation id is not validated on server start.**                    |
+| ClearAnimationOnFinish   | `Boolean`<br />(Default: false)                   | **No**    | If true, animations triggered by this interaction will be halted when the interaction completes.                                                      |
+| ClearSoundEventOnFinish  | `Boolean`<br />(Default: false)                   | **No**    | If true, sounds triggered by this interaction will be halted when the interaction completes.                                                          |
+| CameraEffect             | `Asset`<br />(Asset Type: `CameraEffect` )        | **No**    | If provided, the CameraEffect will be applied while this interaction is executing.                                                                    |
+| MovementEffects          | `MovementEffects`                                 | **No**    | If provided, apply the movement effects to the User entity while this interaction is executing.                                                       |
+| StartDelay               | `Float`<br />(Default: 0.0f)                      | **No**    | The interaction will wait this many seconds before triggering the effects in this object.                                                             |
+
+**InteractionRules Fields**
+
+| Field Name          | Type                                                                                                | Required? | Notes                                                                                                                                                                                                                                     |
+| ------------------- | --------------------------------------------------------------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| BlockedBy           | `Array`<br />(Element Type: `InteractionType`)<br />(Default: Based on the chain's InteractionType) | **No**    | If provided, this RootInteraction cannot be executed while interaction chains of the provided types are executing.<br />**This field only functions for rules attached to a RootInteraction. It has no effect on an Interaction.**        |
+| Blocking            | `Array`<br />(Element Type: `InteractionType`)                                                      | **No**    | If provided, interaction chains with the specified InteractionTypes cannot be executed while this interaction is executing.                                                                                                               |
+| InterruptedBy       | `Array`<br />(Element Type: `InteractionType`)                                                      | **No**    | If provided, interaction chains with the specified InteractionTypes will cancel this interaction chain when they execute.<br />**This field only functions for rules attached to a RootInteraction. It has no effect on an Interaction.** |
+| Interrupting        | `Array`<br />(Element Type: `InteractionType`)                                                      | **No**    | If provided, interaction chains with the specified InteractionTypes will be canceled when this interaction begins.                                                                                                                        |
+| BlockedByBypass     | `String`                                                                                            | **No**    | If provided, this RootInteraction cannot be blocked by interaction chains whose RootInteraction has this value as an asset tag.                                                                                                           |
+| BlockingBypass      | `String`                                                                                            | **No**    | If provided, this interaction will not block RootInteractions that have the this value as an asset tag.                                                                                                                                   |
+| InterruptedByBypass | `String`                                                                                            | **No**    | If provided, this RootInteraction cannot be canceled by RootInteractions that have this value as an asset tag.                                                                                                                            |
+| InterruptingBypass  | `String`                                                                                            | **No**    | If provided, this interaction will not cancel interaction chains whose RootInteraction has this value as an asset tag.                                                                                                                    |
+
+**InteractionType Values**
+
+- `Primary`
+- `Secondary`
+- `Ability1`
+- `Ability2`
+- `Ability3`
+- `Use`
+- `Pick`
+- `Pickup`
+- `CollisionEnter`
+- `CollisionLeave`
+- `Collision`
+- `EntityStatEffect`
+- `SwapTo`
+- `SwapFrom`
+- `Death`
+- `Wielding`
+- `ProjectileSpawn`
+- `ProjectileHit`
+- `ProjectileMiss`
+- `ProjectileBounce`
+- `Held`
+- `HeldOffhand`
+- `Equipped`
+- `Dodge`
+- `GameModeSwap`
+
+**InteractionSettings Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                        |
+| ---------------- | ------------------------------- | --------- | -------------------------------------------------------------------------------------------- |
+| AllowSkipOnClick | `Boolean`<br />(Default: false) | **No**    | If true, the user will be able to skip this interaction by clicking shortly after it starts. |
+
+**InteractionCameraSettings Fields**
+
+| Field Name  | Type                                             | Required? | Notes                                                                                                                                                           |
+| ----------- | ------------------------------------------------ | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| FirstPerson | `Array`<br />(Element Type: `InteractionCamera`) | **No**    | A list of camera keyframes to be played if the player is in first-person.<br />**The time of each keyframe must be after the keyframe before it in the array.** |
+| ThirdPerson | `Array`<br />(Element Type: `InteractionCamera`) | **No**    | A list of camera keyframes to be played if the player is in third-person.<br />**The time of each keyframe must be after the keyframe before it in the array.** |
+
+**InteractionCamera Fields**
+
+| Field Name | Type                         | Required? | Notes                                                                                                                                       |
+| ---------- | ---------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------- |
+| Time       | `Float`<br />(Default: 0.1f) | **No**    | How long after the interaction begins executing that the camera should arrive at this keyframe.<br />**Cannot be less than or equal to 0.** |
+| Position   | `Vector3`                    | **Yes**   | Where the camera should be located when it arrives at this keyframe.                                                                        |
+| Rotation   | `Direction`                  | **Yes**   | Where the camera should be pointing when it arrives at this keyframe.                                                                       |
+
+### SimpleInteraction
+
+Most interaction types below are inherited from SimpleInteraction and have these
+fields.  If a type does not have these fields, the documentation will mention it.
+
+The purpose of SimpleInteraction is to facilitate Interaction chaining by taking different paths
+based on whether the Interaction succeeded or failed.  The circumstances under which
+a given Interaction fails are generally type-specific (and described in the documentation
+below), but all interactions will be marked failed if they are cancelled via one of the
+many, many mechanisms for doing so.
+
+It is valid to create an interaction asset of type "Simple", which can be valuable when you want to use the
+interaction fields with no additional functionality.
+
+**SimpleInteraction Fields**
+
+| Field Name | Type                                     | Required? | Notes                                                                                          |
+| ---------- | ---------------------------------------- | --------- | ---------------------------------------------------------------------------------------------- |
+| Next       | `Asset`<br />(Asset Type: `Interaction`) | **No**    | After this Interaction has finished, "Next" will be executed if this Interaction did not fail. |
+| Failed     | `Asset`<br />(Asset Type: `Interaction`) | **No**    | After this Interaction has finished, "Failed" will be executed if this Interaction failed.     |
+
+## Flow Control
+
+These are interaction types used to control the flow of an interaction chain and allow interactions
+to be composed into more complex behaviors.  These interaction types generally do not pertain to
+the game and instead pertain to the interaction system itself.
+
+### Condition
+
+This interaction will fail if one of the fields is provided but does not match the current state.
+
+**Condition Fields**
+
+| Field Name       | Type       | Required? | Notes                                                                                                                                                                                    |
+| ---------------- | ---------- | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| RequiredGameMode | `GameMode` | **No**    | If provided, the interaction will fail if the current GameMode does not match the provided value.                                                                                        |
+| Jumping          | `Boolean`  | **No**    | If provided, the interaction will fail if the player's Jumping state does not match the provided value. (i.e. if True, the player must be jumping, if False, the player must not be)     |
+| Swimming         | `Boolean`  | **No**    | If provided, the interaction will fail if the player's Swimming state does not match the provided value. (i.e. if True, the player must be swimming, if False, the player must not be)   |
+| Crouching        | `Boolean`  | **No**    | If provided, the interaction will fail if the player's Crouching state does not match the provided value. (i.e. if True, the player must be crouching, if False, the player must not be) |
+| Running          | `Boolean`  | **No**    | If provided, the interaction will fail if the player's Running state does not match the provided value. (i.e. if True, the player must be running, if False, the player must not be)     |
+| Flying           | `Boolean`  | **No**    | If provided, the interaction will fail if the player's Flying state does not match the provided value. (i.e. if True, the player must be flying, if False, the player must not be)       |
+
+**GameMode Values**
+
+- `Creative`: The game is currently in Creative Mode
+- `Adventure`: The game is currently in Adventure Mode
+
+### FirstClick
+
+This interaction does not inherit from SimpleInteraction and therefore has no Next or Failed fields.
+
+This interaction has two fields that each contain a reference to an Interaction: Click and Hold.  If the root interaction
+of the chain was initiated by a client button/key press (or simulated NPC input) and the input was a tap, then
+the Click interaction is run. if it was a longer press, then the Hold interaction is run.
+
+As a minor implementation detail, this interaction is internally marked as failed when the Hold path is followed.
+This generally shouldn't matter.  If the interaction was not initiated by a key press at all, the Click path will be followed,
+but it seems risky to rely on that behavior.
+
+**FirstClick Fields**
+
+| Field Name | Type                                     | Required? | Notes                                                                                                                                                    |
+| ---------- | ---------------------------------------- | --------- | -------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Click      | `Asset`<br />(Asset Type: `Interaction`) | **No**    | If provided and the root interaction of the chain was initiated by button/key press, this interaction is executed next if the press was a quick tap.     |
+| Hold       | `Asset`<br />(Asset Type: `Interaction`) | **No**    | If provided and the root interaction of the chain was initiated by a button/key press, this interaction is executed next if the press was a longer hold. |
+
+### Interrupt
+
+This interaction can be used to cancel one or more running interaction chains on an entity and **all forked interaction
+chains those chains have spawned that are still currently running**.  All interaction chains canceled in this manner will be marked as
+Failed, which may have additional implications if the canceled chains are themselves forked from
+other chains that are still running.
+
+**Interrupt Fields**
+
+| Field Name     | Type                                           | Required? | Notes                                                                                                                                                                                               |
+| -------------- | ---------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Entity         | `InteractionTarget`<br />(Default: User)       | **Yes**   | The entity that is the owner of the target interaction chains.  This field can indicate the Owner, User, or Target of this interaction chain.                                                       |
+| InterruptTypes | `Array`<br />(Element Type: `InteractionType`) | **No**    | A set of InteractionTypes that are to be interrupted. Only interactions of these types are affected. If null, all types will be interrupted.<br />**(Note: An empty set will interrupt NO TYPES.)** |
+| RequiredTag    | `String`                                       | **No**    | An asset tag that, if provided, the RootInteraction of the interaction chain must have in order to be canceled.                                                                                     |
+| ExcludedTag    | `String`                                       | **No**    | An asset tag that, if provided, the RootInteraction of the interaction chain must not have in order to be canceled.                                                                                 |
+
+**InteractionTarget Values**
+
+- `User` - The user of this interaction chain. The entity whose actions caused this interaction chain to be executed. This is usually the same as the Owner.
+- `Owner` - The owner of this interaction chain. The entity upon whom this interaction chain is executing.
+- `Target` - The entity target of this interaction chain, if any.  This value is mutable (and can therefore come from many places) but most commonly, it is an entity the User was targeting when this interaction chain began executing.
+
+**InteractionType Values**
+
+- `Primary`
+- `Secondary`
+- `Ability1`
+- `Ability2`
+- `Ability3`
+- `Use`
+- `Pick`
+- `Pickup`
+- `CollisionEnter`
+- `CollisionLeave`
+- `Collision`
+- `EntityStatEffect`
+- `SwapTo`
+- `SwapFrom`
+- `Death`
+- `Wielding`
+- `ProjectileSpawn`
+- `ProjectileHit`
+- `ProjectileMiss`
+- `ProjectileBounce`
+- `Held`
+- `HeldOffhand`
+- `Equipped`
+- `Dodge`
+- `GameModeSwap`
+
+### Parallel
+
+This interaction does not inherit from SimpleInteraction and therefore has no Next or Failed fields.
+
+This interaction has a field `Interactions` that is an array of RootInteraction assets. The list must contain at least
+two RootInteractions.  This interaction will fork all of its children except for the first into their
+own interaction chains and immediately complete. After this interaction completes, this interaction chain will
+execute the first RootInteraction in the `Interactions` list.
+
+This interaction does not have any failure conditions and is indifferent to the fate of the forked interaction chains.
+
+**Parallel Fields**
+
+| Field Name   | Type                                                | Required? | Notes                                                         |
+| ------------ | --------------------------------------------------- | --------- | ------------------------------------------------------------- |
+| Interactions | `AssetArray`<br />(Element Type: `RootInteraction`) | **Yes**   | An array of RootInteractions that will be forked or executed. |
+
+### Repeat
+
+This interaction has a field `ForkInteractions` that is an asset of type RootInteraction. This interaction will fork that
+RootInteraction into its own interaction chain and then wait for it to complete. If the RootInteraction fails, this
+interaction will complete immediately and be marked failed. Otherwise, the RootInteraction will be forked and run again,
+up to a specified total number of times.
+
+**Repeat Fields**
+
+| Field Name       | Type                                                                                   | Required? | Notes                                                                                                                                                                                                              |
+| ---------------- | -------------------------------------------------------------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| ForkInteractions | `Asset`<br />(Asset Type: `RootInteraction`)                                           | **Yes**   | A RootInteraction that will be forked.                                                                                                                                                                             |
+| Repeat           | `Integer`<br />(Default: 1)<br />**Must be -1 or a positive integer. 0 is not valid.** | **No**    | The total number of times to fork ForkInteractions. If -1 is provided, ForkInteractions will continue being forked and executed indefinitely, until this interaction is cancelled or until ForkInteractions fails. |
+
+### Replace
+
+This interaction does not inherit from SimpleInteraction and therefore has no Next or Failed fields.
+
+This interaction uses the InteractionVars system that is avaiable for items. InteractionVars are RootInteractions that
+can be attached to an Item asset with a name.
+
+This interaction specifies a var name, and if this interaction chain was executed through
+an item and that item has an InteractionVar of the same name, then this interaction will immediately execute
+the RootInteraction on the var.  Otherwise, it will execute the default RootInteraction specified in this interaction.
+If no default is specified, then this interaction will be marked as failed.
+
+**Replace Fields**
+
+| Field Name   | Type                                         | Required? | Notes                                                                                                                                                                                                           |
+| ------------ | -------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Var          | `String`                                     | **Yes**   | The name of the InteractionVar to execute.                                                                                                                                                                      |
+| DefaultValue | `Asset`<br />(Asset Type: `RootInteraction`) | **No**    | The RootInteraction to execute if the owning item does not have an InteractionVar by the specified name. If not provided, the interaction will be marked as failed instead.                                     |
+| DefaultOk    | `Boolean`<br />(Default: false)              | **No**    | If false, then an angry message will be printed to the server logs if the owning item does not have an InteractionVar by the specified name.  The functioning of this interaction will be otherwise unaffected. |
+
+### RunRootInteraction
+
+This interaction immediately executes the provided RootInteraction as part of this interaction chain. This interaction
+does not have any failure conditions.
+
+**RunRootInteraction Fields**
+
+| Field Name      | Type                                         | Required? | Notes                           |
+| --------------- | -------------------------------------------- | --------- | ------------------------------- |
+| RootInteraction | `Asset`<br />(Asset Type: `RootInteraction`) | **Yes**   | The RootInteraction to execute. |
+
+### Selector
+
+This interaction will execute a Selector to find entities and/or blocks (depending on the Selector) and fork off an
+interaction chain for each located entity or block. This interaction will not wait for those interaction chains
+to complete and is indifferent to their fate. The forked interaction chains will use the located entity/block as
+their target entity/target block. Each entity or block will only fork one interaction chain over the life of this
+interaction.  The Selector is guaranteed to run once for each execution of this interaction, but some Selectors
+are intended to be run over a period of time and sweep across an area to locate targets. In order to use those Selectors
+properly, you will need to extend the execution time of this interaction using `RunTime` or `WaitForAnimationToFinish`.
+The Selector will be executed repeatedly over the lifetime of the interaction.
+
+If the Selector is configured to locate entities, you can add additional sets of entity matching rules. If a located entity
+matches one of the rules, the matching RootInteraction will be forked instead of the standard `HitEntity` RootInteraction.
+
+Entities located by the Selector will be ignored if they do not have a NetworkId, if they are dead, or if they are invulnerable.
+The only exception to this rule is that players in Creative Mode that are marked to receive hits will not be ignored.
+
+This interaction's failure conditions are configurable via the `FailOn` field. You can configure this interaction to never
+fail, to fail if the Selector does not locate any blocks before this interaction finishes executing, to fail if the
+Selector does not locate any entities before this interaction finishes executing, or to fail in either case.
+
+**Selector Fields**
+
+| Field Name     | Type                                         | Required? | Notes                                                                                                                                                                                                                                     |
+| -------------- | -------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Selector       | `Selector`                                   | **Yes**   | The Selector is executed at least once and may be executed repeatedly to locate blocks and/or entities in an area.                                                                                                                        |
+| HitEntity      | `Asset`<br />(Asset Type: `RootInteraction`) | **No**    | If included and the `Selector` locates an entity that does not match any `HitEntityRules`, this RootInteraction will be forked into a new interaction chain with the located entity as the target entity.                                 |
+| HitEntityRules | `Array`<br />(Element Type: `HitEntity`)     | **No**    | If included, these rules will be matched against any entity located by the `Selector`. If an entity matches a set of rules, the RootInteraction associated with the rules will be forked instead of the standard `HitEntity` interaction. |
+| HitBlock       | `Asset`<br />(Asset Type: `RootInteraction`) | **No**    | If included and the `Selector` locates a block, this RootInteraction will be forked into a new interaction chain with the located block as the block target.                                                                              |
+| FailOn         | `FailOnType`<br />(Default: `Neither`)       | **No**    | Defines under what circumstances this interaction will fail.  It can be marked to fail when it completes without locating any blocks, it can be marked to fail when it completes without locating any entities, both, or neither.         |
+| IgnoreOwner    | `Boolean`<br />(Default: true)               | **No**    | If true, the Selector will not locate the User entity of this interaction.                                                                                                                                                                |
+
+**HitEntity Fields**
+
+| Field Name | Type                                         | Required? | Notes                                                                                                 |
+| ---------- | -------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------- |
+| Matchers   | `Array`<br />(Element Type: `EntityMatcher`) | **Yes**   | A set of rules that an entity must match. An entity must successful match all rules to be considered. |
+| Next       | `Asset`<br />(Asset Type: `RootInteraction`) | **Yes**   | The RootInteraction to fork if an entity matches all rules.                                           |
+
+**EntityMatcher Fields**
+
+| Field Name | Type                            | Required? | Notes                                                                                                     |
+| ---------- | ------------------------------- | --------- | --------------------------------------------------------------------------------------------------------- |
+| Type       | `String`                        | **Yes**   | If provided, specifies a type of EntityMatcher to use. Each matcher type may come with additional fields. |
+| Invert     | `Boolean`<br />(Default: false) | **No**    | If true, an entity must fail this rule for it to be marked as succeeded.                                  |
+
+**EntityMatcher Type: Player**
+
+This EntityMatcher will succesfully match the entity only if they are a player.
+
+**EntityMatcher Type: Vulnerable**
+
+This Entitymatcher will successfully match the entity only if they are not marked as invulnerable.
+
+**FailOnType Values**
+
+- `Neither`
+- `Entity`
+- `Block`
+- `Either`
+
+### Serial
+
+This interaction does not inherit from SimpleInteraction and therefore has no Next or Failed fields.
+
+This interaction has a field `Interactions` which is a list of Interaction assets. This interaction immediately
+completes and the interaction chain continues by executing the interactions in the list one at a time. This
+interaction does not have any failure conditions.
+
+**Serial Fields**
+
+| Field Name   | Type                                            | Required? | Notes                                      |
+| ------------ | ----------------------------------------------- | --------- | ------------------------------------------ |
+| Interactions | `AssetArray`<br />(Element Type: `Interaction`) | **Yes**   | An array of Interaction assets to execute. |
+
+## Cooldowns
+
+RootInteractions interface with a complex cooldown system that can be used for a variety of purposes. Aside from simply
+adding an important aspect of resource management to your game design, cooldowns can be used to ensure that click-activated
+interaction chains don't repeatedly spam if the player holds down the input.
+
+By default, every RootInteraction has a cooldown timer that is keyed to the RootInteraction name, and by default, it
+will launch a cooldown of 0.35 seconds when activated by client input.  Otherwise, no cooldown will be activated.  However,
+by configuring your RootInteraction, you can change the key for the cooldown (so that multiple RootInteractions can share
+a single cooldown), set the cooldown timer to whatever you like, and configure multiple charges that can build up over time
+to allow the entity to activate the RootInteraction multiple times before being forced to pause.
+
+One important concept to keep in mind is the difference between **cooldown** and **charge time**.  The cooldown, if any,
+is activated each time a RootInteraction triggers, even if the player has more available charges. If the RootInteraction
+is configured to use charges, then they will gradually build up over time. In order for a RootInteraction to be activated,
+the cooldown (if any) must be expired, and the RootInteraction must have at least one charge (if it has been
+configured to use charges).
+
+Bear in mind that the entire Cooldown configuration is shared between different RootInteractions with the same cooldown id.
+If you activate an ability with 5 charges and a short cooldown and then another ability with a much longer cooldown and no
+charges, the second ability will use the cooldown properties of the first ability until/unless the first ability finishes
+charging and is cleared from the system.  You should generally only have multiple RootInteractions share a cooldown id
+if they have the same configuration.
+
+The interactions below interact with the cooldown system to allow you to manipulate cooldowns via the interaction system. By
+using these interactions, you can have several interaction chains with different cooldown configurations share cooldowns
+that are checked and activated as part of the interaction chain itself, or have some components of an interaction change
+use a second cooldown separate from the main one.
+
+### CooldownCondition
+
+**CooldownCondition Fields**
+
+This interaction will fail if the specified cooldown id is on cooldown for the User entity.  This interaction will only
+function for players- the interaction will always succeed for NPCs.  In order for this interaction to succeed, the
+cooldown, if any, must have expired and at least one charge, if any, must have filled.
+
+| Field Name | Type     | Required? | Notes                     |
+| ---------- | -------- | --------- | ------------------------- |
+| Id         | `String` | **Yes**   | The cooldown id to check. |
+
+### IncrementCooldown
+
+**IncrementCooldown Fields**
+
+This interaction will modify a cooldown that is currently active on the User entity, allowing charges and remaining
+cooldown to be modified.
+Despite its name, this interaction can be used to reduce a cooldown as well as increase it. If the cooldown is not
+currently active, this interaction will have no effect. The interaction has no special failure conditions.
+
+| Field Name        | Type                        | Required? | Notes                                                                                                                                                                                                                                                                                     |
+| ----------------- | --------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Id                | `String`                    | **No**    | If provided, the cooldown id of the cooldown to be manipulated. If not provided, the cooldown id of the current chain's RootInteraction will be used.                                                                                                                                     |
+| Time              | `Float`<br />(Default: 0.0) | **No**    | The amount to increase the remaining cooldown by. Can be negative. The remaining cooldown time will not be reduced below zero or increased above the maximum cooldown time.                                                                                                               |
+| ChargeTime        | `Float`<br />(Default: 0.0) | **No**    | The amount to increase the remaining time until the next charge is filled by. Can be negative. The remaining charge time cannot be reduced below zero or increased above the maximum cooldown time. **This will not work on abilities that have a maximum of 1 charge, for some reason.** |
+| Charge            | `Integer`<br />(Default: 0) | **No**    | The amount to increase the number of charges by. Can be negative. The number of charges cannot be reduced below 0 or increased above the maximum.                                                                                                                                         |
+| InterruptRecharge | `Boolean`(Default: false)   | **No**    | If true and `Charge` is not 0, will reset the remaining time to the next charge to the maximum value after changing the charge count.                                                                                                                                                     |
+
+### ResetCooldown
+
+This interaction will trigger a cooldown on the User entity with a specified configuration. The charges will be refilled
+but the cooldown will be immediately triggered.  The mechanisms for deciding on the configuration are a little bit complicated.
+You may specify a cooldown configuration via the `Cooldown` field. If you do not include an `Id` field, then the
+interaction chain's RootInteraction will be used for any field not specified in the configuration. If there is an active
+cooldown under the specified `Id` (or under the RootInteraction's cooldown id if none is specified) then the fields
+from that active cooldown will overwrite data in the RootInteraction's cooldown, but not data in your `Cooldown` field.
+
+**ResetCooldown Fields**
+
+| Field Name | Type                  | Required? | Notes                                                        |
+| ---------- | --------------------- | --------- | ------------------------------------------------------------ |
+| Cooldown   | `InteractionCooldown` | **No**    | A cooldown configuration to use for the new, reset cooldown. |
+
+**InteractionCooldown Fields**
+
+| Field Name        | Type                                 | Required? | Notes                                                                                                                                                                                                 |
+| ----------------- | ------------------------------------ | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Id                | `String`                             | **No**    | The cooldown id to use for this cooldown. If not provided, the RootInteraction's cooldown id will be used, if any.                                                                                    |
+| Cooldown          | `Float`<br />(Default: 0.0)          | **No**    | The duration of the cooldown, in seconds.                                                                                                                                                             |
+| Charges           | `Array`<br />(Element Type: `Float`) | **No**    | If provided, a list of how many charges this cooldown can build, and how long each charge takes to build, in seconds.                                                                                 |
+| InterruptRecharge | `Boolean`<br />(Default: false)      | **No**    | If true, the charge time will be reset when the number of charges changes.                                                                                                                            |
+| ClickBypass       | `Boolean`<br />(Default: false)      | **No**    | If true, RootInteractions keyed to this cooldown can still be activated when it is on cooldown provided that the RootInteraction was triggered by a distinct key or mouse button press on the client. |
+
+### TriggerCooldown
+
+This interaction is similar to ResetCooldown, except instead of refilling the cooldown's charges, one charge will be deducted
+as normal.
+
+**TriggerCooldown Fields**
+
+| Field Name | Type                  | Required? | Notes                                                        |
+| ---------- | --------------------- | --------- | ------------------------------------------------------------ |
+| Cooldown   | `InteractionCooldown` | **No**    | A cooldown configuration to use for the new, reset cooldown. |
+
+**InteractionCooldown Fields**
+
+| Field Name        | Type                                 | Required? | Notes                                                                                                                                                                                                 |
+| ----------------- | ------------------------------------ | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Id                | `String`                             | **No**    | The cooldown id to use for this cooldown. If not provided, the RootInteraction's cooldown id will be used, if any.                                                                                    |
+| Cooldown          | `Float`<br />(Default: 0.0)          | **No**    | The duration of the cooldown, in seconds.                                                                                                                                                             |
+| Charges           | `Array`<br />(Element Type: `Float`) | **No**    | If provided, a list of how many charges this cooldown can build, and how long each charge takes to build, in seconds.                                                                                 |
+| InterruptRecharge | `Boolean`<br />(Default: false)      | **No**    | If true, the charge time will be reset when the number of charges changes.                                                                                                                            |
+| ClickBypass       | `Boolean`<br />(Default: false)      | **No**    | If true, RootInteractions keyed to this cooldown can still be activated when it is on cooldown provided that the RootInteraction was triggered by a distinct key or mouse button press on the client. |
+
+## Combo Chains
+
+Hytale additionally comes with a rich "combo chaining" system, which allows several inputs in a row to result in different
+attacks and special moves.  Rather than being attached to the RootInteraction like the cooldown system, these are
+primarily driven by the `Chaining` interaction.
+
+### Chaining
+
+This interaction does not inherit from SimpleInteraction and therefore has no Failed field. Its Next field works differently
+from most interaction types.
+
+Chaining is a type of flow control interaction- each time a Chaining interaction with the same `ChainId` is called, a single
+interaction in the `Next` list is chosen and the others are ignored. The first time the `ChainId` is used, the first
+interaction in the list is chosen, the next time the second, etc. Once the end of the list is reached, the first
+interaction will be chosen again.
+
+Bear in mind: the progress through the Next list is based on the **ChainId**, not the interaction!  That means that two
+different Chaining interactions can share a single combo chain. You could have a pair of daggers that attacks with
+the left when the left mouse button is clicked and with the right when the right mouse button is clicked.  You could give
+both interaction chains a Chaining interaction with the same `ChainId` and three `Next` entries that do a light-light-heavy
+combo.  Each specific hit would occur with either the left or the right knife based on which button you clicked, but
+the combo would be otherwise identical regardless of which you chose.
+
+The Chaining interaction also has a concept called "flags".  It is possible to attach named flags to a `ChainId` by using
+the ChainFlag interaction.  Then, you specify the flag name in Chaining's `Flags` field. If a Flag is active when the
+Chaining interaction is run, the Flag's interaction will be run instead of the appropriate interaction in `Next`.
+Bear in mind: the entity's progress through the `Next` list still advances, the resulting `Next` interaction is just not
+run.  Only one flag can be active at a time.
+
+Lastly, it is possible to cancel the entity's progress through the combo chain and reset them to the first interaction in
+the list. This can be done with the CancelChain interaction, but it will also happen automatically if the player does
+not trigger an interaction with the ChainId for the specified ChainingAllowance.  When either of these happen, all flags will be
+canceled as well.
+
+All of these effects are triggered on the User entity only. Non-players can use the chaining system, but Flags do not currently
+work for non-players.  This interaction has no special failure conditions.
+
+**Chaining Fields**
+
+| Field Name        | Type                                                       | Required? | Notes                                                                                                                                                                                                                       |
+| ----------------- | ---------------------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| ChainId           | `String`                                                   | **No**    | If provided, acts as a key that multiple Chaining interactions can use to share combo chain progress and flags. If not provided, a unique ChainId will be generated for this interaction.                                   |
+| ChainingAllowance | `Double`<br />(Default: 0.0)                               | **No**    | If, at the time this interaction is triggered, it has been this long in seconds since the last time a Chaining interaction with the same ChainId was executed, all state for this ChainId will be cleared before execution. |
+| Next              | `AssetArray`<br />(Element Type: `Interaction`)            | **Yes**   | A list of interactions to cycle between each time this interaction is run.                                                                                                                                                  |
+| Flags             | `Map`<br />(Key Type: `String`, Value Type: `Interaction`) | **No**    | A map of flag names to interactions to run if the flag is active when this interaction executes.                                                                                                                            |
+
+### CancelChain
+
+This interaction resets all progress and flag data on the User entity for the provided `ChainId`.  The next time a Chaining
+interaction is called for the provided `ChainId`, it will begin at the first interaction in the `Next` list. This
+interaction has no special failure conditions.
+
+**CancelChain Fields**
+
+| Field Name | Type     | Required? | Notes                                 |
+| ---------- | -------- | --------- | ------------------------------------- |
+| ChainId    | `String` | **Yes**   | A ChainId whose data should be reset. |
+
+### ChainFlag
+
+This interaction activates a flag on the User entity for the provided `ChainId`, which can be used to change behavior the
+next time a Chaining interaction with this `ChainId` is run. This will overwrite any flag that has
+already been raised. This interaction will have no effect for non-players. This interaction has no special failure
+conditions.
+
+| Field Name | Type     | Required? | Notes                                        |
+| ---------- | -------- | --------- | -------------------------------------------- |
+| ChainId    | `String` | **Yes**   | A ChainId on whom the flag should be raised. |
+| Flag       | `String` | **Yes**   | The name of the flag to raise.               |
+
+## Charging
+
+A unique flow-control interaction that is frequently used is the Charging interaction.  It is a flow-control interaction
+that delays while the input button used to trigger the interaction chain is held.  When it is released (or the interaction
+is forced to end), the interaction chain can continue with a different interaction based on how long the input was held
+for.
+
+These interactions are all related by either being the Charging interaction, or other interaction types that inherit the
+Charging interaction's behavior.
+
+### Charging
+
+This interaction does not inherit from SimpleInteraction and therefore its Next field works different from most interactions.
+This interaction adds its own Failed field which works the same way that SimpleInteraction's does.
+
+This interaction only works properly when its interaction chain was triggered by a client key or button press (or
+NPC-simulated equivalent). This interaction will continue executing for as long as the key or button press is held (with
+some exceptions, covered below) by the User entity.  Like other interactions, it has a `Next` field indicating which interaction to execute
+after this one, but the field is a map from `Float` values to `Interaction` assets. When this interaction ends, either
+due to the input being released or the charge duration completing, this interaction will determine the largest `Float` key that is less
+than the amount of time in seconds that the interaction was executing for.  The Interaction mapped to that key will be
+executed next.
+
+The interaction includes some cancellation conditions that are specific to this interaction. For instance, the interaction
+has a `CancelOnOtherClick` field that matches the field on RootInteraction. If it is active on this interaction but not
+the RootInteraction, then clicking while charging will cancel this interaction (and execute the `Failed` interaction rather
+than any of the `Next` interactions) but otherwise continue the interaction chain.
+
+Another valuable feature Charging has is the `Forks` field.  For input-triggered interactions that are triggered while the
+Charging interaction is executing, you can add an entry for the relevant InteractionType to this field and instead of
+triggering the usual interaction chain based on held item, targeted block, etc. the RootInteraction specified in the
+`Forks` field will be triggered.  This can unlock rich attack modes and behaviors. For instance, having a shield bash attack
+triggered off left click while blocking, or a special attack that triggers when both mouse buttons are pressed at the
+same time.
+
+There are two modes of operation for the Charging interaction. One is to have the ability charge for as long
+as the input is held and only end execution when the entity releases the input.  Bows in the main Hytale game work
+that way.  That is accomplished by setting `AllowIndefiniteHold` to true.  Another mode of operation is to have the
+interaction complete execution when the execution time has surpassed the largest key value in the `Next` field and
+immediately begin executing the Interaction mapped to that key.  Food in the main Hytale game work like this.  It
+is accomplished by setting `AllowIndefiniteHold` to false.
+
+One pitfall to be careful of when setting `AllowIndefiniteHold` to false is the way it interacts with cooldowns.\
+Normally, input-initiated interaction chains start a 0.35s cooldown on the triggered RootInteraction that prevents
+holding the mouse button from immediately spamming a new interaction when the first one completes.  However, if the
+duration of a Charging interaction is longer than 0.35s, then the cooldown will have already completed when the
+interaction chain finishes, which will often result in a new execution beginning immediately before the player can
+stop pressing the mouse button.  One solution for this problem is to add a `Simple` interaction to the end of your
+interaction chain with a `RunTime` of 0.35s to simulate the cooldown.  Alternatively, you can add a longer cooldown
+(the maximum duration of your Charging interaction plus 0.35s) to the RootInteraction. However, the longer cooldown is
+not always desirable, as the interaction may have ended prematurely, resulting in an unusually long lockout between
+executions.
+
+**Charging Fields**
+
+| Field Name                         | Type                                                                    | Required? | Notes                                                                                                                                                                                                                                                                                                                                                                                       |
+| ---------------------------------- | ----------------------------------------------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| FailOnDamage                       | `Boolean`<br />(Default: false)                                         | **No**    | If true, this interaction will fail and end immediately if the User entity takes any damage while it is executing.                                                                                                                                                                                                                                                                          |
+| CancelOnOtherClick                 | `Boolean`<br />(Default: true)                                          | **No**    | If true, this interaction will fail and end immediately if the User entity sends another button or key press while it is executing.                                                                                                                                                                                                                                                         |
+| Forks                              | `Map`<br />(Key Type: `InteractionType`, Value Type: `RootInteraction`) | **No**    | A map of InteractionType to RootInteraction. If entity input triggers the InteractionType while this interaction is executing, the mapped RootInteraction will be forked into its own interaction chain. This will happen instead of the usual handling for that InteractionType.  This fork will occur even if `CancelOnOtherClick` is set to true.                                        |
+| Failed                             | `Asset`<br />(Asset Type: `Interaction`)                                | **No**    | After this Interaction has finished, "Failed" will be executed if this Interaction failed.                                                                                                                                                                                                                                                                                                  |
+| AllowIndefiniteHold                | `Boolean`<br />(Default: false)                                         | **No**    | If true, this interaction will continue executing for as long as the User entity continues to hold the input. If false, execution will end as soon as the execution time in seconds reaches the largest key value in the `Next` map.                                                                                                                                                        |
+| DisplayProgress                    | `Boolean`<br />(Default: true)                                          | **No**    | If true, players executing this interaction will see a progress bar will be displayed below their cursor indicating how close to reaching the highest key value in `Next` they are.                                                                                                                                                                                                         |
+| Next                               | `Map`<br />(Key Type: `Float`, Value Type: `Interaction`)               | **No**    | A map from `Float` to `Interaction`.  When this interaction successfully finishes executing (either because the input was released or because the maximum duration was reached), this interaction will find the `Float` value with the largest duration in seconds that is less than the amount of time this interaction executed for. That key's mapped Interaction will then be executed. |
+| MouseSensitivityAdjustmentTarget   | `Float`<br />(Default: 1.0)                                             | **No**    | While charging, this mouse sensitivity multiplier will gradually be applied.                                                                                                                                                                                                                                                                                                                |
+| MouseSensitivityAdjustmentDuration | `Float`<br />(Default: 1.0)                                             | **No**    | Duration in seconds. After this many seconds, `MouseSensitivityAdjustmentTarget` will be fully applied to the mouse sensitivity.                                                                                                                                                                                                                                                            |
+| Delay                              | `ChargingDelay`                                                         | **No**    | Settings that allow charging progress to be pushed back when the User entity takes damage.                                                                                                                                                                                                                                                                                                  |
+
+**ChargingDelay Fields**
+
+| Field Name    | Type                        | Required? | Notes                                                                                                                                                                                                                                                                     |
+| ------------- | --------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| MinHealth     | `Float`<br />(Default: 0.0) | **No**    | Damage taken as a percentage of entity health (0.0-1.0). If a hit deals less than this much damage, no pushback will be applied.  If a hit deals exactly this much damage, `MinDelay` seconds worth of pushback will be applied.                                          |
+| MaxHealth     | `Float`<br />(Default: 0.0) | **No**    | Damage taken as a percentage of entity health (0.0-1.0). If a hit deals at least this much damage, `MaxDelay` seconds worth of pushback will be applied.                                                                                                                  |
+| MinDelay      | `Float`<br />(Default: 0)   | **No**    | The amount of pushback, in seconds, to apply if the entity takes a hit that deals `MinHealth` damage. The amount of pushback applied by a hit is a gradiant between `MinDelay` and `MaxDelay` based on the amount of damage between `MinHealth` and `MaxHealth`.          |
+| MaxDelay      | `Float`<br />(Default: 0)   | **No**    | The amount of pushback, in seconds, to apply if the entity takes a hit that deals at least `MaxHealth` damage. The amount of pushback applied by a hit is a gradiant between `MinDelay` and `MaxDelay` based on the amount of damage between `MinHealth` and `MaxHealth`. |
+| MaxTotalDelay | `Float`<br />(Deault: 0)    | **No**    | The maximum amount of pushback the entity can receive over the course of a single charge, regardless of how many times they are hit.                                                                                                                                      |
+
+**InteractionType Values**
+
+- `Primary`
+- `Secondary`
+- `Ability1`
+- `Ability2`
+- `Ability3`
+- `Use`
+- `Pick`
+- `Pickup`
+- `CollisionEnter`
+- `CollisionLeave`
+- `Collision`
+- `EntityStatEffect`
+- `SwapTo`
+- `SwapFrom`
+- `Death`
+- `Wielding`
+- `ProjectileSpawn`
+- `ProjectileHit`
+- `ProjectileMiss`
+- `ProjectileBounce`
+- `Held`
+- `HeldOffhand`
+- `Equipped`
+- `Dodge`
+- `GameModeSwap`
+
+### Wielding
+
+This interaction is inherited from Charging rather than SimpleInteraction.  However, its `Failed` and `Next` fields function
+identically to SimpleInteraction.  It does not inherit all fields from Charging, so be sure to pay close attention to
+the field list below.
+
+This interaction drives most blocking behavior in the game. While this interaction is executing, attacks made against
+the Owner entity will (conditionally) trigger effects defined in this interaction.  Unlike the Charging interaction,
+this interaction can always execute indefinitely and will only end when it fails or when the input is released.
+
+One option available in Wielding is `AngledWielding`, which allows damage and knockback modifiers to only be applied
+depending on the direction the attack against the Owner entity is coming from.  The AngledWielding type has a
+field `Angle` which determines which direction the protection points relative to the player (0 is the player's
+front), and `AngleDistance` which determines how wide the cone of protection extends around the player.  Block effects
+from this interaction (such as `BlockedEffects`, `BlockedInteractions`, and `StaminaCost`) will only apply if
+the DamageCause matches `DamageModifiers` OR if the DamageCause matches `AngledWielding.DamageModifiers` and
+the source of the damage matches `Angle` and `AngleDistance`.  It is possible for damage and knockback multipliers
+specified on both this interaction's modifier fields and `AngledWielding`'s modifier fields to stack, if both
+have entries for the same DamageCause.
+
+This interaction will only have an effect on damage taken by one of the DamageCause entries in `DamageModifiers` or
+`AngledWielding.DamageModifiers`.  If a DamageCause is in `DamageModifiers`, then the block effect will be triggered
+and the damage modifier applied regardless of what direction the Owner entity is attacked from.  If a DamageCause is in
+`AngledWielding.DamageModifiers`, then the damage modifier is only applied if the
+
+\*\* Wielding Fields\*\*
+
+| Field Name          | Type                                                                    | Required? | Notes                                                                                                                                                                                                                                                                                                                                                                                                      |
+| ------------------- | ----------------------------------------------------------------------- | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| FailOnDamage        | `Boolean`<br />(Default: false)                                         | **No**    | If true, this interaction will fail and end immediately if the User entity takes any damage while it is executing.                                                                                                                                                                                                                                                                                         |
+| CancelOnOtherClick  | `Boolean`<br />(Default: true)                                          | **No**    | If true, this interaction will fail and end immediately if the User entity sends another button or key press while it is executing.                                                                                                                                                                                                                                                                        |
+| Forks               | `Map`<br />(Key Type: `InteractionType`, Value Type: `RootInteraction`) | **No**    | A map of InteractionType to RootInteraction. If entity input triggers the InteractionType while this interaction is executing, the mapped RootInteraction will be forked into its own interaction chain. This will happen instead of the usual handling for that InteractionType.  This fork will occur even if `CancelOnOtherClick` is set to true (after which this interaction chain will be canceled). |
+| Next                | `Asset`<br />(Asset Type: `Interaction`)                                | **No**    | After this interaction has finished, "Next" will be executed if this interaction did not fail.                                                                                                                                                                                                                                                                                                             |
+| Failed              | `Asset`<br />(Asset Type: `Interaction`)                                | **No**    | After this interaction has finished, "Failed" will be executed if this interaction failed.                                                                                                                                                                                                                                                                                                                 |
+| DamageModifiers     | `Map`<br />(Key Type: `DamageCause`, Value Type: `Float`)               | **No**    | A map from DamageCause to Float, where the Float is multiplied against any damage received from the mapped DamageCause while this interaction is executing.                                                                                                                                                                                                                                                |
+| KnockbackModifiers  | `Map`<br />(Key Type: `DamageCause`, Value Type: `Float`)               | **No**    | A map from DamageCause to Float, where the Float is multiplied against any knockback force received from the mapped DamageCause while this interaction is executing.                                                                                                                                                                                                                                       |
+| AngledWielding      | `AngledWielding`                                                        | **No**    | Configuration to only trigger block effects from certain angles.                                                                                                                                                                                                                                                                                                                                           |
+| StaminaCost         | `StaminaCost`                                                           | **No**    | If the Owner entity receives damage that matches `DamageModifiers` or `AngledWielding` while this interaction is executing, then the entity's stamina will be deducted according to this configuration.                                                                                                                                                                                                    |
+| BlockedEffects      | `DamageEffects`                                                         | **No**    | If the Owner entity receives damage that matches `DamageModifiers` or `AngledWielding` while this interaction is executing, then these effects will be applied to the instance of damage.                                                                                                                                                                                                                  |
+| BlockedInteractions | `Asset`<br />(Asset Type: `RootInteraction`)                            | **No**    | If the Owner entity receives damage that matches `DamageModifiers` or `AngledWielding` while this interaction is executing, then this RootInteraction will be launched as a brand new interaction chain with the Owner entity as both Owner and User, and the attacker as the Target entity.  This new interaction chain is, notably, brand new, **not** forked from the current one.                      |
+
+**AngledWielding Fields**
+
+| Field Name         | Type                                                      | Required? | Notes                                                                                                                                                                                                            |
+| ------------------ | --------------------------------------------------------- | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Angle              | `Float`<br />(Default: 0.0)                               | **No**    | Angle in degrees relative to the Owner entity where the angled protection is centered. 0.0 means pointed towards the front of the Owner entity.                                                                  |
+| AngleDistance      | `Float`<br />(Default: 0.0)                               | **No**    | Angle in degrees indicating how wide the cone of protection is.                                                                                                                                                  |
+| DamageModifiers    | `Map`<br />(Key Type: `DamageCause`, Value Type: `Float`) | **No**    | A map from DamageCause to Float, where the Float is multiplied against any damage received from the mapped DamageCause received from within the cone of protection while this interaction is executing.          |
+| KnockbackModifiers | `Map`<br />(Key Type: `DamageCause`, Value Type: `Float`) | **No**    | A map from DamageCause to Float, where the Float is multiplied against any knockback force received from the mapped DamageCause received from within the cone of protection while this interaction is executing. |
+
+**StaminaCost Fields**
+
+| Field Name | Type                                             | Required? | Notes                                                                                                                                                                                                                                                |
+| ---------- | ------------------------------------------------ | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| CostType   | `CostType`<br />(Default: `MaxHealthPercentage`) | **No**    | How to calculate stamina consumed by blocking from the raw pre-block damage. If `Damage`, then the stamina consumed will be `rawDamage / Value`. If `MaxHealthPercentage`, then the stamina consumed will be `rawDamage / (EntityMaxHealth * Value)` |
+| Value      | `Float`<br />(Default: 0.04)                     | **No**    | The value to use in the `CostType` formula.                                                                                                                                                                                                          |
+
+**DamageEffects Fields**
+
+| Field Name             | Type                                         | Required? | Notes                                                                           |
+| ---------------------- | -------------------------------------------- | --------- | ------------------------------------------------------------------------------- |
+| ModelParticles         | `Array`<br />(Element Type: `ModelParticle`) | **No**    | Particle systems to trigger in the first-person view.                           |
+| WorldParticles         | `Array`<br />(Element Type: `WorldParticle`) | **No**    | Particle systems to trigger in the third-person view.                           |
+| LocalSoundEventId      | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | 2D sound to play locally to the attacking entity if they are a player.          |
+| WorldSoundEventId      | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | Sound to play in the world at the Owner entity's location.                      |
+| PlayerSoundEventId     | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | 2D sound to play locally to the Owner entity if they are a player.              |
+| ViewDistance           | `Double`<br />(Default: 75.0)                | **No**    | Distance at which these effects should play for other players.                  |
+| Knockback              | `Knockback`                                  | **No**    | The properties of the knockback that will be applied.                           |
+| CameraEffect           | `Asset`<br />(Asset Type: `CameraEffect`)    | **No**    | CameraEffect to briefly apply locally to the Owner entity if they are a player. |
+| StaminaDrainMultiplier | `Float`<br />(Default: 1.0)                  | **No**    | This multiplier is applied to the `StaminaCost`, if any.                        |
+
+**Knockback Fields**
+
+| Field Name     | Type                                       | Required? | Notes                                                                                                                      |
+| -------------- | ------------------------------------------ | --------- | -------------------------------------------------------------------------------------------------------------------------- |
+| Type           | `String`                                   | **No**    | If provided, specifies a type of knockback to use. Each knockback type may come with additional fields.                    |
+| Force          | `Double`<br />(Default: 0.0)               | **No**    | The amount of force to apply to the Owner entity.                                                                          |
+| Duration       | `Double`<br />(Default: 0.0)               | **No**    | If 0.0, apply the force as a single impulse.  If more, continuously apply the force over a period of time.                 |
+| VelocityType   | `ChangeVelocityType`<br />(Default: `Add`) | **No**    | How to apply the force, either adding it to the entity's current velocity, or setting the velocity to the knockback force. |
+| VelocityConfig | `VelocityConfig`                           | **No**    | Characteristics of friction as the Owner entity is thrown by this knockback.                                               |
+
+**Knockback Type: Force**
+
+Apply the calculated knockback force along the provided direction.
+
+| Field Name | Type                         | Required? | Notes                                                                                |
+| ---------- | ---------------------------- | --------- | ------------------------------------------------------------------------------------ |
+| Direction  | `Vector3`<br />(Default: Up) | **No**    | Which direction the player should be flung, relative to the direction of the attack. |
+
+**Knockback Type: Point**
+
+Apply the calculated knockback force laterally along the XZ plane, plus provided Y velocity.
+
+| Field Name | Type                        | Required? | Notes                                                                                                   |
+| ---------- | --------------------------- | --------- | ------------------------------------------------------------------------------------------------------- |
+| OffsetX    | `Integer`<br />(Default: 0) | **No**    | Offset the source position of the knockback left or right perpendicular to the direction of the attack. |
+| OffsetZ    | `Integer`<br />(Default: 0) | **No**    | Offset the source position of the knockback, forward or backward along the directon of the attack.      |
+| RotateY    | `Integer`<br />(Default: 0) | **No**    | Rotate the knockback direction around the Y axis, where 0 is the default attack direction.              |
+| VelocityY  | `Float`<br />(Default: 0.0) | **No**    | Add vertical velocity to the knockback force after the direction and force has been calculated.         |
+
+**Knockback Type: Directional**
+
+Apply the calculated knockback force along the attack direction, removing any vertical component and replacing it with a provided Y velocity.
+
+| Field Name | Type                      | Required? | Notes                                                                                                                                            |
+| ---------- | ------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------ |
+| RelativeX  | `Float`<br />(Default: 0) | **No**    | Apply additional force left or right perpendicular to the direction of the attack. The additional force is multiplied by the knockback strength. |
+| RelativeZ  | `Float`<br />(Default: 0) | **No**    | Apply additional force forward or backward along the attack direction. The additional force is multiplied by the knockback strength.             |
+| VelocityY  | `Float`<br />(Default: 0) | **No**    | Replace the vertical velocity of the knockback with this value.  This value is not multiplied by knockback strength.                             |
+
+**VelocityConfig Fields**
+
+| Field Name          | Type                                              | Required? | Notes                                                                                                                                                                                           |
+| ------------------- | ------------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| GroundResistance    | `Float`<br />(Default: 0.82)                      | **No**    | The minimum amount of friction applied when the entity is in contact with the ground.  1.0 = no friction, 0.0 = total friction                                                                  |
+| GroundResistanceMax | `Float`<br />(Default: 0.0)                       | **No**    | The maximum amount of friction applied when the entity is in contact with the ground.  1.0 = no friction, 0.0 = total friction                                                                  |
+| AirResistance       | `Float`<br />(Default: 0.96)                      | **No**    | The minimum amount of friction applied when the entity is in the air. 1.0 = no friction, 0.0 = total friction                                                                                   |
+| AirResistanceMax    | `Float`<br />(Default: 0.0)                       | **No**    | The maximum amount of friction applied when the entity is in the air. 1.0 = no friction, 0.0 = total friction                                                                                   |
+| Threshold           | `Float`<br />(Default: 1.0)                       | **No**    | The speed at which the maximum amount of friction will be applied to the entity. The amount of friction applied will increase from minimum to maximum as the entity moves from 0 to this speed. |
+| Style               | `VelocityThresholdStyle`<br />(Default: `Linear`) | **No**    | The curve that friction follows as the entity's speed increases toward the `Threshold`.                                                                                                         |
+
+**CostType Values**
+
+- `MaxHealthPercentage`
+- `Damage`
+
+**ChangeVelocityType Values**
+
+- `Add`
+- `Set`
+
+**VelocityThresholdStyle Values**
+
+- `Linear`
+- `Exp`
+
+## Blocks
+
+These are interaction types meant to reason about and modify blocks in the world.  The most important concept unique
+to these interactions is the Block Target.  Like the Entity Target, it is mutable and can come from many places.
+However, for interaction chains initiated by the client, the block target will initially be the block that the player's cursor was
+over, if any.
+
+Additionally, for interaction chains initiated by the client, the client will send along which face of the block is targeted,
+which is used by a few block-related interactions.
+It is left up to each interaction type that cares about block faces as to how to handle this behavior for simulated input
+(i.e. NPCs initiating chains that are normally initated by the client).  At the time of this writing, all block-related
+interactions choose the top face where relevant in simulated input.
+
+### BlockCondition
+
+This interaction has a field `Matchers` which specifies certain conditions, such as block type, state, etc.  This
+interaction fails if the current target block does not match all of them.
+
+**BlockCondition Fields**
+
+| Field Name       | Type                                        | Required? | Notes                                                                                                                                                                                                                                                                                                                                   |
+| ---------------- | ------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false)             | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction.                                                                                                                                                                                                       |
+| Matchers         | `Array`<br />(Element Type: `BlockMatcher`) | **Yes**   | A list of conditions that the target block must match or this condition will fail.<br />**Note: This field is technically not required but there is a bug that makes it dangerous to not provide at the time of this writing.**<br />**Note: If no conditions are added to this array, the interaction will fail, counterintuitively.** |
+
+**BlockMatcher Fields**
+
+| Field Name | Type                       | Required? | Notes                                                                          |
+| ---------- | -------------------------- | --------- | ------------------------------------------------------------------------------ |
+| Block      | `BlockIdMatcher`           | **No**    | If provided, requires the block itself match some set of conditions.           |
+| Face       | `BlockFace`                | **No**    | If provided and not 'None', requires a specific block face be targeted.        |
+| StaticFace | `Boolean` (Default: false) | **No**    | If false, the face condition will be adjusted by the block's current rotation. |
+
+**BlockFace Values**
+
+- `Up`
+- `Down`
+- `North`
+- `South`
+- `East`
+- `West`
+- `None`
+
+**BlockIdMatcher Fields**
+
+| Field Name | Type                                   | Required? | Notes                                                                      |
+| ---------- | -------------------------------------- | --------- | -------------------------------------------------------------------------- |
+| Id         | `Asset`<br />(Asset Type: `BlockType`) | **No**    | If provided, the block must match the specified `BlockType`.               |
+| State      | `String`                               | **No**    | If provided, the block's current state must match the provided state name. |
+| Tag        | `String`                               | **No**    | If provided, the block type's asset tags must contain the provided tag.    |
+
+### DestroyCondition
+
+This interaction fails if the current User entity cannot destroy the current target blcok.
+
+**DestroyCondition Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+
+### PlacementCountCondition
+
+This interaction accepts the name of a BlockType that has the TrackedPlacement BlockEntity. The interaction will fail if the number of
+blocks of the provided BlockType in the world do not match the provided condition.
+
+**PlacementCountCondition Fields**
+
+| Field Name | Type                           | Required? | Notes                                                                                                                                                                                                                                                           |
+| ---------- | ------------------------------ | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Block      | `String`                       | **Yes**   | The BlockType to examine. The number of instances of the BlockType in the world will be compared to Value.<br />**Note: The specified BlockType must have the TrackedPlacement BlockEntity. Otherwise, the number of blocks in the world will always be zero.** |
+| Value      | `Integer`<br />(Default: 0)    | **No**    | The value to compare the number of blocks in the world with.                                                                                                                                                                                                    |
+| LessThan   | \`Boolean<br />(Default: true) | **No**    | If true, the interaction will fail if the number of blocks in the world is greater than or equal to Value. If false, the interaction will fail if the number of blocks in the world is less than or equal to Value.                                             |
+
+### BreakBlock
+
+This interaction attempts to break the target block while acting as the User entity. The User entity must be a player. It
+is not guaranteed to work, depending on world settings and the User entity's current state, it may not work.  If it
+fails, it will fail the interaction under some circumstances, but not others.
+
+**Note: In particular, if `Harvest`=false and the player is in Survival mode, the player will simply execute a damage operation
+against the block. Even when the Tool field is specified, the player's currently-held item can impact the results in unintuitive
+ways.**
+
+This interaction will fail if there is no block target, if `Harvest`=true and the
+block is not harvestable, or if the world settings prevent the Harvest/Break operation.
+It will generally not fail otherwise, even if the block was not broken or damaged.
+The block will generally break every time if `Harvest`=true or the player is in
+Creative mode.
+
+**BreakBlock Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                                                                                                                                                                                                  |
+| ---------------- | ------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction.                                                                                                                                                                      |
+| Harvest          | `Boolean` (Default: false)      | **No**    | If true, harvest the block and deposit the drops in the player's inventory. This operation will generally always succeed.  If false, this interaction will effectively perform whatever action would have occurred if the player had left-clicked the block.                                           |
+| Tool             | `String`                        | **No**    | If `Harvest`=true, the player is in Survival mode, and this field is provided, then the break operation will be performed as though with this tool type.<br />**This field mostly doesn't work.  Your held item will be used for most block damage calculations regardless of this field's contents.** |
+| MatchTool        | `Boolean` (Default: false)      | **No**    | If true, `Harvest`=true, the player is in Survival mode, and `Tool` is provided, block breaking will be prevented unless `Tool` is a valid gathering tool for the target block. The interaction will not be failed, even if block breaking is prevented in this manner.                                |
+
+### ChangeBlock
+
+This interaction requires a mapping from one or more current BlockTypes to one or more target BlockTypes.  If the
+target block is one of the key BlockTypes, then it will be changed to the mapped target BlockType.  If the current
+BlockType of the target block does not appear as a key in the Changes field, then this interaction fails.
+
+**ChangeBlock Fields**
+
+| Field Name        | Type                                                        | Required? | Notes                                                                                                                             |
+| ----------------- | ----------------------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget  | `Boolean`<br />(Default: false)                             | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+| Changes           | `Map`<br />(Key Type: `BlockType`, Value Type: `BlockType`) | **No**    | A list of potential block type changes, with each entry having a current and new BlockType id.                                    |
+| WorldSoundEventId | `Asset`<br />(Asset Type: `SoundEvent`)                     | **No**    | If provided, this SoundEvent is played in the world at the position of the block if the block successfully changes.               |
+| RequireNotBroken  | `Boolean`<br />(Default: false)                             | **No**    | If true, this interaction will fail if the player's held item is broken (durability 0), and the block change will not take place. |
+
+### ChangeState
+
+This interaction requires a mapping from one or more current block state names to one or more state names. If the
+target block is in one of the key block states, then it will be changed to the mapped target blocks tate. If the
+current block state of the target block does nto appear as a key in the Changes field, then this interaction fails.
+
+All blocks start out with a null state by default.  This null state can be referenced by the key "default" and the block
+can be returned to that state with the value "default".
+
+**ChangeState Fields**
+
+| Field Name       | Type                                                  | Required? | Notes                                                                                                                                          |
+| ---------------- | ----------------------------------------------------- | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false)                       | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction.              |
+| Changes          | `Map`<br />(Key Type: `String`, Value Type: `String`) | **No**    | A list of potential block state changes, with each entry having a current and new state name.                                                  |
+| UpdateBlockState | `Boolean`<br />(Default: false)                       | **No**    | If true, performs a full refresh of the block's BlockEntity component and notifies nearby players as though a full block type change occurred. |
+
+### CycleBlockGroup
+
+This interaction will attempt to change the target block to the next block type in one of the BlockGroups it belongs to.
+If the block type belongs to multiple BlockGroups, which one is used is effectively arbitrary. The User entity must be
+a player. If the block cannot be changed for any reason (entity not a player, no block target, block does not belong
+to a BlockGroup, etc.). If the block is the only entry in the BlockGroup, this interaction will succeed and the block
+will be considered changed despite nothing happening.  Unlike most other block-changing interactions, this one will
+fail if the world settings prevent players from breaking blocks.
+
+**This interaction always reduces the player's held item's durability by a single 'hit' worth of damage if the block
+changes. There is no way to prevent it. The block type will change and the interaction will succeed even if the player's
+held item is broken, however.**
+
+**CycleBlockGroup Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+
+### DestroyBlock
+
+This interaction destroys the target block without dropping anything.  It will successfully destroy the block if the
+target block exists and this interaction has no failure conditions.
+
+**This interaction has no additional fields.**
+
+### PickBlock
+
+This interaction is effectively equivalent to using the middle mouse button in creative mode. In survival mode, the
+block's item will be moved to the user's current active hotbar slot if it is in the player's inventory.  This
+interaction is performed entirely on the client and cannot be performed by non-players.  It is unclear if this
+interaction has failure conditions.
+
+**PickBlock Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+
+### PlaceBlock
+
+This interaction is effectively identical to a right clicking while holding a block in their hand, with some
+additional options. For one, it can be executed with any LivingEntity as the User entity. For another, it has some
+useful fields.  For the most part, though, it follows the same behaviors and rules as any ordinary block placement
+by a player.
+
+It's not clear under what circumstances this interaction can fail. The server will not fail the interaction under any
+special circumstances (including when there is no target block, or when `BlockTypeToPlace` is not provided and the
+LivingEntity is not holding a block). However, the client is very involved with the function of this interaction and
+its behavior is unknown.
+
+**PlaceBlock Fields**
+
+| Field Name         | Type                                   | Required? | Notes                                                                                                                                                                                                                                                                                                                                                           |
+| ------------------ | -------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| BlockTypeToPlace   | `Asset`<br />(Asset Type: `BlockType`) | **No**    | If provided, the block placed by this interaction will be the specified BlockType. If not provided, the User entity's held item will be used, instead, if it is a block.                                                                                                                                                                                        |
+| RemoveItemInHand   | `Boolean`<br />(Default: True)         | **No**    | If true and the User entity is not a player in Creative mode, the item in the player's hand must match the block being placed and one quantity will be removed for each block placed. If the item does not match, the block cannot be placed.  If false, the player's hand item is ignored entirely.\*\*                                                        |
+| AllowDragPlacement | `Boolean`<br />(Default: True)         | **No**    | If true and the interaction was triggered on the client by a player, then the player can hold the input that was used to activate this interaction chain and move the mouse around in order to execute this interaction repeatedly and place several blocks. The interaction chain will not move onto the next interaction until the player releases the input. |
+
+### RunOnBlockTypes
+
+This interaction retrieves all blocks within a provided radius of the User entity. For each block that matches any of
+the provided BlockSets, a new interaction chain will be forked that uses the matching block as the target block.
+This interaction will continue executing until all forked interaction chains have completed.  The interaction will fail if no
+blocks within the radius match the provided BlockSets or if all of the forked interaction chains fail.
+
+**RunOnBlockTypes Fields**
+
+| Field Name   | Type                                         | Required?        | Notes                                                                                                                                                                                                                                                                                      |
+| ------------ | -------------------------------------------- | ---------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| Range        | `Integer`                                    | **Yes**          | The spherical radius around the User entity to search for blocks. Must be at least 1.                                                                                                                                                                                                      |
+| BlockSets    | `AssetArray`<br />(Element Type: `BlockSet`) | **No**           | A list of BlockSets to match nearby blocks again. Only blocks that match any of the BlockSets will have interaction chains forked for them.                                                                                                                                                |
+| MaxCount     | `Integer`                                    | **Yes**          | The maximum number of blocks that will be located with the search. Further blocks will be ignored. If there are more matching blocks within the radius than this number, the specific set of blocks that will be found is completely arbitrary and may change from execution to execution. |
+| Interactions | `Asset`<br />(Asset Type: `RootInteraction`) | **No, but yes.** | The RootInteraction that will be forked for each matching block.  This interaction will not fail to validate if it is missing, but every execution of this interaction will fail.                                                                                                          |
+
+### UseBlock
+
+If the target block has an interaction for this interaction chain's interaction type, execute it immediately as part of
+this interaction chain. The execution will be wrapped in UseBlockEvent.Pre and UseBlockEvent.Post events, and cancellations
+of the UserBlockEvent.Pre event are respected. The User entity is considered the triggering entity for both events.
+
+If the target block does not have an interaction for this interaction chain's interaction type, this interaction fails.
+
+**This interaction has no additional fields.**
+
+## Items
+
+These are interactions intended to interface with an entity's inventory. There is no concept of an "item target",
+unfortunately, so these generally either interact with the entity's held item or the entity's inventory at a high level.
+
+### AddItem
+
+Adds a specified quantity of a specified item to the User entity's inventory, preferring to add it to the
+entity's hotbar where possible. This interaction will have no effect on User entities that are not LivingEntities.
+This interaction has no failure states.
+
+**Note: This interaction has a bug in its field validators that will cause interactions that reference items declared
+in the same mod to fail validation on startup.  Additionally, this interaction has a bug that will cause it to
+fail and have no effect if the User entity has no block target. Use ModifyInventory instead.**
+
+**AddItem Fields**
+
+| Field Name       | Type                              | Required? | Notes                                                                                                                             |
+| ---------------- | --------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false)   | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+| ItemId           | `Asset`<br />(Asset Type: `Item`) | **Yes**   | The item id of the item to add to the player's inventory.                                                                         |
+| Quantity         | `Integer`<br />(Default: 0)       | **No**    | The quantity of the item to add to the player's inventory.                                                                        |
+
+### CheckUniqueItemUsage
+
+This interaction will check whether it has run once for the User entity with their currently-held item before. If it hasn't,
+it will succeed. If it has, it will fail. It will also fail if the User entity is not a player. The interaction will record
+the item id of the User entity's currently-held item on success, ensuring it cannot be successfully run with that player
+and item id combination again.
+
+**This interaction has no additional fields.**
+
+### ChangeActiveSlot
+
+This interaction does not inherit from SimpleInteraction and therefore has no Next or Failed fields.  The `CancelOnItemChange`
+field is ignored for this interaction and is always treated as false. This interaction will set the User entity's currently-
+active hotbar slot to the specified slot index. If none is specified, the interaction chain's target slot will be used,
+if any. Otherwise, slot 0 will be used.  If a slot is specified and it is already active, then this interaction will
+have no effect, but if no slot is specified and the interaction chain's target slot is already active, the logic in
+the next paragraph will still be executed. This interaction will also have no effect if the User entity is not a
+LivingEntity.
+
+Once the slot has changed, a new SwapTo interaction chain will be forked off for the selected slot.
+If a target slot was specified, then the interaction chain's current target slot will be set to the specified slot, as will
+the forked SwapTo interaction chain. If this interaction chain was initiated by a player swapping an item into or out of
+an occupied active hotbar slot, then the swap will be executed after the slot is changed and before the SwapTo
+interaction is forked. Not running this interaction in the resulting SwapFrom interaction chain is a way for the server
+to cancel players performing these sorts of swap interactions. The default behavior for these swap interactions is that
+the SwapFrom interaction chain will be initiated with the currently-active-slot as the target slot. As a result, the
+target slot will usually not change when this interaction runs, it merely exists as a signal for the server to continue the
+item swap.
+
+**ChangeActiveSlot Fields**
+
+| Field Name | Type      | Required? | Notes                                                                                                                                                                                                     |
+| ---------- | --------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| TargetSlot | `Integer` | **No**    | If not provided, indicates the slot the player's active hotbar slot should be changed to.  Otherwise, the interaction chain's target slot will be used (which is usually the already-active hotbar slot). |
+
+### EquipItem
+
+This interaction will equip the User entity's currently-held item into the appropriate armor slot, if it is armor. The
+interaction will fail if the item is armor but it cannot be equipped for some reason. The interaction will succeed but
+take no action if the User entity cannot equip armor or if the item is not armor.
+
+**This interaction has no additional fields.**
+
+### IncreaseBackpackCapacity
+
+This interaction will increase the User entity's backpack size by the provided amount.  **It will additionally remove one
+quantity from the player's currently-held item. There is no way to prevent this.**  This interaction will have no effect
+if the User entity is not a player.  This interaction has no special failure conditions, even if the User entity
+is not a player, or the player is not currently holding an item.
+
+| Field Name | Type                        | Required? | Notes                                                                                   |
+| ---------- | --------------------------- | --------- | --------------------------------------------------------------------------------------- |
+| Capacity   | `Integer`<br />(Default: 1) | **No**    | The additional backpack capacity to add to the player. **Must be between 1 and 32767.** |
+
+### ModifyInventory
+
+This interaction attempts to perform one or more inventory-modifying actions against the User entity. The User entity must
+be a player. If they are not, no actions will be performed, but the interaction will not fail. Any item removals performed
+by this interaction, either as a result of `ItemToRemove` or `AdjustHeldItemQuantity`, are both atomic (meaning the entire
+quantity must be removed, or none) and required (meaning that the interaction will fail and no further actions taken if
+the removal fails for any reason).  Item additions performed by this interaction, either as a result of `ItemToAdd` or
+`AdjustHeldItemQuantity` will drop excess items on the ground near the player if necesary and continue on.
+
+This interaction first executes the item removal in `ItemToRemove`, if any, then adjusts the held item as specified by
+`AdjustHeldItemQuantity`, if provided, then executes the item addition in `ItemToAdd`, if any, and then finally executes
+the damage/healing of the held item in `AdjustHeldItemDurability`, if provided.
+
+**ModifyDurability Fields**
+
+| Field Name               | Type                            | Required? | Notes                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
+| ------------------------ | ------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| RequiredGameMode         | `GameMode`                      | **No**    | If provided, only execute the inventory-modifying actions if the player is in the provided GameMode. The interaction will not fail if the GameMode doesn't match.                                                                                                                                                                                                                                                                                                                                                                               |
+| ItemToRemove             | `ItemStack`                     | **No**    | If provided, a matching item will be removed in the provided quantity. If there is no matching item in the player inventory in the required quantity, then the interaction will fail and further actions will not be executed.                                                                                                                                                                                                                                                                                                                  |
+| AdjustHeldItemQuantity   | `Integer`<br />(Default: 0)     | **No**    | The player's held item, if any, will have its quantity will be modified by the provided amount- subtracted from if this number is negative or added to if this item is positive.  If the player has no held item, then this field will have no effect regardless of its value and the interaction will NOT fail.  If the player's inventory does not have sufficient quantity of items to support the removal, this interaction will fail and further actions will not be executed. Excess items will be dropped on the ground near the player. |
+| ItemToAdd                | `ItemStack`                     | **No**    | If provided, the ItemStack will be added to the player's inventory. Excess items will be dropped on the ground near the player.                                                                                                                                                                                                                                                                                                                                                                                                                 |
+| AdjustHeldItemDurability | `Double`<br />(Default: 0.0)    | **No**    | The player's held item, if any, will have its durability adjusted by the specified amount.  The durability cannot go below 0 or raise above the item's maximum durability. Invalid durability values in this field will not cause the interaction to fail. Neither will it fail if the player has no held item.                                                                                                                                                                                                                                 |
+| BrokenItem               | `String`                        | **No**    | This field should contain an ItemId, but it is not validated by the server on startup, so be careful.  This field can have the value of "Empty" to specify no item, or an empty hand. If specified and the `AdjustHeldItemDurability` operation reduces the player's held item to 0 durability, the player's held item is changed to this ItemId. If the inventory replacement fails, this interaction will fail.                                                                                                                               |
+| NotifyOnBreak            | `Boolean`<br />(Default: false) | **No**    | If true and the `AdjustHeldItemDurability` operation reduces the player's held item to 0 durability, this interaction will perform the usual audiovisual feedback of a broken tool. It will play the usual tool breaking sound and send the player a text message in chat that their item has broken.                                                                                                                                                                                                                                           |
+| NotifyOnBreakMessage     | `String`                        | **No**    | If provided, and `NotifyOnBreak` is true, when the player is notified of a broken tool by this interaction, the message sent to their chat will instead be the translation key specified by this field. The translation key supports the templating parameter `{itemName}`. See the translation key `server.general.repair.itemBroken_Hoe` for an example.                                                                                                                                                                                      |
+
+**GameMode Values**
+
+- `Creative`: The game is currently in Creative Mode
+- `Adventure`: The game is currently in Adventure Mode
+
+**ItemStack Fields**
+
+| Field Name                   | Type                              | Required? | Notes                                                                                |
+| ---------------------------- | --------------------------------- | --------- | ------------------------------------------------------------------------------------ |
+| Id                           | `Asset`<br />(Asset Type: `Item`) | **Yes**   | The id of the Item asset this stack contains.                                        |
+| Quantity                     | `Integer`<br />(Default: 1)       | **No**    | The number of items in this stack.<br />**Must be greater than 0.**                  |
+| Durability                   | `Double`<br />(Default: 0.0)      | **No**    | The durability of the item stack.<br />**Cannot be negative.**                       |
+| MaxDurability                | `Double`<br />(Default: 0.0)      | **No**    | The maximum durability of the item this stack contains.<br />**Cannot be negative.** |
+| Metadata                     | `Bson Document`                   | **No**    | If provided, applies the bson to the item stack metadata.                            |
+| OverrideDroppedItemAnimation | `Boolean`\*(Default: false)       | **No**    | ???                                                                                  |
+
+### PickupItem
+
+This interaction will attempt to pick up the User entity's current target entity and add it to their inventory. It will
+fail if the User entity is not a player, if they do not have a target entity, or if the target entity is not an item
+located in the world.  It will not fail if the player simply cannot pick up the item.
+
+**This interaction has no additional fields.**
+
+### RefillContainer
+
+This interaction will fail if the User entity is not a player. The interaction will draw a ray from the player's head
+down their look direction until the edge of the player's held item's interaction range or until the first solid block.
+The nearest fluid block of a type listed in this interaction's `States` map will result in the one of the player's
+currently-held items being converted to the fluid's related item state.  If the `States` map indicates a durability
+for the new item state, then the converted item will use that durability. If the item is already in the fluid's related
+item state, then this interaction will fail if the player's held item is already at maximum durability (unless the
+`States` map indicates a durability value greater than the item's maximum, in which case the interaction will succeed
+but the item will not change).  Otherwise, the durability listed for the fluid in the `States` map will be added to the
+item's current durability.
+
+If the interaction has not failed by this point, the fluid block in the world may be transformed to a different type if one is listed
+in the `States` map.
+
+If any part of this process does not proceed for any reason (for instance, if the player is not holding an item),
+then this interaction will fail.
+
+**RefillContainer Fields**
+
+| Field Name | Type                                                       | Required? | Notes                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| ---------- | ---------------------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| States     | `Map`<br />(Key Type: `String`, Value Type: `RefillState`) | **Yes**   | A map from item state names to `RefillState` objects, which contain information such as acceptable fluid block types, durability increases, and what fluid type to convert the targeted fluid block to after refill, if any. If the player targets a fluid block that matches one of the fluid types in the `RefillState`, the item will be converted to the keyed item state and the `RefillState` will be used to decide what happens next. |
+
+**RefillState Fields**
+
+| Field Name     | Type                                  | Required? | Notes                                                                                                                                                                                                                                                                                                                           |
+| -------------- | ------------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| AllowedFluids  | `Array`<br />(Element Type: `String`) | **Yes**   | If any of these fluids are targeted by the player, the player's held item will be converted to the keyed item state and `Durability` and `TransformFluid` will be used.                                                                                                                                                         |
+| Durability     | `Double`<br />(Default: -1.0)         | **No**    | If the player's held item changes item states, this value is the new item's durability, unless it is negative, in which case the item will begin at full durability. If the player's held item is already in the item state, and the item is not already at full durability, this value will be added to the item's durability. |
+| TransformFluid | `String`                              | **No**    | If provided, this field is a fluid id that the targeted fluid block should be transformed to if the player's held item is successfully updated.                                                                                                                                                                                 |
+
+## Entities
+
+### DamageEntity
+
+This interaction does not inherit from SimpleInteraction, but adds its own Next and Failed fields that
+work similarly.
+
+This interaction will cause the User entity to damage the Target entity.  It has the capability to apply different
+damage based on the direction of the attack or what body part was targeted by the User entity, with each possibility
+providing different damage calculations, effects, and Next interaction. If multiple entires match the attack, `TargetedDamage`
+(body part damage) takes highest priority, then the first matching `AngledDamage` in the list, then the default
+damage in the base interaction fields.  It is possible for elements of these different damage priorities to be taken peacemeal if higher-priority
+damage fields do not overwrite lower-priority damage fields. For instance,
+damage calculation could be taken from `TargetedDamage`, the damage effects could be taken from the first matching
+`AngledDamage`, and the Next interaction coming from the default damage field.
+
+If all damage dealt by this interaction is cancelled, then this interaction will fail, and the `Failed` interaction
+will be executed next in the chain. If any damage dealt by this interaction is blocked, then this interaction will
+succeed, but the `Blocked` interaction wil lbe executed next in the chain. Otherwise, the highest-precedent matching
+`Next` interaction that you provide will be executed.  For instance, if you provide `Next` interactions for all
+`TargetedDamage` and `AngledDamage` entries, and one in the interaction's `Next` field, then a headshot could result
+in a unique `Next` interaction being executed, even if there is a matching `AngledDamage` entry. However, if you leave
+the `Next` interaction out of your `TargetedDamage` entries, a special `Next` interaction for backstabs could be
+executed.  Otherwise, the `Next` field in the root of the interaction will be executed instead.
+
+DamageEntity has an unusual relationship with `RunTime`. This interaction always ends immediately after its first tick,
+regardless of the status of `RunTime` or `WaitForAnimationToFinish`.  However, if damage dealt by this interaction is
+calculated as `DamageCalculatorType` `Dps`, then the `RunTime` will be used to determine the precise amount of damage to
+deal. If `RunTime` is 0, then no damage will be dealt.
+
+**DamageEntity Fields**
+
+| Field Name       | Type                                                          | Required?                                                                                                                    | Notes                                                                                                                                                                                                                                                                                                                                                                         |
+| ---------------- | ------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| DamageCalculator | `DamageCalculator`                                            | **No**                                                                                                                       | If provided, describes the damage amounts and types to apply to the Target entity.                                                                                                                                                                                                                                                                                            |
+| DamageEffects    | `DamageEffects`                                               | **No**                                                                                                                       | If provided, describes particles, sounds, knockback, etc. to apply to the target entity on damage.                                                                                                                                                                                                                                                                            |
+| Next             | `Asset`<br />(Asset Type: `Interaction`)                      | **No**  After this interaction has finished, "Next" will be executed if damage was dealt to the target and none was blocked. |                                                                                                                                                                                                                                                                                                                                                                               |
+| AngledDamage     | `Array`<br />(Element Type: `AngledDamage`)                   | **No**                                                                                                                       | If provided, allows alternative `DamageCalculator`, `DamageEffects`, and `Next` entries for attacks that approach the target from certain angles.                                                                                                                                                                                                                             |
+| TargetedDamage   | `Map`<br />(Key Type: `String`, Value Type: `TargetedDamage`) | **Yes**                                                                                                                      | This field must be provided, but is not required to have any entries.  This is a map from body part names to `TargetedDamage` values. Hypixel only uses one body part name: `Head`, and it is not clear whether there are others.  If provided, allows alternative `DamageCalculator`, `DamageEffects`, and `Next` entries for attacks that damage specific enemy body parts. |
+| EntityStatsOnHit | `Array`<br />(Element Type: `EntityStatOnHit`)                | **No**                                                                                                                       | If provided, allows this attack to reduce enemy stats other than health.  Each individual damage application dealt by the same ability will apply stat reductions, at diminishing returns. All damage dealt in interaction chains forked by a Selector interaction will share the number of hits across all targets.                                                          |
+| Failed           | `Asset`<br />(Asset Type: `Interaction`)                      | **No**                                                                                                                       | After this interaction has finished, "Failed" will be executed if no damage hits were applied to the player, or if all damage hits were cancelled.                                                                                                                                                                                                                            |
+| Blocked          | `Asset`<br />(Asset Type: `Interaction`)                      | **No**                                                                                                                       | After this interaction has finished, "Blocked" will be executed if any damage hits were blocked by the target.                                                                                                                                                                                                                                                                |
+
+**DamageCalculator Fields**
+
+| Field Name                | Type                                                      | Required? | Notes                                                                                                                                                                                                                                                 |
+| ------------------------- | --------------------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Type                      | `DamageCalculatorType`<br />(Default: Absolute)           | **No**    | Whether the damage being applied is `Absolute` or \`Dps'.                                                                                                                                                                                             |
+| Class                     | `DamageClass`<br />(Default: Unknown)                     | **No**    | The type of attack producing the damage. Some weapon systems apply equipment modifiers based on this value.                                                                                                                                           |
+| BaseDamage                | `Map`<br />(Key Type: `DamageCause`, Value Type: `Float`) | **No**    | A set of DamageCauses and how much base damage is dealt for each.                                                                                                                                                                                     |
+| SequentialModifierStep    | `Float`<br />(Default: 0.0)                               | **No**    | Value between 0.0-1.0. Each additional hit from a single ability will have its damage reduced by this much as a percentage. All damage dealt in interaction chains forked by a Selector interaction will share the number of hits across all targets. |
+| SequentialModifierMinimum | `Float`<br />(Default: 0.0)                               | **No**    | Value between 0.0-1.0. `SequentialModifierStep` cannot reduce damage below this percentage regardless of the number of hits.                                                                                                                          |
+| RandomPercentageModifier  | `Float`<br />(Default: 0.0)                               | **No**    | A random value between +/- this amount multiplied by the base damage will be added to the base damage.                                                                                                                                                |
+
+**DamageEffects Fields**
+
+| Field Name             | Type                                         | Required? | Notes                                                                                   |
+| ---------------------- | -------------------------------------------- | --------- | --------------------------------------------------------------------------------------- |
+| ModelParticles         | `Array`<br />(Element Type: `ModelParticle`) | **No**    | Particle systems to trigger in the first-person view.                                   |
+| WorldParticles         | `Array`<br />(Element Type: `WorldParticle`) | **No**    | Particle systems to trigger in the third-person view.                                   |
+| LocalSoundEventId      | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | 2D sound to play locally to the attacking entity if they are a player.                  |
+| WorldSoundEventId      | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | Sound to play in the world at the Target entity's location.                             |
+| PlayerSoundEventId     | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | 2D sound to play locally to the Target entity if they are a player.                     |
+| ViewDistance           | `Double`<br />(Default: 75.0)                | **No**    | Distance at which these effects should play for other players.                          |
+| Knockback              | `Knockback`                                  | **No**    | The properties of the knockback that will be applied.                                   |
+| CameraEffect           | `Asset`<br />(Asset Type: `CameraEffect`)    | **No**    | CameraEffect to briefly apply locally to the Target entity if they are a player.        |
+| StaminaDrainMultiplier | `Float`<br />(Default: 1.0)                  | **No**    | This multiplier is applied to the stamina cost incurred by the target blocking, if any. |
+
+**AngledDamage Fields**
+
+| Field Name       | Type                                     | Required? | Notes                                                                                                                                                                                                     |
+| ---------------- | ---------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| AngleDistance    | `Float`<br />(Default: 0)                | **No**    | The width in degrees of the matching arc around the Target entity. If the attack against the Target originates from within the arc, then the properties below will be applied to the attack, if provided. |
+| Angle            | `Float`<br />(Default: 0.0)              | **No**    | The angle in degrees around the Target entity at which the matching arc is centered.                                                                                                                      |
+| DamageCalculator | `DamageCalculator`                       | **No**    | If provided and the attack against the Target entity originates from within the provided arc, this DamageCalculator will override the interaction's `DamageCalculator` field.                             |
+| DamageEffects    | `DamageEffects`                          | **No**    | If provided and the attack against the Target entity originates from within the provided arc, this DamageEffects will override the interaction's `DamageEffects` field.                                   |
+| Next             | `Asset`<br />(Asset Type: `Interaction`) | **No**    | If provided and the attack against the Target entity originates from within the provided arc, this Interaction will override the interaction's `Next` field.                                              |
+
+**TargetedDamage Fields**
+
+| Field Name       | Type                                     | Required? | Notes                                                                                                                                                                                            |
+| ---------------- | ---------------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| DamageCalculator | `DamageCalculator`                       | **No**    | If provided and this TargetedDamage was matched, this DamageCalculator will override the interaction's `DamageCalculator` field and the `DamageCalculator` field of any matching `AngledDamage`. |
+| DamageEffects    | `DamageEffects`                          | **No**    | If provided and this TargetedDamage was matched, this DamageEffects will override the interaction's `DamageEffects` field and the `DamageEffects` field of any matching `AngledDamage`.          |
+| Next             | `Asset`<br />(Asset Type: `Interaction`) | **No**    | If provided and this TargetedDamage was matched, this Interaction will override the interaction's `Next` field and the `Next` field of any matching `AngledDamage`.                              |
+
+**EntityStatOnHit Fields**
+
+| Field Name                  | Type                                                                       | Required? | Notes                                                                                                                                                                                                                                                                                        |
+| --------------------------- | -------------------------------------------------------------------------- | --------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| EntityStatId                | `Asset`<br />(AssetType: `EntityStatType`)                                 | **Yes**   | Which entity stat to affect.                                                                                                                                                                                                                                                                 |
+| Amount                      | `Float`<br />(Default: 0.0)                                                | **No**    | How much of the stat to apply for each damage application. Use negative numbers to reduce stats.                                                                                                                                                                                             |
+| MultipliersPerEntitiesHit   | `Array`<br />(Element Type: `Float`, Default: `[1.0, 0.6, 0.4, 0.2, 0.1]`) | **No**    | The diminishing returns curve to be applied for multiple damage applications by the same ability. Each hit's stat impact will be multiplied by the next value in the list.  If there are more hits than array elements, subsequent hits will be multiplied by `MultiplierPerExtraEntityHit`. |
+| MultiplierPerExtraEntityHit | `Float`<br />(Default: 0.05)                                               | **No**    | If an ability carries out more damage applications than there are elements in the `MultipliersPerEntitiesHit` array, then subsequent stat values will be multiplied by this number.                                                                                                          |
+
+**Knockback Fields**
+
+| Field Name     | Type                                       | Required? | Notes                                                                                                                      |
+| -------------- | ------------------------------------------ | --------- | -------------------------------------------------------------------------------------------------------------------------- |
+| Type           | `String`                                   | **No**    | If provided, specifies a type of knockback to use. Each Target type may come with additional fields.                       |
+| Force          | `Double`<br />(Default: 0.0)               | **No**    | The amount of force to apply to the Owner entity.                                                                          |
+| Duration       | `Double`<br />(Default: 0.0)               | **No**    | If 0.0, apply the force as a single impulse.  If more, continuously apply the force over a period of time.                 |
+| VelocityType   | `ChangeVelocityType`<br />(Default: `Add`) | **No**    | How to apply the force, either adding it to the entity's current velocity, or setting the velocity to the knockback force. |
+| VelocityConfig | `VelocityConfig`                           | **No**    | Characteristics of friction as the Owner entity is thrown by this knockback.                                               |
+
+**Knockback Type: Force**
+
+Apply the calculated knockback force along the provided direction.
+
+| Field Name | Type                         | Required? | Notes                                                                                |
+| ---------- | ---------------------------- | --------- | ------------------------------------------------------------------------------------ |
+| Direction  | `Vector3`<br />(Default: Up) | **No**    | Which direction the entity should be flung, relative to the direction of the attack. |
+
+**Knockback Type: Point**
+
+Apply the calculated knockback force laterally along the XZ plane, plus provided Y velocity.
+
+| Field Name | Type                        | Required? | Notes                                                                                                   |
+| ---------- | --------------------------- | --------- | ------------------------------------------------------------------------------------------------------- |
+| OffsetX    | `Integer`<br />(Default: 0) | **No**    | Offset the source position of the knockback left or right perpendicular to the direction of the attack. |
+| OffsetZ    | `Integer`<br />(Default: 0) | **No**    | Offset the source position of the knockback, forward or backward along the directon of the attack.      |
+| RotateY    | `Integer`<br />(Default: 0) | **No**    | Rotate the knockback direction around the Y axis, where 0 is the default attack direction.              |
+| VelocityY  | `Float`<br />(Default: 0.0) | **No**    | Add vertical velocity to the knockback force after the direction and force has been calculated.         |
+
+**Knockback Type: Directional**
+
+Apply the calculated knockback force along the attack direction, removing any vertical component and replacing it with a provided Y velocity.
+
+| Field Name | Type                      | Required? | Notes                                                                                                                                            |
+| ---------- | ------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------ |
+| RelativeX  | `Float`<br />(Default: 0) | **No**    | Apply additional force left or right perpendicular to the direction of the attack. The additional force is multiplied by the knockback strength. |
+| RelativeZ  | `Float`<br />(Default: 0) | **No**    | Apply additional force forward or backward along the attack direction. The additional force is multiplied by the knockback strength.             |
+| VelocityY  | `Float`<br />(Default: 0) | **No**    | Replace the vertical velocity of the knockback with this value.  This value is not multiplied by knockback strength.                             |
+
+**VelocityConfig Fields**
+
+| Field Name          | Type                                              | Required? | Notes                                                                                                                                                                                           |
+| ------------------- | ------------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| GroundResistance    | `Float`<br />(Default: 0.82)                      | **No**    | The minimum amount of friction applied when the entity is in contact with the ground.  1.0 = no friction, 0.0 = total friction                                                                  |
+| GroundResistanceMax | `Float`<br />(Default: 0.0)                       | **No**    | The maximum amount of friction applied when the entity is in contact with the ground.  1.0 = no friction, 0.0 = total friction                                                                  |
+| AirResistance       | `Float`<br />(Default: 0.96)                      | **No**    | The minimum amount of friction applied when the entity is in the air. 1.0 = no friction, 0.0 = total friction                                                                                   |
+| AirResistanceMax    | `Float`<br />(Default: 0.0)                       | **No**    | The maximum amount of friction applied when the entity is in the air. 1.0 = no friction, 0.0 = total friction                                                                                   |
+| Threshold           | `Float`<br />(Default: 1.0)                       | **No**    | The speed at which the maximum amount of friction will be applied to the entity. The amount of friction applied will increase from minimum to maximum as the entity moves from 0 to this speed. |
+| Style               | `VelocityThresholdStyle`<br />(Default: `Linear`) | **No**    | The curve that friction follows as the entity's speed increases toward the `Threshold`.                                                                                                         |
+
+**DamageCalculatorType Values**
+
+- `Absolute`
+- `Dps`
+
+**DamageClass Values**
+
+- `Unknown`
+- `Light`
+- `Charged`
+- `Signature`
+
+**ChangeVelocityType Values**
+
+- `Add`
+- `Set`
+
+**VelocityThresholdStyle Values**
+
+- `Linear`
+- `Exp`
+
+### LaunchProjectile
+
+This is just a worse version of Projectile and is slated to be removed.  Use Projectile.
+
+### Projectile
+
+This interaction will spawn a new projectile at the User entity's eye position that will travel in its look direction.
+
+| Field Name | Type                                          | Required? | Notes                                                  |
+| ---------- | --------------------------------------------- | --------- | ------------------------------------------------------ |
+| Config     | `Asset`<br />(Asset Type: `ProjectileConfig`) | **No**    | Configuration describing the projectile to be spawned. |
+
+### RemoveEntity
+
+Despawns the specified entity from the world. This interaction will have no effect if the specified entity is a player. This
+interaction has no special failure conditions.
+
+| Field Name | Type                                     | Required? | Notes                  |
+| ---------- | ---------------------------------------- | --------- | ---------------------- |
+| Entity     | `InteractionTarget`<br />(Default: User) | **No**    | The entity to despawn. |
+
+**InteractionTarget Values**
+
+- `User` - The user of this interaction chain. The entity whose actions caused this interaction chain to be executed. This is usually the same as the Owner.
+- `Owner` - The owner of this interaction chain. The entity upon whom this interaction chain is executing.
+- `Target` - The entity target of this interaction chain, if any.  This value is mutable (and can therefore come from many places) but most commonly, it is an entity the User was targeting when this interaction chain began executing.
+
+### SendMessage
+
+This interaction sends a message to the Owner entity if that entity can receive messages.  Otherwise, the message
+is written to the server logs.  If the entity is a player, the message will appear in the player's chat window.
+
+\*\*SendMessage
+
+| Field Name | Type     | Required? | Notes                                                                                                                 |
+| ---------- | -------- | --------- | --------------------------------------------------------------------------------------------------------------------- |
+| Message    | `String` | **No**    | A text message to be sent to the Owner entity.  If this field is not provided, `Key` is used instead.                 |
+| Key        | `String` | **No**    | A translation key for a message to be sent to the Owner entity. If `Message` is provided, then this field is ignored. |
+
+### UseEntity
+
+This interaction is not in use by Hypixel and has some unusual qualities that mean it probably won't do what you want it
+to.  Do not use it.
+
+This interaction will retrieve the entity currently targeted by the client (NOT the interaction chain's current Target
+entity) and execute that entity's RootInteraction for this interaction chain's current interaction type. The
+RootInteraction will be executed as part of this current interaction chain. None of the properties of this interaction
+chain will be modified.
+
+This interaction will fail if the client is not currently targeting an entity, or if no interaction for the current
+interaction type exists on the entity.
+
+## Stats
+
+Hytale's resource system has been written about fairly extensively.  You can use these interactions to modify stats in
+response to actions or use stats as a cost for abilities.
+
+### ChangeStat
+
+This interaction applies a set of raw stat changes to the User entity. It has no special failure conditions.
+
+| Field Name    | Type                                                         | Required? | Notes                                                                                                                                                                                                                      |
+| ------------- | ------------------------------------------------------------ | --------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| StatModifiers | `Map`<br />(Key Type: `EntityStatType`, Value Type: `Float`) | **Yes**   | A set of stats to modify and what value to apply to them.                                                                                                                                                                  |
+| ValueType     | `ValueType`<br />(Default: Absolute)                         | **No**    | Whether the values in the `StatModifiers` map represent flat values to apply to the stat total, or percentages (0.0-100.0). Percentage values are percentage of the difference between the maximum and minimum stat value. |
+| Behaviour     | `ChangeStatBehavior`<br />(Default: Add)                     | **No**    | Whether the values in the `StatModifiers` map represent deltas to add into the User entity's current stat values, or fixed values to set the entity's stats to.                                                            |
+
+**ValueType Values**
+
+- `Absolute`
+- `Percent`
+
+**ChangeStatBehaviour Values**
+
+- `Add`
+- `Set`
+
+### ChangeStatWithModifier
+
+This interaction is like ChangeStat, except an armor stat modifier can be chosen which will apply bonuses and penalties
+to a stat from the User entity's equipped armor before it is applied.
+
+| Field Name            | Type                                                         | Required? | Notes                                                                                                                                                                                                                      |
+| --------------------- | ------------------------------------------------------------ | --------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| StatModifiers         | `Map`<br />(Key Type: `EntityStatType`, Value Type: `Float`) | **Yes**   | A set of stats to modify and what value to apply to them.                                                                                                                                                                  |
+| ValueType             | `ValueType`<br />(Default: Absolute)                         | **No**    | Whether the values in the `StatModifiers` map represent flat values to apply to the stat total, or percentages (0.0-100.0). Percentage values are percentage of the difference between the maximum and minimum stat value. |
+| Behaviour             | `ChangeStatBehavior`<br />(Default: Add)                     | **No**    | Whether the values in the `StatModifiers` map represent deltas to add into the User entity's current stat values, or fixed values to set the entity's stats to.                                                            |
+| InteractionModifierId | `InteractionModifierId`                                      | **Yes**   | The armor interaction modifier to apply bonuses and penalties for.                                                                                                                                                         |
+
+**ValueType Values**
+
+- `Absolute`
+- `Percent`
+
+**ChangeStatBehaviour Values**
+
+- `Add`
+- `Set`
+
+**InteractionModifierId Values**
+
+- `Dodge`
+
+### StatsCondition
+
+This interaction will fail if the User entity cannot afford the specified stats costs, or if it does not have the
+requested stats.
+
+| Field Name | Type                                                         | Required? | Notes                                                                                                                                                                                    |
+| ---------- | ------------------------------------------------------------ | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Costs      | `Map`<br />(Key Type:` EntityStatType`, Value Type: `Float`) | **Yes**   | A set of costs that the User entity needs to be able to afford for this interaction to succeed.                                                                                          |
+| ValueType  | `ValueType`<br />(Default: Absolute)                         | **No**    | Whether the values in the `Costs` map represetn flat values or percentages (0.0-100.0).  Percentage values are percentage of the difference between the maximum and minimum value.       |
+| LessThan   | `Boolean`<br />(Default: false)                              | **No**    | If true, this interaction will fail unless the User entity's current stat values are at or **below** the specified levels.  If false, they must be at or **above** the specified levels. |
+| Lenient    | `Boolean`<br />(Default: false)                              | **No**    | If true and `LessThan` is true, and a player's minimum stat value is below zero, then the player can afford a stat cost if the current value of a stat if above 0.                       |
+
+**ValueType Values**
+
+- `Absolute`
+- `Percent`
+
+### StatsConditionWithModifier
+
+This interaction is like StatsCondition, except an armor stat modifier can be chosen which will apply bonuses and penalties
+to a stat's cost from the User entity's equipped armor before it is compared.
+
+| Field Name            | Type                                                         | Required? | Notes                                                                                                                                                                                    |
+| --------------------- | ------------------------------------------------------------ | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Costs                 | `Map`<br />(Key Type:` EntityStatType`, Value Type: `Float`) | **Yes**   | A set of costs that the User entity needs to be able to afford for this interaction to succeed.                                                                                          |
+| ValueType             | `ValueType`<br />(Default: Absolute)                         | **No**    | Whether the values in the `Costs` map represetn flat values or percentages (0.0-100.0).  Percentage values are percentage of the difference between the maximum and minimum value.       |
+| LessThan              | `Boolean`<br />(Default: false)                              | **No**    | If true, this interaction will fail unless the User entity's current stat values are at or **below** the specified levels.  If false, they must be at or **above** the specified levels. |
+| Lenient               | `Boolean`<br />(Default: false)                              | **No**    | If true and `LessThan` is true, and a player's minimum stat value is below zero, then the player can afford a stat cost if the current value of a stat if above 0.                       |
+| InteractionModifierId | `InteractionModifierId`                                      | **Yes**   | The armor interaction modifier to apply bonuses and penalties for.                                                                                                                       |
+
+**ValueType Values**
+
+- `Absolute`
+- `Percent`
+
+**InteractionModifierId Values**
+
+- `Dodge`
+
+## EntityEffects
+
+EntityEffects are buff or debuff effects that can be applied to a LivingEntity.  These can have a variety of effects from
+movement speed changes to periodic damage.
+
+### EffectCondition
+
+This interaction will fail if the specified entity's EntityEffects do not match the provided conditions.
+
+**EffectCondition Fields**
+
+| Field Name      | Type                                             | Required? | Notes                                                                                                                                                                                                             |
+| --------------- | ------------------------------------------------ | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Entity          | `InteractionTarget`<br />(Default: User)         | **Yes**   | The entity to examine for EntityEffects. This field can indicate the Owner, User, or Target of this interaction chain.                                                                                            |
+| Match           | `Match`<br />(Default: All)                      | **No**    | If `All`, then this interaction will fail if any EntityEffect in the `EntityEffectIds` is not on the specified entity. If `None`, then this interaction will fail if any EntityEffect IS on the specified entity. |
+| EntityEffectIds | `AssetArray`<br />(Element Type: `EntityEffect`) | **Yes**   | The set of EntityEffects to check against the specified entity and `Match`.                                                                                                                                       |
+
+**InteractionTarget Values**
+
+- `User` - The user of this interaction chain. The entity whose actions caused this interaction chain to be executed. This is usually the same as the Owner.
+- `Owner` - The owner of this interaction chain. The entity upon whom this interaction chain is executing.
+- `Target` - The entity target of this interaction chain, if any.  This value is mutable (and can therefore come from many places) but most commonly, it is an entity the User was targeting when this interaction chain began executing.
+
+**Match Values**
+
+- `All` - All EntityEffects must be on the specified entity for this interaction to succeed.
+- `None` - None of the EntityEffects must be on the specified entity for this interaction to succeed.
+
+### ApplyEffect
+
+This interaction will apply the specified EntityEffect to the specified Entity.  It has no special failure conditions.
+
+**ApplyEffect Fields**
+
+| Field Name | Type                                      | Required? | Notes                                                                                                                  |
+| ---------- | ----------------------------------------- | --------- | ---------------------------------------------------------------------------------------------------------------------- |
+| Entity     | `InteractionTarget`<br />(Default: User)  | **Yes**   | The entity to apply the EntityEffect to. This field can indicate the Owner, User, or Target of this interaction chain. |
+| EffectId   | `Asset`<br />(Asset Type: `EntityEffect`) | **Yes**   | The effect to apply.                                                                                                   |
+
+**InteractionTarget Values**
+
+- `User` - The user of this interaction chain. The entity whose actions caused this interaction chain to be executed. This is usually the same as the Owner.
+- `Owner` - The owner of this interaction chain. The entity upon whom this interaction chain is executing.
+- `Target` - The entity target of this interaction chain, if any.  This value is mutable (and can therefore come from many places) but most commonly, it is an entity the User was targeting when this interaction chain began executing.
+
+### ClearEntityEffect
+
+This interaction will remove the specified EntityEffect from the specified Entity. It has no special failure conditions.
+It will not fail if the Entity does not have the EntityEffect.
+
+**ClearEntityEffect Fields**
+
+| Field Name | Type                                      | Required? | Notes                                                                                                                     |
+| ---------- | ----------------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------- |
+| Entity     | `InteractionTarget`<br />(Default: User)  | **Yes**   | The entity to remove the EntityEffect from. This field can indicate the Owner, User, or Target of this interaction chain. |
+| EffectId   | `Asset`<br />(Asset Type: `EntityEffect`) | **Yes**   | The effect to remove.                                                                                                     |
+
+**InteractionTarget Values**
+
+- `User` - The user of this interaction chain. The entity whose actions caused this interaction chain to be executed. This is usually the same as the Owner.
+- `Owner` - The owner of this interaction chain. The entity upon whom this interaction chain is executing.
+- `Target` - The entity target of this interaction chain, if any.  This value is mutable (and can therefore come from many places) but most commonly, it is an entity the User was targeting when this interaction chain began executing.
+
+## Farming
+
+These are interaction types built to support the in-game farming system in Hytale. They are mostly block-related interactions
+with a few exceptions.
+
+### ChangeFarmingStage
+
+If the target block is a farming block, this interaction will attempt to modify the current farming stage in one of
+three ways.  The interaction can optionally specify which StageSet to use for the new stage. If it is not specified,
+the current StageSet will be used. If any part of the the process of changing the growth stage fails, this interaction
+will fail, with the one exception that attempting to set the stage to the crop's existing stage will have no effect but
+still succeed.
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                                                                                                                                                                          |
+| ---------------- | ------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction.                                                                                                                                              |
+| StageSet         | `String`                        | **No**    | If provided, set the block's current stage to one in the provided StageSet. Otherwise, use the crop's current StageSet.                                                                                                                                                        |
+| Increase         | `Integer`                       | **No**    | If provided, increase the current stage by the specified amount. If the specified stage does not exist, the block will be set to the closest extant stage.                                                                                                                     |
+| Decrease         | `Integer`                       | **No**    | If provided and `Increase` is not provided, decrease the current stage by the specified amount. If the specified stage does not exist, the block will be set to the closest extant stage.                                                                                      |
+| Stage            | `Integer`<br />(Default: -1)    | **No**    | If provided and `Increase`/`Decrease` are not provided, set the current stage to the specified stage. If this value is less than 0, set the current stage to the final growth stage. If the specified stage does not exist, the block will be set to the closest extant stage. |
+
+### FertilizeSoil
+
+If the target block is unfertilized tilled soil or a farming block on top of unfertilized tilled soil, fertilizes the soil.
+The interaction will fail otherwise.
+
+**FertilizeSoil Fields**
+
+| Field Name       | Type                                  | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false)       | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+| RefreshModifiers | `Array`<br />(Element Type: `String`) | **No**    | Does nothing.                                                                                                                     |
+
+### HarvestCrop
+
+This interaction will attempt to execute the harvest action on the current block target and add the crop's drops to the User entity's
+inventory.  The block will either be destroyed or set to its post-harvest growth stage, depending on the farming
+configuration of the block.  This will happen (and the player will receive the full harvest drops) regardless of the
+block's current growth stage. This interaction has no special failure conditions, even if the block target isn't a
+farming block or gathering isn't permitted in the current world, but nothing will occur in those cases.
+
+**HarvestCrop Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+
+### UseWateringCan
+
+If the target block is tilled soil or a farming block on top of tilled soil, waters the soil for the specified duration.
+The interaction will fail otherwise.
+
+**UseWateringCan Fields**
+
+| Field Name       | Type                                  | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false)       | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+| Duration         | `Integer`<br />(Default: 0)           | **No**    | The duration in seconds to water the soil for.                                                                                    |
+| RefreshModifiers | `Array`<br />(Element Type: `String`) | **No**    | Does nothing.                                                                                                                     |
diff --git a/content/docs/it-IT/contributing/pr-guidelines.mdx b/content/docs/it-IT/contributing/pr-guidelines.mdx
index 7a251032..c226da04 100644
--- a/content/docs/it-IT/contributing/pr-guidelines.mdx
+++ b/content/docs/it-IT/contributing/pr-guidelines.mdx
@@ -19,6 +19,8 @@ To ensure a smooth and efficient review process, both contributors and reviewers
 4. **Code Quality**
    - Ensure your code follows the project's coding standards and best practices.
    - Include comments where necessary to explain complex logic.
+   - Always test your changes locally before submitting the PR to catch any issues early.
+   - Format your code using `bun format` to maintain consistency across the codebase.
 5. **Testing**
    - Test your changes thoroughly before submitting the PR.
    - If applicable, include unit tests or integration tests to verify your changes.
diff --git a/content/docs/it-IT/contributing/translate.mdx b/content/docs/it-IT/contributing/translate.mdx
new file mode 100644
index 00000000..c62ffdde
--- /dev/null
+++ b/content/docs/it-IT/contributing/translate.mdx
@@ -0,0 +1,74 @@
+---
+title: Translate
+description: How to translate HytaleModding to your language
+---
+
+# Translating HytaleModding
+
+HytaleModding is translated with the help of the community using **Crowdin**. If you want to help translate or improve existing translations, this is the right place.
+
+## Steps to Translate
+
+All translations are managed **via Crowdin**.
+
+1. Visit [our Crowdin project](https://crowdin.com/project/hytalemodding) and log in if required.
+2. Click on your language.
+3. Click on the file/article you wish to translate. We recommend starting with Official Documentation, and then Server Plugin Documentation.
+4. Start translating!
+5. Approved translations will appear on the website.
+
+### Video Guide
+
+<iframe src="https://www.youtube.com/embed/NHiG1rDRgks" allowFullScreen />
+
+## How to discuss
+
+You can always report issues or discuss specific topics directly on Crowdin, but we recommend using Discord instead of the Crowdin comment system to keep everything organized in one place.
+
+1. Join [our Discord](https://discord.gg/hytalemodding)
+2. Open `#translations` channel. Here you can discuss or ask questions that are not related to a specific language.
+3. If you want to join a thread, you are required to run `/translator <your-language>` command here. The bot will add you to the thread for your language.
+
+## Translation Guidelines
+
+- You need to be confident in what you are translating. You should be able to read the text you just translated and understand the meaning of it very easily.
+- It should use the simplest form of language possible. Use English words if the translation is unknown to the majority in your country.
+- Use your imagination, trust yourself. Feel free to change any context as you wish as long as it can still get the same point across and is understandable.
+- These guidelines are more important than language-specific guidelines, but less important than Hytale terminology and rules.
+
+## What not to translate
+
+We request you all to not translate these specific sections of the website:
+
+### Callout types
+
+Callouts are the boxes that contain important information. We request you to not translate the types as they only work in English.
+
+**Example:**
+
+```mdx
+<Callout type="warning" title="Translate this title!">
+Translate the text inside the callout!
+</Callout>
+```
+
+In this example, please don't translate the word warning, the rest you can translate.
+
+### Icons
+
+Icon names must not be translated.
+They are technical identifiers mapped directly to existing icons. Translating them will break the icon rendering.
+
+```mdx
+icon: Globe
+```
+
+---
+
+{/* 
+For translators who will edit this page:
+
+- You are required to translate the Guidelines as they change.
+- General guidelines should be translated but not edited.
+- Learn how to use Markdown from writing_guides.mdx
+*/}
diff --git a/content/docs/it-IT/established-information/server/content-categories/art-assets.mdx b/content/docs/it-IT/established-information/server/content-categories/art-assets.mdx
index 94b38062..8d1d1715 100644
--- a/content/docs/it-IT/established-information/server/content-categories/art-assets.mdx
+++ b/content/docs/it-IT/established-information/server/content-categories/art-assets.mdx
@@ -14,7 +14,7 @@ Hytale offre un supporto completo per la modellazione 3D e la creazione di textu
 Hytale utilizza Blockbench come strumento principale per la modellazione 3D e l’animazione:
 
 * Supporto ufficiale: viene usato per creare modelli, texture e animazioni di Hytale.
-* Plugin dedicato: Hytale avrà un plugin Blockbench dedicato, che sarà rilasciato il prima possibile.
+* **Special plugin**: Hytale has a dedicated [Blockbench Plugin](https://www.blockbench.net/plugins/hytale_plugin).
 * Compatibilità diretta: il plugin consente di creare modelli, texture e animazioni compatibili con Hytale direttamente in Blockbench.
 * Sostituisce gli strumenti legacy: rimpiazza completamente il vecchio Hytale Model Maker per supportare meglio i workflow già consolidati nella community.
 * Sicurezza: permette di aggiungere solo elementi compatibili con il motore, così non c’è rischio di rompere nulla.
diff --git a/content/docs/it-IT/guides/ecs/block-components.mdx b/content/docs/it-IT/guides/ecs/block-components.mdx
new file mode 100644
index 00000000..ca68b38a
--- /dev/null
+++ b/content/docs/it-IT/guides/ecs/block-components.mdx
@@ -0,0 +1,247 @@
+---
+title: Block Components
+description: Learn how to use the block components.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+  - name: oskarscot
+    link: https://oskar.scot
+---
+
+# Overview
+
+In this guide, you'll learn how to use block components to create a ticking block.
+
+<Callout>
+  For a more complete reference, you may also want to review FarmingSystems.Ticking, as much of the underlying logic is based on its implementation.
+</Callout>
+
+## Steps
+
+### 1. ExampleBlock - holds block behavior
+
+```java
+public class ExampleBlock implements Component<ChunkStore> {
+
+    public static final BuilderCodec CODEC = BuilderCodec.builder(ExampleBlock.class, ExampleBlock::new).build();
+
+    // Components usually require a copy constructor as well but since we don't actually hold any data in this component this is not neccessary
+    public ExampleBlock() { }
+
+    public static ComponentType getComponentType() {
+        return ExamplePlugin.get().getExampleBlockComponentType();
+    }
+
+    @Nullable
+    public Component<ChunkStore> clone() {
+        return new ExampleBlock();
+    }
+}
+```
+
+ExampleBlock is a custom component that stores the behavior and data for your ticking block. Here, it simply places an Ice Block at x + 1 relative to its current position when it ticks.
+
+---
+
+### 2. ExampleInitializer - marks blocks as ticking when placed
+
+```java
+public class ExampleInitializer extends RefSystem {
+
+    @Override
+    public void onEntityAdded(@Nonnull Ref ref, @Nonnull AddReason reason, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+        BlockModule.BlockStateInfo info = (BlockModule.BlockStateInfo) commandBuffer.getComponent(ref, BlockModule.BlockStateInfo.getComponentType());
+        if (info == null) return;
+
+        ExampleBlock generator = (ExampleBlock) commandBuffer.getComponent(ref, ExamplePlugin.get().getExampleBlockComponentType());
+        if (generator != null) {
+            int x = ChunkUtil.xFromBlockInColumn(info.getIndex());
+            int y = ChunkUtil.yFromBlockInColumn(info.getIndex());
+            int z = ChunkUtil.zFromBlockInColumn(info.getIndex());
+
+            WorldChunk worldChunk = (WorldChunk) commandBuffer.getComponent(info.getChunkRef(), WorldChunk.getComponentType());
+            if (worldChunk != null) {
+				worldChunk.setTicking(x, y, z, true);
+            }
+        }
+    }
+
+    @Override
+    public void onEntityRemove(@Nonnull Ref ref, @Nonnull RemoveReason reason, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+    }
+
+    @Override
+    public Query getQuery() {
+        return Query.and(BlockModule.BlockStateInfo.getComponentType(), ExamplePlugin.get().getExampleBlockComponentType());
+    }
+}
+```
+
+ExampleInitializer is a RefSystem that reacts when block entities with the ExampleBlock component are added or removed. This is crucial for marking blocks as ticking when they're first placed.
+
+**Key Points:**
+
+- Tells the game that this block should tick, allowing `ExampleSystem` to process it.
+
+```java
+worldChunk.setTicking(x, y, z, true);
+```
+
+---
+
+### 3. ExampleSystem - handles ticking
+
+```java
+public class ExampleSystem extends EntityTickingSystem {
+
+    public void tick(float dt, int index, @Nonnull ArchetypeChunk archetypeChunk, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+        BlockSection blocks = (BlockSection) archetypeChunk.getComponent(index, BlockSection.getComponentType());
+
+        assert blocks != null;
+
+        if (blocks.getTickingBlocksCountCopy() != 0) {
+            ChunkSection section = (ChunkSection) archetypeChunk.getComponent(index, ChunkSection.getComponentType());
+
+            assert section != null;
+
+            BlockComponentChunk blockComponentChunk = (BlockComponentChunk) commandBuffer.getComponent(section.getChunkColumnReference(), BlockComponentChunk.getComponentType());
+
+            assert blockComponentChunk != null;
+
+            blocks.forEachTicking(blockComponentChunk, commandBuffer, section.getY(), (blockComponentChunk1, commandBuffer1, localX, localY, localZ, blockId) -> {
+                Ref<ChunkStore> blockRef = blockComponentChunk.getEntityReference(ChunkUtil.indexBlockInColumn(localX, localY, localZ));
+                if (blockRef == null) {
+                    return BlockTickStrategy.IGNORED;
+                } else {
+                    ExampleBlock exampleBlock = (ExampleBlock) commandBuffer1.getComponent(blockRef, ExampleBlock.getComponentType());
+                    if (exampleBlock != null) {
+                        WorldChunk worldChunk = (WorldChunk) commandBuffer.getComponent(section.getChunkColumnReference(), WorldChunk.getComponentType());
+                        World world = worldChunk.getWorld();
+
+                        int globalX = localX + (worldChunk.getX() * 32);
+                        int globalZ = localZ + (worldChunk.getZ() * 32);
+
+                        // We need to execute setBlock on the world thread as you cannot call store functions from a system
+                        // This is because of the architecture of the server, depending on your needs you can also use the CommandBuffer
+                        world.execute(() -> {
+                            world.setBlock(globalX + 1, localY, globalZ, "Rock_Ice");
+                        });
+
+                        return BlockTickStrategy.CONTINUE;
+
+                    } else {
+                        return BlockTickStrategy.IGNORED;
+                    }
+                }
+            });
+        }
+    }
+
+    @Nullable
+    public Query getQuery() {
+        return Query.and(BlockSection.getComponentType(), ChunkSection.getComponentType());;
+    }
+}
+```
+
+ExampleSystem is an EntityTickingSystem that runs every tick to execute the logic for all ticking blocks with the ExampleBlock component.
+
+**Key Points:**
+
+- **Get the block component**
+
+```java
+ExampleBlock exampleBlock = (ExampleBlock) commandBuffer.getComponent(blockRef, ExampleBlock.getComponentType());
+```
+
+- **Convert local chunk coordinates to world coordinates**
+
+```java
+int globalX = localX + (worldChunk.getX() * 32);
+int globalZ = localZ + (worldChunk.getZ() * 32);
+```
+
+- **Run the block logic**
+
+```java
+exampleBlock.runBlockAction(globalX, localY, globalZ, worldChunk.getWorld());
+```
+
+- **Keep the block ticking in the next tick**
+
+```java
+return BlockTickStrategy.CONTINUE;
+```
+
+---
+
+### 4. ExamplePlugin - registers components and systems
+
+```java
+public class ExamplePlugin extends JavaPlugin {
+    protected static ExamplePlugin instance;
+    private static final HytaleLogger LOGGER = HytaleLogger.forEnclosingClass();
+    private ComponentType exampleBlockComponentType;
+
+    public static ExamplePlugin get() {
+        return instance;
+    }
+
+    public ExamplePlugin(@Nonnull JavaPluginInit init) {
+        super(init);
+        LOGGER.atInfo().log("Hello from " + this.getName() + " version " + this.getManifest().getVersion().toString());
+    }
+
+    @Override
+    protected void setup() {
+        instance = this;
+        LOGGER.atInfo().log("Setting up plugin " + this.getName());
+        this.exampleBlockComponentType = this.getChunkStoreRegistry().registerComponent(ExampleBlock.class, "ExampleBlock", ExampleBlock.CODEC);
+    }
+	
+	@Override
+	protected void start() {
+		this.getChunkStoreRegistry().registerSystem(new ExampleSystem());
+		this.getChunkStoreRegistry().registerSystem(new ExampleInitializer());
+	}
+
+    public ComponentType getExampleBlockComponentType() {
+        return this.exampleBlockComponentType;
+    }
+}
+```
+
+---
+
+### 5. Configure In-Game
+
+![block-component-1](/assets/guides/block-component-1.png)
+
+![block-component-2](/assets/guides/block-component-2.png)
+
+With this logic, the block will now continuously place an Ice Block at the coordinates x + 1 relative to its current position every time it ticks.
+
+---
+
+## Common Issues
+
+### NullPointerException on Startup
+
+**Error message:**
+
+```java
+java.lang.NullPointerException: Cannot invoke "com.hypixel.hytale.component.query.Query.validateRegistry(com.hypixel.hytale.component.ComponentRegistry)" because "query" is null
+```
+
+**Cause:**
+This error occurs when your module is loaded **before** the required Hytale modules.
+
+**Fix:**
+Add `EntityModule` and `BlockModule` as dependencies in your `manifest.json` to ensure proper load order.
+
+```json
+"Dependencies": {
+  "Hytale:EntityModule": "*",
+  "Hytale:BlockModule": "*"
+}
+```
diff --git a/content/docs/it-IT/guides/ecs/hytale-ecs-theory.mdx b/content/docs/it-IT/guides/ecs/hytale-ecs-theory.mdx
index 20c3a94d..52d8b1f5 100644
--- a/content/docs/it-IT/guides/ecs/hytale-ecs-theory.mdx
+++ b/content/docs/it-IT/guides/ecs/hytale-ecs-theory.mdx
@@ -29,7 +29,7 @@ for now this is the basic understanding for the `ChunkStore`. You can use it to
 
 ## Holder
 
-A Holder is essentially a blueprint for an entity. Before an entity exists in the Store (and thus in the world), is exists as a `Holder`. It collects and holds all the necessary components (data). You can compare it analogous to shopping cart. You grab all components you need and once you have everything, check out at the store which will take your cart and create a valid entity ID and hand you back a receipt (a Ref).
+A Holder is essentially a blueprint for an entity. Before an entity exists in the Store (and thus in the world), it exists as a `Holder`. It collects and holds all the necessary components (data). You can compare it analogous to shopping cart. You grab all components you need and once you have everything, check out at the store which will take your cart and create a valid entity ID and hand you back a receipt (a Ref).
 
 Let's take a look at an example: initializing players. In `Universe`, the `addPlayer` method demonstrates it perfectly.
 When a player connects, we don't immediately throw them into the ECS. We first construct their data in a Holder.
@@ -167,7 +167,7 @@ MyComponent comp = commandBuffer.getComponent(ref, componentType);
 
 Codecs handle serialization and deserialization of components. Hytale uses them to save and load entity data to and from disk as well as sending component data over the network. When creating a custom component, you must also create a corresponding Codec.
 
-There are mutliple Codec types already implemented in the default Codec Interface:
+There are multiple Codec types already implemented in the default Codec Interface:
 
 - Codec.STRING
 - Codec.BOOLEAN
@@ -215,7 +215,7 @@ This might seem tedious at first but it ensures that your component can be corre
   KeyedCodec<Integer> exampleInt = new KeyedCodec<Integer>("ExampleIntIdForCodec", Codec.INTEGER);
   ```
 
-- **Setter Function**: This is a lambda function that takes an instance of your component and returns the value of the field you want to serialize. For example, if you have a field called `myCustomField` in your custom component, your getter function would look like this:
+- **Setter Function**: This is a lambda function that takes an instance of your component + the value to set and sets the field value on the component. For example, if you have a field called `myCustomField` in your custom component, your setter function would look like this:
   ```java
   (data, value) -> data.myCustomField = value
   ```
@@ -276,7 +276,7 @@ public class PoisonComponent implements Component<EntityStore> {
 
 You can also add validators to your Codec fields to ensure that the data being serialized/deserialized meets certain criteria. For example, if you want to ensure that the `damagePerTick` field is always non-negative or the poison name is never null, you can add a validator like this:
 
-````java
+```java
 .append(
     new KeyedCodec<Float>("DamagePerTick", Codec.FLOAT),
     (data, value) -> data.damagePerTick = value,
@@ -292,14 +292,15 @@ You can also add validators to your Codec fields to ensure that the data being s
 )
 .addValidator(Validators.nonNull())
 .add()
+```
 
 ### Complex Codec Examples
 
-If you want to have a map inside your component, you can use the MapCodec class to build a KeyedCoded for it. Here's an example of how to create a Codec for a Map field:
+If you want to have a map inside your component, you can use the MapCodec class to build a KeyedCodec for it. Here's an example of how to create a Codec for a Map field:
 
 ```java
 var damagePerTick = new KeyedCodec<>("DamagePerTick", new MapCodec<>(Codec.FLOAT, HashMap<String, Float>::new));
-````
+```
 
 <Callout type="info">
   This also works with custom Objects as long as you have a Codec defined for the Object type.
diff --git a/content/docs/it-IT/guides/java-basics/00-introduction.mdx b/content/docs/it-IT/guides/java-basics/00-introduction.mdx
index b2bc6e60..184d5109 100644
--- a/content/docs/it-IT/guides/java-basics/00-introduction.mdx
+++ b/content/docs/it-IT/guides/java-basics/00-introduction.mdx
@@ -7,7 +7,7 @@ Benvenuto nel tuo viaggio nella Programmazione Java! Questa guida è progettata
 
 ## Cos'è Java?
 
-Java è un potente linguaggio di programmazione orientato agli oggetti, creato nel 1995. È uno dei linguaggi di programmazione più popolari al mondo ed è utilizzato in tutti gli ambiti, dalle applicazioni mobile ai software aziendali. Sopratutto, è il linguaggio utilizzato da Hytale per i server e le sue API di modding.
+Java è un potente linguaggio di programmazione orientato agli oggetti, creato nel 1995. È uno dei linguaggi di programmazione più popolari al mondo ed è utilizzato in tutti gli ambiti, dalle applicazioni mobile ai software aziendali. Most importantly for us, it's the language Hytale uses for its servers & modding API.
 
 ## Cosa Imparerai
 
diff --git a/content/docs/it-IT/guides/java-basics/02-operators.mdx b/content/docs/it-IT/guides/java-basics/02-operators.mdx
index 3e6c8c29..ba8acaf9 100644
--- a/content/docs/it-IT/guides/java-basics/02-operators.mdx
+++ b/content/docs/it-IT/guides/java-basics/02-operators.mdx
@@ -119,7 +119,7 @@ String salutoConNome = "Ciao, " + name + "!"; // "Ciao, Alice!"
 
 ## Precedenza degli Operatori
 
-La Precedenza degli Operatori indica quale viene valutato prima in una singola linea di codice. Pensa a come funziona la precedenza in matematica!
+Operator Precedence means which operator gets evaluated first in an line of code. Pensa a come funziona la precedenza in matematica!
 
 ```java
 int risultato = 10 + 5 * 2; // risultato è 20, non 30
diff --git a/content/docs/it-IT/guides/java-basics/03-control-flow-if.mdx b/content/docs/it-IT/guides/java-basics/03-control-flow-if.mdx
index f47197df..7a2b7927 100644
--- a/content/docs/it-IT/guides/java-basics/03-control-flow-if.mdx
+++ b/content/docs/it-IT/guides/java-basics/03-control-flow-if.mdx
@@ -7,7 +7,7 @@ I programmi devono prendere delle decisioni. Le istruzioni if permettono al tuo
 
 ## Istruzione If Base
 
-La forma più semplice controlla una singola condizione;
+The simplest form checks one condition:
 
 ```java
 int vita = 20;
diff --git a/content/docs/it-IT/guides/java-basics/08-access-modifiers.mdx b/content/docs/it-IT/guides/java-basics/08-access-modifiers.mdx
index b61c2a15..9b026cc1 100644
--- a/content/docs/it-IT/guides/java-basics/08-access-modifiers.mdx
+++ b/content/docs/it-IT/guides/java-basics/08-access-modifiers.mdx
@@ -471,20 +471,20 @@ In parole povere: i membri dell' istanza appartengono agli oggetti; i membri sta
 
 ```java
 class Data {
-    public int x; // Membro istanziato
-    public static int y = 1000; // Membro statico
+    public int x; // Instanced member
+    public static int y = 1000; // Static member
 
-    // Membro istanziato:
-    // può accedere sia a membri statici che non-statici
+    // Instanced member:
+    // can access to both static and non-static members
     public void foo() {
-        x = 100; // OK - equivalente a this.x = 100;
-        y = 100; // OK - equivalente a Data.y = 200;
+        x = 100; // OK - same as this.x = 100;
+        y = 100; // OK - same as Data.y = 200;
     }
 
-    // Membro statico:
-    // non può accedere a membri non statici
+    // Static member:
+    // cannot access to non-static variables
     public static void bar() {
-        x = 100; // Errore: la variable non statica x non può essere chiamata in un contesto statico
+        x = 100; // Error: non-static variable x cannot be referenced from a static context
         y = 100; // OK
     }
 }
@@ -504,7 +504,7 @@ Data.x = 1000; // Errore: non è possibile accedere alle variabili d'istanza in
 
 ### Campi statici
 
-A static field represents a data member owned by the class type rather then the object. Static fields are also stored in a specific memory location that's been shared between all the object instances that are created.
+A static field represents a data member owned by the class type rather than the object. Static fields are also stored in a specific memory location that's been shared between all the object instances that are created.
 
 It is declared as following:
 
diff --git a/content/docs/it-IT/guides/plugin/animated-block-textures.mdx b/content/docs/it-IT/guides/plugin/animated-block-textures.mdx
new file mode 100644
index 00000000..42bfa51f
--- /dev/null
+++ b/content/docs/it-IT/guides/plugin/animated-block-textures.mdx
@@ -0,0 +1,101 @@
+---
+title: Animated Block Textures
+description: Learn how to attach a .blockyanim to a block
+authors:
+  - name: Burkino
+---
+
+import { File, Folder, Files } from 'fumadocs-ui/components/files';
+
+So, you want to make your blocks feel more alive through animations, do you?\
+Now for the most part this is the exact same as [Creating custom blocks](./creating-block).
+![blue fire gif](/assets/guides/blue_fire.gif)
+
+## Prerequisites
+
+This is NOT a guide on animating or texturing or even using BlockBench, why? Because I don't know how to do that.\
+The only thing we will be doing is taking the fire texture, changing the color, and applying it to our new fire block.
+
+## Setup
+
+To start, you're obviously going to want to grab the `Common/VFX/Fire/Fire.png` file. How you do it is up to you, in the Asset Editor you'll need to switch to the Common tab.\
+I'll assume you know how colorize or change the hue of an image, so go ahead and do that now and save it as `Blue_Fire.png`.
+
+The other assets used in this guide are `Common/VFX/Fire/Fire.blockymodel` and `Common/Blocks/Animations/Fire/Fire_Burn.blockyanim` (both renamed to `Blue_Fire`) but since we won't be changing them it's probably fine to leave them. I will reference the `Blue_Fire` versions as a way to point out what should be custom assets.\
+I will also duplicate `Server/Item/Item/Deco/Deco_Fire.json` and call it `Deco_Blue_Fire.json`.
+
+## Applying the changes
+
+The `Deco_Blue_Fire` block is actually just a particle emitter, however we will not be using particles, so lets start by removing them in `Block > Particles`.\
+Next we want to set the Block Model (called `CustomModel` in JSON) to `VFX/Blue_Fire/Blue_Fire.blockymodel` and Block Model Textures (`CustomModelTexture` in JSON) to
+
+```json
+[
+    {
+        "Texture": "VFX/Blue_Fire/Blue_Fire.png",
+        "Weight": 1
+    }
+]
+```
+
+Finally, we will apply the .blockyanim to our model, this is done through the Block Model Animation property (`CustomModelAnimation` in JSON) and the value should be `Blocks/Animations/Blue_Fire/Blue_Fire_Burn.blockyanim`.
+
+## Final Code
+
+With that your new blue fire should be done. Here is the minimal JSON for our blue fire.\
+There is an additional `Looping` and `RequiresAlphaBlending` property that I have not gone over, however I hope it is self-explanatory.
+
+```json
+{
+  "BlockType": {
+    "DrawType": "Model",
+    "CustomModel": "VFX/Blue_Fire/Blue_Fire.blockymodel",
+    "CustomModelAnimation": "Blocks/Animations/Blue_Fire/Blue_Fire_Burn.blockyanim",
+    "CustomModelTexture": [
+      {
+        "Texture": "VFX/Blue_Fire/Blue_Fire.png",
+        "Weight": 1
+      }
+    ],
+    "Looping": true,
+    "RequiresAlphaBlending": false
+  },
+  "PlayerAnimationsId": "Block"
+}
+```
+
+<Files>
+  <Folder name="resources" defaultOpen>
+    <Folder name="Server" defaultOpen>
+      <Folder name="Item" defaultOpen>
+        <Folder name="Items" defaultOpen>
+          <Folder name="Deco" defaultOpen>
+            <File name="Deco_Blue_Fire.json" />
+          </Folder>
+        </Folder>
+      </Folder>
+    </Folder>
+
+    <Folder name="Common" defaultOpen>
+      <Folder name="Blocks" defaultOpen>
+        <Folder name="Animations" defaultOpen>
+          <Folder name="Blue_Fire" defaultOpen>
+            <File name="Blue_Fire_Burn.blockyanim" />
+          </Folder>
+        </Folder>
+      </Folder>
+
+      <Folder name="VFX" defaultOpen>
+        <Folder name="Blue_Fire" defaultOpen>
+          <File name="Blue_Fire.blockymodel" />
+
+          <File name="Blue_Fire.png" />
+        </Folder>
+      </Folder>
+    </Folder>
+  </Folder>
+</Files>
+
+## Next steps
+
+Now that you know how to attach an animation to a block, try adding it to a block state.
diff --git a/content/docs/it-IT/guides/plugin/build-and-test.mdx b/content/docs/it-IT/guides/plugin/build-and-test.mdx
index 0e7fe7eb..f37534c3 100644
--- a/content/docs/it-IT/guides/plugin/build-and-test.mdx
+++ b/content/docs/it-IT/guides/plugin/build-and-test.mdx
@@ -9,18 +9,18 @@ If you followed along with the [Setting Up Your Development Environment](./setti
 
 ## Building Your Mod
 
-In our case, we've **Maven** as the build system. Maven is a powerful build automation tool that manages dependencies, compiles your code, and packages everything into a distributable JAR file.
+In our case, we've **Gradle** as the build system. Gradle is a powerful build automation tool that manages dependencies, compiles your code, and packages everything into a distributable JAR file.
 
-### Understanding Maven
+### Understanding Gradle
 
-Maven uses a `pom.xml` file (Project Object Model) to define your project's configuration, dependencies, and build settings. You can learn more about Maven at the [official Apache Maven website](https://maven.apache.org/).
+Gradle can use a `build.gradle.kts` file (Kotlin DSL) to define your project's configuration, dependencies, and build settings. You can learn more about Gradle at the [official Gradle website](https://gradle.org/).
 
-### Building with Maven
+### Building with Gradle
 
 To build your mod, open a terminal in your project directory and run:
 
 ```bash
-mvn package
+./gradlew build
 ```
 
 This command will:
@@ -29,16 +29,35 @@ This command will:
 2. Run any tests (if present)
 3. Package everything into a JAR file
 
+<Callout type="info">
+  If you are using the plugin template from the [Setting Up Your Development Environment](./setting-up-env) guide, then the build script is already set up for you. It includes paths to your Hytale game library and handles the packaging of your mod, managing hytale dependencies and manifest changes.
+
+  If you have a different path to your Hytale installation, you may receive the following error:
+
+  ```bash
+  FAILURE: Build failed with an exception.
+
+  * What went wrong:
+  Failed to find Hytale at the expected location. Please make sure you have installed the game. The expected location can be changed using the hytale.home_path property. Currently looking in 'C:\Path\To\Hytale'
+  ```
+
+  You can change the path by adding a property to your `gradle.properties` file (if it doesn't exist, create it in the root of your project):
+
+  ```properties
+  hytale.home_path=C:\Correct\Path\To\Hytale
+  ```
+</Callout>
+
 ### Build Output
 
-Once the build completes successfully, your mod will be located in the `target` directory and named:
+Once the build completes successfully, your mod will be located in the `build/libs` directory and named:
 
 ```
-ExamplePlugin-1.0-SNAPSHOT.jar
+ExamplePlugin-1.0.jar
 ```
 
 <Callout type="info">
-  The exact name may vary depending on what you configured in your `pom.xml` file. Check the `artifactId` and `version` fields to see what your JAR will be named.
+  The exact name may vary depending on what you configured in your `build.gradle.kts` and `settings.gradle.kts` file. Check the `rootProject.name` and `version` fields to see what your JAR will be named.
 </Callout>
 
 ## Testing Your Mod
@@ -49,11 +68,11 @@ Now that you've built your mod, it's time to test it in Hytale!
 
 First, you need to find Hytale's mods directory:
 
-1. Press **Win + R** on your keyboard
-2. Type `%appdata%` and press Enter
-3. Navigate to: `Hytale\UserData\Mods`
+1. Go to your Hytale installation directory (The default location is usually in your AppData folder)
+   > On Windows, you can access it by clicking `windows + R` and typing `%appdata%`.
+2. Navigate to: `/UserData/Mods`
 
-The full path should look like:
+The default path would look like:
 
 ```
 C:\Users\YourUsername\AppData\Roaming\Hytale\UserData\Mods
@@ -65,7 +84,7 @@ C:\Users\YourUsername\AppData\Roaming\Hytale\UserData\Mods
 
 ### 2. Copy Your Mod
 
-Copy the `ExamplePlugin-1.0-SNAPSHOT.jar` file from your project's `target` directory into the `Mods` folder you just located.
+Copy the `ExamplePlugin-1.0.jar` file from your project's `build/libs` directory into the `Mods` folder you just located.
 
 ### 3. Launch Hytale and Verify
 
@@ -84,7 +103,7 @@ If your mod doesn't appear in the mods list:
 - Make sure the JAR file is in the correct `Mods` folder
 - Check that your `manifest.json` file is properly configured
 - Look for any error messages in the Hytale logs
-- Verify that you're using the correct version of Java and Maven
+- Verify that you're using the correct version of Java and Gradle
 
 ## Next Steps
 
diff --git a/content/docs/it-IT/guides/plugin/creating-commands.mdx b/content/docs/it-IT/guides/plugin/creating-commands.mdx
index d33597f3..08572f16 100644
--- a/content/docs/it-IT/guides/plugin/creating-commands.mdx
+++ b/content/docs/it-IT/guides/plugin/creating-commands.mdx
@@ -8,6 +8,8 @@ authors:
     url: https://oskar.scot
   - name: jacobwojoski
     url: https://github.com/jacobwojoski
+  - name: Marcel-TO
+    url: https://marcel-to.net
 ---
 
 In this guide, you will learn how to create custom commands for your Hytale mod.
@@ -36,7 +38,7 @@ The most basic command is an `AbstractAsyncCommand`. It has very minimal data av
   `AbstractAsyncCommand` runs on its own background thread. This means its execute is not tied to any world instance and because of this it can not edit any **Stores** or **Refs** without getting the desired world first. To access this data any of the other command types would be preferred and are likely what you will want to use instead.
 </Callout>
 
-The main purpose for a command like this would be for something that can happen everywhere and is not tied to a specific world. For example a `serverRules` command to tell the user thats running the command in chat what the servers rules are nomatter what world they are in.
+The main purpose for a command like this would be for something that can happen everywhere and is not tied to a specific world. For example a `serverRules` command to tell the user that's running the command in chat what the server's rules are no matter what world they are in.
 
 ```java
 // Command that can be run that lists the server rules in chat to the player
@@ -49,7 +51,7 @@ public class ServerRulesCommand extends AbstractAsyncCommand {
     }
 
     // Run the command
-    // conetext - info about who ran the command. Server console?, Some player?
+    // context - info about who ran the command. Server console?, Some player?
     @Override
     protected CompletableFuture<Void> executeAsync(@Nonnull CommandContext context) {
         context.sendMessage(Message.raw("The only rule is there are no rules."));
@@ -134,7 +136,7 @@ Uses a Ray to see what the player is looking at and tries to run the command on
 
 ## Adding Arguments
 
-Arguments are additional fields that the user can input when running a command. The different types of arguments along with small snipits and a large example can be seen below.
+Arguments are additional fields that the user can input when running a command. The different types of arguments along with small snippets and a large example can be seen below.
 
 ### Command Argument Types
 
@@ -163,14 +165,14 @@ this.messageArg = this.withOptionalArg("message", "Message to print while healin
 
 ### Default Arguments
 
-Adding a default argument has two additional arguemnt for the default value and default value description. You need to use `withDefaultArg` method.
+Adding a default argument has two additional argument for the default value and default value description. You need to use `withDefaultArg` method.
 
 ```java
 // args <Command String> <Description> <Default Value> <Desc of default value>
 this.healthArg = this.withDefaultArg("health", "Amount to heal player", ArgTypes.FLOAT, (float)100, "Desc of Default: 100");
 ```
 
-### Flag Arguemnts
+### Flag Arguments
 
 Similar as above but the flags return is either true if it exists or false if it does not. You need to use `withFlagArg` method.
 
@@ -181,20 +183,13 @@ this.debugArg = this.withFlagArg("debug", "Add debug logs");
 
 ### ArgTypes
 
-The following ArgTypes are available (only lists common types):
-
-- `ArgTypes.STRING`
-- `ArgTypes.INTEGER`
-- `ArgTypes.BOOLEAN`
-- `ArgTypes.FLOAT`
-- `ArgTypes.DOUBLE`
-- `ArgTypes.UUID`
+You can find all the available argument types on the [ArgTypes](../../argtypes) page.
 
 ### Example Command Arg Types
 
-Shows all Command arguemnt types with different various input types.
+Shows all Command argument types with different various input types.
 
-**NOTE:** When getting the value of an argument during execute you need to pass the context with `someArg.get(commandContext)`. Where `commandContext` is the first variable in the execute funtion.
+**NOTE:** When getting the value of an argument during execute you need to pass the context with `someArg.get(commandContext)`. Where `commandContext` is the first variable in the execute function.
 
 ```java
 // Example usage: /healplayer --health 50 --message "Feels Good" --debug
@@ -204,7 +199,7 @@ public class HealPlayerCommand extends AbstractTargetPlayerCommand {
     private final FlagArg debugArg;
 
     public HealPlayerCommand() {
-        super("healplayer", "Healing a player for an <input> ammount of HP (default: 100)");
+        super("healplayer", "Healing a player for an <input> amount of HP (default: 100)");
 
         // Abstract TargetPlayerCommand passes the player that ran the command by default and implements
         // the use of `--player <value>` to specify someone else
@@ -213,10 +208,10 @@ public class HealPlayerCommand extends AbstractTargetPlayerCommand {
         this.healthArg = this.withDefaultArg("health", "Amount to heal player", ArgTypes.FLOAT, (float)100, "Desc of Default: 100");
 
         // Or you could do the following making the health value required instead of with a default.
-        //    You would need to change the decleration to RequiredArg<Float>
+        //    You would need to change the declaration to RequiredArg<Float>
         // this.healthArg = this.withRequiredArg("health", "Amount to heal player", ArgTypes.FLOAT);
 
-        // Optional args reguare the user the input `--<key> <value>` so the following would require `--message "Good Luck"`
+// Optional args require the user the input `--<key> <value>` so the following would require `--message "Good Luck"`
         this.messageArg = this.withOptionalArg("message", "Message to print while healing", ArgTypes.STRING);
 
         // No type needed due to being a bool
@@ -230,7 +225,7 @@ public class HealPlayerCommand extends AbstractTargetPlayerCommand {
             commandContext.sendMessage(Message.raw("We are debugging"));
         }
 
-        // Health is stored in a generic stat map to allowing mods/future contect to easily add more stats if desired.
+        // Health is stored in a generic stat map to allowing mods/future content to easily add more stats if desired.
         EntityStatMap stats = store.getComponent(ref, EntityStatMap.getComponentType());
         int healthIdx = DefaultEntityStatTypes.getHealth();
         EntityStatValue health = stats.get(healthIdx);
@@ -252,7 +247,7 @@ public class HealPlayerCommand extends AbstractTargetPlayerCommand {
 
 ## Argument Validators
 
-Argument validators are a way to check the command before the command gets executed. They are added with the `addValidator` method on an argument when calling `withXxxArg`. They provide a nice output to the user when an input value is invalid.
+Argument validators are a way to check the command before the command gets executed. They are added with the `addValidator` method on an argument when calling `withXxxArg`. They provide a nice output to the user when an input value is invalid. There are some common validators provided in the `Validators` class such as `greaterThan`, `lessThan`, and `or`, `max`, `range`, etc.
 
 ```java
 ...
@@ -260,18 +255,59 @@ Argument validators are a way to check the command before the command gets execu
     OptionalArg<Integer> healAmount = withOptionalArg("amount", "Heal Amount", ArgTypes.INTEGER)
         .addValidator(Validators.greaterThan(0))
         .addValidator(Validators.lessThan(1000));
-
-    // Custom check example
-    OptionalArg<Integer> healAmount = withOptionalArg("amount", "Heal Amount", ArgTypes.INTEGER)
-            .addValidator( value -> {
-                if (value != null && value <= 0) {
-                    return ValidationResult.error("ammount argument must be a positive number");
-                }
-                return ValidationResult.success();
-            });
 ...
 ```
 
+### Custom Validators
+
+You can also create custom validators by implementing the `com.hypixel.hytale.codec.validation.Validator` interface. The interfaces forces you to implement the `accept` and `updateSchema` method. The `accept` method takes in the argument value and validates it. If the validation fails, you can use the `fail` method of the `com.hypixel.hytale.codec.validation.ValidationResults` class to return an error message.
+The `updateSchema` method is used to update the schema of the command argument. This is used for commands that have dynamic schemas based on the input value. For example, if you have a command that takes in a player name as an argument, you can use the `updateSchema` method to update the schema to include a list of online players for validation.
+
+Here is an example of a custom validator that checks if a string value is equal to a banned word. In this example, the banned word is "badword". If the input value is "badword", the validator will fail and return an error message.
+
+```java
+import com.hypixel.hytale.codec.schema.SchemaContext;
+import com.hypixel.hytale.codec.schema.config.Schema;
+import com.hypixel.hytale.codec.validation.ValidationResults;
+import com.hypixel.hytale.codec.validation.Validator;
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+
+public class MyCustomValidator implements Validator<String> {
+    @Nonnull
+    private final String value;
+
+    public MyCustomValidator(@Nonnull String value) {
+        this.value = value;
+    }
+
+    @Override
+    public void accept(@Nullable String input, @Nonnull ValidationResults results) {
+        if (this.value.equalsIgnoreCase(input)) {
+            results.fail("The given role has been banned.");
+        }
+    }
+
+    @Override
+    public void updateSchema(SchemaContext context, @Nonnull Schema target) {
+        // This method can be used to update the schema of the command argument. This is useful for commands that have dynamic schemas based on the input value. For example, if you have a command that takes in a player name as an argument, you can use the `updateSchema` method to update the schema to include a list of online players for validation.
+        throw new UnsupportedOperationException("Not implemented yet.");
+    }
+}
+```
+
+After the custom validator is created, you can add it to an argument like the following example. In this example, we add the `MyCustomValidator` to a string argument called "role". If the user inputs "badword" as the role, the command will fail and return the error message defined in the `MyCustomValidator`.
+
+```java
+    ...
+    // Custom validator example
+    String bannedRole = "badword";
+
+    OptionalArg<String> roleArg = withOptionalArg("role", "Role to assign", ArgTypes.STRING)
+        .addValidator(new MyCustomValidator(bannedRole));
+    ...
+```
+
 ---
 
 ## Permissions
@@ -312,7 +348,7 @@ This allows the server to control who has access to specific commands. You add t
 
 If you want variants of the same command without doing argument parsing you can instead use `addUsageVariant(new OtherCommandClass())` in the original commands constructor.
 
-The only difference is in the `OtherCommandClass()` constrcutor you don't pass the command name to the super class.
+The only difference is in the `OtherCommandClass()` constructor you don't pass the command name to the super class.
 
 <Callout type="info">
   You can also use `addAliases("some_alias", "some_other_alias")` as a way to add shorthand or other ways to write the same command.
@@ -387,7 +423,7 @@ public class AdminCommand extends AbstractCommandCollection {
     public AdminCommand () {
         super("admin", "Admin commands");
         addSubCommand(new UserCommandCollection());
-        addSybCommand(new ServerCommandCollection);
+        addSubCommand(new ServerCommandCollection);
     }
 }
 ```
@@ -417,5 +453,5 @@ public class MyPlugin extends JavaPlugin {
 
 ## Video Link
 
-_Special Thanks to [TroubleDev](https://www.youtube.com/@TroubleDEV) for his excelent video guide on all of these features._
+_Special Thanks to [TroubleDev](https://www.youtube.com/@TroubleDEV) for his excellent video guide on all of these features._
 _Video Link: [TroubleDev - Hytale's Command API Explained](https://www.youtube.com/watch?v=KnmhG9MDMgo)_
diff --git a/content/docs/it-IT/guides/plugin/creating-events.mdx b/content/docs/it-IT/guides/plugin/creating-events.mdx
index 95863990..d3f0925d 100644
--- a/content/docs/it-IT/guides/plugin/creating-events.mdx
+++ b/content/docs/it-IT/guides/plugin/creating-events.mdx
@@ -1,6 +1,6 @@
 ---
-title: Creating Events
-description: Learn how to create custom events for your Hytale mod.
+title: Creating Events Listeners
+description: Learn how to create event listeners for your Hytale mod.
 authors:
   - name: Neil Revin
     url: https://itsneil.dev
@@ -10,7 +10,7 @@ authors:
 
 ## Event Class
 
-You can import a Event class and create a function with the Event as a argument. [Click here](../../server/events) to look at all available events.
+You can import an Event class and create a function with the Event as an argument. [Click here](../../server/events) to look at all available events.
 
 Example plugin when a player is ready (joins a server):
 
diff --git a/content/docs/it-IT/guides/plugin/item-registry.mdx b/content/docs/it-IT/guides/plugin/item-registry.mdx
new file mode 100644
index 00000000..9a0fd53a
--- /dev/null
+++ b/content/docs/it-IT/guides/plugin/item-registry.mdx
@@ -0,0 +1,95 @@
+---
+title: Working with the Item Registry
+description: Learn how to access and query the game's item registry to list all items, check if items exist, and retrieve item properties.
+authors:
+  - name: Denis
+---
+
+In this guide, you'll learn how to work with Hytale's Item Registry system. This is useful when you need to programmatically list all available items, validate item IDs, or retrieve item properties at runtime.
+
+## Prerequisites
+
+Before diving in, you should be familiar with:
+
+- [Setting up your development environment](./setting-up-env)
+- [Creating commands](./creating-commands) (optional, for testing)
+
+## Required Imports
+
+To work with the Item Registry, you'll need the following imports:
+
+```java
+import com.hypixel.hytale.assetstore.map.DefaultAssetMap;
+import com.hypixel.hytale.server.core.asset.type.item.config.Item;
+```
+
+## Getting the Item Registry
+
+The Item Registry is accessed through the `Item.getAssetMap()` method, which returns a `DefaultAssetMap<String, Item>` containing all registered items in the game:
+
+```java
+DefaultAssetMap<String, Item> itemMap = Item.getAssetMap();
+```
+
+## Listing All Items
+
+To iterate through all items in the registry, you can get the underlying map and loop through its entries:
+
+```java
+DefaultAssetMap<String, Item> itemMap = Item.getAssetMap();
+var map = itemMap.getAssetMap();
+
+for (var entry : map.entrySet()) {
+    String itemId = String.valueOf(entry.getKey());
+    Item item = entry.getValue();
+    
+    // Do something with the item
+    LOGGER.atInfo().log("Item ID: " + itemId);
+}
+```
+
+You can also get the total count of registered items:
+
+```java
+int totalItems = map.size();
+```
+
+## Checking if an Item Exists
+
+To check if a specific item exists in the registry, use `getAsset()` and verify the result:
+
+```java
+public boolean itemExists(String itemId) {
+    var assetMap = Item.getAssetMap();
+    if (assetMap != null) {
+        Item item = assetMap.getAsset(itemId);
+        return item != null && item != Item.UNKNOWN;
+    }
+    return false;
+}
+```
+
+<Callout type="info">
+  The `Item.UNKNOWN` constant represents an invalid or unrecognized item. Always check for both `null` and `Item.UNKNOWN` when validating items.
+</Callout>
+
+## Accessing Item Properties
+
+Once you have an `Item` instance, you can access various properties:
+
+```java
+var assetMap = Item.getAssetMap();
+Item item = assetMap.getAsset("Soil_Grass");
+
+if (item != null && item != Item.UNKNOWN) {
+    String id = item.getId(); // Soil_Grass
+    int maxStack = item.getMaxStack(); // 100
+    boolean isBlock = item.hasBlockType(); // true
+    boolean isConsumable = item.isConsumable(); // false
+}
+```
+
+## Related Guides
+
+- [Inventory Management](./inventory-management) - Learn how to add and remove items from player inventories
+- [Create Custom Item and Interaction](./item-interaction) - Learn how to create your own custom items
diff --git a/content/docs/it-IT/guides/plugin/permission-management.mdx b/content/docs/it-IT/guides/plugin/permission-management.mdx
index 6b7cfd46..55f06101 100644
--- a/content/docs/it-IT/guides/plugin/permission-management.mdx
+++ b/content/docs/it-IT/guides/plugin/permission-management.mdx
@@ -10,132 +10,569 @@ authors:
     link: https://discord.com/users/292656109939064833
   - name: Ivan
     link: https://discord.com/users/505770451218333717
+  - name: ZenithDevHQ
+    link: https://github.com/ZenithDevHQ
 ---
 
-In this guide, you'll learn how to manage permission nodes and groups in your Hytale plugin.
+In this guide, you'll learn how to manage permission nodes and groups in your Hytale plugin. Permissions control what actions players can perform on your server, from basic commands to advanced administrative functions.
 
-## The `PermissionsModule` class
+## What Are Permissions?
 
-The `PermissionsModule` class is responsible for managing permission nodes and groups in your plugin. It provides methods to check, grant and revoke permissions and groups for players. It allows the following operations
+Permissions are string identifiers that control access to features and commands. When a player tries to perform an action (like using a command), the server checks if they have the required permission.
 
-- Add permissions to user
-- Remove permissions from user
-- Add permissions to group (this also creates the group if it doesn't exist)
-- Remove permissions from group
-- Add user to group
-- Remove user from group
-- List all groups for a user
-- Check if a user has a permission (it checks both user and group permissions for the given player UUID)
+**Example permission nodes:**
 
-With this class you cannot:
+- `hytale.command.gamemode` - Permission to use the gamemode command
+- `hytale.editor.brush.use` - Permission to use brush tools
+- `myplugin.teleport.home` - A custom permission for your plugin
 
-- List all defined groups
-- Remove a group
+Permissions follow a hierarchical naming pattern: `namespace.category.action`
 
-### Adding Permission Nodes
+## Key Concepts
 
-You need a `Set<String>` containing all the permission nodes you want to add, these are added on top of the already existing permission nodes the user may have, it is not a replacement.
+Before diving into code, let's understand the core concepts:
+
+| Concept             | Description                                                                |
+| ------------------- | -------------------------------------------------------------------------- |
+| **Permission Node** | A string like `myplugin.feature.use` that represents a specific permission |
+| **Group**           | A named collection of permissions (e.g., "Admin", "VIP", "Default")        |
+| **Provider**        | The backend that stores and retrieves permissions                          |
+| **Wildcard**        | A pattern like `*` or `myplugin.*` that matches multiple permissions       |
+
+### How Permissions Are Checked
+
+When checking if a player has a permission, Hytale follows this order:
+
+1. **User's direct permissions** - Permissions granted directly to the player
+2. **Group permissions** - Permissions from groups the player belongs to
+3. **Virtual groups** - Game-mode-based permissions (e.g., Creative mode grants builder tools)
+4. **Default value** - Falls back to `false` if no match found
+
+<Callout type="info">
+  The first definitive match wins. If a player has a permission granted at the user level, group permissions won't override it.
+</Callout>
+
+---
+
+## The `PermissionsModule` Class
+
+The `PermissionsModule` class is the central hub for managing permissions. Access it using the singleton pattern:
 
 ```java
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.addUserPermission(playerUUID, permissions);
 ```
 
-### Removing Permission Nodes
+### Available Operations
+
+The module supports these operations:
+
+| Operation                     | Method                                          |
+| ----------------------------- | ----------------------------------------------- |
+| Add permissions to user       | `addUserPermission(uuid, permissions)`          |
+| Remove permissions from user  | `removeUserPermission(uuid, permissions)`       |
+| Add permissions to group      | `addGroupPermission(groupName, permissions)`    |
+| Remove permissions from group | `removeGroupPermission(groupName, permissions)` |
+| Add user to group             | `addUserToGroup(uuid, groupName)`               |
+| Remove user from group        | `removeUserFromGroup(uuid, groupName)`          |
+| Get user's groups             | `getGroupsForUser(uuid)`                        |
+| Check permission              | `hasPermission(uuid, permissionNode)`           |
+
+<Callout type="warning">
+  The module does **not** support:
+
+  - Listing all defined groups
+  - Deleting a group entirely
+
+  Groups are implicitly created when you first add permissions to them.
+</Callout>
+
+---
 
-Same as above, we just use the `removeUserPermission` method instead to remove permission nodes.
+## Checking Permissions
+
+The most common operation is checking if a player has a permission.
+
+### Basic Permission Check
+
+```java
+// Returns true if player has the permission, false otherwise
+boolean canUse = PermissionsModule.get().hasPermission(playerUUID, "myplugin.feature.use");
+
+if (canUse) {
+    // Player has permission, allow the action
+} else {
+    // Player lacks permission, deny or show error
+}
+```
+
+### Permission Check with Default Value
+
+You can specify what to return when no permission is explicitly set:
+
+```java
+// Returns true by default if no explicit permission is found
+boolean canUse = PermissionsModule.get().hasPermission(playerUUID, "myplugin.feature.use", true);
+```
+
+This is useful for features that should be enabled by default but can be revoked.
+
+### Using PermissionHolder Interface
+
+Players and command senders implement `PermissionHolder`, allowing direct checks:
+
+```java
+// In a command or event handler where you have access to the player
+if (player.hasPermission("myplugin.admin.manage")) {
+    // Player has admin permission
+}
+```
+
+---
+
+## Managing User Permissions
+
+### Adding Permissions to a User
+
+Permissions are additive - new permissions are added on top of existing ones, not replaced.
+
+```java
+PermissionsModule perms = PermissionsModule.get();
+
+// Add a single permission
+perms.addUserPermission(playerUUID, Set.of("myplugin.vip.chat"));
+
+// Add multiple permissions at once
+Set<String> newPerms = Set.of(
+    "myplugin.vip.chat",
+    "myplugin.vip.fly",
+    "myplugin.vip.kit"
+);
+perms.addUserPermission(playerUUID, newPerms);
+```
+
+### Removing Permissions from a User
 
 ```java
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.removeUserPermission(playerUUID, permissions);
+
+// Remove specific permissions
+Set<String> toRemove = Set.of("myplugin.vip.fly");
+perms.removeUserPermission(playerUUID, toRemove);
 ```
 
-### Add permissions to group
+---
+
+## Managing Groups
+
+Groups let you assign a collection of permissions to multiple players. This is more manageable than assigning permissions individually.
+
+### Adding Permissions to a Group
+
+If the group doesn't exist, it will be created automatically.
 
 ```java
-String groupName = "testGroup";
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.addGroupPermission(groupName, permissions);
+
+// Create/update the "VIP" group with permissions
+Set<String> vipPerms = Set.of(
+    "myplugin.vip.chat",
+    "myplugin.vip.fly",
+    "myplugin.vip.kit"
+);
+perms.addGroupPermission("VIP", vipPerms);
 ```
 
-### Remove permissions from group
+### Removing Permissions from a Group
 
 ```java
-String groupName = "testGroup";
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.removeGroupPermission(groupName, permissions);
+
+// Remove specific permissions from the group
+Set<String> toRemove = Set.of("myplugin.vip.fly");
+perms.removeGroupPermission("VIP", toRemove);
 ```
 
-### Add user to group
+### Adding a User to a Group
 
 ```java
-String groupName = "testGroup";
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.addUserToGroup(playerUUID, groupName);
+
+// Add player to the VIP group - they now have all VIP permissions
+perms.addUserToGroup(playerUUID, "VIP");
 ```
 
-### Remove user from group
+### Removing a User from a Group
 
 ```java
-String groupName = "testGroup";
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.removeUserFromGroup(playerUUID, groupName);
+
+// Remove player from VIP group
+perms.removeUserFromGroup(playerUUID, "VIP");
 ```
 
-### List all groups for a user
+### Getting a User's Groups
 
 ```java
 PermissionsModule perms = PermissionsModule.get();
-perms.getGroupsForUser(playerUUID);
+
+// Get all groups the player belongs to
+Set<String> groups = perms.getGroupsForUser(playerUUID);
+
+for (String group : groups) {
+    System.out.println("Player is in group: " + group);
+}
 ```
 
-### Check Permission Nodes
+---
+
+## Built-in Groups
+
+Hytale includes two default groups:
+
+| Group     | Default Permissions   | Purpose                           |
+| --------- | --------------------- | --------------------------------- |
+| `OP`      | `*` (all permissions) | Server operators with full access |
+| `Default` | None                  | Base group for all players        |
+
+Players without any explicit group assignment are automatically part of the `Default` group.
 
-To check if a player has a specific permission node, you can use the `hasPermission` method.
+---
+
+## Wildcards
+
+Wildcards let you grant or deny multiple permissions with a single pattern.
+
+### Wildcard Patterns
+
+| Pattern             | Meaning                                          |
+| ------------------- | ------------------------------------------------ |
+| `*`                 | Grants **all** permissions                       |
+| `myplugin.*`        | Grants all permissions starting with `myplugin.` |
+| `-*`                | Denies **all** permissions                       |
+| `-myplugin.admin.*` | Denies all admin permissions in your plugin      |
+
+### Example: Admin Group with Wildcards
 
 ```java
-boolean hasPermission = PermissionsModule.hasPermission(playerUUID, "permission.node");
+// Grant all permissions to admins
+perms.addGroupPermission("Admin", Set.of("*"));
+
+// Grant all plugin permissions to moderators
+perms.addGroupPermission("Moderator", Set.of("myplugin.*"));
+
+// Grant all permissions except admin commands
+perms.addGroupPermission("Helper", Set.of(
+    "*",
+    "-myplugin.admin.*"  // Deny admin permissions
+));
 ```
 
-## Additional: Defining your own provider for permissions and groups
+<Callout type="warning">
+  Negation permissions (starting with `-`) take precedence at each level. Use them carefully to avoid accidentally blocking permissions.
+</Callout>
+
+---
+
+## Built-in Permission Nodes
+
+Hytale provides constants for common permissions in the `HytalePermissions` class:
+
+### Command Permissions
+
+```java
+// Generate permission for a command
+String perm = HytalePermissions.fromCommand("gamemode");
+// Result: "hytale.command.gamemode"
+
+// Generate permission for a subcommand
+String perm = HytalePermissions.fromCommand("gamemode", "creative");
+// Result: "hytale.command.gamemode.creative"
+```
+
+### Common Permission Nodes
+
+| Permission                    | Description                  |
+| ----------------------------- | ---------------------------- |
+| `hytale.command.op.add`       | Add players to OP group      |
+| `hytale.command.op.remove`    | Remove players from OP group |
+| `hytale.editor.brush.use`     | Use brush tools              |
+| `hytale.editor.prefab.use`    | Use prefabs                  |
+| `hytale.editor.selection.use` | Use selection tools          |
+| `hytale.editor.history`       | Undo/redo operations         |
+| `hytale.camera.flycam`        | Use fly camera mode          |
+
+---
+
+## Listening to Permission Events
+
+You can react to permission changes using Hytale's event system.
+
+### Available Events
+
+| Event                                            | Triggered When                   |
+| ------------------------------------------------ | -------------------------------- |
+| `PlayerPermissionChangeEvent.PermissionsAdded`   | Permissions added to a user      |
+| `PlayerPermissionChangeEvent.PermissionsRemoved` | Permissions removed from a user  |
+| `PlayerGroupEvent.Added`                         | User added to a group            |
+| `PlayerGroupEvent.Removed`                       | User removed from a group        |
+| `GroupPermissionChangeEvent.Added`               | Permissions added to a group     |
+| `GroupPermissionChangeEvent.Removed`             | Permissions removed from a group |
 
-The PermissionsModule also enables us to define our own PermissionProvider's, this can be useful for:
+### Example: Reacting to Permission Changes
 
-- Cross server permission systems
-- Implementing features missing in the `HytalePermissionsProvider` like permission expiry
+```java
+public class PermissionListener {
+
+    public static void onPermissionsAdded(PlayerPermissionChangeEvent.PermissionsAdded event) {
+        UUID playerUUID = event.getPlayerUuid();
+        Set<String> added = event.getAddedPermissions();
+
+        System.out.println("Permissions added to " + playerUUID + ": " + added);
 
-To implement our PermissionProvider, first we need to define a provider class that implements PermissionProvider:
+        // Maybe notify the player or update cached data
+    }
+
+    public static void onGroupAdded(PlayerGroupEvent.Added event) {
+        UUID playerUUID = event.getPlayerUuid();
+        String groupName = event.getGroupName();
+
+        System.out.println("Player " + playerUUID + " joined group: " + groupName);
+    }
+}
+```
+
+### Registering the Events
 
 ```java
-public class DatabasePermissionProvider implements PermissionProvider
+public class MyPlugin extends JavaPlugin {
+
+    @Override
+    public void setup() {
+        EventRegistry events = this.getEventRegistry();
+
+        events.registerGlobal(
+            PlayerPermissionChangeEvent.PermissionsAdded.class,
+            PermissionListener::onPermissionsAdded
+        );
+
+        events.registerGlobal(
+            PlayerGroupEvent.Added.class,
+            PermissionListener::onGroupAdded
+        );
+    }
+}
 ```
 
-Then we just implement the required methods using a database implementation.
+---
+
+## Creating a Custom Permission Provider
+
+For advanced use cases, you can create your own permission provider. This is useful for:
+
+- Database-backed permissions (MySQL, MongoDB, etc.)
+- Cross-server permission synchronization
+- Custom features like permission expiry or contexts
+
+### Implementing PermissionProvider
+
+```java
+public class DatabasePermissionProvider implements PermissionProvider {
+
+    @Nonnull
+    @Override
+    public String getName() {
+        return "DatabasePermissionProvider";
+    }
+
+    // User permission methods
+    @Override
+    public void addUserPermissions(@Nonnull UUID uuid, @Nonnull Set<String> permissions) {
+        // Save to your database
+    }
+
+    @Override
+    public void removeUserPermissions(@Nonnull UUID uuid, @Nonnull Set<String> permissions) {
+        // Remove from your database
+    }
+
+    @Override
+    public Set<String> getUserPermissions(@Nonnull UUID uuid) {
+        // Query your database
+        return Set.of();
+    }
+
+    // Group permission methods
+    @Override
+    public void addGroupPermissions(@Nonnull String group, @Nonnull Set<String> permissions) {
+        // Save to your database
+    }
+
+    @Override
+    public void removeGroupPermissions(@Nonnull String group, @Nonnull Set<String> permissions) {
+        // Remove from your database
+    }
+
+    @Override
+    public Set<String> getGroupPermissions(@Nonnull String group) {
+        // Query your database
+        return Set.of();
+    }
+
+    // User-group membership methods
+    @Override
+    public void addUserToGroup(@Nonnull UUID uuid, @Nonnull String group) {
+        // Save to your database
+    }
+
+    @Override
+    public void removeUserFromGroup(@Nonnull UUID uuid, @Nonnull String group) {
+        // Remove from your database
+    }
+
+    @Override
+    public Set<String> getGroupsForUser(@Nonnull UUID uuid) {
+        // Query your database
+        return Set.of("Default");
+    }
+}
+```
 
 <Callout type="warning">
-  Hytale will try to use the first available permissions provider to add/remove gamemode groups (i.e. `Creative`, `Adventure`).
+  Hytale automatically assigns players to game-mode groups (like `Creative` or `Adventure`) using the first available provider.
+
+  If your provider throws an error when the group doesn't exist, the player will be disconnected! Always handle missing groups gracefully.
+</Callout>
+
+### Registering Your Provider
 
-  If your provider throws an error (for instance, if the group does not exist) when the server is preparing the player, the player will be disconnected.
+```java
+public class MyPlugin extends JavaPlugin {
+
+    @Override
+    public void setup() {
+        // Add your provider alongside the default one
+        PermissionsModule.get().addProvider(new DatabasePermissionProvider());
+    }
+}
+```
+
+The `PermissionsModule` aggregates permissions from all registered providers. This means:
+
+- Permission checks query all providers
+- Write operations (add/remove) use the **first** provider
+
+### Replacing the Default Provider
+
+If you want full control, you can remove the default provider:
+
+```java
+public class MyPlugin extends JavaPlugin {
+
+    @Override
+    public void setup() {
+        PermissionsModule perms = PermissionsModule.get();
+
+        // Remove the default provider FIRST
+        perms.removeProvider(perms.getFirstPermissionProvider());
+
+        // Then add your provider
+        perms.addProvider(new DatabasePermissionProvider());
+    }
+}
+```
+
+<Callout type="info">
+  When you remove the default provider, the `/op self` command will stop working since it checks for provider tampering.
 </Callout>
 
-We can then register the provider using the built-in permission module:
+---
+
+## Best Practices
+
+### Permission Naming Conventions
+
+Follow the pattern: `namespace.category.action`
 
 ```java
-PermissionsModule.get().addProvider(new DatabasePermissionProvider());
+// Good - clear hierarchy
+"myplugin.admin.ban"
+"myplugin.user.teleport.home"
+"myplugin.vip.chat.color"
+
+// Bad - unclear structure
+"myplugin_ban"
+"teleport"
+"vipChatColor"
 ```
 
-Please note that the `HytalePermissionsProvider` will still be enabled alongside your provider.
-The `PermissionsModule` will aggregate groups and permissions from all available providers.
+### Use Constants for Permissions
 
-If you want to disable the default `HytalePermissionsProvider`, you can use:
+Define your permissions as constants to avoid typos:
 
 ```java
-// put this **before** you add your provider
-PermissionsModule.get().removeProvider(PermissionsModule.get().getFirstPermissionProvider());
+public final class MyPermissions {
+    public static final String ADMIN_BAN = "myplugin.admin.ban";
+    public static final String ADMIN_KICK = "myplugin.admin.kick";
+    public static final String USER_HOME = "myplugin.user.home";
+    public static final String VIP_FLY = "myplugin.vip.fly";
+}
+
+// Usage
+if (player.hasPermission(MyPermissions.ADMIN_BAN)) {
+    // ...
+}
 ```
+
+### Don't Over-Permission
+
+Only create permissions for actions that genuinely need access control. Not everything needs a permission check.
+
+### Thread Safety
+
+If you create a custom provider, ensure it's thread-safe. Permission checks can occur from multiple threads simultaneously. Use `ReadWriteLock` or `ConcurrentHashMap` for your data structures.
+
+---
+
+## In-Game Commands
+
+Hytale provides built-in commands for managing permissions:
+
+### `/op` Command
+
+| Command               | Description                                                        |
+| --------------------- | ------------------------------------------------------------------ |
+| `/op self`            | Toggle your own OP status (singleplayer or with `--allow-op` flag) |
+| `/op add <player>`    | Add a player to the OP group                                       |
+| `/op remove <player>` | Remove a player from the OP group                                  |
+
+### `/perm` Command
+
+Use `/perm --help` in-game for full usage. Common operations:
+
+| Command                                  | Description                   |
+| ---------------------------------------- | ----------------------------- |
+| `/perm user list <uuid>`                 | List user's permissions       |
+| `/perm user add <uuid> <perm>`           | Add permission to user        |
+| `/perm user remove <uuid> <perm>`        | Remove permission from user   |
+| `/perm user group list <uuid>`           | List user's groups            |
+| `/perm user group add <uuid> <group>`    | Add user to group             |
+| `/perm user group remove <uuid> <group>` | Remove user from group        |
+| `/perm group list <group>`               | List group's permissions      |
+| `/perm group add <group> <perm>`         | Add permission to group       |
+| `/perm group remove <group> <perm>`      | Remove permission from group  |
+| `/perm test <perm>`                      | Test if you have a permission |
+
+---
+
+## Summary
+
+You've learned how to:
+
+- **Check permissions** using `PermissionsModule.hasPermission()`
+- **Manage user permissions** with `addUserPermission()` and `removeUserPermission()`
+- **Work with groups** using `addGroupPermission()`, `addUserToGroup()`, etc.
+- **Use wildcards** like `*` and `myplugin.*` for bulk permissions
+- **Listen to events** for permission changes
+- **Create custom providers** for database-backed permissions
+
+For more advanced permission systems with features like inheritance, expiry, and contexts, we're looking into expanding this guide with advanced permission management techniques in the future.
diff --git a/content/docs/it-IT/guides/plugin/setting-up-env.mdx b/content/docs/it-IT/guides/plugin/setting-up-env.mdx
index d2718098..5be5e9e0 100644
--- a/content/docs/it-IT/guides/plugin/setting-up-env.mdx
+++ b/content/docs/it-IT/guides/plugin/setting-up-env.mdx
@@ -4,6 +4,10 @@ description: Learn how to set up your development environment for modding Hytale
 authors:
   - name: Neil Revin
     link: https://itsneil.dev
+  - name: Marcel-TO
+    url: https://marcel-to.net
+  - name: Ádám Liszkai
+    link: https://adaliszk.dev
 ---
 
 This guide will walk you through setting up a complete development environment for Hytale modding, including all necessary tools and dependencies.
@@ -19,24 +23,73 @@ Before we begin, make sure you have:
 
 ## Required Software
 
-### 1. Java Development Kit (JDK)
+### Integrated Development Environment (IDE)
 
+We recommend IntelliJ IDEA Community Edition for Hytale modding. If you use IntelliJ IDEA, **almost everything is built-in**. You can clone a template, open a new project, and start working right away!
+
+1. Download from [JetBrains website](https://www.jetbrains.com/idea/download/)
+2. Install with default settings
+3. Launch and complete the initial setup wizard
+
+When opening a project, wait for indexing to finish, then start coding.
+Now, IDEA may say "No JDK configured" at the top of the source file you have.
+In that case, you can click Download JDK and choose JetBrains JDK 25.
+
+<Callout type="success">
+  If IDEA opened the project without errors, your environment is ready.
+</Callout>
+
+More details by [JetBrains](https://www.jetbrains.com/help/idea/2026.1/run-for-the-first-time.html)
+help page, where we recommend that you also check the
+[SDK configuration](https://www.jetbrains.com/help/idea/2026.1/sdk.html) guide.
+
+<Callout type="info">
+  We recommened following
+  [TheNullicorn's](https://gist.github.com/TheNullicorn/90a619796c40f20ae1fcf13094c1a57d) guide to ensure
+  you are using the correct `Nonnull` in your projects.
+</Callout>
+
+#### What the IDE Does for You
+
+When opened in IntelliJ IDEA, the project automatically:
+
+- Detects and configures Gradle or Maven
+- Downloads all dependencies
+- Sets up project structure and classpaths
+- Configures run/build tasks
+
+You do **not** need to manually install or configure Maven or Gradle if you stay inside the IDE.
+
+Skip to the [Setting Up Your Workspace](#setting-up-your-workspace).
+
+### Manual Setup: Java Development Kit (JDK)
+
+For any other setup, you will need to install and configure your system to have and load Java.
 Hytale modding requires Java 25 or later. We recommend using OpenJDK.
 
-#### Windows
+#### Windows via Installer
 
 1. Download OpenJDK 25 from [Adoptium](https://adoptium.net/)
 2. Run the installer with default settings
+   - Optionally enable feature `Set or Override JAVA_HOME variable` to resolve version related build issues with your project.
 3. Verify installation by opening Command Prompt and running:
 
+#### Windows via Scoop
+
+1. Install Scoop via PowerShell using [scoop.sh](https://scoop.sh/)
+2. Install OpenJDK 25:
+
 ```bash
-java -version
+scoop bucket add java
+scoop install java/openjdk25
 ```
 
 #### macOS
 
+1. Install Brew via Terminal using [brew.sh](https://brew.sh)
+2. Install JDK via Homebrew:
+
 ```bash
-# Using Homebrew
 brew install openjdk@25
 ```
 
@@ -51,22 +104,41 @@ brew install openjdk@25
 
 #### Linux (Ubuntu/Debian)
 
+1. Install JDK via the built-in package repository:
+
 ```bash
 sudo apt update
 sudo apt install openjdk-25-jdk
 ```
 
-### 2. Integrated Development Environment (IDE)
+### Verify installation:
 
-We recommend IntelliJ IDEA Community Edition for Hytale modding.
+Run the following command to see what version of Java you have:
 
-1. Download from [JetBrains website](https://www.jetbrains.com/idea/download/)
-2. Install with default settings
-3. Launch and complete the initial setup wizard
+```bash
+java -version
+```
+
+### Java Build Tool (Optional)
+
+We recommend using a Gradle Wrapper for managing dependencies and building your Hytale plugins. It provides benefits by eliminating the need for a system-wide Gradle installation and ensuring consistent Gradle versions across different environments. (Alternatively you can use Maven, but this guide focuses on Gradle since it is the default for our plugin template.)
+
+The plugin template in the following sections includes a Gradle Wrapper, so you can skip this step if you plan to use the template.
+
+#### Choosing Gradle (if not using the template)
+
+If you prefer to install Gradle manually, follow these steps:
 
-### 3) Java Build Tool
+1. Visit the official website: https://gradle.org/releases/
+2. Download the newest gradle binary: `gradle-9.3.1-bin.zip` (Binary zip archive)
+3. Unzip it
+4. Add the `gradle-9.3.1/bin/` folder to your PATH
+
+You can now try the command `gradle -version` to verify Gradle is installed correctly. Make sure to do this in a fresh new terminal instead of one you had opened from before!
+
+#### Choosing Maven (if not using the template)
 
-We recommend using Apache Maven for managing dependencies and building your Hytale plugins. (Alternatively you can use Gradle, but this guide focuses on Maven.)
+If you prefer to use Maven instead of Gradle, follow these steps to install Maven:
 
 1. Visit the official website: https://maven.apache.org/download.cgi
 2. Download this file: `apache-maven-3.9.12-bin.zip` (Binary zip archive)
@@ -89,22 +161,61 @@ cd MyFirstMod
 
 If you don't have Git installed, you can download the ZIP file from the repository page and extract it to a folder named `MyFirstMod`.
 
-### 2. Open Plugin in your IDEA
+### 2. Open Plugin in your IDE
 
-1. Open IntelliJ IDEA
+1. Open Your IDE (e.g., IntelliJ IDEA)
 2. Click "Open" and navigate to your `MyFirstMod` directory
-3. IntelliJ will automatically detect it as a Maven project
+3. Most IDEs like IntelliJ will automatically detect it as a Gradle project
 4. Wait for the project to index and dependencies to download
 
-<Callout type="info">
-  We recommened following [this](https://gist.github.com/TheNullicorn/90a619796c40f20ae1fcf13094c1a57d) guide to ensure you are using the correct `Nonnull` in your projects.
-</Callout>
+## Alternate Approach: Hytale Dependency
+
+If you prefer to set up your project from scratch without using the template and importing the hytale dependencies manually, ensure your build configuration includes the Hytale repositories and dependencies:
+
+For Gradle, add the following to your `build.gradle.kts`:
+
+```kotlin
+repositories {
+    mavenCentral()
+    maven {
+        name = "hytale"
+        url = uri("https://maven.hytale.com/release") // Or "hytale-pre-release" for pre-release versions
+    }
+}
+dependencies {
+    // + here means the latest version, but you can hard-wire any known version!
+    implementation("com.hypixel.hytale:Server:+")
+}
+```
+
+For Maven, add the following to your `pom.xml`:
+
+```xml
+<project>
+    <repositories>
+        <repository>
+            <id>hytale-release</id> <!-- Or "hytale-pre-release" for pre-release versions -->
+            <url>https://maven.hytale.com/release</url> <!-- Or "https://maven.hytale.com/pre-release" -->
+        </repository>
+    </repositories>
+
+    <dependencies>
+        <dependency>
+            <groupId>com.hypixel.hytale</groupId>
+            <artifactId>Server</artifactId>
+            <!-- Replace with latest version, Hytale provides jars for the last five releases -->
+            <version>LATEST_VERSION_HERE</version>
+            <scope>provided</scope>
+        </dependency>
+    </dependencies>
+</project>
+```
 
 ## Next Steps
 
 Now that you have your development environment set up with the plugin template:
 
-1. **Customize the template** - Edit the `pom.xml` and `manifest.json` file to change your mod's name and details
+1. **Customize the template** - Edit the `settings.gradle.kts`, `build.gradle.kts` and `manifest.json` file to change your mod's name and details
 2. **Explore the code structure** - Familiarize yourself with the template's organization
 3. **Start modding** - Begin writing your first Hytale plugin!
 
diff --git a/content/docs/it-IT/guides/plugin/spawning-entities.mdx b/content/docs/it-IT/guides/plugin/spawning-entities.mdx
index e12c0aea..15be2fb3 100644
--- a/content/docs/it-IT/guides/plugin/spawning-entities.mdx
+++ b/content/docs/it-IT/guides/plugin/spawning-entities.mdx
@@ -36,7 +36,7 @@ Store<EntityStore> store = world.getEntityStore().getStore();
 
 ## Creating Entities
 
-Once you have the `EntityStore` instance, you can start to create a entity and give it components. Entities are just instances of `Holder<EntityStore>` with several components attached to them.
+Once you have the `EntityStore` instance, you can start to create an entity and give it components. Entities are just instances of `Holder<EntityStore>` with several components attached to them.
 
 <Callout type="warning">
   To interact with the `World` instance, some methods require you to run the code inside the world's execution context.
@@ -118,3 +118,48 @@ Finally, we can add the entity to the world by calling the `addEntity` method on
 ```java
 store.addEntity(holder, AddReason.SPAWN);
 ```
+
+## Making the entity persist
+
+Hytale automatically saves all entities, but the `NetworkId` component (required for players to be able to see the entity) needs to be manually added every time the entity is loaded.
+
+### Using a system
+
+If you have a component that is unique to your entities, this can be done by creating and registering a custom system as follows:
+
+```java
+public class AddNetworkIdToMyEntitySystem extends HolderSystem<EntityStore> {
+    private final ComponentType<EntityStore, MyEntityComponent> myEntityComponentType = MyEntityComponent.getComponentType();
+    private final ComponentType<EntityStore, NetworkId> networkIdComponentType = NetworkId.getComponentType();
+    private final Query<EntityStore> query = Query.and(this.myEntityComponentType, Query.not(this.networkIdComponentType));
+
+    @Override
+    public void onEntityAdd(@NotNull Holder<EntityStore> holder, @NotNull AddReason reason, @NotNull Store<EntityStore> store) {
+        if (!holder.getArchetype().contains(NetworkId.getComponentType())) {
+            holder.addComponent(NetworkId.getComponentType(), new NetworkId(store.getExternalData().takeNextNetworkId()));
+        }
+    }
+
+    @Override
+    public void onEntityRemoved(@NotNull Holder<EntityStore> holder, @NotNull RemoveReason reason, @NotNull Store<EntityStore> store) {}
+
+    @Override
+    public @Nullable Query<EntityStore> getQuery() {
+        return query;
+    }
+}
+```
+
+In your plugin's `setup()` function
+
+```java
+this.getEntityStoreRegistry().registerSystem(new AddNetworkIdToMyEntitySystem())
+```
+
+### Using PropComponent
+
+Alternatively you can add `PropComponent` to your entity. Hytale adds `PropComponent` to entities spawned with the Entity Tool, and such entities automatically get `NetworkId` and `PrefabCopyableComponent` (which makes the entity work with prefabs).
+
+<Callout type="warning">
+  There is no guarantee, that Hytale will not add some other behavior to this component in the future, which may break your entity, so be careful if you decide to rely on it.
+</Callout>
diff --git a/content/docs/it-IT/guides/plugin/store-persistent-data.mdx b/content/docs/it-IT/guides/plugin/store-persistent-data.mdx
new file mode 100644
index 00000000..1071dff3
--- /dev/null
+++ b/content/docs/it-IT/guides/plugin/store-persistent-data.mdx
@@ -0,0 +1,171 @@
+---
+title: Storing Persistent Data on the Player
+description: Learn how to save and load persistent data using Components
+authors:
+  - name: Neil Revin
+    url: https://itsneil.dev/
+  - name: ArcticDev
+    url: https://github.com/ArcticRaven
+  - name: oskarscot
+    url: https://oskar.scot
+  - name: JammingEng
+    url: https://github.com/JammingEnd
+---
+
+Here is how to store persistent data using a custom component on a Player.
+
+## Build your Component Class
+
+Creating a custom component class leverages the Component system made with the ECS architecture in mind. For more information on Components, check out the [ECS Guide](../ecs/hytale-ecs-theory#components).
+
+Start by creating your custom component class. This will be extremely similar to how regular components are created, however we'll setup a custom Codec so the server can translate this data to BSON, or the server's internal json encoder.
+
+<Callout type="info">
+  Each variable you want to store in your component must have its own Codec field defined in the BuilderCodec.
+  For more information on how to create custom Codecs, check out the [ECS Codec Guide](../ecs/hytale-ecs-theory#codec).
+</Callout>
+
+```java
+public class YourPlayerData implements Component<EntityStore> {
+
+    // define some vars!
+    private int someInteger;
+    private String someString;
+    private Map<String, String> someMap;
+
+    public static final BuilderCodec<YourPlayerData> CODEC =
+            BuilderCodec.builder(YourPlayerData.class, YourPlayerData::new)
+            .append(new KeyedCodec<>("SomeInteger", Codec.INTEGER),
+                    (data, value) -> data.someInteger = value, // setter
+                    data -> data.someInteger) // getter
+            .addValidator(Validators.nonNull())
+            .add()
+            .append(new KeyedCodec<>("SomeString", Codec.STRING),
+                    (data, value) -> data.someString = value, // setter
+                    data -> data.someString) // getter
+            .add()
+            .append(new KeyedCodec<>("SomeMap",
+                            new MapCodec<>(Codec.STRING, HashMap::new, false)),
+                    (data, value) -> data.someMap = value, // setter
+                    data -> data.someMap) // getter
+            .add()
+            .build();
+
+
+
+    // Getters and Setters are for the purpose of this example omitted.
+
+    // constructor
+    public YourPlayerData() {
+        this.someInteger = 0;
+        this.someString = "";
+        this.someMap = new HashMap<>();
+    }
+
+    // copy constructor for cloning
+    public YourPlayerData(YourPlayerData clone) {
+        this.someInteger = clone.someInteger;
+        this.someString = clone.someString;
+        this.someMap = clone.someMap;
+    }
+
+    @Nonnull
+    @Override
+    public Component<EntityStore> clone() {
+        return new YourPlayerData(this);
+    }
+}
+```
+
+## Register your Component
+
+Inside your main class's `setup()` method, register your new Component.
+
+```java
+public class YourPlugin extends JavaPlugin {
+
+    private ComponentType<EntityStore, YourPlayerData> yourPlayerDataComponent;
+
+    public YourPlugin(@Nonnull JavaPluginInit init) {
+        super(init);
+    }
+
+    @Override
+    protected void setup(){
+        this.yourPlayerDataComponent = this.getEntityStoreRegistry().registerComponent(
+            YourPlayerData.class,
+            "YourPlayerDataComponent",
+            YourPlayerData.CODEC
+        );
+    }
+
+    public ComponentType<EntityStore, YourPlayerData> getYourPlayerDataComponent() {
+        return this.yourPlayerDataComponent;
+    }
+}
+```
+
+## Using your Component
+
+To use your newly created component, you can add the Component to a player using the `addComponent` method, although this only adds it temporarily, meaning when the player/entity leaves the world, the component is removed. You can use `putComponent` to ensure the component persists between sessions.
+
+```java
+// You will need the Ref and Store to apply components
+private void someEntryMethod(@Nonnull Ref<EntityStore> ref, @Nonnull Store<EntityStore> store)
+{
+       // Any entity will work, for now we will use the player
+      Player player = (Player) store.getComponent(ref, Player.getComponentType());
+
+      // since we're using putComponent, it could be useful to check if it already exists on the player in case we want to update it
+     if(store.getComponent(ref, YourPlugin.instance().getYourPlayerDataComponent()) != null)
+     {
+          // here we implement logic that updates the component
+         var comp = store.getComponent(ref, YourPlugin.instance().getYourPlayerDataComponent())
+         // declare public fields or methods in the component class
+         comp.SomeString = "An Updated Field";
+     } else {
+          // Here we put the component
+          var myCustomComp = new CustomComponent();
+          // declare public fields or methods in the component class
+          myCustomComp.SomeString = "Edited String";
+
+          // putComponent allows you to insert declared objects
+          store.putComponent(ref, YourPlugin.instance().getYourPlayerDataComponent(), myCustomComp);
+     }
+}
+```
+
+## Using your Data
+
+Your component will be stored within the `Store<EntityStore>` when added to the player. In the provided example,
+we'll fetch this data off the player using the `ensureAndGetComponent()` method, which will add the component to
+the player if it does not exist with the default values.
+
+```java
+public class IncompleteCustomCommand extends AbstractPlayerCommand {
+
+    public IncompleteCustomCommand() {
+        super("nope", "don't use this command");
+    }
+
+    @Override
+    protected void execute(
+        @NonNullDecl CommandContext commandContext,
+        @NonNullDecl Store<EntityStore> store,
+        @NonNullDecl Ref<EntityStore> ref,
+        @NonNullDecl PlayerRef playerRef,
+        @NonNullDecl World world
+    ) {
+        YourPlayerData customData = store.ensureAndGetComponent(ref, YourPlugin.instance().getYourPlayerDataComponent());
+        // ensureAndGetComponent adds the component to the ref, with the default values defined inside your component.
+ 		// use your data
+    }
+}
+```
+
+And that's it! Your data will now be saved and loaded automatically with the player.
+
+Using custom components to store persistent data on players is a powerful way to maintain state across sessions.
+By following the steps outlined above, you can easily create, register, and utilize your own data structures within the Hytale ECS framework.
+This approach ensures that your data is seamlessly integrated with the game's existing systems.
+For more information about Hytale's Entity Component System visit the [Hytale ECS Theory](https://hytalemodding.dev/en/docs/guides/ecs/hytale-ecs-theory) guide.
diff --git a/content/docs/it-IT/guides/plugin/teleporting-players.mdx b/content/docs/it-IT/guides/plugin/teleporting-players.mdx
index 57cee77f..32ce0435 100644
--- a/content/docs/it-IT/guides/plugin/teleporting-players.mdx
+++ b/content/docs/it-IT/guides/plugin/teleporting-players.mdx
@@ -1,26 +1,32 @@
 ---
 title: Teleporting the player
 description: Learn how to teleport the player.
+authors:
+  - name: oskarscot
+    url: https://oskar.scot
 ---
 
-To teleport players in Hytale, you will need to get a `World` object so we can safely run the teleport on the world thread. The world thread manages all entity updates, so modifying entities off-thread can crash the server or cause inconsistent state.
-Next, we get the entity store and make a `Teleport` object.
-We add a `Teleport` component to the player’s entity reference in the entity store. This triggers the teleportation logic for that player.
+Teleporting players in Hytale works by simply attaching a `Teleport` component to a player with the desired world and transform.
+You can only trigger teleports from a world where the player is currently present.
+Teleport itself is a component but it also provides factory methods to configure the Teleport. Just as with any entity component, an EntityStore and a Ref to the EntityStore is required
+
+We can create a simple teleport utility like this:
 
 ```java
-public static void teleportPlayer(Player player, int x, int y, int z) {
-        World world = player.getWorld();
-        if (world == null) return;
-        world.execute(() -> {
-            if (player.getReference() == null) return;
-            Store<EntityStore> store = player.getReference().getStore();
-            Teleport teleport = Teleport.createForPlayer(world,
-                new Vector3d(x ,y, z), // Target position
-                new Vector3f(0, 0, 0)  // Target rotation (pitch, yaw, roll)
-            );
+public static void teleportPlayer(Ref<EntityStore> ref, Store<EntityStore> store, World targetWorld, double x, double y, double z) {                                                                                       
+    Transform transform = new Transform(x, y, z);                                                                                                                           
+    Teleport teleport = Teleport.createForPlayer(targetWorld, transform);                                                                                                   
+    store.addComponent(ref, Teleport.getComponentType(), teleport);                                                                                                         
+}  
+```
 
-            store.addComponent(player.getReference(), Teleport.getComponentType(), teleport);
-        });
+A `Transform` is a representation of a position Vector3d and rotation Vector3f which works in the following way:
 
-}
+```java
+Transform transform = new Transform(
+    new Vector3d(x, y, z),      // Position
+    new Rotation(yaw, pitch, 0) // Rotation, last value seems to always be 0
+);
+Teleport teleport = Teleport.createForPlayer(targetWorld, transform);
+store.addComponent(ref, Teleport.getComponentType(), teleport);
 ```
diff --git a/content/docs/it-IT/guides/plugin/tracking-mod-analytics-with-hstats.mdx b/content/docs/it-IT/guides/plugin/tracking-mod-analytics-with-hstats.mdx
new file mode 100644
index 00000000..45c022e0
--- /dev/null
+++ b/content/docs/it-IT/guides/plugin/tracking-mod-analytics-with-hstats.mdx
@@ -0,0 +1,65 @@
+---
+title: Tracking Mod Analytics with HStats
+description: Learn how you can track Analytics for your Hytale Mod for Free using hstats.dev
+authors:
+  - name: Al3x
+    url: https://hstats.dev
+---
+
+In this guide, you will learn how to integrate HStats into your Plugin/Mod which will allow you to track how many Servers are using it along with other stats.
+
+<Callout type="info">
+  HStats is a third-party tool and is not affiliated with HytaleModding or Hypixel Studios
+</Callout>
+
+# Step 1: Register your Mod to HStats
+
+Before you touch any code, you will need to add your mod to the HStats website which will give you a UUID for your mod.
+
+- Create or Login to an Account on https://hstats.dev
+- Navigate to the dashboard page (https://hstats.dev/dashboard)
+- On the left, type in your mod's name and click "Add Mod"
+- Keep note of the UUID generated for later.
+
+# Step 2: Add the HStats Class to Your Project
+
+To keep things simple, HStats uses a single Java class file that handles everything for you.
+
+- Download / Copy the File from the GitHub page (https://github.com/hstats-dev/HStatsExamplePlugin/blob/main/src/main/java/com/al3x/HStats.java)
+- Paste into your Project. You should now have a HStats.java file somewhere in your projects directory.
+- Update the package name from com.al3x to whatever fits your project.
+
+# Step 3: Initialize HStats in your code
+
+You only need to add one line of code to your mod's setup method in your main class to start tracking.
+
+`new HStats("YOUR-MOD-UUID", "1.0.0");`
+
+Replace `YOUR-MOD-UUID` with the Mod UUID we made note of earlier and change the `1.0.0` version to whatever version your mod is currently on.
+
+Your setup method should now look something like this:
+
+```java
+@Override
+protected void setup() {
+  super.setup();
+  new HStats("c34a2b2a-afd8-4d6a-821e-7a63e12c5ea6", "1.0.0");
+}
+```
+
+# Extras
+
+Your done! Your mod should now be listed under the Mods page (https://hstats.dev/mods) as well as under your dashboard.
+
+Servers using your mod should now post updates about every minute to HStats which you can view in the Dashboard.
+
+### Embeds
+
+HStats allows you to generate an Embed Card that you can place on your CurseForge or GitHub page. This is useful for server owners to be able to see how many other servers are using your mod.
+
+- In your dashboard, scroll down to the Embed Card section.
+- Customize the appearance (Light/Dark mode, layout, etc).
+- Copy the generated URL to display your "Active Servers" and "Players Online" live on your mod's description page
+
+Heres an example of what they look like:
+![HStats Example](https://api.hstats.dev/api/embed/d52fa672-6966-47b2-b501-1a11bddebac3/card.svg?theme=light\&layout=compact\&size=md\&show_id=true\&dark=false)
diff --git a/content/docs/it-IT/guides/plugin/world-gen.mdx b/content/docs/it-IT/guides/plugin/world-gen.mdx
index 4c23b0c9..7b193ffd 100644
--- a/content/docs/it-IT/guides/plugin/world-gen.mdx
+++ b/content/docs/it-IT/guides/plugin/world-gen.mdx
@@ -100,7 +100,7 @@ Biome biome = biomeGen.generateBiomeAt(zoneResult, seed, x, z);
 
 ### Zone & Cave Integration
 
-Each zone defines it's own cave patterns:
+Each zone defines its own cave patterns:
 
 ```java
 Zone zone = /* ... */;
diff --git a/content/docs/it-IT/guides/prefabs.mdx b/content/docs/it-IT/guides/prefabs.mdx
index 08404b30..b1a55109 100644
--- a/content/docs/it-IT/guides/prefabs.mdx
+++ b/content/docs/it-IT/guides/prefabs.mdx
@@ -14,7 +14,7 @@ Prefabs are Hytale's way of creating reusable structures.
 There are a few fundamental concepts to understand about prefabs:
 
 - Users interact with prefabs via a prefab editing world.
-- Prefabs the physical structures in the game world, and are saved as JSON files.
+- Prefabs are the physical structures in the game world, and are saved as JSON files.
 
 ## How to Create a Prefab
 
diff --git a/content/docs/it-IT/official-documentation/custom-ui/common-styling.mdx b/content/docs/it-IT/official-documentation/custom-ui/common-styling.mdx
new file mode 100644
index 00000000..c36e3e3a
--- /dev/null
+++ b/content/docs/it-IT/official-documentation/custom-ui/common-styling.mdx
@@ -0,0 +1,50 @@
+---
+title: Common Styling
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# Common Styling
+
+## Common UI Styling Library
+
+This document describes the shared UI components and styles defined in `Common.ui`.
+
+---
+
+### Styles
+
+We are providing some styles that can be re-used in any custom UI that, provide a cohesive UI experience with the core game UI. These styles are available in the `Common.ui` file.
+
+You can find a list of all the styles defined with live examples by running the `/ui-gallery` command ingame.
+
+<Callout type="warning">
+  This command is not available yet, but will be in a future patch.
+</Callout>
+
+![Gallery](/assets/official-documentation/ui/gallery.png)
+
+### Importing
+
+To use these styles in your UI file:
+
+```
+$Common = "Common.ui";
+
+// Then reference styles and components:
+$Common.@TextButton { @Text = "My Button"; }
+$Common.@Container { ... }
+```
+
+<Callout type="info">
+  The `Common.ui` file is at `Common/UI/Custom/Common.ui` within the Hytale pack. If your custom ui document is in a subfolder of `Common/UI/Custom/`, reference it via relative path traversal:
+
+  ```
+  $Common = "../Common.ui";
+  ```
+
+  You can find more info about paths [here](markup#path).
+</Callout>
diff --git a/content/docs/it-IT/official-documentation/custom-ui/index.mdx b/content/docs/it-IT/official-documentation/custom-ui/index.mdx
new file mode 100644
index 00000000..f94c4e88
--- /dev/null
+++ b/content/docs/it-IT/official-documentation/custom-ui/index.mdx
@@ -0,0 +1,125 @@
+---
+title: Custom UI
+icon: LayoutDashboard
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# Custom UI
+
+## What is Custom UI?
+
+Custom UI is Hytale's framework for creating **custom user interfaces** controlled by the game server. Unlike the built-in Client UI (which is part of the game client and cannot be modified), Server UI allows you to create interactive screens and HUD overlays through Java plugins and asset packs.
+
+As a modder, Custom UI gives you the power to:
+
+- **Create custom interactive pages** - Shop interfaces, quest dialogs, server settings menus, admin panels
+- **Add custom HUD overlays** - Quest trackers, status displays, custom health bars, server information
+- **Design with markup** - Use `.ui` files to define reusable UI templates
+- **Handle user interactions** - Respond to button clicks, form submissions, and other events
+- **Localize your UI** - Support multiple languages using the game's translation system
+
+## How Custom UI Fits Into Hytale's UI
+
+Hytale's user interface is divided into two main categories:
+
+### Client UI (Not Moddable)
+
+Built-in interfaces controlled by the C# game client:
+
+- Main menu and settings
+- Character creation
+- Built-in HUD (health, hotbar, chat)
+- Inventory and crafting screens
+- Development tools
+
+**You cannot modify these** - they are part of the core game client.
+
+### In-Game UI (Moddable via Server)
+
+Server-controlled interfaces that you can create and customize:
+
+#### Custom Pages
+
+Full-screen interactive overlays that appear during gameplay:
+
+- Can be dismissed by the player (ESC key)
+- Capture all input (keyboard and mouse)
+- Support loading states while waiting for server responses
+- Perfect for: shops, dialogs, menus, configuration screens
+
+#### Custom HUDs
+
+Persistent overlay elements drawn on top of the game world:
+
+- Display-only (no user interaction)
+- Always visible during gameplay
+- Lightweight and non-intrusive
+- Perfect for: quest objectives, status indicators, server info panels
+
+## Architecture Overview
+
+Server UI uses a **command-based architecture**:
+
+```
+┌─────────────────────┐         ┌──────────────────────┐
+│   Java Server       │         │    C# Client         │
+│   (Your Plugin)     │         │    (Game)            │
+├─────────────────────┤         ├──────────────────────┤
+│                     │         │                      │
+│ InteractiveCustomUI │         │   CustomPage or      │
+│ Page                │         │   CustomHud          │
+│   ↓ build()         ├────────→│     ↓ Apply          │
+│ UICommandBuilder    │         │   Element Tree       │
+│   - append()        │         │     ↓ Layout         │
+│   - set()           │         │   Rendered UI        │
+│   - clear()         │         │                      │
+│                     │         │                      │
+│ ↓ handleDataEvent() │← Events │   User Interaction   │
+│   Process input     │         │   (click, type, etc) │
+│   sendUpdate()      │         │                      │
+└─────────────────────┘         └──────────────────────┘
+```
+
+**The flow:**
+
+1. Your Java code builds UI using `UICommandBuilder`
+2. Commands are sent to the client as data
+3. Client parses `.ui` markup files and creates visual elements
+4. User interacts with the UI
+5. Events are sent back to your Java code
+6. You process events and send updates back
+
+## Key Principles
+
+### Declarative, Not Imperative
+
+You don't create UI objects directly. Instead, you send **commands** that describe what you want:
+
+- "Append this button template to that container"
+- "Set this label's text to 'Hello World'"
+- "Clear all children from this list"
+
+### Asset-Driven
+
+UI structure is defined in `.ui` markup files (assets), not hardcoded in Java. This enables:
+
+- Designers to modify layouts without touching code
+- Reusable UI components
+- Consistent visual language
+
+### Event-Driven
+
+User interactions trigger events that flow back to your server code. You register event bindings and handle them in `handleDataEvent()`.
+
+### Selector-Based
+
+You target specific UI elements using **selectors:**
+
+- `#MyButton` - Element with ID "MyButton"
+- `#List[0]` - First child of element "List"
+- `#List[0] #Title` - Element with ID "Title" in the first child of element "List"
+- `#Label.TextColor` - The TextColor property of element "Label"
diff --git a/content/docs/it-IT/official-documentation/custom-ui/layout.mdx b/content/docs/it-IT/official-documentation/custom-ui/layout.mdx
new file mode 100644
index 00000000..0a24ca09
--- /dev/null
+++ b/content/docs/it-IT/official-documentation/custom-ui/layout.mdx
@@ -0,0 +1,492 @@
+---
+title: Layout
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# Layout
+
+The layout system determines how UI elements are positioned and sized on screen. Understanding layout is crucial for creating well-structured, responsive interfaces.
+
+## Layout Fundamentals
+
+Every UI element has:
+
+- **Container Rectangle** - The space allocated by the parent
+- **Anchor** - How the element positions/sizes itself within the container
+- **Padding** - Inner spacing that affects child layout
+- **LayoutMode** - How the element arranges its children (if it's a container)
+
+```
+┌─────────────────────────────────────┐
+│  Container Rectangle (from parent)  │
+│  ┌───────────────────────────────┐  │
+│  │  Anchored Rectangle           │  │
+│  │  ┌─────────────────────────┐  │  │
+│  │  │ Padding                 │  │  │
+│  │  │  ┌───────────────────┐  │  │  │
+│  │  │  │  Content Area     │  │  │  │
+│  │  │  └───────────────────┘  │  │  │
+│  │  └─────────────────────────┘  │  │
+│  └───────────────────────────────┘  │
+└─────────────────────────────────────┘
+```
+
+## Anchor
+
+`Anchor` controls how an element positions and sizes itself within its container rectangle.
+
+### Fixed Size
+
+```
+Button {
+    Anchor: (Width: 200, Height: 40);
+}
+```
+
+Creates a 200×40 pixel button.
+
+### Positioning
+
+```
+Label {
+    Anchor: (Top: 10, Left: 20, Width: 100, Height: 30);
+}
+```
+
+- **Top**: 10 pixels from container's top edge
+- **Left**: 20 pixels from container's left edge
+- **Width**: 100 pixels wide
+- **Height**: 30 pixels tall
+
+### Anchoring to Edges
+
+```
+Button {
+    Anchor: (Bottom: 10, Right: 10, Width: 100, Height: 30);
+}
+```
+
+Anchors the button to the bottom-right corner, 10 pixels from each edge.
+
+### Stretching
+
+```
+Group {
+    Anchor: (Top: 0, Bottom: 0, Left: 0, Right: 0);
+}
+```
+
+Stretches to fill the entire container (all edges at 0 pixels).
+
+**Shorthand:**
+
+```
+Group {
+    Anchor: (Full: 0);
+}
+```
+
+### Mixed Anchoring
+
+```
+Panel {
+    Anchor: (Top: 10, Bottom: 10, Left: 20, Width: 300);
+}
+```
+
+- Fixed width of 300 pixels
+- Stretches vertically between top and bottom edges
+- 10 pixels from top and bottom
+- 20 pixels from left
+
+## Padding
+
+`Padding` creates inner spacing, affecting where children are positioned.
+
+### Uniform Padding
+
+```
+Group {
+    Padding: (Full: 20);
+}
+```
+
+20 pixels of padding on all sides.
+
+### Directional Padding
+
+```
+Group {
+    Padding: (Top: 10, Bottom: 20, Left: 15, Right: 15);
+}
+```
+
+Different padding per edge.
+
+### Shorthand
+
+```
+// Horizontal and vertical
+Group {
+    Padding: (Horizontal: 20, Vertical: 10);
+}
+
+// Equivalent to:
+// Top: 10, Bottom: 10, Left: 20, Right: 20
+```
+
+### Effect on Children
+
+```
+Group {
+    Anchor: (Width: 200, Height: 100);
+    Padding: (Full: 10);
+
+    Label {
+        Anchor: (Full: 0);
+    }
+}
+```
+
+The label fills the group, but there's a 10-pixel gap on all sides due to padding.
+
+```
+┌──────────────────────┐
+│ Group (200×100)      │
+│  ┌────────────────┐  │
+│  │ Label          │  │ ← 10px padding all around
+│  │                │  │
+│  └────────────────┘  │
+└──────────────────────┘
+```
+
+## LayoutMode
+
+`LayoutMode` determines how a container arranges its children.
+
+### Top (Vertical Stack)
+
+```
+Group {
+    LayoutMode: Top;
+
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+}
+```
+
+Children stack vertically from top to bottom:
+
+```
+┌──────────┐
+│ Button 1 │
+├──────────┤
+│ Button 2 │
+├──────────┤
+│ Button 3 │
+└──────────┘
+
+
+```
+
+Each child's `Anchor.Bottom` adds spacing between elements:
+
+```
+Button { Anchor: (Height: 30, Bottom: 10); }  // 10px gap after this button
+```
+
+### Bottom (Vertical Stack)
+
+```
+Group {
+    LayoutMode: Bottom;
+
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+}
+```
+
+Children stack vertically from top to bottom but aligned to the bottom edge of the parent:
+
+```
+
+
+
+┌──────────┐
+│ Button 1 │
+├──────────┤
+│ Button 2 │
+├──────────┤
+│ Button 3 │
+└──────────┘
+```
+
+### Left (Horizontal Stack)
+
+```
+Group {
+    LayoutMode: Left;
+
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+}
+```
+
+Children arrange horizontally from left to right:
+
+```
+┌────────┬────────┬────────┐
+│ Button │ Button │ Button │
+│   1    │   2    │   3    │
+└────────┴────────┴────────┘
+```
+
+Use `Anchor.Right` for spacing between elements.
+
+### Right (Horizontal Stack)
+
+```
+Group {
+    LayoutMode: Right;
+
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+}
+```
+
+Children arrange horizontally from left to right but aligned to the right side of the parent:
+
+```
+                                                                 ┌────────┬────────┬────────┐
+                                                                 │ Button │ Button │ Button │
+                                                                 │   1    │   2    │   3    │
+                                                                 └────────┴────────┴────────┘
+```
+
+### Center
+
+```
+Group {
+    LayoutMode: Center;
+
+    Group #Dialog {
+        Anchor: (Width: 400, Height: 300);
+    }
+}
+```
+
+Centers the children horizontally.
+
+### Middle
+
+```
+Group {
+    LayoutMode: Middle;
+
+    Group #Dialog {
+        Anchor: (Width: 400, Height: 300);
+    }
+}
+```
+
+Centers the children vertically.
+
+### CenterMiddle (Horizontal Stack, Fully Centered)
+
+```
+Group {
+    LayoutMode: CenterMiddle;
+
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+}
+```
+
+Children stack horizontally from left to right, centered both horizontally and vertically within the parent:
+
+```
+┌────────────────────────────────────────────┐
+│                                            │
+│                                            │
+│         ┌──────┐ ┌──────┐ ┌──────┐         │
+│         │  B1  │ │  B2  │ │  B3  │         │
+│         └──────┘ └──────┘ └──────┘         │
+│                                            │
+│                                            │
+└────────────────────────────────────────────┘
+```
+
+---
+
+### MiddleCenter (Vertical Stack, Fully Centered)
+
+```
+Group {
+    LayoutMode: MiddleCenter;
+
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+}
+```
+
+Children stack vertically from top to bottom, centered both horizontally and vertically within the parent:
+
+```
+┌────────────────────────────────────────────┐
+│                                            │
+│              ┌──────────┐                  │
+│              │ Button 1 │                  │
+│              ├──────────┤                  │
+│              │ Button 2 │                  │
+│              ├──────────┤                  │
+│              │ Button 3 │                  │
+│              └──────────┘                  │
+│                                            │
+└────────────────────────────────────────────┘
+```
+
+---
+
+### Full
+
+```
+Group {
+    LayoutMode: Full;
+
+    Label {
+        Anchor: (Top: 20, Left: 20, Width: 100, Height: 30);
+    }
+}
+```
+
+Children use absolute positioning via their `Anchor` properties.
+
+### TopScrolling
+
+```
+Group {
+    LayoutMode: TopScrolling;
+    ScrollbarStyle: $Common.@DefaultScrollbar;
+
+    // ... many children
+}
+```
+
+Like `Top`, but adds a scrollbar if content exceeds container height.
+
+Or use `BottomScrolling` for bottom-aligned content.
+
+### LeftScrolling
+
+```
+Group {
+    LayoutMode: LeftScrolling;
+    ScrollbarStyle: $Common.@DefaultScrollbar;
+
+    // ... many children
+}
+```
+
+Like `Left`, but adds a scrollbar for horizontal scrolling.
+
+Or use `RightScrolling` for right-aligned content.
+
+### LeftCenterWrap (Wrapping Horizontal Stack, Horizontally Centered)
+
+```
+Group {
+    LayoutMode: LeftCenterWrap;
+
+    Button { Anchor: (Width: 80, Height: 30); }
+    Button { Anchor: (Width: 80, Height: 30); }
+    Button { Anchor: (Width: 80, Height: 30); }
+    Button { Anchor: (Width: 80, Height: 30); }
+    Button { Anchor: (Width: 80, Height: 30); }
+}
+```
+
+Children flow left to right. When there's no more horizontal space, they wrap to the next row. Each row is horizontally centered within the parent:
+
+```
+┌────────────────────────────────────────────┐
+│                                            │
+│       ┌──────┐ ┌──────┐ ┌──────┐           │
+│       │  B1  │ │  B2  │ │  B3  │           │
+│       └──────┘ └──────┘ └──────┘           │
+│            ┌──────┐ ┌──────┐               │
+│            │  B4  │ │  B5  │               │
+│            └──────┘ └──────┘               │
+│                                            │
+└────────────────────────────────────────────┘
+```
+
+## FlexWeight
+
+`FlexWeight` distributes remaining space among children.
+
+```
+Group {
+    LayoutMode: Left;
+    Anchor: (Width: 400);
+
+    Button {
+        Anchor: (Width: 100);
+    }
+
+    Group {
+        FlexWeight: 1;  // Takes all remaining space
+    }
+
+    Button {
+        Anchor: (Width: 100);
+    }
+}
+```
+
+Result:
+
+- First button: 100px
+- Middle group: 200px (400 - 100 - 100 = 200)
+- Last button: 100px
+
+### Multiple FlexWeights
+
+```
+Group {
+    LayoutMode: Left;
+    Anchor: (Width: 600);
+
+    Group { FlexWeight: 1; }
+    Group { FlexWeight: 2; }
+    Group { FlexWeight: 1; }
+}
+```
+
+Remaining space (600px) is split:
+
+- First group: 600 × (1/4) = 150px
+- Second group: 600 × (2/4) = 300px
+- Third group: 600 × (1/4) = 150px
+
+## Visibility
+
+```
+Button #HiddenButton {
+    Visible: false;
+}
+```
+
+**Effect:**
+
+- Element and its children are not displayed
+- Element is **not included in layout** (doesn't take up space)
diff --git a/content/docs/it-IT/official-documentation/custom-ui/markup.mdx b/content/docs/it-IT/official-documentation/custom-ui/markup.mdx
new file mode 100644
index 00000000..564110ed
--- /dev/null
+++ b/content/docs/it-IT/official-documentation/custom-ui/markup.mdx
@@ -0,0 +1,226 @@
+---
+title: Markup
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# Markup
+
+## Markup
+
+An element is the basic building block of a user interface. There are various types of elements with different properties, which are documented below.
+
+Here's what the syntax looks like:
+
+```
+// Basic declaration of an element
+// with its Anchor property set to attach on all sides of its parent
+// with 10 pixels of margin
+Group { Anchor: (Left: 10, Top: 10, Right: 10, Bottom: 10); }
+
+Group { Anchor: (Full: 10); } // More concise version
+
+// Declaration of a Label with a name
+// (can be used to access the element from game code)
+Label #MyLabel {
+  Style: LabelStyle(FontSize: 16); // or just Style: (FontSize: 16), type can be inferred.
+  Text: "Hi! I am text.";
+}
+
+// Declaration of a Group containing 2 children
+// You can use FlexWeight to distribute any left-over space after explicit widths/heights have been subtracted
+Group {
+  LayoutMode: Left;
+  Label { Text: "Child 1"; FlexWeight: 2; }
+  Label { Text: "Child 2"; FlexWeight: 1; }
+}
+```
+
+### Documents
+
+A UI document (_.ui_ file) contains trees of elements. There can be multiple root elements.
+
+### Named Expressions
+
+Named expressions can be declared at any level of a document (including at the root) and will be scoped to that subtree, though they need to be declared at the top of the block.
+
+```
+// Example of named expressions, declared and used with @ prefix
+@Title = "Hytale";
+@ExtraSpacing = 5;
+
+Label {
+  Text: @Title;
+  Style: (LetterSpacing: 2 + @ExtraSpacing);
+}
+```
+
+You can use the spread operator `...` to reuse a named expression while overriding some of its fields:
+
+```
+@MyBaseStyle = LabelStyle(FontSize: 24, LetterSpacing: 2);
+
+Label {
+  Style: (...@MyBaseStyle, FontSize: 36);
+}
+```
+
+You can even layer multiple named expressions like so:
+
+```
+@TitleStyle = LabelStyle(FontSize: 24, HorizontalAlignment: Center);
+@SpacedTextStyle = LabelStyle(LetterSpacing: 2);
+
+Label {
+  Style: (...@BigTextStyle, ...@SpacedTextStyle);
+}
+```
+
+#### Document references
+
+A document can reference another document and access its named expressions.
+
+```
+// Document references are defined with $ prefix
+$Common = "../Common.ui";
+
+TextButton {
+  Style: $Common.@DefaultButtonStyle;
+}
+```
+
+### Templates
+
+You can declare a reusable bit of interface as a named expression and then instantiate it as many times as you want in the tree while customizing it.
+
+You can override local named expressions as well as insert additional children at any point in the template tree. However, local named expressions must be defined at the very top of the block, before properties and child elements.
+
+```
+// This is the template
+@Row = Group {
+  Anchor: (Height: 50);
+  Label #Label { Anchor: (Left: 0, Width: 100); Text: @LabelText; }
+  Group #Content { Anchor: (Left: 100); }
+};
+
+// Here we'll be using it twice in the document tree
+Group #Rows {
+  LayoutMode: TopScrolling;
+
+  @Row #MyFirstRow {
+    @LabelText = "First row";
+    #Content { TextInput {} }
+  }
+
+  @Row #MySecondRow {
+    @LabelText = "Second row";
+  }
+}
+```
+
+### Property Types
+
+#### Basic Types
+
+- **Boolean**
+  - `Visible: false;`
+  - `Visible: true;`
+- **Int**
+  - `Height: 20;`
+- **Float, Double, Decimal**
+  - `Min: 0.2;`
+- **String**
+  - `Text: "Hi!";`
+- **Char**
+  - `PasswordChar: "*";`
+  - _Note: The syntax is the same as a string, however a value of this type cannot contain more than one character!_
+- **Color**
+  - `Background: #ffffff;`&#x20;
+- **Objects**
+  - `Style: (Background: #ffffff)`
+- **Array**&#x20;
+  - `TextSpans: [(Text: "Hi", IsBold: true)]`
+
+#### Translations
+
+Translation keys can be referenced anywhere in markup where you can provide a string, and they are then converted to a string when an element gets instantiated.
+
+**Example:**
+
+```
+Label {
+  Text: %ui.general.cancel;
+}
+```
+
+#### Colors
+
+A color literal can be written as follows:
+
+- `#rrggbb`: 6-digit hexadecimal representation for red, green, blue (fully opaque)
+- `#rrggbb(a.a)`: 6-digit hexadecimal representation for red, green, blue with alpha between 0 and 1
+- `#rrggbbaa`: 8-digit hexadecimal representation for red, green, blue and alpha
+
+```
+Group {
+  Background: #000000(0.3);
+}
+```
+
+<Callout>
+  The `#rrggbb(a.a)` format is prefered over the `#rrggbbaa` format for
+  readability reasons.
+</Callout>
+
+#### Font Name
+
+Font names can be referenced directly by their string ID. Internally this is using a custom type called `UIFontName`, however strings will be converted automatically to this type in markup.
+
+```
+Label {
+  Text: "Hi";
+  Style: (FontName: "Secondary");
+}
+```
+
+**Available Font Names**
+
+- _Default_ - This is the default font that is used for most text and is always used unless a different option has been specified
+- _Secondary_ - This font is mostly used for headlines or elements that are supposed to stick out
+- _Mono_ - This is only used for development; For things such as profiling or error overlays.
+
+#### Path
+
+We can reference other UI assets with the `UIPath` type. Similar to `UIFontName`_,_ Strings are automatically converted to a `UIPath`. Paths are always relative to the file where they have been declared in. Looking up _MyButton.png_ in _Menu/MyAwesomeMenu.ui_ will result in _Menu/MyButton.png_. If you want to reference a file that is in a parent folder you can go back one directory by writing two dots (_../MyButton.png_).
+
+The markup syntax of a `UIPath` is the same as a String. (e.g. `Path: "Test.png"`)
+
+Here are some more examples:
+
+| UIPath             | .ui File                              | Resulting Path    |
+| ------------------ | ------------------------------------- | ----------------- |
+| MyButton.png       | Menu/MyAwesomeMenu.ui                 | Menu/MyButton.png |
+| ../MyButton.png    | Menu/MyAwesomeMenu.ui                 | MyButton.png      |
+| ../../MyButton.png | Menu/Popup/Templates/MyAwesomeMenu.ui | Menu/MyButton.png |
+
+#### Objects
+
+Objects contain a set of properties. In this example we are assigning an Anchor object to the _Anchor_ property:
+
+```
+Group {
+  Anchor: (
+   Height: 10,
+   Width: 20
+ );
+}
+```
+
+You can find all objects that can be used in markup [here](type-documentation#elements).
+
+## Visual Studio Code Extension
+
+There is an official extension for Visual Studio Code which adds syntax highlighting for .ui files. You can find it [here](https://marketplace.visualstudio.com/items?itemName=HypixelStudiosCanadaInc.vscode-hytaleui).
diff --git a/content/docs/it-IT/official-documentation/custom-ui/type-documentation/index.mdx b/content/docs/it-IT/official-documentation/custom-ui/type-documentation/index.mdx
new file mode 100644
index 00000000..69cea406
--- /dev/null
+++ b/content/docs/it-IT/official-documentation/custom-ui/type-documentation/index.mdx
@@ -0,0 +1,127 @@
+---
+title: Type Documentation
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# Type Documentation
+
+This is a generated list of UI elements accessible by markup. More information about the User Interface framework can be found in the main documentation.
+
+## Elements
+
+- [ActionButton](type-documentation/elements/actionbutton)
+- [AssetImage](type-documentation/elements/assetimage)
+- [BackButton](type-documentation/elements/backbutton)
+- [BlockSelector](type-documentation/elements/blockselector)
+- [Button](type-documentation/elements/button)
+- [CharacterPreviewComponent](type-documentation/elements/characterpreviewcomponent)
+- [CheckBox](type-documentation/elements/checkbox)
+- [CheckBoxContainer](type-documentation/elements/checkboxcontainer)
+- [CircularProgressBar](type-documentation/elements/circularprogressbar)
+- [CodeEditor](type-documentation/elements/codeeditor)
+- [ColorOptionGrid](type-documentation/elements/coloroptiongrid)
+- [ColorPicker](type-documentation/lements/colorpicker)
+- [ColorPickerDropdownBox](type-documentation/elements/colorpickerdropdownbox)
+- [CompactTextField](type-documentation/elements/compacttextfield)
+- [DropdownBox](type-documentation/elements/dropdownbox)
+- [DropdownEntry](type-documentation/elements/dropdownentry)
+- [DynamicPane](type-documentation/elements/dynamicpane)
+- [DynamicPaneContainer](type-documentation/elements/dynamicpanecontainer)
+- [FloatSlider](type-documentation/elements/floatslider)
+- [FloatSliderNumberField](type-documentation/elements/floatslidernumberfield)
+- [Group](type-documentation/elements/group)
+- [HotkeyLabel](type-documentation/elements/hotkeylabel)
+- [ItemGrid](type-documentation/elements/itemgrid)
+- [ItemIcon](type-documentation/elements/itemicon)
+- [ItemPreviewComponent](type-documentation/elements/itempreviewcomponent)
+- [ItemSlot](type-documentation/elements/itemslot)
+- [ItemSlotButton](type-documentation/elements/itemslotbutton)
+- [Label](type-documentation/elements/label)
+- [LabeledCheckBox](type-documentation/elements/labeledcheckbox)
+- [MenuItem](type-documentation/elements/menuitem)
+- [MultilineTextField](type-documentation/elements/multilinetextfield)
+- [NumberField](type-documentation/elements/numberfield)
+- [Panel](type-documentation/elements/panel)
+- [ProgressBar](type-documentation/elements/progressbar)
+- [ReorderableList](type-documentation/elements/reorderablelist)
+- [ReorderableListGrip](type-documentation/elements/reorderablelistgrip)
+- [SceneBlur](type-documentation/elements/sceneblur)
+- [Slider](type-documentation/elements/slider)
+- [SliderNumberField](type-documentation/elements/slidernumberfield)
+- [Sprite](type-documentation/elements/sprite)
+- [TabButton](type-documentation/elements/tabbutton)
+- [TabNavigation](type-documentation/elements/tabnavigation)
+- [TextButton](type-documentation/elements/textbutton)
+- [TextField](type-documentation/elements/textfield)
+- [TimerLabel](type-documentation/elements/timerlabel)
+- [ToggleButton](type-documentation/elements/togglebutton)
+
+## Property Types
+
+- [Anchor](type-documentation/property-types/anchor)
+- [BlockSelectorStyle](type-documentation/property-types/blockselectorstyle)
+- [ButtonSounds](type-documentation/property-types/buttonsounds)
+- [ButtonStyle](type-documentation/property-types/buttonstyle)
+- [ButtonStyleState](type-documentation/property-types/buttonstylestate)
+- [CheckBoxStyle](type-documentation/property-types/checkboxstyle)
+- [CheckBoxStyleState](type-documentation/property-types/checkboxstylestate)
+- [ClientItemStack](type-documentation/property-types/clientitemstack)
+- [ColorOptionGridStyle](type-documentation/property-types/coloroptiongridstyle)
+- [ColorPickerDropdownBoxStateBackground](type-documentation/property-types/colorpickerdropdownboxstatebackground)
+- [ColorPickerDropdownBoxStyle](type-documentation/property-types/colorpickerdropdownboxstyle)
+- [ColorPickerStyle](type-documentation/property-types/colorpickerstyle)
+- [DropdownBoxSearchInputStyle](type-documentation/property-types/dropdownboxsearchinputstyle)
+- [DropdownBoxSounds](type-documentation/property-types/dropdownboxsounds)
+- [DropdownBoxStyle](type-documentation/property-types/dropdownboxstyle)
+- [InputFieldButtonStyle](type-documentation/property-types/inputfieldbuttonstyle)
+- [InputFieldDecorationStyle](type-documentation/property-types/inputfielddecorationstyle)
+- [InputFieldDecorationStyleState](type-documentation/property-types/inputfielddecorationstylestate)
+- [InputFieldIcon](type-documentation/property-types/inputfieldicon)
+- [InputFieldStyle](type-documentation/property-types/inputfieldstyle)
+- [ItemGridSlot](type-documentation/property-types/itemgridslot)
+- [ItemGridStyle](type-documentation/property-types/itemgridstyle)
+- [LabeledCheckBoxStyle](type-documentation/property-types/labeledcheckboxstyle)
+- [LabeledCheckBoxStyleState](type-documentation/property-types/labeledcheckboxstylestate)
+- [LabelSpan](type-documentation/property-types/labelspan)
+- [LabelStyle](type-documentation/property-types/labelstyle)
+- [NumberFieldFormat](type-documentation/property-types/numberfieldformat)
+- [Padding](type-documentation/property-types/padding)
+- [PatchStyle](type-documentation/property-types/patchstyle)
+- [PopupStyle](type-documentation/property-types/popupstyle)
+- [ScrollbarStyle](type-documentation/property-types/scrollbarstyle)
+- [SliderStyle](type-documentation/property-types/sliderstyle)
+- [SoundStyle](type-documentation/property-types/soundstyle)
+- [SpriteFrame](type-documentation/property-types/spriteframe)
+- [SubMenuItemStyle](type-documentation/property-types/submenuitemstyle)
+- [SubMenuItemStyleState](type-documentation/property-types/submenuitemstylestate)
+- [Tab](type-documentation/property-types/tab)
+- [TabNavigationStyle](type-documentation/property-types/tabnavigationstyle)
+- [TabStyle](type-documentation/property-types/tabstyle)
+- [TabStyleState](type-documentation/property-types/tabstylestate)
+- [TextButtonStyle](type-documentation/property-types/textbuttonstyle)
+- [TextButtonStyleState](type-documentation/property-types/textbuttonstylestate)
+- [TextTooltipStyle](type-documentation/property-types/texttooltipstyle)
+- [ToggleButtonStyle](type-documentation/property-types/togglebuttonstyle)
+- [ToggleButtonStyleState](type-documentation/property-types/togglebuttonstylestate)
+
+## Enums
+
+- [ActionButtonAlignment](type-documentation/enums/actionbuttonalignment)
+- [CodeEditorLanguage](type-documentation/enums/codeeditorlanguage)
+- [ColorFormat](type-documentation/enums/colorformat)
+- [DropdownBoxAlign](type-documentation/enums/dropdownboxalign)
+- [InputFieldButtonSide](type-documentation/enums/inputfieldbuttonside)
+- [InputFieldIconSide](type-documentation/enums/inputfieldiconside)
+- [ItemGridInfoDisplayMode](type-documentation/enums/itemgridinfodisplaymode)
+- [LabelAlignment](type-documentation/enums/labelalignment)
+- [LayoutMode](type-documentation/enums/layoutmode)
+- [MouseWheelScrollBehaviourType](type-documentation/enums/mousewheelscrollbehaviourtype)
+- [ProgressBarAlignment](type-documentation/enums/progressbaralignment)
+- [ProgressBarDirection](type-documentation/enums/progressbardirection)
+- [ResizeType](type-documentation/enums/resizetype)
+- [TimerDirection](type-documentation/enums/timerdirection)
+- [TooltipAlignment](type-documentation/enums/tooltipalignment)
diff --git a/content/docs/it-IT/official-documentation/npc/2-getting-started-with-templates.mdx b/content/docs/it-IT/official-documentation/npc/2-getting-started-with-templates.mdx
index 91081ca1..99d078e0 100644
--- a/content/docs/it-IT/official-documentation/npc/2-getting-started-with-templates.mdx
+++ b/content/docs/it-IT/official-documentation/npc/2-getting-started-with-templates.mdx
@@ -9,7 +9,7 @@ authors:
 
 There are no hard and fast rules for making a start on a template. I like to duplicate **BlankTemplate** and start from there because it already provides the basic structure of the file.
 
-This leaves me with the following template (`Template_Goblin_Ogre.json`): (note: the file could be looking different in the current version of the game)
+This leaves me with the following template (`Template_Goblin_Ogre.json`): (**note: the file could be looking different in the current version of the game**)
 
 ```json
 {
@@ -33,7 +33,7 @@ This leaves me with the following template (`Template_Goblin_Ogre.json`): (note:
     }
   },
   "Appearance": { "Compute": "Appearance" },
-  "DropList": { "Compute": "Droplist" },
+  "DropList": { "Compute": "DropList" },
   "MaxHealth": { "Compute": "MaxHealth" },
   "MotionControllerList": [
     {
@@ -65,10 +65,10 @@ And the following variant (`Goblin_Ogre.json`) next to the template. There's a t
   "Type": "Variant",
   "Reference": "Template_Goblin_Ogre",
   "Modify": {
-    "Appearance": "Goblin_Ogre",
+    "Appearance": "Goblin",
     "MaxHealth": 124
   }
 }
 ```
 
-Our artists have defined the `Goblin_Ogre` appearance already so I'm going to use that.
+Our artists have not yet finished animations for the `Goblin_Ogre`, for that sake of the tutorial I am going to use appearance `Goblin`, because it offers a more complete set of animations that we will need.
diff --git a/content/docs/it-IT/official-documentation/worldgen/pack-tutorial/asset-packs.mdx b/content/docs/it-IT/official-documentation/worldgen/pack-tutorial/asset-packs.mdx
index 38809fad..dcf1f3b9 100644
--- a/content/docs/it-IT/official-documentation/worldgen/pack-tutorial/asset-packs.mdx
+++ b/content/docs/it-IT/official-documentation/worldgen/pack-tutorial/asset-packs.mdx
@@ -9,13 +9,13 @@ authors:
 
 <OfficialDocumentationNotice />
 
-# How to modify Hytale
+# How to modify Hytale?
 
-## What's an Asset Pack
+## What's an Asset Pack?
 
-Hytales gameplay is driven by assets in the game that can be modified by creators. Asset Packs are our solution to let you override or add features to the base game with your own work. These can in the form of zip files of folders, which contain a custom set of assets. This is not the only way for a creator to change Hytale but this is the most accessible form.;
+Hytales gameplay is driven by assets in the game that can be modified by creators. Asset Packs are our solution to let you override or add features to the base game with your own work. These can be the form of zip files of folders, which contain a custom set of assets. This is not the only way for a creator to change Hytale but this is the most accessible form.;
 
-### How do I make an Asset Pack
+### How do I make an Asset Pack?
 
 <video controls className="my-6 aspect-video w-full rounded-lg border">
   <source src="https://cdn.internal.hytalemodding.dev/guides/official/how-to-asset-pack.mp4" type="video/mp4" />
@@ -48,7 +48,7 @@ An asset pack is typically a zip or folder, with a `manifest.json` inside. This
 }
 ```
 
-### Where are they stored
+### Where are they stored?
 
 Asset Packs are stored with other mods in the Mods folder.
 
@@ -76,7 +76,7 @@ C:\Users\<user>\AppData\Roaming\Hytale\UserData\Saves\New World 5\mods
 
 When you have Asset Packs or Mods installed, these will appear in the New World menu under the Options menu.;
 
-### How do I change an existing asset
+### How do I change an existing asset?
 
 <video controls className="my-6 aspect-video w-full rounded-lg border">
   <source src="https://cdn.internal.hytalemodding.dev/guides/official/how-to-asset.mp4" type="video/mp4" />
diff --git a/content/docs/it-IT/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx b/content/docs/it-IT/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx
index 44528376..24e628b5 100644
--- a/content/docs/it-IT/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx
+++ b/content/docs/it-IT/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx
@@ -106,7 +106,7 @@ If a BaseHeight is provided, the TopY and BottomY values are relative to the Bas
 
 Applies a Material Provider slot on a set of horizontal stripes of blocks of varying thickness and position. Below is an example image of basalt stripes into a stone cliff.
 
-{/* ![](https://540086904-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F7KAmBkOg6d13nZCkf9ku%2Fuploads%2FbcxO9LpArn8gPCaBwFg5%2Funknown.png?alt=media&token=1c72b67a-8253-4d03-8c64-1ad5f6830050) */}
+![Example of basalt stripes](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/basalt-stripes-example.png)
 
 #### Parameters:
 
diff --git a/content/docs/it-IT/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx b/content/docs/it-IT/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx
index 5e34acd4..a4418473 100644
--- a/content/docs/it-IT/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx
+++ b/content/docs/it-IT/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx
@@ -294,7 +294,7 @@ Combines all the positions into a single Positioins field.
 
 ---
 
-### SimpleHoritontal
+### SimpleHorizontal
 
 Keeps only the positions that are within the provided range.
 
diff --git a/content/docs/it-IT/official-documentation/worldgen/worldgen-tutorial/README.mdx b/content/docs/it-IT/official-documentation/worldgen/worldgen-tutorial/README.mdx
new file mode 100644
index 00000000..5f66d245
--- /dev/null
+++ b/content/docs/it-IT/official-documentation/worldgen/worldgen-tutorial/README.mdx
@@ -0,0 +1,166 @@
+---
+title: How to edit and create Biomes
+description: Explores where world generation assets can be found and how to edit them.
+---
+
+### Where are the Assets
+
+World generation assets are kept in the HytaleGenerator directory within the assets.
+
+```
+/Server/HytaleGenerator/
+```
+
+<div className="flex flex-row rounded-lg border p-4">
+  <div className="flex-1/2 border-r pr-4">
+    ```
+    /Biomes
+    ```
+
+    Biome assets, with content configurations.
+  </div>
+
+  <div className="flex-1/2 pl-4">
+    ```
+    /WorldStructure
+    ```
+
+    Generator files that define which biomes spawn together.
+  </div>
+</div>
+
+<div className="flex flex-row rounded-lg border p-4">
+  <div className="flex-1/2 border-r pr-4">
+    ```
+    /Density
+    ```
+
+    Density assets that can be referenced by any other assets.
+  </div>
+
+  <div className="flex-1/2 pl-4">
+    ```
+    /Assignments
+    ```
+
+    Prop assets that can be referenced by any Biome assets.
+  </div>
+</div>
+
+***
+
+An example of this structure can be found bellow, packed in an asset pack with the instance configuration.
+
+[https://drive.google.com/file/d/1sIz_CluANIIe3n8vNiOi-4PQdeqCO0qY/view?usp=drive_link](https://drive.google.com/file/d/1sIz_CluANIIe3n8vNiOi-4PQdeqCO0qY/view?usp=drive_link)
+
+<Callout>
+  Ensure you place your asset pack in the correct directory, under Mods.
+</Callout>
+
+### How to visit our worlds
+
+https://drive.google.com/file/d/1BJurxyj-taE-PXWm04bk7Dl6X7ZHTH92/view?usp=sharing
+
+#### Requirements
+
+- You must be an **Operator** in the world.
+  - To do this, run <mark style="color:$danger;">`/op self`</mark>
+- You must be in **Creative mode**.
+  - Press the <mark style="color:$danger;">`O`</mark> key, O for Orange.&#x20;
+
+The generation assets define a set of generators but on their own you cannot visit these. Currently you require an Instance with a generator that will allow you to visit your work.
+
+```
+/Server/Instances/
+```
+
+Instances are separate worlds that players can join using the `/instances` command. Each instance has an `Instance.bson` configuration asset that specifies which generator to use, among other worldly settings.
+
+```json
+{
+  "WorldGen": {
+    "Type": "HytaleGenerator",
+    "WorldStructure": "Basic",
+    "playerSpawn" : {
+      "X" : 123,
+      "Y" : 480,
+      "Z" : 10000,
+      "Pitch" : 0,
+      "Yaw" : 0,
+      "Roll" : 0
+    }
+  }
+}
+```
+
+<Callout>
+  You can create custom instances for different world structures and biomes as you need them.
+</Callout>
+
+### How to edit Biomes
+
+<video>
+  <source src="https://cdn.internal.hytalemodding.dev/guides/official/How-to-edit-Biomes.mp4" type="video/mp4" />
+</video>
+
+We currently use the Hytale Node Editor when editing world generation assets. This can be accessed while in-game from the Content Creation menu when pressing B. The node editor is then found under the asset editor dropdown on the upper left.&#x20;
+
+![Node Editor 1](/assets/official-documentation/worldgen/worldgen-tutorial/biomes/node-editor-1.png)
+
+Once you have the Hytale Node Editor open, through the file menu you can open Biomes by navigating to the Biomes directory and selecting one from your pack.&#x20;
+
+```
+/Server/HytaleGenerator/Biomes/
+```
+
+### Biome Asset Structure
+
+Every Biome has a root Biome node, this node splits into 5 structures. This is covered briefly but more information on each field can be found on the World Generation Concepts page.
+
+![Node Editor 2](/assets/official-documentation/worldgen/worldgen-tutorial/biomes/node-editor-2.png)
+
+<Callout>
+  Each biome is for the most part self contained, meaning it has control over what appears with the biome. The only exception to this are Base Heights.
+</Callout>
+
+<Tabs>
+  <Tab value="Terrain">
+    Mathematical function nodes that calculate the physical shape of the Biome's terrain.
+  </Tab>
+
+  <Tab value="Materials">
+    Logical nodes that determine what materials (blocks) make up a Biome's terrain.
+  </Tab>
+
+  <Tab value="Props">
+    Function nodes that add objects like prefabs and decorations to the terrain.
+  </Tab>
+
+  <Tab value="Environments">
+    Logical nodes that determine the environment asset at a given coordinate within the biome. This asset determines things like weather, NPC spawns, and sounds.
+  </Tab>
+
+  <Tab value="Tints">
+    Logical function nodes that determine a colour code that can be used by certain blocks in the world. Typically this will be grasses and soils.
+  </Tab>
+</Tabs>
+
+### How to preview your work
+
+[https://drive.google.com/file/d/1mNcHn9LhFnWDF0DzWFH6_YllmKAUvUry/view?t=6](https://drive.google.com/file/d/1mNcHn9LhFnWDF0DzWFH6_YllmKAUvUry/view?t=6)
+
+Once you are in an Instance world with the Hytale Generator active you will only be able to see your work by generating new chunks. There are a few ways to do this.
+
+The viewport command selects an area around the Player that will live reload as you make changes to the generator.&#x20;
+
+```
+/viewport --radius 5 
+```
+
+You can also create a new world to show your changes.&#x20;
+
+```
+/instances spawn <instance> 
+```
+
+The last option is to simply fly south, new chunks will generate with the changes made.
diff --git a/content/docs/it-IT/quick-start.mdx b/content/docs/it-IT/quick-start.mdx
index 940c8e3d..4d6f5e29 100644
--- a/content/docs/it-IT/quick-start.mdx
+++ b/content/docs/it-IT/quick-start.mdx
@@ -9,3 +9,8 @@ Welcome to the Hytale modding documentation! Here you'll find everything you nee
 * [Setting up your dev environment](./guides/plugin/setting-up-env)
 * [Entity Component System (ECS)](./guides/ecs/entity-component-system)
 * [Publishing your mod](./publishing)
+
+### Useful Links
+
+* [Kaupenjoe's Modding Videos](https://www.youtube.com/@ModdingByKaupenjoe)
+* [TroubleDEV's Modding Videos](https://www.youtube.com/@TroubleDEV)
diff --git a/content/docs/it-IT/server/argtypes.mdx b/content/docs/it-IT/server/argtypes.mdx
new file mode 100644
index 00000000..e54a442e
--- /dev/null
+++ b/content/docs/it-IT/server/argtypes.mdx
@@ -0,0 +1,61 @@
+---
+title: ArgTypes
+description: Available ArgTypes
+icon: List
+full: true
+authors:
+  - name: Valeena
+---
+
+| Name                        | Target Class                           | Description                                                                                                                               |   |
+| :-------------------------- | :------------------------------------- | :---------------------------------------------------------------------------------------------------------------------------------------- | - |
+| Boolean                     | java.lang.Boolean                      | A 'true' or 'false' input                                                                                                                 |   |
+| Integer                     | java.lang.Integer                      | A whole number                                                                                                                            |   |
+| String                      | java.lang.String                       | Words, text, numbers, letters. To input more than one word at a time, you may need to wrap it with double quotes (`"my fancy sentence"`). |   |
+| Float                       | java.lang.Float                        | A floating-pointer number                                                                                                                 |   |
+| Double                      | java.lang.Double                       | A decimal number                                                                                                                          |   |
+| UUID                        | java.util.UUID                         | A UUID (Universally Unique IDentifier)                                                                                                    |   |
+| Player_UUID                 | java.util.UUID                         | A UUID or an online player username                                                                                                       |   |
+| Game_Profile_Lookup_Async   | ProfileServiceClient.PublicGameProfile | A player UUID or username. If not found locally, performs a remote lookup via the Profile Service.                                        |   |
+| Relative_Double_Coord       | Coord                                  | An x, y, or z coordinate as a decimal, optionally relative by specifying a tilde (~) in front of the number                               |   |
+| Relative_Int_Coord          | IntCoord                               | An x, y, or z coordinate as a whole number, optionally relative by specifying a tilde (~) in front of the number                          |   |
+| Relative_Integer            | RelativeInteger                        | A tilde to mark an integer relative to a base                                                                                             |   |
+| Relative_Float              | RelativeFloat                          | A tilde to mark a float relative to a base                                                                                                |   |
+| Player_Ref                  | PlayerRef                              | A UUID or an online player's username                                                                                                     |   |
+| World                       | World                                  | A world folder name                                                                                                                       |   |
+| Model_Asset                 | ModelAsset                             | A reference to an Asset of type Model                                                                                                     |   |
+| Weather_Asset               | Weather                                | A reference to an Asset of type Weather                                                                                                   |   |
+| Interaction_Asset           | Interaction                            | A reference to an Asset of type Interaction                                                                                               |   |
+| Root_Interaction_Asset      | RootInteraction                        | A reference to an Asset of type Root Interaction                                                                                          |   |
+| Effect_Asset                | EntityEffect                           | A refernece to an Asset of type EntityEffect                                                                                              |   |
+| Environment_Asset           | Environment                            | A reference to an Asset of type Environment                                                                                               |   |
+| Item_Asset                  | Item                                   | A reference to an Asset of type Item                                                                                                      |   |
+| Block_Type_Asset            | BlockType                              | A reference to an Asset of type BlockType                                                                                                 |   |
+| Particle_System             | ParticleSystem                         | A reference to an Asset of type ParticleSystem                                                                                            |   |
+| Hitbox_Collision_Config     | HitboxCollisionConfig                  | A reference to an Asset of type HitboxCollisionConfig                                                                                     |   |
+| Repulsion_Config            | RepulsionConfig                        | A reference to an Asset of type RepulsionConfig                                                                                           |   |
+| Sound_Event_Asset           | SoundEvent                             | A reference to an Asset of type SoundEvent                                                                                                |   |
+| Ambiance_Fx_Asset           | AmbianceFX                             | A reference to an Asset of type AmbianceFX                                                                                                |   |
+| Sound_Category              | SoundCategory                          | A sound category (sfx, music, ambient, ui)                                                                                                |   |
+| Entity_ID                   | `ArgWrapper<EntityWrappedArg, UUID>`   | A UUID representing an entity id                                                                                                          |   |
+| Integer_Comparison_Operator | IntegerComparisonOperator              | A mathematical sign for integer comparison                                                                                                |   |
+| Integer_Operation           | IntegerOperation                       | A mathematical sign for performing an operation                                                                                           |   |
+| Int_Range                   | `Pair<Integer, Integer>`               | Two integers representing a minimum and maximum of a range                                                                                |   |
+| Relative_Int_Range          | RelativeIntRange                       | Two integers representing a minimum and maximum of a range                                                                                |   |
+| Vector2I                    | Vector2i                               | Two integers, generally corresponding to x/z axis                                                                                         |   |
+| Vector3I                    | Vector3i                               | Three integers, generally corresponding to x/y/z axis                                                                                     |   |
+| Relative_Vector3I           | RelativeVector3i                       | Three optionally relative integers, generally corresponding to x/y/z axis                                                                 |   |
+| Relative_Block_Position     | RelativeIntPosition                    | A position with three integer coordinates, representing a block's location in world space.                                                |   |
+| Relative_Position           | Relative                               | A position with three decimal coordinates, representing a location in world space.                                                        |   |
+| Relative_Chunk_Position     | RealtiveChunkPosition                  | A position with two integer coordinates (x, z), representing a chunk's location.                                                          |   |
+| Rotation                    | Vector3f                               | A rotation with three coordinates, representing the pitch, yaw, and roll respectively                                                     |   |
+| Block_Type_Key              | String                                 | A block type                                                                                                                              |   |
+| Block_ID                    | Integer                                | A block type, converted to an int id                                                                                                      |   |
+| Color                       | Integer                                | A color value in hex format, hex integer, or decimal integer                                                                              |   |
+| Weighted_Block_Type         | `Pair<Integer, String>`                | A weight corresponding to a blocktype                                                                                                     |   |
+| Weighted_Block_Entry        | String                                 | A block with optional weight prefix                                                                                                       |   |
+| Block_Pattern               | BlockPattern                           | A list of blocks with optional weights                                                                                                    |   |
+| Individual_Block_Mask       | BlockMask                              | Create a block mask using symbols and block names                                                                                         |   |
+| Block_Mask                  | BlockMask                              | A tick rate value (e.g., 30tps, 33ms, or 30)                                                                                              |   |
+| Tick_Rate                   | Integer                                | A list of block masks that combine together                                                                                               |   |
+| Game_Mode                   | GameMode                               | GameMode                                                                                                                                  |   |
diff --git a/content/docs/it-IT/server/interaction-reference.mdx b/content/docs/it-IT/server/interaction-reference.mdx
new file mode 100644
index 00000000..6c0d01b3
--- /dev/null
+++ b/content/docs/it-IT/server/interaction-reference.mdx
@@ -0,0 +1,1586 @@
+---
+title: Interactions
+description: A list of most Interaction types provided by Hypixel, along with the meaning of their fields, and how they fit together.
+icon: List
+authors:
+  - name: Stephen Baynham
+    url: https://github.com/cannibalvox
+---
+
+### The Interaction Base Type
+
+All interactions of every type below are inherited from Interaction and have these fields.
+
+**Interaction Fields**
+
+| Field Name                | Type                                                                 | Required? | Notes                                                                                                                                                                                                                       |
+| ------------------------- | -------------------------------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| ViewDistance              | `Double`<br />(Default: 96.0)                                        | **No**    | Distance in blocks at which other players can see the effects from this interaction.                                                                                                                                        |
+| Effects                   | `InteractionEffects`                                                 | **No**    | Sound, animations, and particle effects that should trigger when this interaction begins executing.                                                                                                                         |
+| HorizontalSpeedMultiplier | `Float`<br />(Default: 1.0)                                          | **No**    | Multiplier applied to the User entity's movement speed while this interaction is executing                                                                                                                                  |
+| RunTime                   | `Float`                                                              | **No**    | If provided, this interaction will continue executing for at least this long before the interaction chain moves onto the next interaction.                                                                                  |
+| CancelOnItemChange        | `Boolean`<br />(Default: true)                                       | **No**    | If true, this interaction will be cancelled if the User entity's held item changes during execution. This can happen either due to the selected hotbar slot changing or the contents of the item's inventory slot changing. |
+| Rules                     | `InteractionRules`                                                   | **Yes**   | If provided, adds additional limitations and cancellation conditions to this interaction.                                                                                                                                   |
+| Settings                  | `Map`<br />(Key Type: `GameMode`, Value Type: `InteractionSettings`) | **No**    | If provided, adds additional per-GameMode settings to the interaction.                                                                                                                                                      |
+| Camera                    | `InteractionCameraSettings`                                          | **No**    | Arrays of camera motion keyframes for cutscenes and reveals.                                                                                                                                                                |
+
+**GameMode Values**
+
+- `Creative`: The game is currently in Creative Mode
+- `Adventure`: The game is currently in Adventure Mode
+
+**InteractionEffects Fields**
+
+| Field Name               | Type                                              | Required? | Notes                                                                                                                                                 |
+| ------------------------ | ------------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Particles                | `Array`<br />(Element Type: `ModelParticle`)      | **No**    | Particle systems to activate when this interaction begins if the player is in third-person mode.                                                      |
+| FirstPersonParticles     | `Array`<br />(Element Type: `ModelParticle`)      | **No**    | Particle systems to activate when this interaction begins if the player is in first-person mode.                                                      |
+| WorldSoundEventId        | `Asset`<br />(Asset Type: `SoundEvent`)           | **No**    | A sound to play in the world at the User entity's location when this interaction begins.<br />**The SoundEvent must be single-channel (mono) sound.** |
+| LocalSoundEventId        | `Asset`<br />(Asset Type: `SoundEvent`)           | **No**    | A 2D sound to play for the User entity when this interaction begins. Ignored if the User entity is not a player.                                      |
+| Trails                   | `Array`<br />(Element Type: `ModelTrail`)         | **No**    | Trail effects to activate on the User entity when this interaction begins.                                                                            |
+| WaitForAnimationToFinish | `Boolean`<br />(Default: false)                   | **No**    | If true, this interaction will continue executing for at least the length of any animations in this InteractionEffects object.                        |
+| ItemPlayerAnimationsId   | `Asset`<br />(Asset Type: `ItemPlayerAnimations`) | **No**    | If provided, the User entity will use this ItemPlayerAnimations set while this interaction is executing.                                              |
+| ItemAnimationId          | `String`                                          | **No**    | Id of an animation to trigger when this interaction begins executing.<br />**This animation id is not validated on server start.**                    |
+| ClearAnimationOnFinish   | `Boolean`<br />(Default: false)                   | **No**    | If true, animations triggered by this interaction will be halted when the interaction completes.                                                      |
+| ClearSoundEventOnFinish  | `Boolean`<br />(Default: false)                   | **No**    | If true, sounds triggered by this interaction will be halted when the interaction completes.                                                          |
+| CameraEffect             | `Asset`<br />(Asset Type: `CameraEffect` )        | **No**    | If provided, the CameraEffect will be applied while this interaction is executing.                                                                    |
+| MovementEffects          | `MovementEffects`                                 | **No**    | If provided, apply the movement effects to the User entity while this interaction is executing.                                                       |
+| StartDelay               | `Float`<br />(Default: 0.0f)                      | **No**    | The interaction will wait this many seconds before triggering the effects in this object.                                                             |
+
+**InteractionRules Fields**
+
+| Field Name          | Type                                                                                                | Required? | Notes                                                                                                                                                                                                                                     |
+| ------------------- | --------------------------------------------------------------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| BlockedBy           | `Array`<br />(Element Type: `InteractionType`)<br />(Default: Based on the chain's InteractionType) | **No**    | If provided, this RootInteraction cannot be executed while interaction chains of the provided types are executing.<br />**This field only functions for rules attached to a RootInteraction. It has no effect on an Interaction.**        |
+| Blocking            | `Array`<br />(Element Type: `InteractionType`)                                                      | **No**    | If provided, interaction chains with the specified InteractionTypes cannot be executed while this interaction is executing.                                                                                                               |
+| InterruptedBy       | `Array`<br />(Element Type: `InteractionType`)                                                      | **No**    | If provided, interaction chains with the specified InteractionTypes will cancel this interaction chain when they execute.<br />**This field only functions for rules attached to a RootInteraction. It has no effect on an Interaction.** |
+| Interrupting        | `Array`<br />(Element Type: `InteractionType`)                                                      | **No**    | If provided, interaction chains with the specified InteractionTypes will be canceled when this interaction begins.                                                                                                                        |
+| BlockedByBypass     | `String`                                                                                            | **No**    | If provided, this RootInteraction cannot be blocked by interaction chains whose RootInteraction has this value as an asset tag.                                                                                                           |
+| BlockingBypass      | `String`                                                                                            | **No**    | If provided, this interaction will not block RootInteractions that have the this value as an asset tag.                                                                                                                                   |
+| InterruptedByBypass | `String`                                                                                            | **No**    | If provided, this RootInteraction cannot be canceled by RootInteractions that have this value as an asset tag.                                                                                                                            |
+| InterruptingBypass  | `String`                                                                                            | **No**    | If provided, this interaction will not cancel interaction chains whose RootInteraction has this value as an asset tag.                                                                                                                    |
+
+**InteractionType Values**
+
+- `Primary`
+- `Secondary`
+- `Ability1`
+- `Ability2`
+- `Ability3`
+- `Use`
+- `Pick`
+- `Pickup`
+- `CollisionEnter`
+- `CollisionLeave`
+- `Collision`
+- `EntityStatEffect`
+- `SwapTo`
+- `SwapFrom`
+- `Death`
+- `Wielding`
+- `ProjectileSpawn`
+- `ProjectileHit`
+- `ProjectileMiss`
+- `ProjectileBounce`
+- `Held`
+- `HeldOffhand`
+- `Equipped`
+- `Dodge`
+- `GameModeSwap`
+
+**InteractionSettings Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                        |
+| ---------------- | ------------------------------- | --------- | -------------------------------------------------------------------------------------------- |
+| AllowSkipOnClick | `Boolean`<br />(Default: false) | **No**    | If true, the user will be able to skip this interaction by clicking shortly after it starts. |
+
+**InteractionCameraSettings Fields**
+
+| Field Name  | Type                                             | Required? | Notes                                                                                                                                                           |
+| ----------- | ------------------------------------------------ | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| FirstPerson | `Array`<br />(Element Type: `InteractionCamera`) | **No**    | A list of camera keyframes to be played if the player is in first-person.<br />**The time of each keyframe must be after the keyframe before it in the array.** |
+| ThirdPerson | `Array`<br />(Element Type: `InteractionCamera`) | **No**    | A list of camera keyframes to be played if the player is in third-person.<br />**The time of each keyframe must be after the keyframe before it in the array.** |
+
+**InteractionCamera Fields**
+
+| Field Name | Type                         | Required? | Notes                                                                                                                                       |
+| ---------- | ---------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------- |
+| Time       | `Float`<br />(Default: 0.1f) | **No**    | How long after the interaction begins executing that the camera should arrive at this keyframe.<br />**Cannot be less than or equal to 0.** |
+| Position   | `Vector3`                    | **Yes**   | Where the camera should be located when it arrives at this keyframe.                                                                        |
+| Rotation   | `Direction`                  | **Yes**   | Where the camera should be pointing when it arrives at this keyframe.                                                                       |
+
+### SimpleInteraction
+
+Most interaction types below are inherited from SimpleInteraction and have these
+fields.  If a type does not have these fields, the documentation will mention it.
+
+The purpose of SimpleInteraction is to facilitate Interaction chaining by taking different paths
+based on whether the Interaction succeeded or failed.  The circumstances under which
+a given Interaction fails are generally type-specific (and described in the documentation
+below), but all interactions will be marked failed if they are cancelled via one of the
+many, many mechanisms for doing so.
+
+It is valid to create an interaction asset of type "Simple", which can be valuable when you want to use the
+interaction fields with no additional functionality.
+
+**SimpleInteraction Fields**
+
+| Field Name | Type                                     | Required? | Notes                                                                                          |
+| ---------- | ---------------------------------------- | --------- | ---------------------------------------------------------------------------------------------- |
+| Next       | `Asset`<br />(Asset Type: `Interaction`) | **No**    | After this Interaction has finished, "Next" will be executed if this Interaction did not fail. |
+| Failed     | `Asset`<br />(Asset Type: `Interaction`) | **No**    | After this Interaction has finished, "Failed" will be executed if this Interaction failed.     |
+
+## Flow Control
+
+These are interaction types used to control the flow of an interaction chain and allow interactions
+to be composed into more complex behaviors.  These interaction types generally do not pertain to
+the game and instead pertain to the interaction system itself.
+
+### Condition
+
+This interaction will fail if one of the fields is provided but does not match the current state.
+
+**Condition Fields**
+
+| Field Name       | Type       | Required? | Notes                                                                                                                                                                                    |
+| ---------------- | ---------- | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| RequiredGameMode | `GameMode` | **No**    | If provided, the interaction will fail if the current GameMode does not match the provided value.                                                                                        |
+| Jumping          | `Boolean`  | **No**    | If provided, the interaction will fail if the player's Jumping state does not match the provided value. (i.e. if True, the player must be jumping, if False, the player must not be)     |
+| Swimming         | `Boolean`  | **No**    | If provided, the interaction will fail if the player's Swimming state does not match the provided value. (i.e. if True, the player must be swimming, if False, the player must not be)   |
+| Crouching        | `Boolean`  | **No**    | If provided, the interaction will fail if the player's Crouching state does not match the provided value. (i.e. if True, the player must be crouching, if False, the player must not be) |
+| Running          | `Boolean`  | **No**    | If provided, the interaction will fail if the player's Running state does not match the provided value. (i.e. if True, the player must be running, if False, the player must not be)     |
+| Flying           | `Boolean`  | **No**    | If provided, the interaction will fail if the player's Flying state does not match the provided value. (i.e. if True, the player must be flying, if False, the player must not be)       |
+
+**GameMode Values**
+
+- `Creative`: The game is currently in Creative Mode
+- `Adventure`: The game is currently in Adventure Mode
+
+### FirstClick
+
+This interaction does not inherit from SimpleInteraction and therefore has no Next or Failed fields.
+
+This interaction has two fields that each contain a reference to an Interaction: Click and Hold.  If the root interaction
+of the chain was initiated by a client button/key press (or simulated NPC input) and the input was a tap, then
+the Click interaction is run. if it was a longer press, then the Hold interaction is run.
+
+As a minor implementation detail, this interaction is internally marked as failed when the Hold path is followed.
+This generally shouldn't matter.  If the interaction was not initiated by a key press at all, the Click path will be followed,
+but it seems risky to rely on that behavior.
+
+**FirstClick Fields**
+
+| Field Name | Type                                     | Required? | Notes                                                                                                                                                    |
+| ---------- | ---------------------------------------- | --------- | -------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Click      | `Asset`<br />(Asset Type: `Interaction`) | **No**    | If provided and the root interaction of the chain was initiated by button/key press, this interaction is executed next if the press was a quick tap.     |
+| Hold       | `Asset`<br />(Asset Type: `Interaction`) | **No**    | If provided and the root interaction of the chain was initiated by a button/key press, this interaction is executed next if the press was a longer hold. |
+
+### Interrupt
+
+This interaction can be used to cancel one or more running interaction chains on an entity and **all forked interaction
+chains those chains have spawned that are still currently running**.  All interaction chains canceled in this manner will be marked as
+Failed, which may have additional implications if the canceled chains are themselves forked from
+other chains that are still running.
+
+**Interrupt Fields**
+
+| Field Name     | Type                                           | Required? | Notes                                                                                                                                                                                               |
+| -------------- | ---------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Entity         | `InteractionTarget`<br />(Default: User)       | **Yes**   | The entity that is the owner of the target interaction chains.  This field can indicate the Owner, User, or Target of this interaction chain.                                                       |
+| InterruptTypes | `Array`<br />(Element Type: `InteractionType`) | **No**    | A set of InteractionTypes that are to be interrupted. Only interactions of these types are affected. If null, all types will be interrupted.<br />**(Note: An empty set will interrupt NO TYPES.)** |
+| RequiredTag    | `String`                                       | **No**    | An asset tag that, if provided, the RootInteraction of the interaction chain must have in order to be canceled.                                                                                     |
+| ExcludedTag    | `String`                                       | **No**    | An asset tag that, if provided, the RootInteraction of the interaction chain must not have in order to be canceled.                                                                                 |
+
+**InteractionTarget Values**
+
+- `User` - The user of this interaction chain. The entity whose actions caused this interaction chain to be executed. This is usually the same as the Owner.
+- `Owner` - The owner of this interaction chain. The entity upon whom this interaction chain is executing.
+- `Target` - The entity target of this interaction chain, if any.  This value is mutable (and can therefore come from many places) but most commonly, it is an entity the User was targeting when this interaction chain began executing.
+
+**InteractionType Values**
+
+- `Primary`
+- `Secondary`
+- `Ability1`
+- `Ability2`
+- `Ability3`
+- `Use`
+- `Pick`
+- `Pickup`
+- `CollisionEnter`
+- `CollisionLeave`
+- `Collision`
+- `EntityStatEffect`
+- `SwapTo`
+- `SwapFrom`
+- `Death`
+- `Wielding`
+- `ProjectileSpawn`
+- `ProjectileHit`
+- `ProjectileMiss`
+- `ProjectileBounce`
+- `Held`
+- `HeldOffhand`
+- `Equipped`
+- `Dodge`
+- `GameModeSwap`
+
+### Parallel
+
+This interaction does not inherit from SimpleInteraction and therefore has no Next or Failed fields.
+
+This interaction has a field `Interactions` that is an array of RootInteraction assets. The list must contain at least
+two RootInteractions.  This interaction will fork all of its children except for the first into their
+own interaction chains and immediately complete. After this interaction completes, this interaction chain will
+execute the first RootInteraction in the `Interactions` list.
+
+This interaction does not have any failure conditions and is indifferent to the fate of the forked interaction chains.
+
+**Parallel Fields**
+
+| Field Name   | Type                                                | Required? | Notes                                                         |
+| ------------ | --------------------------------------------------- | --------- | ------------------------------------------------------------- |
+| Interactions | `AssetArray`<br />(Element Type: `RootInteraction`) | **Yes**   | An array of RootInteractions that will be forked or executed. |
+
+### Repeat
+
+This interaction has a field `ForkInteractions` that is an asset of type RootInteraction. This interaction will fork that
+RootInteraction into its own interaction chain and then wait for it to complete. If the RootInteraction fails, this
+interaction will complete immediately and be marked failed. Otherwise, the RootInteraction will be forked and run again,
+up to a specified total number of times.
+
+**Repeat Fields**
+
+| Field Name       | Type                                                                                   | Required? | Notes                                                                                                                                                                                                              |
+| ---------------- | -------------------------------------------------------------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| ForkInteractions | `Asset`<br />(Asset Type: `RootInteraction`)                                           | **Yes**   | A RootInteraction that will be forked.                                                                                                                                                                             |
+| Repeat           | `Integer`<br />(Default: 1)<br />**Must be -1 or a positive integer. 0 is not valid.** | **No**    | The total number of times to fork ForkInteractions. If -1 is provided, ForkInteractions will continue being forked and executed indefinitely, until this interaction is cancelled or until ForkInteractions fails. |
+
+### Replace
+
+This interaction does not inherit from SimpleInteraction and therefore has no Next or Failed fields.
+
+This interaction uses the InteractionVars system that is avaiable for items. InteractionVars are RootInteractions that
+can be attached to an Item asset with a name.
+
+This interaction specifies a var name, and if this interaction chain was executed through
+an item and that item has an InteractionVar of the same name, then this interaction will immediately execute
+the RootInteraction on the var.  Otherwise, it will execute the default RootInteraction specified in this interaction.
+If no default is specified, then this interaction will be marked as failed.
+
+**Replace Fields**
+
+| Field Name   | Type                                         | Required? | Notes                                                                                                                                                                                                           |
+| ------------ | -------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Var          | `String`                                     | **Yes**   | The name of the InteractionVar to execute.                                                                                                                                                                      |
+| DefaultValue | `Asset`<br />(Asset Type: `RootInteraction`) | **No**    | The RootInteraction to execute if the owning item does not have an InteractionVar by the specified name. If not provided, the interaction will be marked as failed instead.                                     |
+| DefaultOk    | `Boolean`<br />(Default: false)              | **No**    | If false, then an angry message will be printed to the server logs if the owning item does not have an InteractionVar by the specified name.  The functioning of this interaction will be otherwise unaffected. |
+
+### RunRootInteraction
+
+This interaction immediately executes the provided RootInteraction as part of this interaction chain. This interaction
+does not have any failure conditions.
+
+**RunRootInteraction Fields**
+
+| Field Name      | Type                                         | Required? | Notes                           |
+| --------------- | -------------------------------------------- | --------- | ------------------------------- |
+| RootInteraction | `Asset`<br />(Asset Type: `RootInteraction`) | **Yes**   | The RootInteraction to execute. |
+
+### Selector
+
+This interaction will execute a Selector to find entities and/or blocks (depending on the Selector) and fork off an
+interaction chain for each located entity or block. This interaction will not wait for those interaction chains
+to complete and is indifferent to their fate. The forked interaction chains will use the located entity/block as
+their target entity/target block. Each entity or block will only fork one interaction chain over the life of this
+interaction.  The Selector is guaranteed to run once for each execution of this interaction, but some Selectors
+are intended to be run over a period of time and sweep across an area to locate targets. In order to use those Selectors
+properly, you will need to extend the execution time of this interaction using `RunTime` or `WaitForAnimationToFinish`.
+The Selector will be executed repeatedly over the lifetime of the interaction.
+
+If the Selector is configured to locate entities, you can add additional sets of entity matching rules. If a located entity
+matches one of the rules, the matching RootInteraction will be forked instead of the standard `HitEntity` RootInteraction.
+
+Entities located by the Selector will be ignored if they do not have a NetworkId, if they are dead, or if they are invulnerable.
+The only exception to this rule is that players in Creative Mode that are marked to receive hits will not be ignored.
+
+This interaction's failure conditions are configurable via the `FailOn` field. You can configure this interaction to never
+fail, to fail if the Selector does not locate any blocks before this interaction finishes executing, to fail if the
+Selector does not locate any entities before this interaction finishes executing, or to fail in either case.
+
+**Selector Fields**
+
+| Field Name     | Type                                         | Required? | Notes                                                                                                                                                                                                                                     |
+| -------------- | -------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Selector       | `Selector`                                   | **Yes**   | The Selector is executed at least once and may be executed repeatedly to locate blocks and/or entities in an area.                                                                                                                        |
+| HitEntity      | `Asset`<br />(Asset Type: `RootInteraction`) | **No**    | If included and the `Selector` locates an entity that does not match any `HitEntityRules`, this RootInteraction will be forked into a new interaction chain with the located entity as the target entity.                                 |
+| HitEntityRules | `Array`<br />(Element Type: `HitEntity`)     | **No**    | If included, these rules will be matched against any entity located by the `Selector`. If an entity matches a set of rules, the RootInteraction associated with the rules will be forked instead of the standard `HitEntity` interaction. |
+| HitBlock       | `Asset`<br />(Asset Type: `RootInteraction`) | **No**    | If included and the `Selector` locates a block, this RootInteraction will be forked into a new interaction chain with the located block as the block target.                                                                              |
+| FailOn         | `FailOnType`<br />(Default: `Neither`)       | **No**    | Defines under what circumstances this interaction will fail.  It can be marked to fail when it completes without locating any blocks, it can be marked to fail when it completes without locating any entities, both, or neither.         |
+| IgnoreOwner    | `Boolean`<br />(Default: true)               | **No**    | If true, the Selector will not locate the User entity of this interaction.                                                                                                                                                                |
+
+**HitEntity Fields**
+
+| Field Name | Type                                         | Required? | Notes                                                                                                 |
+| ---------- | -------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------- |
+| Matchers   | `Array`<br />(Element Type: `EntityMatcher`) | **Yes**   | A set of rules that an entity must match. An entity must successful match all rules to be considered. |
+| Next       | `Asset`<br />(Asset Type: `RootInteraction`) | **Yes**   | The RootInteraction to fork if an entity matches all rules.                                           |
+
+**EntityMatcher Fields**
+
+| Field Name | Type                            | Required? | Notes                                                                                                     |
+| ---------- | ------------------------------- | --------- | --------------------------------------------------------------------------------------------------------- |
+| Type       | `String`                        | **Yes**   | If provided, specifies a type of EntityMatcher to use. Each matcher type may come with additional fields. |
+| Invert     | `Boolean`<br />(Default: false) | **No**    | If true, an entity must fail this rule for it to be marked as succeeded.                                  |
+
+**EntityMatcher Type: Player**
+
+This EntityMatcher will succesfully match the entity only if they are a player.
+
+**EntityMatcher Type: Vulnerable**
+
+This Entitymatcher will successfully match the entity only if they are not marked as invulnerable.
+
+**FailOnType Values**
+
+- `Neither`
+- `Entity`
+- `Block`
+- `Either`
+
+### Serial
+
+This interaction does not inherit from SimpleInteraction and therefore has no Next or Failed fields.
+
+This interaction has a field `Interactions` which is a list of Interaction assets. This interaction immediately
+completes and the interaction chain continues by executing the interactions in the list one at a time. This
+interaction does not have any failure conditions.
+
+**Serial Fields**
+
+| Field Name   | Type                                            | Required? | Notes                                      |
+| ------------ | ----------------------------------------------- | --------- | ------------------------------------------ |
+| Interactions | `AssetArray`<br />(Element Type: `Interaction`) | **Yes**   | An array of Interaction assets to execute. |
+
+## Cooldowns
+
+RootInteractions interface with a complex cooldown system that can be used for a variety of purposes. Aside from simply
+adding an important aspect of resource management to your game design, cooldowns can be used to ensure that click-activated
+interaction chains don't repeatedly spam if the player holds down the input.
+
+By default, every RootInteraction has a cooldown timer that is keyed to the RootInteraction name, and by default, it
+will launch a cooldown of 0.35 seconds when activated by client input.  Otherwise, no cooldown will be activated.  However,
+by configuring your RootInteraction, you can change the key for the cooldown (so that multiple RootInteractions can share
+a single cooldown), set the cooldown timer to whatever you like, and configure multiple charges that can build up over time
+to allow the entity to activate the RootInteraction multiple times before being forced to pause.
+
+One important concept to keep in mind is the difference between **cooldown** and **charge time**.  The cooldown, if any,
+is activated each time a RootInteraction triggers, even if the player has more available charges. If the RootInteraction
+is configured to use charges, then they will gradually build up over time. In order for a RootInteraction to be activated,
+the cooldown (if any) must be expired, and the RootInteraction must have at least one charge (if it has been
+configured to use charges).
+
+Bear in mind that the entire Cooldown configuration is shared between different RootInteractions with the same cooldown id.
+If you activate an ability with 5 charges and a short cooldown and then another ability with a much longer cooldown and no
+charges, the second ability will use the cooldown properties of the first ability until/unless the first ability finishes
+charging and is cleared from the system.  You should generally only have multiple RootInteractions share a cooldown id
+if they have the same configuration.
+
+The interactions below interact with the cooldown system to allow you to manipulate cooldowns via the interaction system. By
+using these interactions, you can have several interaction chains with different cooldown configurations share cooldowns
+that are checked and activated as part of the interaction chain itself, or have some components of an interaction change
+use a second cooldown separate from the main one.
+
+### CooldownCondition
+
+**CooldownCondition Fields**
+
+This interaction will fail if the specified cooldown id is on cooldown for the User entity.  This interaction will only
+function for players- the interaction will always succeed for NPCs.  In order for this interaction to succeed, the
+cooldown, if any, must have expired and at least one charge, if any, must have filled.
+
+| Field Name | Type     | Required? | Notes                     |
+| ---------- | -------- | --------- | ------------------------- |
+| Id         | `String` | **Yes**   | The cooldown id to check. |
+
+### IncrementCooldown
+
+**IncrementCooldown Fields**
+
+This interaction will modify a cooldown that is currently active on the User entity, allowing charges and remaining
+cooldown to be modified.
+Despite its name, this interaction can be used to reduce a cooldown as well as increase it. If the cooldown is not
+currently active, this interaction will have no effect. The interaction has no special failure conditions.
+
+| Field Name        | Type                        | Required? | Notes                                                                                                                                                                                                                                                                                     |
+| ----------------- | --------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Id                | `String`                    | **No**    | If provided, the cooldown id of the cooldown to be manipulated. If not provided, the cooldown id of the current chain's RootInteraction will be used.                                                                                                                                     |
+| Time              | `Float`<br />(Default: 0.0) | **No**    | The amount to increase the remaining cooldown by. Can be negative. The remaining cooldown time will not be reduced below zero or increased above the maximum cooldown time.                                                                                                               |
+| ChargeTime        | `Float`<br />(Default: 0.0) | **No**    | The amount to increase the remaining time until the next charge is filled by. Can be negative. The remaining charge time cannot be reduced below zero or increased above the maximum cooldown time. **This will not work on abilities that have a maximum of 1 charge, for some reason.** |
+| Charge            | `Integer`<br />(Default: 0) | **No**    | The amount to increase the number of charges by. Can be negative. The number of charges cannot be reduced below 0 or increased above the maximum.                                                                                                                                         |
+| InterruptRecharge | `Boolean`(Default: false)   | **No**    | If true and `Charge` is not 0, will reset the remaining time to the next charge to the maximum value after changing the charge count.                                                                                                                                                     |
+
+### ResetCooldown
+
+This interaction will trigger a cooldown on the User entity with a specified configuration. The charges will be refilled
+but the cooldown will be immediately triggered.  The mechanisms for deciding on the configuration are a little bit complicated.
+You may specify a cooldown configuration via the `Cooldown` field. If you do not include an `Id` field, then the
+interaction chain's RootInteraction will be used for any field not specified in the configuration. If there is an active
+cooldown under the specified `Id` (or under the RootInteraction's cooldown id if none is specified) then the fields
+from that active cooldown will overwrite data in the RootInteraction's cooldown, but not data in your `Cooldown` field.
+
+**ResetCooldown Fields**
+
+| Field Name | Type                  | Required? | Notes                                                        |
+| ---------- | --------------------- | --------- | ------------------------------------------------------------ |
+| Cooldown   | `InteractionCooldown` | **No**    | A cooldown configuration to use for the new, reset cooldown. |
+
+**InteractionCooldown Fields**
+
+| Field Name        | Type                                 | Required? | Notes                                                                                                                                                                                                 |
+| ----------------- | ------------------------------------ | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Id                | `String`                             | **No**    | The cooldown id to use for this cooldown. If not provided, the RootInteraction's cooldown id will be used, if any.                                                                                    |
+| Cooldown          | `Float`<br />(Default: 0.0)          | **No**    | The duration of the cooldown, in seconds.                                                                                                                                                             |
+| Charges           | `Array`<br />(Element Type: `Float`) | **No**    | If provided, a list of how many charges this cooldown can build, and how long each charge takes to build, in seconds.                                                                                 |
+| InterruptRecharge | `Boolean`<br />(Default: false)      | **No**    | If true, the charge time will be reset when the number of charges changes.                                                                                                                            |
+| ClickBypass       | `Boolean`<br />(Default: false)      | **No**    | If true, RootInteractions keyed to this cooldown can still be activated when it is on cooldown provided that the RootInteraction was triggered by a distinct key or mouse button press on the client. |
+
+### TriggerCooldown
+
+This interaction is similar to ResetCooldown, except instead of refilling the cooldown's charges, one charge will be deducted
+as normal.
+
+**TriggerCooldown Fields**
+
+| Field Name | Type                  | Required? | Notes                                                        |
+| ---------- | --------------------- | --------- | ------------------------------------------------------------ |
+| Cooldown   | `InteractionCooldown` | **No**    | A cooldown configuration to use for the new, reset cooldown. |
+
+**InteractionCooldown Fields**
+
+| Field Name        | Type                                 | Required? | Notes                                                                                                                                                                                                 |
+| ----------------- | ------------------------------------ | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Id                | `String`                             | **No**    | The cooldown id to use for this cooldown. If not provided, the RootInteraction's cooldown id will be used, if any.                                                                                    |
+| Cooldown          | `Float`<br />(Default: 0.0)          | **No**    | The duration of the cooldown, in seconds.                                                                                                                                                             |
+| Charges           | `Array`<br />(Element Type: `Float`) | **No**    | If provided, a list of how many charges this cooldown can build, and how long each charge takes to build, in seconds.                                                                                 |
+| InterruptRecharge | `Boolean`<br />(Default: false)      | **No**    | If true, the charge time will be reset when the number of charges changes.                                                                                                                            |
+| ClickBypass       | `Boolean`<br />(Default: false)      | **No**    | If true, RootInteractions keyed to this cooldown can still be activated when it is on cooldown provided that the RootInteraction was triggered by a distinct key or mouse button press on the client. |
+
+## Combo Chains
+
+Hytale additionally comes with a rich "combo chaining" system, which allows several inputs in a row to result in different
+attacks and special moves.  Rather than being attached to the RootInteraction like the cooldown system, these are
+primarily driven by the `Chaining` interaction.
+
+### Chaining
+
+This interaction does not inherit from SimpleInteraction and therefore has no Failed field. Its Next field works differently
+from most interaction types.
+
+Chaining is a type of flow control interaction- each time a Chaining interaction with the same `ChainId` is called, a single
+interaction in the `Next` list is chosen and the others are ignored. The first time the `ChainId` is used, the first
+interaction in the list is chosen, the next time the second, etc. Once the end of the list is reached, the first
+interaction will be chosen again.
+
+Bear in mind: the progress through the Next list is based on the **ChainId**, not the interaction!  That means that two
+different Chaining interactions can share a single combo chain. You could have a pair of daggers that attacks with
+the left when the left mouse button is clicked and with the right when the right mouse button is clicked.  You could give
+both interaction chains a Chaining interaction with the same `ChainId` and three `Next` entries that do a light-light-heavy
+combo.  Each specific hit would occur with either the left or the right knife based on which button you clicked, but
+the combo would be otherwise identical regardless of which you chose.
+
+The Chaining interaction also has a concept called "flags".  It is possible to attach named flags to a `ChainId` by using
+the ChainFlag interaction.  Then, you specify the flag name in Chaining's `Flags` field. If a Flag is active when the
+Chaining interaction is run, the Flag's interaction will be run instead of the appropriate interaction in `Next`.
+Bear in mind: the entity's progress through the `Next` list still advances, the resulting `Next` interaction is just not
+run.  Only one flag can be active at a time.
+
+Lastly, it is possible to cancel the entity's progress through the combo chain and reset them to the first interaction in
+the list. This can be done with the CancelChain interaction, but it will also happen automatically if the player does
+not trigger an interaction with the ChainId for the specified ChainingAllowance.  When either of these happen, all flags will be
+canceled as well.
+
+All of these effects are triggered on the User entity only. Non-players can use the chaining system, but Flags do not currently
+work for non-players.  This interaction has no special failure conditions.
+
+**Chaining Fields**
+
+| Field Name        | Type                                                       | Required? | Notes                                                                                                                                                                                                                       |
+| ----------------- | ---------------------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| ChainId           | `String`                                                   | **No**    | If provided, acts as a key that multiple Chaining interactions can use to share combo chain progress and flags. If not provided, a unique ChainId will be generated for this interaction.                                   |
+| ChainingAllowance | `Double`<br />(Default: 0.0)                               | **No**    | If, at the time this interaction is triggered, it has been this long in seconds since the last time a Chaining interaction with the same ChainId was executed, all state for this ChainId will be cleared before execution. |
+| Next              | `AssetArray`<br />(Element Type: `Interaction`)            | **Yes**   | A list of interactions to cycle between each time this interaction is run.                                                                                                                                                  |
+| Flags             | `Map`<br />(Key Type: `String`, Value Type: `Interaction`) | **No**    | A map of flag names to interactions to run if the flag is active when this interaction executes.                                                                                                                            |
+
+### CancelChain
+
+This interaction resets all progress and flag data on the User entity for the provided `ChainId`.  The next time a Chaining
+interaction is called for the provided `ChainId`, it will begin at the first interaction in the `Next` list. This
+interaction has no special failure conditions.
+
+**CancelChain Fields**
+
+| Field Name | Type     | Required? | Notes                                 |
+| ---------- | -------- | --------- | ------------------------------------- |
+| ChainId    | `String` | **Yes**   | A ChainId whose data should be reset. |
+
+### ChainFlag
+
+This interaction activates a flag on the User entity for the provided `ChainId`, which can be used to change behavior the
+next time a Chaining interaction with this `ChainId` is run. This will overwrite any flag that has
+already been raised. This interaction will have no effect for non-players. This interaction has no special failure
+conditions.
+
+| Field Name | Type     | Required? | Notes                                        |
+| ---------- | -------- | --------- | -------------------------------------------- |
+| ChainId    | `String` | **Yes**   | A ChainId on whom the flag should be raised. |
+| Flag       | `String` | **Yes**   | The name of the flag to raise.               |
+
+## Charging
+
+A unique flow-control interaction that is frequently used is the Charging interaction.  It is a flow-control interaction
+that delays while the input button used to trigger the interaction chain is held.  When it is released (or the interaction
+is forced to end), the interaction chain can continue with a different interaction based on how long the input was held
+for.
+
+These interactions are all related by either being the Charging interaction, or other interaction types that inherit the
+Charging interaction's behavior.
+
+### Charging
+
+This interaction does not inherit from SimpleInteraction and therefore its Next field works different from most interactions.
+This interaction adds its own Failed field which works the same way that SimpleInteraction's does.
+
+This interaction only works properly when its interaction chain was triggered by a client key or button press (or
+NPC-simulated equivalent). This interaction will continue executing for as long as the key or button press is held (with
+some exceptions, covered below) by the User entity.  Like other interactions, it has a `Next` field indicating which interaction to execute
+after this one, but the field is a map from `Float` values to `Interaction` assets. When this interaction ends, either
+due to the input being released or the charge duration completing, this interaction will determine the largest `Float` key that is less
+than the amount of time in seconds that the interaction was executing for.  The Interaction mapped to that key will be
+executed next.
+
+The interaction includes some cancellation conditions that are specific to this interaction. For instance, the interaction
+has a `CancelOnOtherClick` field that matches the field on RootInteraction. If it is active on this interaction but not
+the RootInteraction, then clicking while charging will cancel this interaction (and execute the `Failed` interaction rather
+than any of the `Next` interactions) but otherwise continue the interaction chain.
+
+Another valuable feature Charging has is the `Forks` field.  For input-triggered interactions that are triggered while the
+Charging interaction is executing, you can add an entry for the relevant InteractionType to this field and instead of
+triggering the usual interaction chain based on held item, targeted block, etc. the RootInteraction specified in the
+`Forks` field will be triggered.  This can unlock rich attack modes and behaviors. For instance, having a shield bash attack
+triggered off left click while blocking, or a special attack that triggers when both mouse buttons are pressed at the
+same time.
+
+There are two modes of operation for the Charging interaction. One is to have the ability charge for as long
+as the input is held and only end execution when the entity releases the input.  Bows in the main Hytale game work
+that way.  That is accomplished by setting `AllowIndefiniteHold` to true.  Another mode of operation is to have the
+interaction complete execution when the execution time has surpassed the largest key value in the `Next` field and
+immediately begin executing the Interaction mapped to that key.  Food in the main Hytale game work like this.  It
+is accomplished by setting `AllowIndefiniteHold` to false.
+
+One pitfall to be careful of when setting `AllowIndefiniteHold` to false is the way it interacts with cooldowns.\
+Normally, input-initiated interaction chains start a 0.35s cooldown on the triggered RootInteraction that prevents
+holding the mouse button from immediately spamming a new interaction when the first one completes.  However, if the
+duration of a Charging interaction is longer than 0.35s, then the cooldown will have already completed when the
+interaction chain finishes, which will often result in a new execution beginning immediately before the player can
+stop pressing the mouse button.  One solution for this problem is to add a `Simple` interaction to the end of your
+interaction chain with a `RunTime` of 0.35s to simulate the cooldown.  Alternatively, you can add a longer cooldown
+(the maximum duration of your Charging interaction plus 0.35s) to the RootInteraction. However, the longer cooldown is
+not always desirable, as the interaction may have ended prematurely, resulting in an unusually long lockout between
+executions.
+
+**Charging Fields**
+
+| Field Name                         | Type                                                                    | Required? | Notes                                                                                                                                                                                                                                                                                                                                                                                       |
+| ---------------------------------- | ----------------------------------------------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| FailOnDamage                       | `Boolean`<br />(Default: false)                                         | **No**    | If true, this interaction will fail and end immediately if the User entity takes any damage while it is executing.                                                                                                                                                                                                                                                                          |
+| CancelOnOtherClick                 | `Boolean`<br />(Default: true)                                          | **No**    | If true, this interaction will fail and end immediately if the User entity sends another button or key press while it is executing.                                                                                                                                                                                                                                                         |
+| Forks                              | `Map`<br />(Key Type: `InteractionType`, Value Type: `RootInteraction`) | **No**    | A map of InteractionType to RootInteraction. If entity input triggers the InteractionType while this interaction is executing, the mapped RootInteraction will be forked into its own interaction chain. This will happen instead of the usual handling for that InteractionType.  This fork will occur even if `CancelOnOtherClick` is set to true.                                        |
+| Failed                             | `Asset`<br />(Asset Type: `Interaction`)                                | **No**    | After this Interaction has finished, "Failed" will be executed if this Interaction failed.                                                                                                                                                                                                                                                                                                  |
+| AllowIndefiniteHold                | `Boolean`<br />(Default: false)                                         | **No**    | If true, this interaction will continue executing for as long as the User entity continues to hold the input. If false, execution will end as soon as the execution time in seconds reaches the largest key value in the `Next` map.                                                                                                                                                        |
+| DisplayProgress                    | `Boolean`<br />(Default: true)                                          | **No**    | If true, players executing this interaction will see a progress bar will be displayed below their cursor indicating how close to reaching the highest key value in `Next` they are.                                                                                                                                                                                                         |
+| Next                               | `Map`<br />(Key Type: `Float`, Value Type: `Interaction`)               | **No**    | A map from `Float` to `Interaction`.  When this interaction successfully finishes executing (either because the input was released or because the maximum duration was reached), this interaction will find the `Float` value with the largest duration in seconds that is less than the amount of time this interaction executed for. That key's mapped Interaction will then be executed. |
+| MouseSensitivityAdjustmentTarget   | `Float`<br />(Default: 1.0)                                             | **No**    | While charging, this mouse sensitivity multiplier will gradually be applied.                                                                                                                                                                                                                                                                                                                |
+| MouseSensitivityAdjustmentDuration | `Float`<br />(Default: 1.0)                                             | **No**    | Duration in seconds. After this many seconds, `MouseSensitivityAdjustmentTarget` will be fully applied to the mouse sensitivity.                                                                                                                                                                                                                                                            |
+| Delay                              | `ChargingDelay`                                                         | **No**    | Settings that allow charging progress to be pushed back when the User entity takes damage.                                                                                                                                                                                                                                                                                                  |
+
+**ChargingDelay Fields**
+
+| Field Name    | Type                        | Required? | Notes                                                                                                                                                                                                                                                                     |
+| ------------- | --------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| MinHealth     | `Float`<br />(Default: 0.0) | **No**    | Damage taken as a percentage of entity health (0.0-1.0). If a hit deals less than this much damage, no pushback will be applied.  If a hit deals exactly this much damage, `MinDelay` seconds worth of pushback will be applied.                                          |
+| MaxHealth     | `Float`<br />(Default: 0.0) | **No**    | Damage taken as a percentage of entity health (0.0-1.0). If a hit deals at least this much damage, `MaxDelay` seconds worth of pushback will be applied.                                                                                                                  |
+| MinDelay      | `Float`<br />(Default: 0)   | **No**    | The amount of pushback, in seconds, to apply if the entity takes a hit that deals `MinHealth` damage. The amount of pushback applied by a hit is a gradiant between `MinDelay` and `MaxDelay` based on the amount of damage between `MinHealth` and `MaxHealth`.          |
+| MaxDelay      | `Float`<br />(Default: 0)   | **No**    | The amount of pushback, in seconds, to apply if the entity takes a hit that deals at least `MaxHealth` damage. The amount of pushback applied by a hit is a gradiant between `MinDelay` and `MaxDelay` based on the amount of damage between `MinHealth` and `MaxHealth`. |
+| MaxTotalDelay | `Float`<br />(Deault: 0)    | **No**    | The maximum amount of pushback the entity can receive over the course of a single charge, regardless of how many times they are hit.                                                                                                                                      |
+
+**InteractionType Values**
+
+- `Primary`
+- `Secondary`
+- `Ability1`
+- `Ability2`
+- `Ability3`
+- `Use`
+- `Pick`
+- `Pickup`
+- `CollisionEnter`
+- `CollisionLeave`
+- `Collision`
+- `EntityStatEffect`
+- `SwapTo`
+- `SwapFrom`
+- `Death`
+- `Wielding`
+- `ProjectileSpawn`
+- `ProjectileHit`
+- `ProjectileMiss`
+- `ProjectileBounce`
+- `Held`
+- `HeldOffhand`
+- `Equipped`
+- `Dodge`
+- `GameModeSwap`
+
+### Wielding
+
+This interaction is inherited from Charging rather than SimpleInteraction.  However, its `Failed` and `Next` fields function
+identically to SimpleInteraction.  It does not inherit all fields from Charging, so be sure to pay close attention to
+the field list below.
+
+This interaction drives most blocking behavior in the game. While this interaction is executing, attacks made against
+the Owner entity will (conditionally) trigger effects defined in this interaction.  Unlike the Charging interaction,
+this interaction can always execute indefinitely and will only end when it fails or when the input is released.
+
+One option available in Wielding is `AngledWielding`, which allows damage and knockback modifiers to only be applied
+depending on the direction the attack against the Owner entity is coming from.  The AngledWielding type has a
+field `Angle` which determines which direction the protection points relative to the player (0 is the player's
+front), and `AngleDistance` which determines how wide the cone of protection extends around the player.  Block effects
+from this interaction (such as `BlockedEffects`, `BlockedInteractions`, and `StaminaCost`) will only apply if
+the DamageCause matches `DamageModifiers` OR if the DamageCause matches `AngledWielding.DamageModifiers` and
+the source of the damage matches `Angle` and `AngleDistance`.  It is possible for damage and knockback multipliers
+specified on both this interaction's modifier fields and `AngledWielding`'s modifier fields to stack, if both
+have entries for the same DamageCause.
+
+This interaction will only have an effect on damage taken by one of the DamageCause entries in `DamageModifiers` or
+`AngledWielding.DamageModifiers`.  If a DamageCause is in `DamageModifiers`, then the block effect will be triggered
+and the damage modifier applied regardless of what direction the Owner entity is attacked from.  If a DamageCause is in
+`AngledWielding.DamageModifiers`, then the damage modifier is only applied if the
+
+\*\* Wielding Fields\*\*
+
+| Field Name          | Type                                                                    | Required? | Notes                                                                                                                                                                                                                                                                                                                                                                                                      |
+| ------------------- | ----------------------------------------------------------------------- | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| FailOnDamage        | `Boolean`<br />(Default: false)                                         | **No**    | If true, this interaction will fail and end immediately if the User entity takes any damage while it is executing.                                                                                                                                                                                                                                                                                         |
+| CancelOnOtherClick  | `Boolean`<br />(Default: true)                                          | **No**    | If true, this interaction will fail and end immediately if the User entity sends another button or key press while it is executing.                                                                                                                                                                                                                                                                        |
+| Forks               | `Map`<br />(Key Type: `InteractionType`, Value Type: `RootInteraction`) | **No**    | A map of InteractionType to RootInteraction. If entity input triggers the InteractionType while this interaction is executing, the mapped RootInteraction will be forked into its own interaction chain. This will happen instead of the usual handling for that InteractionType.  This fork will occur even if `CancelOnOtherClick` is set to true (after which this interaction chain will be canceled). |
+| Next                | `Asset`<br />(Asset Type: `Interaction`)                                | **No**    | After this interaction has finished, "Next" will be executed if this interaction did not fail.                                                                                                                                                                                                                                                                                                             |
+| Failed              | `Asset`<br />(Asset Type: `Interaction`)                                | **No**    | After this interaction has finished, "Failed" will be executed if this interaction failed.                                                                                                                                                                                                                                                                                                                 |
+| DamageModifiers     | `Map`<br />(Key Type: `DamageCause`, Value Type: `Float`)               | **No**    | A map from DamageCause to Float, where the Float is multiplied against any damage received from the mapped DamageCause while this interaction is executing.                                                                                                                                                                                                                                                |
+| KnockbackModifiers  | `Map`<br />(Key Type: `DamageCause`, Value Type: `Float`)               | **No**    | A map from DamageCause to Float, where the Float is multiplied against any knockback force received from the mapped DamageCause while this interaction is executing.                                                                                                                                                                                                                                       |
+| AngledWielding      | `AngledWielding`                                                        | **No**    | Configuration to only trigger block effects from certain angles.                                                                                                                                                                                                                                                                                                                                           |
+| StaminaCost         | `StaminaCost`                                                           | **No**    | If the Owner entity receives damage that matches `DamageModifiers` or `AngledWielding` while this interaction is executing, then the entity's stamina will be deducted according to this configuration.                                                                                                                                                                                                    |
+| BlockedEffects      | `DamageEffects`                                                         | **No**    | If the Owner entity receives damage that matches `DamageModifiers` or `AngledWielding` while this interaction is executing, then these effects will be applied to the instance of damage.                                                                                                                                                                                                                  |
+| BlockedInteractions | `Asset`<br />(Asset Type: `RootInteraction`)                            | **No**    | If the Owner entity receives damage that matches `DamageModifiers` or `AngledWielding` while this interaction is executing, then this RootInteraction will be launched as a brand new interaction chain with the Owner entity as both Owner and User, and the attacker as the Target entity.  This new interaction chain is, notably, brand new, **not** forked from the current one.                      |
+
+**AngledWielding Fields**
+
+| Field Name         | Type                                                      | Required? | Notes                                                                                                                                                                                                            |
+| ------------------ | --------------------------------------------------------- | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Angle              | `Float`<br />(Default: 0.0)                               | **No**    | Angle in degrees relative to the Owner entity where the angled protection is centered. 0.0 means pointed towards the front of the Owner entity.                                                                  |
+| AngleDistance      | `Float`<br />(Default: 0.0)                               | **No**    | Angle in degrees indicating how wide the cone of protection is.                                                                                                                                                  |
+| DamageModifiers    | `Map`<br />(Key Type: `DamageCause`, Value Type: `Float`) | **No**    | A map from DamageCause to Float, where the Float is multiplied against any damage received from the mapped DamageCause received from within the cone of protection while this interaction is executing.          |
+| KnockbackModifiers | `Map`<br />(Key Type: `DamageCause`, Value Type: `Float`) | **No**    | A map from DamageCause to Float, where the Float is multiplied against any knockback force received from the mapped DamageCause received from within the cone of protection while this interaction is executing. |
+
+**StaminaCost Fields**
+
+| Field Name | Type                                             | Required? | Notes                                                                                                                                                                                                                                                |
+| ---------- | ------------------------------------------------ | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| CostType   | `CostType`<br />(Default: `MaxHealthPercentage`) | **No**    | How to calculate stamina consumed by blocking from the raw pre-block damage. If `Damage`, then the stamina consumed will be `rawDamage / Value`. If `MaxHealthPercentage`, then the stamina consumed will be `rawDamage / (EntityMaxHealth * Value)` |
+| Value      | `Float`<br />(Default: 0.04)                     | **No**    | The value to use in the `CostType` formula.                                                                                                                                                                                                          |
+
+**DamageEffects Fields**
+
+| Field Name             | Type                                         | Required? | Notes                                                                           |
+| ---------------------- | -------------------------------------------- | --------- | ------------------------------------------------------------------------------- |
+| ModelParticles         | `Array`<br />(Element Type: `ModelParticle`) | **No**    | Particle systems to trigger in the first-person view.                           |
+| WorldParticles         | `Array`<br />(Element Type: `WorldParticle`) | **No**    | Particle systems to trigger in the third-person view.                           |
+| LocalSoundEventId      | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | 2D sound to play locally to the attacking entity if they are a player.          |
+| WorldSoundEventId      | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | Sound to play in the world at the Owner entity's location.                      |
+| PlayerSoundEventId     | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | 2D sound to play locally to the Owner entity if they are a player.              |
+| ViewDistance           | `Double`<br />(Default: 75.0)                | **No**    | Distance at which these effects should play for other players.                  |
+| Knockback              | `Knockback`                                  | **No**    | The properties of the knockback that will be applied.                           |
+| CameraEffect           | `Asset`<br />(Asset Type: `CameraEffect`)    | **No**    | CameraEffect to briefly apply locally to the Owner entity if they are a player. |
+| StaminaDrainMultiplier | `Float`<br />(Default: 1.0)                  | **No**    | This multiplier is applied to the `StaminaCost`, if any.                        |
+
+**Knockback Fields**
+
+| Field Name     | Type                                       | Required? | Notes                                                                                                                      |
+| -------------- | ------------------------------------------ | --------- | -------------------------------------------------------------------------------------------------------------------------- |
+| Type           | `String`                                   | **No**    | If provided, specifies a type of knockback to use. Each knockback type may come with additional fields.                    |
+| Force          | `Double`<br />(Default: 0.0)               | **No**    | The amount of force to apply to the Owner entity.                                                                          |
+| Duration       | `Double`<br />(Default: 0.0)               | **No**    | If 0.0, apply the force as a single impulse.  If more, continuously apply the force over a period of time.                 |
+| VelocityType   | `ChangeVelocityType`<br />(Default: `Add`) | **No**    | How to apply the force, either adding it to the entity's current velocity, or setting the velocity to the knockback force. |
+| VelocityConfig | `VelocityConfig`                           | **No**    | Characteristics of friction as the Owner entity is thrown by this knockback.                                               |
+
+**Knockback Type: Force**
+
+Apply the calculated knockback force along the provided direction.
+
+| Field Name | Type                         | Required? | Notes                                                                                |
+| ---------- | ---------------------------- | --------- | ------------------------------------------------------------------------------------ |
+| Direction  | `Vector3`<br />(Default: Up) | **No**    | Which direction the player should be flung, relative to the direction of the attack. |
+
+**Knockback Type: Point**
+
+Apply the calculated knockback force laterally along the XZ plane, plus provided Y velocity.
+
+| Field Name | Type                        | Required? | Notes                                                                                                   |
+| ---------- | --------------------------- | --------- | ------------------------------------------------------------------------------------------------------- |
+| OffsetX    | `Integer`<br />(Default: 0) | **No**    | Offset the source position of the knockback left or right perpendicular to the direction of the attack. |
+| OffsetZ    | `Integer`<br />(Default: 0) | **No**    | Offset the source position of the knockback, forward or backward along the directon of the attack.      |
+| RotateY    | `Integer`<br />(Default: 0) | **No**    | Rotate the knockback direction around the Y axis, where 0 is the default attack direction.              |
+| VelocityY  | `Float`<br />(Default: 0.0) | **No**    | Add vertical velocity to the knockback force after the direction and force has been calculated.         |
+
+**Knockback Type: Directional**
+
+Apply the calculated knockback force along the attack direction, removing any vertical component and replacing it with a provided Y velocity.
+
+| Field Name | Type                      | Required? | Notes                                                                                                                                            |
+| ---------- | ------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------ |
+| RelativeX  | `Float`<br />(Default: 0) | **No**    | Apply additional force left or right perpendicular to the direction of the attack. The additional force is multiplied by the knockback strength. |
+| RelativeZ  | `Float`<br />(Default: 0) | **No**    | Apply additional force forward or backward along the attack direction. The additional force is multiplied by the knockback strength.             |
+| VelocityY  | `Float`<br />(Default: 0) | **No**    | Replace the vertical velocity of the knockback with this value.  This value is not multiplied by knockback strength.                             |
+
+**VelocityConfig Fields**
+
+| Field Name          | Type                                              | Required? | Notes                                                                                                                                                                                           |
+| ------------------- | ------------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| GroundResistance    | `Float`<br />(Default: 0.82)                      | **No**    | The minimum amount of friction applied when the entity is in contact with the ground.  1.0 = no friction, 0.0 = total friction                                                                  |
+| GroundResistanceMax | `Float`<br />(Default: 0.0)                       | **No**    | The maximum amount of friction applied when the entity is in contact with the ground.  1.0 = no friction, 0.0 = total friction                                                                  |
+| AirResistance       | `Float`<br />(Default: 0.96)                      | **No**    | The minimum amount of friction applied when the entity is in the air. 1.0 = no friction, 0.0 = total friction                                                                                   |
+| AirResistanceMax    | `Float`<br />(Default: 0.0)                       | **No**    | The maximum amount of friction applied when the entity is in the air. 1.0 = no friction, 0.0 = total friction                                                                                   |
+| Threshold           | `Float`<br />(Default: 1.0)                       | **No**    | The speed at which the maximum amount of friction will be applied to the entity. The amount of friction applied will increase from minimum to maximum as the entity moves from 0 to this speed. |
+| Style               | `VelocityThresholdStyle`<br />(Default: `Linear`) | **No**    | The curve that friction follows as the entity's speed increases toward the `Threshold`.                                                                                                         |
+
+**CostType Values**
+
+- `MaxHealthPercentage`
+- `Damage`
+
+**ChangeVelocityType Values**
+
+- `Add`
+- `Set`
+
+**VelocityThresholdStyle Values**
+
+- `Linear`
+- `Exp`
+
+## Blocks
+
+These are interaction types meant to reason about and modify blocks in the world.  The most important concept unique
+to these interactions is the Block Target.  Like the Entity Target, it is mutable and can come from many places.
+However, for interaction chains initiated by the client, the block target will initially be the block that the player's cursor was
+over, if any.
+
+Additionally, for interaction chains initiated by the client, the client will send along which face of the block is targeted,
+which is used by a few block-related interactions.
+It is left up to each interaction type that cares about block faces as to how to handle this behavior for simulated input
+(i.e. NPCs initiating chains that are normally initated by the client).  At the time of this writing, all block-related
+interactions choose the top face where relevant in simulated input.
+
+### BlockCondition
+
+This interaction has a field `Matchers` which specifies certain conditions, such as block type, state, etc.  This
+interaction fails if the current target block does not match all of them.
+
+**BlockCondition Fields**
+
+| Field Name       | Type                                        | Required? | Notes                                                                                                                                                                                                                                                                                                                                   |
+| ---------------- | ------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false)             | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction.                                                                                                                                                                                                       |
+| Matchers         | `Array`<br />(Element Type: `BlockMatcher`) | **Yes**   | A list of conditions that the target block must match or this condition will fail.<br />**Note: This field is technically not required but there is a bug that makes it dangerous to not provide at the time of this writing.**<br />**Note: If no conditions are added to this array, the interaction will fail, counterintuitively.** |
+
+**BlockMatcher Fields**
+
+| Field Name | Type                       | Required? | Notes                                                                          |
+| ---------- | -------------------------- | --------- | ------------------------------------------------------------------------------ |
+| Block      | `BlockIdMatcher`           | **No**    | If provided, requires the block itself match some set of conditions.           |
+| Face       | `BlockFace`                | **No**    | If provided and not 'None', requires a specific block face be targeted.        |
+| StaticFace | `Boolean` (Default: false) | **No**    | If false, the face condition will be adjusted by the block's current rotation. |
+
+**BlockFace Values**
+
+- `Up`
+- `Down`
+- `North`
+- `South`
+- `East`
+- `West`
+- `None`
+
+**BlockIdMatcher Fields**
+
+| Field Name | Type                                   | Required? | Notes                                                                      |
+| ---------- | -------------------------------------- | --------- | -------------------------------------------------------------------------- |
+| Id         | `Asset`<br />(Asset Type: `BlockType`) | **No**    | If provided, the block must match the specified `BlockType`.               |
+| State      | `String`                               | **No**    | If provided, the block's current state must match the provided state name. |
+| Tag        | `String`                               | **No**    | If provided, the block type's asset tags must contain the provided tag.    |
+
+### DestroyCondition
+
+This interaction fails if the current User entity cannot destroy the current target blcok.
+
+**DestroyCondition Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+
+### PlacementCountCondition
+
+This interaction accepts the name of a BlockType that has the TrackedPlacement BlockEntity. The interaction will fail if the number of
+blocks of the provided BlockType in the world do not match the provided condition.
+
+**PlacementCountCondition Fields**
+
+| Field Name | Type                           | Required? | Notes                                                                                                                                                                                                                                                           |
+| ---------- | ------------------------------ | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Block      | `String`                       | **Yes**   | The BlockType to examine. The number of instances of the BlockType in the world will be compared to Value.<br />**Note: The specified BlockType must have the TrackedPlacement BlockEntity. Otherwise, the number of blocks in the world will always be zero.** |
+| Value      | `Integer`<br />(Default: 0)    | **No**    | The value to compare the number of blocks in the world with.                                                                                                                                                                                                    |
+| LessThan   | \`Boolean<br />(Default: true) | **No**    | If true, the interaction will fail if the number of blocks in the world is greater than or equal to Value. If false, the interaction will fail if the number of blocks in the world is less than or equal to Value.                                             |
+
+### BreakBlock
+
+This interaction attempts to break the target block while acting as the User entity. The User entity must be a player. It
+is not guaranteed to work, depending on world settings and the User entity's current state, it may not work.  If it
+fails, it will fail the interaction under some circumstances, but not others.
+
+**Note: In particular, if `Harvest`=false and the player is in Survival mode, the player will simply execute a damage operation
+against the block. Even when the Tool field is specified, the player's currently-held item can impact the results in unintuitive
+ways.**
+
+This interaction will fail if there is no block target, if `Harvest`=true and the
+block is not harvestable, or if the world settings prevent the Harvest/Break operation.
+It will generally not fail otherwise, even if the block was not broken or damaged.
+The block will generally break every time if `Harvest`=true or the player is in
+Creative mode.
+
+**BreakBlock Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                                                                                                                                                                                                  |
+| ---------------- | ------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction.                                                                                                                                                                      |
+| Harvest          | `Boolean` (Default: false)      | **No**    | If true, harvest the block and deposit the drops in the player's inventory. This operation will generally always succeed.  If false, this interaction will effectively perform whatever action would have occurred if the player had left-clicked the block.                                           |
+| Tool             | `String`                        | **No**    | If `Harvest`=true, the player is in Survival mode, and this field is provided, then the break operation will be performed as though with this tool type.<br />**This field mostly doesn't work.  Your held item will be used for most block damage calculations regardless of this field's contents.** |
+| MatchTool        | `Boolean` (Default: false)      | **No**    | If true, `Harvest`=true, the player is in Survival mode, and `Tool` is provided, block breaking will be prevented unless `Tool` is a valid gathering tool for the target block. The interaction will not be failed, even if block breaking is prevented in this manner.                                |
+
+### ChangeBlock
+
+This interaction requires a mapping from one or more current BlockTypes to one or more target BlockTypes.  If the
+target block is one of the key BlockTypes, then it will be changed to the mapped target BlockType.  If the current
+BlockType of the target block does not appear as a key in the Changes field, then this interaction fails.
+
+**ChangeBlock Fields**
+
+| Field Name        | Type                                                        | Required? | Notes                                                                                                                             |
+| ----------------- | ----------------------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget  | `Boolean`<br />(Default: false)                             | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+| Changes           | `Map`<br />(Key Type: `BlockType`, Value Type: `BlockType`) | **No**    | A list of potential block type changes, with each entry having a current and new BlockType id.                                    |
+| WorldSoundEventId | `Asset`<br />(Asset Type: `SoundEvent`)                     | **No**    | If provided, this SoundEvent is played in the world at the position of the block if the block successfully changes.               |
+| RequireNotBroken  | `Boolean`<br />(Default: false)                             | **No**    | If true, this interaction will fail if the player's held item is broken (durability 0), and the block change will not take place. |
+
+### ChangeState
+
+This interaction requires a mapping from one or more current block state names to one or more state names. If the
+target block is in one of the key block states, then it will be changed to the mapped target blocks tate. If the
+current block state of the target block does nto appear as a key in the Changes field, then this interaction fails.
+
+All blocks start out with a null state by default.  This null state can be referenced by the key "default" and the block
+can be returned to that state with the value "default".
+
+**ChangeState Fields**
+
+| Field Name       | Type                                                  | Required? | Notes                                                                                                                                          |
+| ---------------- | ----------------------------------------------------- | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false)                       | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction.              |
+| Changes          | `Map`<br />(Key Type: `String`, Value Type: `String`) | **No**    | A list of potential block state changes, with each entry having a current and new state name.                                                  |
+| UpdateBlockState | `Boolean`<br />(Default: false)                       | **No**    | If true, performs a full refresh of the block's BlockEntity component and notifies nearby players as though a full block type change occurred. |
+
+### CycleBlockGroup
+
+This interaction will attempt to change the target block to the next block type in one of the BlockGroups it belongs to.
+If the block type belongs to multiple BlockGroups, which one is used is effectively arbitrary. The User entity must be
+a player. If the block cannot be changed for any reason (entity not a player, no block target, block does not belong
+to a BlockGroup, etc.). If the block is the only entry in the BlockGroup, this interaction will succeed and the block
+will be considered changed despite nothing happening.  Unlike most other block-changing interactions, this one will
+fail if the world settings prevent players from breaking blocks.
+
+**This interaction always reduces the player's held item's durability by a single 'hit' worth of damage if the block
+changes. There is no way to prevent it. The block type will change and the interaction will succeed even if the player's
+held item is broken, however.**
+
+**CycleBlockGroup Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+
+### DestroyBlock
+
+This interaction destroys the target block without dropping anything.  It will successfully destroy the block if the
+target block exists and this interaction has no failure conditions.
+
+**This interaction has no additional fields.**
+
+### PickBlock
+
+This interaction is effectively equivalent to using the middle mouse button in creative mode. In survival mode, the
+block's item will be moved to the user's current active hotbar slot if it is in the player's inventory.  This
+interaction is performed entirely on the client and cannot be performed by non-players.  It is unclear if this
+interaction has failure conditions.
+
+**PickBlock Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+
+### PlaceBlock
+
+This interaction is effectively identical to a right clicking while holding a block in their hand, with some
+additional options. For one, it can be executed with any LivingEntity as the User entity. For another, it has some
+useful fields.  For the most part, though, it follows the same behaviors and rules as any ordinary block placement
+by a player.
+
+It's not clear under what circumstances this interaction can fail. The server will not fail the interaction under any
+special circumstances (including when there is no target block, or when `BlockTypeToPlace` is not provided and the
+LivingEntity is not holding a block). However, the client is very involved with the function of this interaction and
+its behavior is unknown.
+
+**PlaceBlock Fields**
+
+| Field Name         | Type                                   | Required? | Notes                                                                                                                                                                                                                                                                                                                                                           |
+| ------------------ | -------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| BlockTypeToPlace   | `Asset`<br />(Asset Type: `BlockType`) | **No**    | If provided, the block placed by this interaction will be the specified BlockType. If not provided, the User entity's held item will be used, instead, if it is a block.                                                                                                                                                                                        |
+| RemoveItemInHand   | `Boolean`<br />(Default: True)         | **No**    | If true and the User entity is not a player in Creative mode, the item in the player's hand must match the block being placed and one quantity will be removed for each block placed. If the item does not match, the block cannot be placed.  If false, the player's hand item is ignored entirely.\*\*                                                        |
+| AllowDragPlacement | `Boolean`<br />(Default: True)         | **No**    | If true and the interaction was triggered on the client by a player, then the player can hold the input that was used to activate this interaction chain and move the mouse around in order to execute this interaction repeatedly and place several blocks. The interaction chain will not move onto the next interaction until the player releases the input. |
+
+### RunOnBlockTypes
+
+This interaction retrieves all blocks within a provided radius of the User entity. For each block that matches any of
+the provided BlockSets, a new interaction chain will be forked that uses the matching block as the target block.
+This interaction will continue executing until all forked interaction chains have completed.  The interaction will fail if no
+blocks within the radius match the provided BlockSets or if all of the forked interaction chains fail.
+
+**RunOnBlockTypes Fields**
+
+| Field Name   | Type                                         | Required?        | Notes                                                                                                                                                                                                                                                                                      |
+| ------------ | -------------------------------------------- | ---------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| Range        | `Integer`                                    | **Yes**          | The spherical radius around the User entity to search for blocks. Must be at least 1.                                                                                                                                                                                                      |
+| BlockSets    | `AssetArray`<br />(Element Type: `BlockSet`) | **No**           | A list of BlockSets to match nearby blocks again. Only blocks that match any of the BlockSets will have interaction chains forked for them.                                                                                                                                                |
+| MaxCount     | `Integer`                                    | **Yes**          | The maximum number of blocks that will be located with the search. Further blocks will be ignored. If there are more matching blocks within the radius than this number, the specific set of blocks that will be found is completely arbitrary and may change from execution to execution. |
+| Interactions | `Asset`<br />(Asset Type: `RootInteraction`) | **No, but yes.** | The RootInteraction that will be forked for each matching block.  This interaction will not fail to validate if it is missing, but every execution of this interaction will fail.                                                                                                          |
+
+### UseBlock
+
+If the target block has an interaction for this interaction chain's interaction type, execute it immediately as part of
+this interaction chain. The execution will be wrapped in UseBlockEvent.Pre and UseBlockEvent.Post events, and cancellations
+of the UserBlockEvent.Pre event are respected. The User entity is considered the triggering entity for both events.
+
+If the target block does not have an interaction for this interaction chain's interaction type, this interaction fails.
+
+**This interaction has no additional fields.**
+
+## Items
+
+These are interactions intended to interface with an entity's inventory. There is no concept of an "item target",
+unfortunately, so these generally either interact with the entity's held item or the entity's inventory at a high level.
+
+### AddItem
+
+Adds a specified quantity of a specified item to the User entity's inventory, preferring to add it to the
+entity's hotbar where possible. This interaction will have no effect on User entities that are not LivingEntities.
+This interaction has no failure states.
+
+**Note: This interaction has a bug in its field validators that will cause interactions that reference items declared
+in the same mod to fail validation on startup.  Additionally, this interaction has a bug that will cause it to
+fail and have no effect if the User entity has no block target. Use ModifyInventory instead.**
+
+**AddItem Fields**
+
+| Field Name       | Type                              | Required? | Notes                                                                                                                             |
+| ---------------- | --------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false)   | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+| ItemId           | `Asset`<br />(Asset Type: `Item`) | **Yes**   | The item id of the item to add to the player's inventory.                                                                         |
+| Quantity         | `Integer`<br />(Default: 0)       | **No**    | The quantity of the item to add to the player's inventory.                                                                        |
+
+### CheckUniqueItemUsage
+
+This interaction will check whether it has run once for the User entity with their currently-held item before. If it hasn't,
+it will succeed. If it has, it will fail. It will also fail if the User entity is not a player. The interaction will record
+the item id of the User entity's currently-held item on success, ensuring it cannot be successfully run with that player
+and item id combination again.
+
+**This interaction has no additional fields.**
+
+### ChangeActiveSlot
+
+This interaction does not inherit from SimpleInteraction and therefore has no Next or Failed fields.  The `CancelOnItemChange`
+field is ignored for this interaction and is always treated as false. This interaction will set the User entity's currently-
+active hotbar slot to the specified slot index. If none is specified, the interaction chain's target slot will be used,
+if any. Otherwise, slot 0 will be used.  If a slot is specified and it is already active, then this interaction will
+have no effect, but if no slot is specified and the interaction chain's target slot is already active, the logic in
+the next paragraph will still be executed. This interaction will also have no effect if the User entity is not a
+LivingEntity.
+
+Once the slot has changed, a new SwapTo interaction chain will be forked off for the selected slot.
+If a target slot was specified, then the interaction chain's current target slot will be set to the specified slot, as will
+the forked SwapTo interaction chain. If this interaction chain was initiated by a player swapping an item into or out of
+an occupied active hotbar slot, then the swap will be executed after the slot is changed and before the SwapTo
+interaction is forked. Not running this interaction in the resulting SwapFrom interaction chain is a way for the server
+to cancel players performing these sorts of swap interactions. The default behavior for these swap interactions is that
+the SwapFrom interaction chain will be initiated with the currently-active-slot as the target slot. As a result, the
+target slot will usually not change when this interaction runs, it merely exists as a signal for the server to continue the
+item swap.
+
+**ChangeActiveSlot Fields**
+
+| Field Name | Type      | Required? | Notes                                                                                                                                                                                                     |
+| ---------- | --------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| TargetSlot | `Integer` | **No**    | If not provided, indicates the slot the player's active hotbar slot should be changed to.  Otherwise, the interaction chain's target slot will be used (which is usually the already-active hotbar slot). |
+
+### EquipItem
+
+This interaction will equip the User entity's currently-held item into the appropriate armor slot, if it is armor. The
+interaction will fail if the item is armor but it cannot be equipped for some reason. The interaction will succeed but
+take no action if the User entity cannot equip armor or if the item is not armor.
+
+**This interaction has no additional fields.**
+
+### IncreaseBackpackCapacity
+
+This interaction will increase the User entity's backpack size by the provided amount.  **It will additionally remove one
+quantity from the player's currently-held item. There is no way to prevent this.**  This interaction will have no effect
+if the User entity is not a player.  This interaction has no special failure conditions, even if the User entity
+is not a player, or the player is not currently holding an item.
+
+| Field Name | Type                        | Required? | Notes                                                                                   |
+| ---------- | --------------------------- | --------- | --------------------------------------------------------------------------------------- |
+| Capacity   | `Integer`<br />(Default: 1) | **No**    | The additional backpack capacity to add to the player. **Must be between 1 and 32767.** |
+
+### ModifyInventory
+
+This interaction attempts to perform one or more inventory-modifying actions against the User entity. The User entity must
+be a player. If they are not, no actions will be performed, but the interaction will not fail. Any item removals performed
+by this interaction, either as a result of `ItemToRemove` or `AdjustHeldItemQuantity`, are both atomic (meaning the entire
+quantity must be removed, or none) and required (meaning that the interaction will fail and no further actions taken if
+the removal fails for any reason).  Item additions performed by this interaction, either as a result of `ItemToAdd` or
+`AdjustHeldItemQuantity` will drop excess items on the ground near the player if necesary and continue on.
+
+This interaction first executes the item removal in `ItemToRemove`, if any, then adjusts the held item as specified by
+`AdjustHeldItemQuantity`, if provided, then executes the item addition in `ItemToAdd`, if any, and then finally executes
+the damage/healing of the held item in `AdjustHeldItemDurability`, if provided.
+
+**ModifyDurability Fields**
+
+| Field Name               | Type                            | Required? | Notes                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
+| ------------------------ | ------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| RequiredGameMode         | `GameMode`                      | **No**    | If provided, only execute the inventory-modifying actions if the player is in the provided GameMode. The interaction will not fail if the GameMode doesn't match.                                                                                                                                                                                                                                                                                                                                                                               |
+| ItemToRemove             | `ItemStack`                     | **No**    | If provided, a matching item will be removed in the provided quantity. If there is no matching item in the player inventory in the required quantity, then the interaction will fail and further actions will not be executed.                                                                                                                                                                                                                                                                                                                  |
+| AdjustHeldItemQuantity   | `Integer`<br />(Default: 0)     | **No**    | The player's held item, if any, will have its quantity will be modified by the provided amount- subtracted from if this number is negative or added to if this item is positive.  If the player has no held item, then this field will have no effect regardless of its value and the interaction will NOT fail.  If the player's inventory does not have sufficient quantity of items to support the removal, this interaction will fail and further actions will not be executed. Excess items will be dropped on the ground near the player. |
+| ItemToAdd                | `ItemStack`                     | **No**    | If provided, the ItemStack will be added to the player's inventory. Excess items will be dropped on the ground near the player.                                                                                                                                                                                                                                                                                                                                                                                                                 |
+| AdjustHeldItemDurability | `Double`<br />(Default: 0.0)    | **No**    | The player's held item, if any, will have its durability adjusted by the specified amount.  The durability cannot go below 0 or raise above the item's maximum durability. Invalid durability values in this field will not cause the interaction to fail. Neither will it fail if the player has no held item.                                                                                                                                                                                                                                 |
+| BrokenItem               | `String`                        | **No**    | This field should contain an ItemId, but it is not validated by the server on startup, so be careful.  This field can have the value of "Empty" to specify no item, or an empty hand. If specified and the `AdjustHeldItemDurability` operation reduces the player's held item to 0 durability, the player's held item is changed to this ItemId. If the inventory replacement fails, this interaction will fail.                                                                                                                               |
+| NotifyOnBreak            | `Boolean`<br />(Default: false) | **No**    | If true and the `AdjustHeldItemDurability` operation reduces the player's held item to 0 durability, this interaction will perform the usual audiovisual feedback of a broken tool. It will play the usual tool breaking sound and send the player a text message in chat that their item has broken.                                                                                                                                                                                                                                           |
+| NotifyOnBreakMessage     | `String`                        | **No**    | If provided, and `NotifyOnBreak` is true, when the player is notified of a broken tool by this interaction, the message sent to their chat will instead be the translation key specified by this field. The translation key supports the templating parameter `{itemName}`. See the translation key `server.general.repair.itemBroken_Hoe` for an example.                                                                                                                                                                                      |
+
+**GameMode Values**
+
+- `Creative`: The game is currently in Creative Mode
+- `Adventure`: The game is currently in Adventure Mode
+
+**ItemStack Fields**
+
+| Field Name                   | Type                              | Required? | Notes                                                                                |
+| ---------------------------- | --------------------------------- | --------- | ------------------------------------------------------------------------------------ |
+| Id                           | `Asset`<br />(Asset Type: `Item`) | **Yes**   | The id of the Item asset this stack contains.                                        |
+| Quantity                     | `Integer`<br />(Default: 1)       | **No**    | The number of items in this stack.<br />**Must be greater than 0.**                  |
+| Durability                   | `Double`<br />(Default: 0.0)      | **No**    | The durability of the item stack.<br />**Cannot be negative.**                       |
+| MaxDurability                | `Double`<br />(Default: 0.0)      | **No**    | The maximum durability of the item this stack contains.<br />**Cannot be negative.** |
+| Metadata                     | `Bson Document`                   | **No**    | If provided, applies the bson to the item stack metadata.                            |
+| OverrideDroppedItemAnimation | `Boolean`\*(Default: false)       | **No**    | ???                                                                                  |
+
+### PickupItem
+
+This interaction will attempt to pick up the User entity's current target entity and add it to their inventory. It will
+fail if the User entity is not a player, if they do not have a target entity, or if the target entity is not an item
+located in the world.  It will not fail if the player simply cannot pick up the item.
+
+**This interaction has no additional fields.**
+
+### RefillContainer
+
+This interaction will fail if the User entity is not a player. The interaction will draw a ray from the player's head
+down their look direction until the edge of the player's held item's interaction range or until the first solid block.
+The nearest fluid block of a type listed in this interaction's `States` map will result in the one of the player's
+currently-held items being converted to the fluid's related item state.  If the `States` map indicates a durability
+for the new item state, then the converted item will use that durability. If the item is already in the fluid's related
+item state, then this interaction will fail if the player's held item is already at maximum durability (unless the
+`States` map indicates a durability value greater than the item's maximum, in which case the interaction will succeed
+but the item will not change).  Otherwise, the durability listed for the fluid in the `States` map will be added to the
+item's current durability.
+
+If the interaction has not failed by this point, the fluid block in the world may be transformed to a different type if one is listed
+in the `States` map.
+
+If any part of this process does not proceed for any reason (for instance, if the player is not holding an item),
+then this interaction will fail.
+
+**RefillContainer Fields**
+
+| Field Name | Type                                                       | Required? | Notes                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| ---------- | ---------------------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| States     | `Map`<br />(Key Type: `String`, Value Type: `RefillState`) | **Yes**   | A map from item state names to `RefillState` objects, which contain information such as acceptable fluid block types, durability increases, and what fluid type to convert the targeted fluid block to after refill, if any. If the player targets a fluid block that matches one of the fluid types in the `RefillState`, the item will be converted to the keyed item state and the `RefillState` will be used to decide what happens next. |
+
+**RefillState Fields**
+
+| Field Name     | Type                                  | Required? | Notes                                                                                                                                                                                                                                                                                                                           |
+| -------------- | ------------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| AllowedFluids  | `Array`<br />(Element Type: `String`) | **Yes**   | If any of these fluids are targeted by the player, the player's held item will be converted to the keyed item state and `Durability` and `TransformFluid` will be used.                                                                                                                                                         |
+| Durability     | `Double`<br />(Default: -1.0)         | **No**    | If the player's held item changes item states, this value is the new item's durability, unless it is negative, in which case the item will begin at full durability. If the player's held item is already in the item state, and the item is not already at full durability, this value will be added to the item's durability. |
+| TransformFluid | `String`                              | **No**    | If provided, this field is a fluid id that the targeted fluid block should be transformed to if the player's held item is successfully updated.                                                                                                                                                                                 |
+
+## Entities
+
+### DamageEntity
+
+This interaction does not inherit from SimpleInteraction, but adds its own Next and Failed fields that
+work similarly.
+
+This interaction will cause the User entity to damage the Target entity.  It has the capability to apply different
+damage based on the direction of the attack or what body part was targeted by the User entity, with each possibility
+providing different damage calculations, effects, and Next interaction. If multiple entires match the attack, `TargetedDamage`
+(body part damage) takes highest priority, then the first matching `AngledDamage` in the list, then the default
+damage in the base interaction fields.  It is possible for elements of these different damage priorities to be taken peacemeal if higher-priority
+damage fields do not overwrite lower-priority damage fields. For instance,
+damage calculation could be taken from `TargetedDamage`, the damage effects could be taken from the first matching
+`AngledDamage`, and the Next interaction coming from the default damage field.
+
+If all damage dealt by this interaction is cancelled, then this interaction will fail, and the `Failed` interaction
+will be executed next in the chain. If any damage dealt by this interaction is blocked, then this interaction will
+succeed, but the `Blocked` interaction wil lbe executed next in the chain. Otherwise, the highest-precedent matching
+`Next` interaction that you provide will be executed.  For instance, if you provide `Next` interactions for all
+`TargetedDamage` and `AngledDamage` entries, and one in the interaction's `Next` field, then a headshot could result
+in a unique `Next` interaction being executed, even if there is a matching `AngledDamage` entry. However, if you leave
+the `Next` interaction out of your `TargetedDamage` entries, a special `Next` interaction for backstabs could be
+executed.  Otherwise, the `Next` field in the root of the interaction will be executed instead.
+
+DamageEntity has an unusual relationship with `RunTime`. This interaction always ends immediately after its first tick,
+regardless of the status of `RunTime` or `WaitForAnimationToFinish`.  However, if damage dealt by this interaction is
+calculated as `DamageCalculatorType` `Dps`, then the `RunTime` will be used to determine the precise amount of damage to
+deal. If `RunTime` is 0, then no damage will be dealt.
+
+**DamageEntity Fields**
+
+| Field Name       | Type                                                          | Required?                                                                                                                    | Notes                                                                                                                                                                                                                                                                                                                                                                         |
+| ---------------- | ------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| DamageCalculator | `DamageCalculator`                                            | **No**                                                                                                                       | If provided, describes the damage amounts and types to apply to the Target entity.                                                                                                                                                                                                                                                                                            |
+| DamageEffects    | `DamageEffects`                                               | **No**                                                                                                                       | If provided, describes particles, sounds, knockback, etc. to apply to the target entity on damage.                                                                                                                                                                                                                                                                            |
+| Next             | `Asset`<br />(Asset Type: `Interaction`)                      | **No**  After this interaction has finished, "Next" will be executed if damage was dealt to the target and none was blocked. |                                                                                                                                                                                                                                                                                                                                                                               |
+| AngledDamage     | `Array`<br />(Element Type: `AngledDamage`)                   | **No**                                                                                                                       | If provided, allows alternative `DamageCalculator`, `DamageEffects`, and `Next` entries for attacks that approach the target from certain angles.                                                                                                                                                                                                                             |
+| TargetedDamage   | `Map`<br />(Key Type: `String`, Value Type: `TargetedDamage`) | **Yes**                                                                                                                      | This field must be provided, but is not required to have any entries.  This is a map from body part names to `TargetedDamage` values. Hypixel only uses one body part name: `Head`, and it is not clear whether there are others.  If provided, allows alternative `DamageCalculator`, `DamageEffects`, and `Next` entries for attacks that damage specific enemy body parts. |
+| EntityStatsOnHit | `Array`<br />(Element Type: `EntityStatOnHit`)                | **No**                                                                                                                       | If provided, allows this attack to reduce enemy stats other than health.  Each individual damage application dealt by the same ability will apply stat reductions, at diminishing returns. All damage dealt in interaction chains forked by a Selector interaction will share the number of hits across all targets.                                                          |
+| Failed           | `Asset`<br />(Asset Type: `Interaction`)                      | **No**                                                                                                                       | After this interaction has finished, "Failed" will be executed if no damage hits were applied to the player, or if all damage hits were cancelled.                                                                                                                                                                                                                            |
+| Blocked          | `Asset`<br />(Asset Type: `Interaction`)                      | **No**                                                                                                                       | After this interaction has finished, "Blocked" will be executed if any damage hits were blocked by the target.                                                                                                                                                                                                                                                                |
+
+**DamageCalculator Fields**
+
+| Field Name                | Type                                                      | Required? | Notes                                                                                                                                                                                                                                                 |
+| ------------------------- | --------------------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Type                      | `DamageCalculatorType`<br />(Default: Absolute)           | **No**    | Whether the damage being applied is `Absolute` or \`Dps'.                                                                                                                                                                                             |
+| Class                     | `DamageClass`<br />(Default: Unknown)                     | **No**    | The type of attack producing the damage. Some weapon systems apply equipment modifiers based on this value.                                                                                                                                           |
+| BaseDamage                | `Map`<br />(Key Type: `DamageCause`, Value Type: `Float`) | **No**    | A set of DamageCauses and how much base damage is dealt for each.                                                                                                                                                                                     |
+| SequentialModifierStep    | `Float`<br />(Default: 0.0)                               | **No**    | Value between 0.0-1.0. Each additional hit from a single ability will have its damage reduced by this much as a percentage. All damage dealt in interaction chains forked by a Selector interaction will share the number of hits across all targets. |
+| SequentialModifierMinimum | `Float`<br />(Default: 0.0)                               | **No**    | Value between 0.0-1.0. `SequentialModifierStep` cannot reduce damage below this percentage regardless of the number of hits.                                                                                                                          |
+| RandomPercentageModifier  | `Float`<br />(Default: 0.0)                               | **No**    | A random value between +/- this amount multiplied by the base damage will be added to the base damage.                                                                                                                                                |
+
+**DamageEffects Fields**
+
+| Field Name             | Type                                         | Required? | Notes                                                                                   |
+| ---------------------- | -------------------------------------------- | --------- | --------------------------------------------------------------------------------------- |
+| ModelParticles         | `Array`<br />(Element Type: `ModelParticle`) | **No**    | Particle systems to trigger in the first-person view.                                   |
+| WorldParticles         | `Array`<br />(Element Type: `WorldParticle`) | **No**    | Particle systems to trigger in the third-person view.                                   |
+| LocalSoundEventId      | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | 2D sound to play locally to the attacking entity if they are a player.                  |
+| WorldSoundEventId      | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | Sound to play in the world at the Target entity's location.                             |
+| PlayerSoundEventId     | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | 2D sound to play locally to the Target entity if they are a player.                     |
+| ViewDistance           | `Double`<br />(Default: 75.0)                | **No**    | Distance at which these effects should play for other players.                          |
+| Knockback              | `Knockback`                                  | **No**    | The properties of the knockback that will be applied.                                   |
+| CameraEffect           | `Asset`<br />(Asset Type: `CameraEffect`)    | **No**    | CameraEffect to briefly apply locally to the Target entity if they are a player.        |
+| StaminaDrainMultiplier | `Float`<br />(Default: 1.0)                  | **No**    | This multiplier is applied to the stamina cost incurred by the target blocking, if any. |
+
+**AngledDamage Fields**
+
+| Field Name       | Type                                     | Required? | Notes                                                                                                                                                                                                     |
+| ---------------- | ---------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| AngleDistance    | `Float`<br />(Default: 0)                | **No**    | The width in degrees of the matching arc around the Target entity. If the attack against the Target originates from within the arc, then the properties below will be applied to the attack, if provided. |
+| Angle            | `Float`<br />(Default: 0.0)              | **No**    | The angle in degrees around the Target entity at which the matching arc is centered.                                                                                                                      |
+| DamageCalculator | `DamageCalculator`                       | **No**    | If provided and the attack against the Target entity originates from within the provided arc, this DamageCalculator will override the interaction's `DamageCalculator` field.                             |
+| DamageEffects    | `DamageEffects`                          | **No**    | If provided and the attack against the Target entity originates from within the provided arc, this DamageEffects will override the interaction's `DamageEffects` field.                                   |
+| Next             | `Asset`<br />(Asset Type: `Interaction`) | **No**    | If provided and the attack against the Target entity originates from within the provided arc, this Interaction will override the interaction's `Next` field.                                              |
+
+**TargetedDamage Fields**
+
+| Field Name       | Type                                     | Required? | Notes                                                                                                                                                                                            |
+| ---------------- | ---------------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| DamageCalculator | `DamageCalculator`                       | **No**    | If provided and this TargetedDamage was matched, this DamageCalculator will override the interaction's `DamageCalculator` field and the `DamageCalculator` field of any matching `AngledDamage`. |
+| DamageEffects    | `DamageEffects`                          | **No**    | If provided and this TargetedDamage was matched, this DamageEffects will override the interaction's `DamageEffects` field and the `DamageEffects` field of any matching `AngledDamage`.          |
+| Next             | `Asset`<br />(Asset Type: `Interaction`) | **No**    | If provided and this TargetedDamage was matched, this Interaction will override the interaction's `Next` field and the `Next` field of any matching `AngledDamage`.                              |
+
+**EntityStatOnHit Fields**
+
+| Field Name                  | Type                                                                       | Required? | Notes                                                                                                                                                                                                                                                                                        |
+| --------------------------- | -------------------------------------------------------------------------- | --------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| EntityStatId                | `Asset`<br />(AssetType: `EntityStatType`)                                 | **Yes**   | Which entity stat to affect.                                                                                                                                                                                                                                                                 |
+| Amount                      | `Float`<br />(Default: 0.0)                                                | **No**    | How much of the stat to apply for each damage application. Use negative numbers to reduce stats.                                                                                                                                                                                             |
+| MultipliersPerEntitiesHit   | `Array`<br />(Element Type: `Float`, Default: `[1.0, 0.6, 0.4, 0.2, 0.1]`) | **No**    | The diminishing returns curve to be applied for multiple damage applications by the same ability. Each hit's stat impact will be multiplied by the next value in the list.  If there are more hits than array elements, subsequent hits will be multiplied by `MultiplierPerExtraEntityHit`. |
+| MultiplierPerExtraEntityHit | `Float`<br />(Default: 0.05)                                               | **No**    | If an ability carries out more damage applications than there are elements in the `MultipliersPerEntitiesHit` array, then subsequent stat values will be multiplied by this number.                                                                                                          |
+
+**Knockback Fields**
+
+| Field Name     | Type                                       | Required? | Notes                                                                                                                      |
+| -------------- | ------------------------------------------ | --------- | -------------------------------------------------------------------------------------------------------------------------- |
+| Type           | `String`                                   | **No**    | If provided, specifies a type of knockback to use. Each Target type may come with additional fields.                       |
+| Force          | `Double`<br />(Default: 0.0)               | **No**    | The amount of force to apply to the Owner entity.                                                                          |
+| Duration       | `Double`<br />(Default: 0.0)               | **No**    | If 0.0, apply the force as a single impulse.  If more, continuously apply the force over a period of time.                 |
+| VelocityType   | `ChangeVelocityType`<br />(Default: `Add`) | **No**    | How to apply the force, either adding it to the entity's current velocity, or setting the velocity to the knockback force. |
+| VelocityConfig | `VelocityConfig`                           | **No**    | Characteristics of friction as the Owner entity is thrown by this knockback.                                               |
+
+**Knockback Type: Force**
+
+Apply the calculated knockback force along the provided direction.
+
+| Field Name | Type                         | Required? | Notes                                                                                |
+| ---------- | ---------------------------- | --------- | ------------------------------------------------------------------------------------ |
+| Direction  | `Vector3`<br />(Default: Up) | **No**    | Which direction the entity should be flung, relative to the direction of the attack. |
+
+**Knockback Type: Point**
+
+Apply the calculated knockback force laterally along the XZ plane, plus provided Y velocity.
+
+| Field Name | Type                        | Required? | Notes                                                                                                   |
+| ---------- | --------------------------- | --------- | ------------------------------------------------------------------------------------------------------- |
+| OffsetX    | `Integer`<br />(Default: 0) | **No**    | Offset the source position of the knockback left or right perpendicular to the direction of the attack. |
+| OffsetZ    | `Integer`<br />(Default: 0) | **No**    | Offset the source position of the knockback, forward or backward along the directon of the attack.      |
+| RotateY    | `Integer`<br />(Default: 0) | **No**    | Rotate the knockback direction around the Y axis, where 0 is the default attack direction.              |
+| VelocityY  | `Float`<br />(Default: 0.0) | **No**    | Add vertical velocity to the knockback force after the direction and force has been calculated.         |
+
+**Knockback Type: Directional**
+
+Apply the calculated knockback force along the attack direction, removing any vertical component and replacing it with a provided Y velocity.
+
+| Field Name | Type                      | Required? | Notes                                                                                                                                            |
+| ---------- | ------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------ |
+| RelativeX  | `Float`<br />(Default: 0) | **No**    | Apply additional force left or right perpendicular to the direction of the attack. The additional force is multiplied by the knockback strength. |
+| RelativeZ  | `Float`<br />(Default: 0) | **No**    | Apply additional force forward or backward along the attack direction. The additional force is multiplied by the knockback strength.             |
+| VelocityY  | `Float`<br />(Default: 0) | **No**    | Replace the vertical velocity of the knockback with this value.  This value is not multiplied by knockback strength.                             |
+
+**VelocityConfig Fields**
+
+| Field Name          | Type                                              | Required? | Notes                                                                                                                                                                                           |
+| ------------------- | ------------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| GroundResistance    | `Float`<br />(Default: 0.82)                      | **No**    | The minimum amount of friction applied when the entity is in contact with the ground.  1.0 = no friction, 0.0 = total friction                                                                  |
+| GroundResistanceMax | `Float`<br />(Default: 0.0)                       | **No**    | The maximum amount of friction applied when the entity is in contact with the ground.  1.0 = no friction, 0.0 = total friction                                                                  |
+| AirResistance       | `Float`<br />(Default: 0.96)                      | **No**    | The minimum amount of friction applied when the entity is in the air. 1.0 = no friction, 0.0 = total friction                                                                                   |
+| AirResistanceMax    | `Float`<br />(Default: 0.0)                       | **No**    | The maximum amount of friction applied when the entity is in the air. 1.0 = no friction, 0.0 = total friction                                                                                   |
+| Threshold           | `Float`<br />(Default: 1.0)                       | **No**    | The speed at which the maximum amount of friction will be applied to the entity. The amount of friction applied will increase from minimum to maximum as the entity moves from 0 to this speed. |
+| Style               | `VelocityThresholdStyle`<br />(Default: `Linear`) | **No**    | The curve that friction follows as the entity's speed increases toward the `Threshold`.                                                                                                         |
+
+**DamageCalculatorType Values**
+
+- `Absolute`
+- `Dps`
+
+**DamageClass Values**
+
+- `Unknown`
+- `Light`
+- `Charged`
+- `Signature`
+
+**ChangeVelocityType Values**
+
+- `Add`
+- `Set`
+
+**VelocityThresholdStyle Values**
+
+- `Linear`
+- `Exp`
+
+### LaunchProjectile
+
+This is just a worse version of Projectile and is slated to be removed.  Use Projectile.
+
+### Projectile
+
+This interaction will spawn a new projectile at the User entity's eye position that will travel in its look direction.
+
+| Field Name | Type                                          | Required? | Notes                                                  |
+| ---------- | --------------------------------------------- | --------- | ------------------------------------------------------ |
+| Config     | `Asset`<br />(Asset Type: `ProjectileConfig`) | **No**    | Configuration describing the projectile to be spawned. |
+
+### RemoveEntity
+
+Despawns the specified entity from the world. This interaction will have no effect if the specified entity is a player. This
+interaction has no special failure conditions.
+
+| Field Name | Type                                     | Required? | Notes                  |
+| ---------- | ---------------------------------------- | --------- | ---------------------- |
+| Entity     | `InteractionTarget`<br />(Default: User) | **No**    | The entity to despawn. |
+
+**InteractionTarget Values**
+
+- `User` - The user of this interaction chain. The entity whose actions caused this interaction chain to be executed. This is usually the same as the Owner.
+- `Owner` - The owner of this interaction chain. The entity upon whom this interaction chain is executing.
+- `Target` - The entity target of this interaction chain, if any.  This value is mutable (and can therefore come from many places) but most commonly, it is an entity the User was targeting when this interaction chain began executing.
+
+### SendMessage
+
+This interaction sends a message to the Owner entity if that entity can receive messages.  Otherwise, the message
+is written to the server logs.  If the entity is a player, the message will appear in the player's chat window.
+
+\*\*SendMessage
+
+| Field Name | Type     | Required? | Notes                                                                                                                 |
+| ---------- | -------- | --------- | --------------------------------------------------------------------------------------------------------------------- |
+| Message    | `String` | **No**    | A text message to be sent to the Owner entity.  If this field is not provided, `Key` is used instead.                 |
+| Key        | `String` | **No**    | A translation key for a message to be sent to the Owner entity. If `Message` is provided, then this field is ignored. |
+
+### UseEntity
+
+This interaction is not in use by Hypixel and has some unusual qualities that mean it probably won't do what you want it
+to.  Do not use it.
+
+This interaction will retrieve the entity currently targeted by the client (NOT the interaction chain's current Target
+entity) and execute that entity's RootInteraction for this interaction chain's current interaction type. The
+RootInteraction will be executed as part of this current interaction chain. None of the properties of this interaction
+chain will be modified.
+
+This interaction will fail if the client is not currently targeting an entity, or if no interaction for the current
+interaction type exists on the entity.
+
+## Stats
+
+Hytale's resource system has been written about fairly extensively.  You can use these interactions to modify stats in
+response to actions or use stats as a cost for abilities.
+
+### ChangeStat
+
+This interaction applies a set of raw stat changes to the User entity. It has no special failure conditions.
+
+| Field Name    | Type                                                         | Required? | Notes                                                                                                                                                                                                                      |
+| ------------- | ------------------------------------------------------------ | --------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| StatModifiers | `Map`<br />(Key Type: `EntityStatType`, Value Type: `Float`) | **Yes**   | A set of stats to modify and what value to apply to them.                                                                                                                                                                  |
+| ValueType     | `ValueType`<br />(Default: Absolute)                         | **No**    | Whether the values in the `StatModifiers` map represent flat values to apply to the stat total, or percentages (0.0-100.0). Percentage values are percentage of the difference between the maximum and minimum stat value. |
+| Behaviour     | `ChangeStatBehavior`<br />(Default: Add)                     | **No**    | Whether the values in the `StatModifiers` map represent deltas to add into the User entity's current stat values, or fixed values to set the entity's stats to.                                                            |
+
+**ValueType Values**
+
+- `Absolute`
+- `Percent`
+
+**ChangeStatBehaviour Values**
+
+- `Add`
+- `Set`
+
+### ChangeStatWithModifier
+
+This interaction is like ChangeStat, except an armor stat modifier can be chosen which will apply bonuses and penalties
+to a stat from the User entity's equipped armor before it is applied.
+
+| Field Name            | Type                                                         | Required? | Notes                                                                                                                                                                                                                      |
+| --------------------- | ------------------------------------------------------------ | --------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| StatModifiers         | `Map`<br />(Key Type: `EntityStatType`, Value Type: `Float`) | **Yes**   | A set of stats to modify and what value to apply to them.                                                                                                                                                                  |
+| ValueType             | `ValueType`<br />(Default: Absolute)                         | **No**    | Whether the values in the `StatModifiers` map represent flat values to apply to the stat total, or percentages (0.0-100.0). Percentage values are percentage of the difference between the maximum and minimum stat value. |
+| Behaviour             | `ChangeStatBehavior`<br />(Default: Add)                     | **No**    | Whether the values in the `StatModifiers` map represent deltas to add into the User entity's current stat values, or fixed values to set the entity's stats to.                                                            |
+| InteractionModifierId | `InteractionModifierId`                                      | **Yes**   | The armor interaction modifier to apply bonuses and penalties for.                                                                                                                                                         |
+
+**ValueType Values**
+
+- `Absolute`
+- `Percent`
+
+**ChangeStatBehaviour Values**
+
+- `Add`
+- `Set`
+
+**InteractionModifierId Values**
+
+- `Dodge`
+
+### StatsCondition
+
+This interaction will fail if the User entity cannot afford the specified stats costs, or if it does not have the
+requested stats.
+
+| Field Name | Type                                                         | Required? | Notes                                                                                                                                                                                    |
+| ---------- | ------------------------------------------------------------ | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Costs      | `Map`<br />(Key Type:` EntityStatType`, Value Type: `Float`) | **Yes**   | A set of costs that the User entity needs to be able to afford for this interaction to succeed.                                                                                          |
+| ValueType  | `ValueType`<br />(Default: Absolute)                         | **No**    | Whether the values in the `Costs` map represetn flat values or percentages (0.0-100.0).  Percentage values are percentage of the difference between the maximum and minimum value.       |
+| LessThan   | `Boolean`<br />(Default: false)                              | **No**    | If true, this interaction will fail unless the User entity's current stat values are at or **below** the specified levels.  If false, they must be at or **above** the specified levels. |
+| Lenient    | `Boolean`<br />(Default: false)                              | **No**    | If true and `LessThan` is true, and a player's minimum stat value is below zero, then the player can afford a stat cost if the current value of a stat if above 0.                       |
+
+**ValueType Values**
+
+- `Absolute`
+- `Percent`
+
+### StatsConditionWithModifier
+
+This interaction is like StatsCondition, except an armor stat modifier can be chosen which will apply bonuses and penalties
+to a stat's cost from the User entity's equipped armor before it is compared.
+
+| Field Name            | Type                                                         | Required? | Notes                                                                                                                                                                                    |
+| --------------------- | ------------------------------------------------------------ | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Costs                 | `Map`<br />(Key Type:` EntityStatType`, Value Type: `Float`) | **Yes**   | A set of costs that the User entity needs to be able to afford for this interaction to succeed.                                                                                          |
+| ValueType             | `ValueType`<br />(Default: Absolute)                         | **No**    | Whether the values in the `Costs` map represetn flat values or percentages (0.0-100.0).  Percentage values are percentage of the difference between the maximum and minimum value.       |
+| LessThan              | `Boolean`<br />(Default: false)                              | **No**    | If true, this interaction will fail unless the User entity's current stat values are at or **below** the specified levels.  If false, they must be at or **above** the specified levels. |
+| Lenient               | `Boolean`<br />(Default: false)                              | **No**    | If true and `LessThan` is true, and a player's minimum stat value is below zero, then the player can afford a stat cost if the current value of a stat if above 0.                       |
+| InteractionModifierId | `InteractionModifierId`                                      | **Yes**   | The armor interaction modifier to apply bonuses and penalties for.                                                                                                                       |
+
+**ValueType Values**
+
+- `Absolute`
+- `Percent`
+
+**InteractionModifierId Values**
+
+- `Dodge`
+
+## EntityEffects
+
+EntityEffects are buff or debuff effects that can be applied to a LivingEntity.  These can have a variety of effects from
+movement speed changes to periodic damage.
+
+### EffectCondition
+
+This interaction will fail if the specified entity's EntityEffects do not match the provided conditions.
+
+**EffectCondition Fields**
+
+| Field Name      | Type                                             | Required? | Notes                                                                                                                                                                                                             |
+| --------------- | ------------------------------------------------ | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Entity          | `InteractionTarget`<br />(Default: User)         | **Yes**   | The entity to examine for EntityEffects. This field can indicate the Owner, User, or Target of this interaction chain.                                                                                            |
+| Match           | `Match`<br />(Default: All)                      | **No**    | If `All`, then this interaction will fail if any EntityEffect in the `EntityEffectIds` is not on the specified entity. If `None`, then this interaction will fail if any EntityEffect IS on the specified entity. |
+| EntityEffectIds | `AssetArray`<br />(Element Type: `EntityEffect`) | **Yes**   | The set of EntityEffects to check against the specified entity and `Match`.                                                                                                                                       |
+
+**InteractionTarget Values**
+
+- `User` - The user of this interaction chain. The entity whose actions caused this interaction chain to be executed. This is usually the same as the Owner.
+- `Owner` - The owner of this interaction chain. The entity upon whom this interaction chain is executing.
+- `Target` - The entity target of this interaction chain, if any.  This value is mutable (and can therefore come from many places) but most commonly, it is an entity the User was targeting when this interaction chain began executing.
+
+**Match Values**
+
+- `All` - All EntityEffects must be on the specified entity for this interaction to succeed.
+- `None` - None of the EntityEffects must be on the specified entity for this interaction to succeed.
+
+### ApplyEffect
+
+This interaction will apply the specified EntityEffect to the specified Entity.  It has no special failure conditions.
+
+**ApplyEffect Fields**
+
+| Field Name | Type                                      | Required? | Notes                                                                                                                  |
+| ---------- | ----------------------------------------- | --------- | ---------------------------------------------------------------------------------------------------------------------- |
+| Entity     | `InteractionTarget`<br />(Default: User)  | **Yes**   | The entity to apply the EntityEffect to. This field can indicate the Owner, User, or Target of this interaction chain. |
+| EffectId   | `Asset`<br />(Asset Type: `EntityEffect`) | **Yes**   | The effect to apply.                                                                                                   |
+
+**InteractionTarget Values**
+
+- `User` - The user of this interaction chain. The entity whose actions caused this interaction chain to be executed. This is usually the same as the Owner.
+- `Owner` - The owner of this interaction chain. The entity upon whom this interaction chain is executing.
+- `Target` - The entity target of this interaction chain, if any.  This value is mutable (and can therefore come from many places) but most commonly, it is an entity the User was targeting when this interaction chain began executing.
+
+### ClearEntityEffect
+
+This interaction will remove the specified EntityEffect from the specified Entity. It has no special failure conditions.
+It will not fail if the Entity does not have the EntityEffect.
+
+**ClearEntityEffect Fields**
+
+| Field Name | Type                                      | Required? | Notes                                                                                                                     |
+| ---------- | ----------------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------- |
+| Entity     | `InteractionTarget`<br />(Default: User)  | **Yes**   | The entity to remove the EntityEffect from. This field can indicate the Owner, User, or Target of this interaction chain. |
+| EffectId   | `Asset`<br />(Asset Type: `EntityEffect`) | **Yes**   | The effect to remove.                                                                                                     |
+
+**InteractionTarget Values**
+
+- `User` - The user of this interaction chain. The entity whose actions caused this interaction chain to be executed. This is usually the same as the Owner.
+- `Owner` - The owner of this interaction chain. The entity upon whom this interaction chain is executing.
+- `Target` - The entity target of this interaction chain, if any.  This value is mutable (and can therefore come from many places) but most commonly, it is an entity the User was targeting when this interaction chain began executing.
+
+## Farming
+
+These are interaction types built to support the in-game farming system in Hytale. They are mostly block-related interactions
+with a few exceptions.
+
+### ChangeFarmingStage
+
+If the target block is a farming block, this interaction will attempt to modify the current farming stage in one of
+three ways.  The interaction can optionally specify which StageSet to use for the new stage. If it is not specified,
+the current StageSet will be used. If any part of the the process of changing the growth stage fails, this interaction
+will fail, with the one exception that attempting to set the stage to the crop's existing stage will have no effect but
+still succeed.
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                                                                                                                                                                          |
+| ---------------- | ------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction.                                                                                                                                              |
+| StageSet         | `String`                        | **No**    | If provided, set the block's current stage to one in the provided StageSet. Otherwise, use the crop's current StageSet.                                                                                                                                                        |
+| Increase         | `Integer`                       | **No**    | If provided, increase the current stage by the specified amount. If the specified stage does not exist, the block will be set to the closest extant stage.                                                                                                                     |
+| Decrease         | `Integer`                       | **No**    | If provided and `Increase` is not provided, decrease the current stage by the specified amount. If the specified stage does not exist, the block will be set to the closest extant stage.                                                                                      |
+| Stage            | `Integer`<br />(Default: -1)    | **No**    | If provided and `Increase`/`Decrease` are not provided, set the current stage to the specified stage. If this value is less than 0, set the current stage to the final growth stage. If the specified stage does not exist, the block will be set to the closest extant stage. |
+
+### FertilizeSoil
+
+If the target block is unfertilized tilled soil or a farming block on top of unfertilized tilled soil, fertilizes the soil.
+The interaction will fail otherwise.
+
+**FertilizeSoil Fields**
+
+| Field Name       | Type                                  | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false)       | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+| RefreshModifiers | `Array`<br />(Element Type: `String`) | **No**    | Does nothing.                                                                                                                     |
+
+### HarvestCrop
+
+This interaction will attempt to execute the harvest action on the current block target and add the crop's drops to the User entity's
+inventory.  The block will either be destroyed or set to its post-harvest growth stage, depending on the farming
+configuration of the block.  This will happen (and the player will receive the full harvest drops) regardless of the
+block's current growth stage. This interaction has no special failure conditions, even if the block target isn't a
+farming block or gathering isn't permitted in the current world, but nothing will occur in those cases.
+
+**HarvestCrop Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+
+### UseWateringCan
+
+If the target block is tilled soil or a farming block on top of tilled soil, waters the soil for the specified duration.
+The interaction will fail otherwise.
+
+**UseWateringCan Fields**
+
+| Field Name       | Type                                  | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false)       | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+| Duration         | `Integer`<br />(Default: 0)           | **No**    | The duration in seconds to water the soil for.                                                                                    |
+| RefreshModifiers | `Array`<br />(Element Type: `String`) | **No**    | Does nothing.                                                                                                                     |
diff --git a/content/docs/ja-JP/contributing/pr-guidelines.mdx b/content/docs/ja-JP/contributing/pr-guidelines.mdx
index 7c1e17d9..33fb3de8 100644
--- a/content/docs/ja-JP/contributing/pr-guidelines.mdx
+++ b/content/docs/ja-JP/contributing/pr-guidelines.mdx
@@ -19,6 +19,8 @@ description: プルリクエストの提出時とレビュー時に、コント
 4. **コードの品質**
    - コードがプロジェクトのコーディング基準とベストプラクティスに従っていることを確認してください。
    - 複雑なロジックの説明が必要な箇所にはコメントを付けてください。
+   - Always test your changes locally before submitting the PR to catch any issues early.
+   - Format your code using `bun format` to maintain consistency across the codebase.
 5. **テスト**
    - PRを提出する前に、変更を徹底的にテストしてください。
    - 該当する場合は、変更を検証するための単体テストまたは統合テストを含めてください。
diff --git a/content/docs/ja-JP/contributing/translate.mdx b/content/docs/ja-JP/contributing/translate.mdx
new file mode 100644
index 00000000..c62ffdde
--- /dev/null
+++ b/content/docs/ja-JP/contributing/translate.mdx
@@ -0,0 +1,74 @@
+---
+title: Translate
+description: How to translate HytaleModding to your language
+---
+
+# Translating HytaleModding
+
+HytaleModding is translated with the help of the community using **Crowdin**. If you want to help translate or improve existing translations, this is the right place.
+
+## Steps to Translate
+
+All translations are managed **via Crowdin**.
+
+1. Visit [our Crowdin project](https://crowdin.com/project/hytalemodding) and log in if required.
+2. Click on your language.
+3. Click on the file/article you wish to translate. We recommend starting with Official Documentation, and then Server Plugin Documentation.
+4. Start translating!
+5. Approved translations will appear on the website.
+
+### Video Guide
+
+<iframe src="https://www.youtube.com/embed/NHiG1rDRgks" allowFullScreen />
+
+## How to discuss
+
+You can always report issues or discuss specific topics directly on Crowdin, but we recommend using Discord instead of the Crowdin comment system to keep everything organized in one place.
+
+1. Join [our Discord](https://discord.gg/hytalemodding)
+2. Open `#translations` channel. Here you can discuss or ask questions that are not related to a specific language.
+3. If you want to join a thread, you are required to run `/translator <your-language>` command here. The bot will add you to the thread for your language.
+
+## Translation Guidelines
+
+- You need to be confident in what you are translating. You should be able to read the text you just translated and understand the meaning of it very easily.
+- It should use the simplest form of language possible. Use English words if the translation is unknown to the majority in your country.
+- Use your imagination, trust yourself. Feel free to change any context as you wish as long as it can still get the same point across and is understandable.
+- These guidelines are more important than language-specific guidelines, but less important than Hytale terminology and rules.
+
+## What not to translate
+
+We request you all to not translate these specific sections of the website:
+
+### Callout types
+
+Callouts are the boxes that contain important information. We request you to not translate the types as they only work in English.
+
+**Example:**
+
+```mdx
+<Callout type="warning" title="Translate this title!">
+Translate the text inside the callout!
+</Callout>
+```
+
+In this example, please don't translate the word warning, the rest you can translate.
+
+### Icons
+
+Icon names must not be translated.
+They are technical identifiers mapped directly to existing icons. Translating them will break the icon rendering.
+
+```mdx
+icon: Globe
+```
+
+---
+
+{/* 
+For translators who will edit this page:
+
+- You are required to translate the Guidelines as they change.
+- General guidelines should be translated but not edited.
+- Learn how to use Markdown from writing_guides.mdx
+*/}
diff --git a/content/docs/ja-JP/established-information/server-plugin-insights.mdx b/content/docs/ja-JP/established-information/server-plugin-insights.mdx
index b56d1c89..ecd6dd8c 100644
--- a/content/docs/ja-JP/established-information/server-plugin-insights.mdx
+++ b/content/docs/ja-JP/established-information/server-plugin-insights.mdx
@@ -15,7 +15,7 @@ description: Slikey氏は、2025年12月15日にサーバーのコードにつ
 
 ### ライセンス
 
-The license permits usage for any **hytale related** things, so as long as you don't use the server / source to make your own game or sell their algorithms.
+Hytaleの利用規約(ライセンス)は、サーバーのソースコードをあらゆる **Hytaleに関連するもの** に許可しています。サーバーやソースコードを自身のゲームを作るのに利用したり、アルゴリズムを売ったりすることは禁止されています。
 
 # 権限システム
 
@@ -79,9 +79,8 @@ public interface IWorldGen {
 
 ![言語キーを格納するための定数](/assets/constants.png)
 
-> you can completely customize the chunk storage provider, we for example made one that is just empty where it doesn't load any chunks from disk
-> you could add an MySQLChunkStorageProvider and it could read the data from a database
-> and the same goes for worldgen, you can simply implement this interface to generate a world generator - slikey
+> チャンクのストレージプロバイダーを完全にカスタマイズすることもできます。例として、ディスクからチャンクを一切読み込まない空のストレージプロバイダーを作ります。
+> 例えば MySQLChunkStorageProvider (MySQLを利用したチャンクのストレージプロバイダー) を追加することができるし、ワールド生成でも同様です。ワールド生成器を作るためにはこのインターフェースを実装するだけです。 - slikey
 
 ![Chunks 1](/assets/chunks-1.png)
 ![Chunks 2](/assets/chunks-2.png)
diff --git a/content/docs/ja-JP/established-information/server/content-categories/art-assets.mdx b/content/docs/ja-JP/established-information/server/content-categories/art-assets.mdx
index d7e9c8f6..f671f280 100644
--- a/content/docs/ja-JP/established-information/server/content-categories/art-assets.mdx
+++ b/content/docs/ja-JP/established-information/server/content-categories/art-assets.mdx
@@ -14,7 +14,7 @@ Hytaleは3Dモデリングとテクスチャ制作を全面的にサポートし
 Hytaleは3Dモデリングとアニメーションの制作に**Blockbench**をメインに使用しています。
 
 * **公式サポート**：Hytaleのモデル、テクスチャ、アニメーションに使用されています。
-* **独自のプラグイン**：Hytaleには専用のBlockbenchプラグインが用意されます。これはできるだけ早くリリースされます。
+* **Special plugin**: Hytale has a dedicated [Blockbench Plugin](https://www.blockbench.net/plugins/hytale_plugin).
 * **直接的な互換性**：Blockbench内で直接Hytaleのモデル、テクスチャ、アニメーションを作成することができます
 * **古いツールを置き換える**：コミュニティで親しまれてきた方法をサポートするため、古いモデリングソフトを置き換えます。
 * **安全機能**：互換性のある要素だけをエンジンに追加できるので、破損の心配はありません。
diff --git a/content/docs/ja-JP/guides/ecs/block-components.mdx b/content/docs/ja-JP/guides/ecs/block-components.mdx
new file mode 100644
index 00000000..ca68b38a
--- /dev/null
+++ b/content/docs/ja-JP/guides/ecs/block-components.mdx
@@ -0,0 +1,247 @@
+---
+title: Block Components
+description: Learn how to use the block components.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+  - name: oskarscot
+    link: https://oskar.scot
+---
+
+# Overview
+
+In this guide, you'll learn how to use block components to create a ticking block.
+
+<Callout>
+  For a more complete reference, you may also want to review FarmingSystems.Ticking, as much of the underlying logic is based on its implementation.
+</Callout>
+
+## Steps
+
+### 1. ExampleBlock - holds block behavior
+
+```java
+public class ExampleBlock implements Component<ChunkStore> {
+
+    public static final BuilderCodec CODEC = BuilderCodec.builder(ExampleBlock.class, ExampleBlock::new).build();
+
+    // Components usually require a copy constructor as well but since we don't actually hold any data in this component this is not neccessary
+    public ExampleBlock() { }
+
+    public static ComponentType getComponentType() {
+        return ExamplePlugin.get().getExampleBlockComponentType();
+    }
+
+    @Nullable
+    public Component<ChunkStore> clone() {
+        return new ExampleBlock();
+    }
+}
+```
+
+ExampleBlock is a custom component that stores the behavior and data for your ticking block. Here, it simply places an Ice Block at x + 1 relative to its current position when it ticks.
+
+---
+
+### 2. ExampleInitializer - marks blocks as ticking when placed
+
+```java
+public class ExampleInitializer extends RefSystem {
+
+    @Override
+    public void onEntityAdded(@Nonnull Ref ref, @Nonnull AddReason reason, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+        BlockModule.BlockStateInfo info = (BlockModule.BlockStateInfo) commandBuffer.getComponent(ref, BlockModule.BlockStateInfo.getComponentType());
+        if (info == null) return;
+
+        ExampleBlock generator = (ExampleBlock) commandBuffer.getComponent(ref, ExamplePlugin.get().getExampleBlockComponentType());
+        if (generator != null) {
+            int x = ChunkUtil.xFromBlockInColumn(info.getIndex());
+            int y = ChunkUtil.yFromBlockInColumn(info.getIndex());
+            int z = ChunkUtil.zFromBlockInColumn(info.getIndex());
+
+            WorldChunk worldChunk = (WorldChunk) commandBuffer.getComponent(info.getChunkRef(), WorldChunk.getComponentType());
+            if (worldChunk != null) {
+				worldChunk.setTicking(x, y, z, true);
+            }
+        }
+    }
+
+    @Override
+    public void onEntityRemove(@Nonnull Ref ref, @Nonnull RemoveReason reason, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+    }
+
+    @Override
+    public Query getQuery() {
+        return Query.and(BlockModule.BlockStateInfo.getComponentType(), ExamplePlugin.get().getExampleBlockComponentType());
+    }
+}
+```
+
+ExampleInitializer is a RefSystem that reacts when block entities with the ExampleBlock component are added or removed. This is crucial for marking blocks as ticking when they're first placed.
+
+**Key Points:**
+
+- Tells the game that this block should tick, allowing `ExampleSystem` to process it.
+
+```java
+worldChunk.setTicking(x, y, z, true);
+```
+
+---
+
+### 3. ExampleSystem - handles ticking
+
+```java
+public class ExampleSystem extends EntityTickingSystem {
+
+    public void tick(float dt, int index, @Nonnull ArchetypeChunk archetypeChunk, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+        BlockSection blocks = (BlockSection) archetypeChunk.getComponent(index, BlockSection.getComponentType());
+
+        assert blocks != null;
+
+        if (blocks.getTickingBlocksCountCopy() != 0) {
+            ChunkSection section = (ChunkSection) archetypeChunk.getComponent(index, ChunkSection.getComponentType());
+
+            assert section != null;
+
+            BlockComponentChunk blockComponentChunk = (BlockComponentChunk) commandBuffer.getComponent(section.getChunkColumnReference(), BlockComponentChunk.getComponentType());
+
+            assert blockComponentChunk != null;
+
+            blocks.forEachTicking(blockComponentChunk, commandBuffer, section.getY(), (blockComponentChunk1, commandBuffer1, localX, localY, localZ, blockId) -> {
+                Ref<ChunkStore> blockRef = blockComponentChunk.getEntityReference(ChunkUtil.indexBlockInColumn(localX, localY, localZ));
+                if (blockRef == null) {
+                    return BlockTickStrategy.IGNORED;
+                } else {
+                    ExampleBlock exampleBlock = (ExampleBlock) commandBuffer1.getComponent(blockRef, ExampleBlock.getComponentType());
+                    if (exampleBlock != null) {
+                        WorldChunk worldChunk = (WorldChunk) commandBuffer.getComponent(section.getChunkColumnReference(), WorldChunk.getComponentType());
+                        World world = worldChunk.getWorld();
+
+                        int globalX = localX + (worldChunk.getX() * 32);
+                        int globalZ = localZ + (worldChunk.getZ() * 32);
+
+                        // We need to execute setBlock on the world thread as you cannot call store functions from a system
+                        // This is because of the architecture of the server, depending on your needs you can also use the CommandBuffer
+                        world.execute(() -> {
+                            world.setBlock(globalX + 1, localY, globalZ, "Rock_Ice");
+                        });
+
+                        return BlockTickStrategy.CONTINUE;
+
+                    } else {
+                        return BlockTickStrategy.IGNORED;
+                    }
+                }
+            });
+        }
+    }
+
+    @Nullable
+    public Query getQuery() {
+        return Query.and(BlockSection.getComponentType(), ChunkSection.getComponentType());;
+    }
+}
+```
+
+ExampleSystem is an EntityTickingSystem that runs every tick to execute the logic for all ticking blocks with the ExampleBlock component.
+
+**Key Points:**
+
+- **Get the block component**
+
+```java
+ExampleBlock exampleBlock = (ExampleBlock) commandBuffer.getComponent(blockRef, ExampleBlock.getComponentType());
+```
+
+- **Convert local chunk coordinates to world coordinates**
+
+```java
+int globalX = localX + (worldChunk.getX() * 32);
+int globalZ = localZ + (worldChunk.getZ() * 32);
+```
+
+- **Run the block logic**
+
+```java
+exampleBlock.runBlockAction(globalX, localY, globalZ, worldChunk.getWorld());
+```
+
+- **Keep the block ticking in the next tick**
+
+```java
+return BlockTickStrategy.CONTINUE;
+```
+
+---
+
+### 4. ExamplePlugin - registers components and systems
+
+```java
+public class ExamplePlugin extends JavaPlugin {
+    protected static ExamplePlugin instance;
+    private static final HytaleLogger LOGGER = HytaleLogger.forEnclosingClass();
+    private ComponentType exampleBlockComponentType;
+
+    public static ExamplePlugin get() {
+        return instance;
+    }
+
+    public ExamplePlugin(@Nonnull JavaPluginInit init) {
+        super(init);
+        LOGGER.atInfo().log("Hello from " + this.getName() + " version " + this.getManifest().getVersion().toString());
+    }
+
+    @Override
+    protected void setup() {
+        instance = this;
+        LOGGER.atInfo().log("Setting up plugin " + this.getName());
+        this.exampleBlockComponentType = this.getChunkStoreRegistry().registerComponent(ExampleBlock.class, "ExampleBlock", ExampleBlock.CODEC);
+    }
+	
+	@Override
+	protected void start() {
+		this.getChunkStoreRegistry().registerSystem(new ExampleSystem());
+		this.getChunkStoreRegistry().registerSystem(new ExampleInitializer());
+	}
+
+    public ComponentType getExampleBlockComponentType() {
+        return this.exampleBlockComponentType;
+    }
+}
+```
+
+---
+
+### 5. Configure In-Game
+
+![block-component-1](/assets/guides/block-component-1.png)
+
+![block-component-2](/assets/guides/block-component-2.png)
+
+With this logic, the block will now continuously place an Ice Block at the coordinates x + 1 relative to its current position every time it ticks.
+
+---
+
+## Common Issues
+
+### NullPointerException on Startup
+
+**Error message:**
+
+```java
+java.lang.NullPointerException: Cannot invoke "com.hypixel.hytale.component.query.Query.validateRegistry(com.hypixel.hytale.component.ComponentRegistry)" because "query" is null
+```
+
+**Cause:**
+This error occurs when your module is loaded **before** the required Hytale modules.
+
+**Fix:**
+Add `EntityModule` and `BlockModule` as dependencies in your `manifest.json` to ensure proper load order.
+
+```json
+"Dependencies": {
+  "Hytale:EntityModule": "*",
+  "Hytale:BlockModule": "*"
+}
+```
diff --git a/content/docs/ja-JP/guides/ecs/hytale-ecs-theory.mdx b/content/docs/ja-JP/guides/ecs/hytale-ecs-theory.mdx
index 20c3a94d..52d8b1f5 100644
--- a/content/docs/ja-JP/guides/ecs/hytale-ecs-theory.mdx
+++ b/content/docs/ja-JP/guides/ecs/hytale-ecs-theory.mdx
@@ -29,7 +29,7 @@ for now this is the basic understanding for the `ChunkStore`. You can use it to
 
 ## Holder
 
-A Holder is essentially a blueprint for an entity. Before an entity exists in the Store (and thus in the world), is exists as a `Holder`. It collects and holds all the necessary components (data). You can compare it analogous to shopping cart. You grab all components you need and once you have everything, check out at the store which will take your cart and create a valid entity ID and hand you back a receipt (a Ref).
+A Holder is essentially a blueprint for an entity. Before an entity exists in the Store (and thus in the world), it exists as a `Holder`. It collects and holds all the necessary components (data). You can compare it analogous to shopping cart. You grab all components you need and once you have everything, check out at the store which will take your cart and create a valid entity ID and hand you back a receipt (a Ref).
 
 Let's take a look at an example: initializing players. In `Universe`, the `addPlayer` method demonstrates it perfectly.
 When a player connects, we don't immediately throw them into the ECS. We first construct their data in a Holder.
@@ -167,7 +167,7 @@ MyComponent comp = commandBuffer.getComponent(ref, componentType);
 
 Codecs handle serialization and deserialization of components. Hytale uses them to save and load entity data to and from disk as well as sending component data over the network. When creating a custom component, you must also create a corresponding Codec.
 
-There are mutliple Codec types already implemented in the default Codec Interface:
+There are multiple Codec types already implemented in the default Codec Interface:
 
 - Codec.STRING
 - Codec.BOOLEAN
@@ -215,7 +215,7 @@ This might seem tedious at first but it ensures that your component can be corre
   KeyedCodec<Integer> exampleInt = new KeyedCodec<Integer>("ExampleIntIdForCodec", Codec.INTEGER);
   ```
 
-- **Setter Function**: This is a lambda function that takes an instance of your component and returns the value of the field you want to serialize. For example, if you have a field called `myCustomField` in your custom component, your getter function would look like this:
+- **Setter Function**: This is a lambda function that takes an instance of your component + the value to set and sets the field value on the component. For example, if you have a field called `myCustomField` in your custom component, your setter function would look like this:
   ```java
   (data, value) -> data.myCustomField = value
   ```
@@ -276,7 +276,7 @@ public class PoisonComponent implements Component<EntityStore> {
 
 You can also add validators to your Codec fields to ensure that the data being serialized/deserialized meets certain criteria. For example, if you want to ensure that the `damagePerTick` field is always non-negative or the poison name is never null, you can add a validator like this:
 
-````java
+```java
 .append(
     new KeyedCodec<Float>("DamagePerTick", Codec.FLOAT),
     (data, value) -> data.damagePerTick = value,
@@ -292,14 +292,15 @@ You can also add validators to your Codec fields to ensure that the data being s
 )
 .addValidator(Validators.nonNull())
 .add()
+```
 
 ### Complex Codec Examples
 
-If you want to have a map inside your component, you can use the MapCodec class to build a KeyedCoded for it. Here's an example of how to create a Codec for a Map field:
+If you want to have a map inside your component, you can use the MapCodec class to build a KeyedCodec for it. Here's an example of how to create a Codec for a Map field:
 
 ```java
 var damagePerTick = new KeyedCodec<>("DamagePerTick", new MapCodec<>(Codec.FLOAT, HashMap<String, Float>::new));
-````
+```
 
 <Callout type="info">
   This also works with custom Objects as long as you have a Codec defined for the Object type.
diff --git a/content/docs/ja-JP/guides/java-basics/00-introduction.mdx b/content/docs/ja-JP/guides/java-basics/00-introduction.mdx
index a03ad638..b0130d74 100644
--- a/content/docs/ja-JP/guides/java-basics/00-introduction.mdx
+++ b/content/docs/ja-JP/guides/java-basics/00-introduction.mdx
@@ -7,7 +7,7 @@ Welcome to your journey into Java Programming! This guide is designed to introdu
 
 ## What is Java?
 
-Java is a powerful, object-oriented programming language created in 1995. It's one of the most popular programming languages in the world and is used for everything from mobile apps to enterprise software. Most importantly for us, it's the language Hytale uses for it's servers & modding API.
+Java is a powerful, object-oriented programming language created in 1995. It's one of the most popular programming languages in the world and is used for everything from mobile apps to enterprise software. Most importantly for us, it's the language Hytale uses for its servers & modding API.
 
 ## What You'll Learn
 
diff --git a/content/docs/ja-JP/guides/java-basics/02-operators.mdx b/content/docs/ja-JP/guides/java-basics/02-operators.mdx
index a132b1c0..18634665 100644
--- a/content/docs/ja-JP/guides/java-basics/02-operators.mdx
+++ b/content/docs/ja-JP/guides/java-basics/02-operators.mdx
@@ -119,7 +119,7 @@ String greetingWithName = "Hello, " + name + "!"; // "Hello, Alice!"
 
 ## Operator Precedence
 
-Operator Precendence means which operator gets evaluated first in an line of code. Think of it like BODMAS/PEMDAS in math!
+Operator Precedence means which operator gets evaluated first in an line of code. Think of it like BODMAS/PEMDAS in math!
 
 ```java
 int result = 10 + 5 * 2; // result is 20, not 30
diff --git a/content/docs/ja-JP/guides/java-basics/03-control-flow-if.mdx b/content/docs/ja-JP/guides/java-basics/03-control-flow-if.mdx
index b9d6c479..af2d1c22 100644
--- a/content/docs/ja-JP/guides/java-basics/03-control-flow-if.mdx
+++ b/content/docs/ja-JP/guides/java-basics/03-control-flow-if.mdx
@@ -7,7 +7,7 @@ Programs need to make decisions. If statements let your code choose different pa
 
 ## Basic If Statement
 
-The simplest form checks one condition;
+The simplest form checks one condition:
 
 ```java
 int health = 20;
diff --git a/content/docs/ja-JP/guides/java-basics/08-access-modifiers.mdx b/content/docs/ja-JP/guides/java-basics/08-access-modifiers.mdx
index af560932..da2bf33b 100644
--- a/content/docs/ja-JP/guides/java-basics/08-access-modifiers.mdx
+++ b/content/docs/ja-JP/guides/java-basics/08-access-modifiers.mdx
@@ -484,7 +484,7 @@ class Data {
     // Static member:
     // cannot access to non-static variables
     public static void bar() {
-        x = 100; // Error: non-static variable x cannot be renference from a static context
+        x = 100; // Error: non-static variable x cannot be referenced from a static context
         y = 100; // OK
     }
 }
@@ -504,7 +504,7 @@ Data.x = 1000; // Error: cannot access instanced variables in a static context
 
 ### Static Fields
 
-A static field represents a data member owned by the class type rather then the object. Static fields are also stored in a specific memory location that's been shared between all the object instances that are created.
+A static field represents a data member owned by the class type rather than the object. Static fields are also stored in a specific memory location that's been shared between all the object instances that are created.
 
 It is declared as following:
 
diff --git a/content/docs/ja-JP/guides/plugin/animated-block-textures.mdx b/content/docs/ja-JP/guides/plugin/animated-block-textures.mdx
new file mode 100644
index 00000000..42bfa51f
--- /dev/null
+++ b/content/docs/ja-JP/guides/plugin/animated-block-textures.mdx
@@ -0,0 +1,101 @@
+---
+title: Animated Block Textures
+description: Learn how to attach a .blockyanim to a block
+authors:
+  - name: Burkino
+---
+
+import { File, Folder, Files } from 'fumadocs-ui/components/files';
+
+So, you want to make your blocks feel more alive through animations, do you?\
+Now for the most part this is the exact same as [Creating custom blocks](./creating-block).
+![blue fire gif](/assets/guides/blue_fire.gif)
+
+## Prerequisites
+
+This is NOT a guide on animating or texturing or even using BlockBench, why? Because I don't know how to do that.\
+The only thing we will be doing is taking the fire texture, changing the color, and applying it to our new fire block.
+
+## Setup
+
+To start, you're obviously going to want to grab the `Common/VFX/Fire/Fire.png` file. How you do it is up to you, in the Asset Editor you'll need to switch to the Common tab.\
+I'll assume you know how colorize or change the hue of an image, so go ahead and do that now and save it as `Blue_Fire.png`.
+
+The other assets used in this guide are `Common/VFX/Fire/Fire.blockymodel` and `Common/Blocks/Animations/Fire/Fire_Burn.blockyanim` (both renamed to `Blue_Fire`) but since we won't be changing them it's probably fine to leave them. I will reference the `Blue_Fire` versions as a way to point out what should be custom assets.\
+I will also duplicate `Server/Item/Item/Deco/Deco_Fire.json` and call it `Deco_Blue_Fire.json`.
+
+## Applying the changes
+
+The `Deco_Blue_Fire` block is actually just a particle emitter, however we will not be using particles, so lets start by removing them in `Block > Particles`.\
+Next we want to set the Block Model (called `CustomModel` in JSON) to `VFX/Blue_Fire/Blue_Fire.blockymodel` and Block Model Textures (`CustomModelTexture` in JSON) to
+
+```json
+[
+    {
+        "Texture": "VFX/Blue_Fire/Blue_Fire.png",
+        "Weight": 1
+    }
+]
+```
+
+Finally, we will apply the .blockyanim to our model, this is done through the Block Model Animation property (`CustomModelAnimation` in JSON) and the value should be `Blocks/Animations/Blue_Fire/Blue_Fire_Burn.blockyanim`.
+
+## Final Code
+
+With that your new blue fire should be done. Here is the minimal JSON for our blue fire.\
+There is an additional `Looping` and `RequiresAlphaBlending` property that I have not gone over, however I hope it is self-explanatory.
+
+```json
+{
+  "BlockType": {
+    "DrawType": "Model",
+    "CustomModel": "VFX/Blue_Fire/Blue_Fire.blockymodel",
+    "CustomModelAnimation": "Blocks/Animations/Blue_Fire/Blue_Fire_Burn.blockyanim",
+    "CustomModelTexture": [
+      {
+        "Texture": "VFX/Blue_Fire/Blue_Fire.png",
+        "Weight": 1
+      }
+    ],
+    "Looping": true,
+    "RequiresAlphaBlending": false
+  },
+  "PlayerAnimationsId": "Block"
+}
+```
+
+<Files>
+  <Folder name="resources" defaultOpen>
+    <Folder name="Server" defaultOpen>
+      <Folder name="Item" defaultOpen>
+        <Folder name="Items" defaultOpen>
+          <Folder name="Deco" defaultOpen>
+            <File name="Deco_Blue_Fire.json" />
+          </Folder>
+        </Folder>
+      </Folder>
+    </Folder>
+
+    <Folder name="Common" defaultOpen>
+      <Folder name="Blocks" defaultOpen>
+        <Folder name="Animations" defaultOpen>
+          <Folder name="Blue_Fire" defaultOpen>
+            <File name="Blue_Fire_Burn.blockyanim" />
+          </Folder>
+        </Folder>
+      </Folder>
+
+      <Folder name="VFX" defaultOpen>
+        <Folder name="Blue_Fire" defaultOpen>
+          <File name="Blue_Fire.blockymodel" />
+
+          <File name="Blue_Fire.png" />
+        </Folder>
+      </Folder>
+    </Folder>
+  </Folder>
+</Files>
+
+## Next steps
+
+Now that you know how to attach an animation to a block, try adding it to a block state.
diff --git a/content/docs/ja-JP/guides/plugin/build-and-test.mdx b/content/docs/ja-JP/guides/plugin/build-and-test.mdx
index 0e7fe7eb..f37534c3 100644
--- a/content/docs/ja-JP/guides/plugin/build-and-test.mdx
+++ b/content/docs/ja-JP/guides/plugin/build-and-test.mdx
@@ -9,18 +9,18 @@ If you followed along with the [Setting Up Your Development Environment](./setti
 
 ## Building Your Mod
 
-In our case, we've **Maven** as the build system. Maven is a powerful build automation tool that manages dependencies, compiles your code, and packages everything into a distributable JAR file.
+In our case, we've **Gradle** as the build system. Gradle is a powerful build automation tool that manages dependencies, compiles your code, and packages everything into a distributable JAR file.
 
-### Understanding Maven
+### Understanding Gradle
 
-Maven uses a `pom.xml` file (Project Object Model) to define your project's configuration, dependencies, and build settings. You can learn more about Maven at the [official Apache Maven website](https://maven.apache.org/).
+Gradle can use a `build.gradle.kts` file (Kotlin DSL) to define your project's configuration, dependencies, and build settings. You can learn more about Gradle at the [official Gradle website](https://gradle.org/).
 
-### Building with Maven
+### Building with Gradle
 
 To build your mod, open a terminal in your project directory and run:
 
 ```bash
-mvn package
+./gradlew build
 ```
 
 This command will:
@@ -29,16 +29,35 @@ This command will:
 2. Run any tests (if present)
 3. Package everything into a JAR file
 
+<Callout type="info">
+  If you are using the plugin template from the [Setting Up Your Development Environment](./setting-up-env) guide, then the build script is already set up for you. It includes paths to your Hytale game library and handles the packaging of your mod, managing hytale dependencies and manifest changes.
+
+  If you have a different path to your Hytale installation, you may receive the following error:
+
+  ```bash
+  FAILURE: Build failed with an exception.
+
+  * What went wrong:
+  Failed to find Hytale at the expected location. Please make sure you have installed the game. The expected location can be changed using the hytale.home_path property. Currently looking in 'C:\Path\To\Hytale'
+  ```
+
+  You can change the path by adding a property to your `gradle.properties` file (if it doesn't exist, create it in the root of your project):
+
+  ```properties
+  hytale.home_path=C:\Correct\Path\To\Hytale
+  ```
+</Callout>
+
 ### Build Output
 
-Once the build completes successfully, your mod will be located in the `target` directory and named:
+Once the build completes successfully, your mod will be located in the `build/libs` directory and named:
 
 ```
-ExamplePlugin-1.0-SNAPSHOT.jar
+ExamplePlugin-1.0.jar
 ```
 
 <Callout type="info">
-  The exact name may vary depending on what you configured in your `pom.xml` file. Check the `artifactId` and `version` fields to see what your JAR will be named.
+  The exact name may vary depending on what you configured in your `build.gradle.kts` and `settings.gradle.kts` file. Check the `rootProject.name` and `version` fields to see what your JAR will be named.
 </Callout>
 
 ## Testing Your Mod
@@ -49,11 +68,11 @@ Now that you've built your mod, it's time to test it in Hytale!
 
 First, you need to find Hytale's mods directory:
 
-1. Press **Win + R** on your keyboard
-2. Type `%appdata%` and press Enter
-3. Navigate to: `Hytale\UserData\Mods`
+1. Go to your Hytale installation directory (The default location is usually in your AppData folder)
+   > On Windows, you can access it by clicking `windows + R` and typing `%appdata%`.
+2. Navigate to: `/UserData/Mods`
 
-The full path should look like:
+The default path would look like:
 
 ```
 C:\Users\YourUsername\AppData\Roaming\Hytale\UserData\Mods
@@ -65,7 +84,7 @@ C:\Users\YourUsername\AppData\Roaming\Hytale\UserData\Mods
 
 ### 2. Copy Your Mod
 
-Copy the `ExamplePlugin-1.0-SNAPSHOT.jar` file from your project's `target` directory into the `Mods` folder you just located.
+Copy the `ExamplePlugin-1.0.jar` file from your project's `build/libs` directory into the `Mods` folder you just located.
 
 ### 3. Launch Hytale and Verify
 
@@ -84,7 +103,7 @@ If your mod doesn't appear in the mods list:
 - Make sure the JAR file is in the correct `Mods` folder
 - Check that your `manifest.json` file is properly configured
 - Look for any error messages in the Hytale logs
-- Verify that you're using the correct version of Java and Maven
+- Verify that you're using the correct version of Java and Gradle
 
 ## Next Steps
 
diff --git a/content/docs/ja-JP/guides/plugin/creating-commands.mdx b/content/docs/ja-JP/guides/plugin/creating-commands.mdx
index d33597f3..08572f16 100644
--- a/content/docs/ja-JP/guides/plugin/creating-commands.mdx
+++ b/content/docs/ja-JP/guides/plugin/creating-commands.mdx
@@ -8,6 +8,8 @@ authors:
     url: https://oskar.scot
   - name: jacobwojoski
     url: https://github.com/jacobwojoski
+  - name: Marcel-TO
+    url: https://marcel-to.net
 ---
 
 In this guide, you will learn how to create custom commands for your Hytale mod.
@@ -36,7 +38,7 @@ The most basic command is an `AbstractAsyncCommand`. It has very minimal data av
   `AbstractAsyncCommand` runs on its own background thread. This means its execute is not tied to any world instance and because of this it can not edit any **Stores** or **Refs** without getting the desired world first. To access this data any of the other command types would be preferred and are likely what you will want to use instead.
 </Callout>
 
-The main purpose for a command like this would be for something that can happen everywhere and is not tied to a specific world. For example a `serverRules` command to tell the user thats running the command in chat what the servers rules are nomatter what world they are in.
+The main purpose for a command like this would be for something that can happen everywhere and is not tied to a specific world. For example a `serverRules` command to tell the user that's running the command in chat what the server's rules are no matter what world they are in.
 
 ```java
 // Command that can be run that lists the server rules in chat to the player
@@ -49,7 +51,7 @@ public class ServerRulesCommand extends AbstractAsyncCommand {
     }
 
     // Run the command
-    // conetext - info about who ran the command. Server console?, Some player?
+    // context - info about who ran the command. Server console?, Some player?
     @Override
     protected CompletableFuture<Void> executeAsync(@Nonnull CommandContext context) {
         context.sendMessage(Message.raw("The only rule is there are no rules."));
@@ -134,7 +136,7 @@ Uses a Ray to see what the player is looking at and tries to run the command on
 
 ## Adding Arguments
 
-Arguments are additional fields that the user can input when running a command. The different types of arguments along with small snipits and a large example can be seen below.
+Arguments are additional fields that the user can input when running a command. The different types of arguments along with small snippets and a large example can be seen below.
 
 ### Command Argument Types
 
@@ -163,14 +165,14 @@ this.messageArg = this.withOptionalArg("message", "Message to print while healin
 
 ### Default Arguments
 
-Adding a default argument has two additional arguemnt for the default value and default value description. You need to use `withDefaultArg` method.
+Adding a default argument has two additional argument for the default value and default value description. You need to use `withDefaultArg` method.
 
 ```java
 // args <Command String> <Description> <Default Value> <Desc of default value>
 this.healthArg = this.withDefaultArg("health", "Amount to heal player", ArgTypes.FLOAT, (float)100, "Desc of Default: 100");
 ```
 
-### Flag Arguemnts
+### Flag Arguments
 
 Similar as above but the flags return is either true if it exists or false if it does not. You need to use `withFlagArg` method.
 
@@ -181,20 +183,13 @@ this.debugArg = this.withFlagArg("debug", "Add debug logs");
 
 ### ArgTypes
 
-The following ArgTypes are available (only lists common types):
-
-- `ArgTypes.STRING`
-- `ArgTypes.INTEGER`
-- `ArgTypes.BOOLEAN`
-- `ArgTypes.FLOAT`
-- `ArgTypes.DOUBLE`
-- `ArgTypes.UUID`
+You can find all the available argument types on the [ArgTypes](../../argtypes) page.
 
 ### Example Command Arg Types
 
-Shows all Command arguemnt types with different various input types.
+Shows all Command argument types with different various input types.
 
-**NOTE:** When getting the value of an argument during execute you need to pass the context with `someArg.get(commandContext)`. Where `commandContext` is the first variable in the execute funtion.
+**NOTE:** When getting the value of an argument during execute you need to pass the context with `someArg.get(commandContext)`. Where `commandContext` is the first variable in the execute function.
 
 ```java
 // Example usage: /healplayer --health 50 --message "Feels Good" --debug
@@ -204,7 +199,7 @@ public class HealPlayerCommand extends AbstractTargetPlayerCommand {
     private final FlagArg debugArg;
 
     public HealPlayerCommand() {
-        super("healplayer", "Healing a player for an <input> ammount of HP (default: 100)");
+        super("healplayer", "Healing a player for an <input> amount of HP (default: 100)");
 
         // Abstract TargetPlayerCommand passes the player that ran the command by default and implements
         // the use of `--player <value>` to specify someone else
@@ -213,10 +208,10 @@ public class HealPlayerCommand extends AbstractTargetPlayerCommand {
         this.healthArg = this.withDefaultArg("health", "Amount to heal player", ArgTypes.FLOAT, (float)100, "Desc of Default: 100");
 
         // Or you could do the following making the health value required instead of with a default.
-        //    You would need to change the decleration to RequiredArg<Float>
+        //    You would need to change the declaration to RequiredArg<Float>
         // this.healthArg = this.withRequiredArg("health", "Amount to heal player", ArgTypes.FLOAT);
 
-        // Optional args reguare the user the input `--<key> <value>` so the following would require `--message "Good Luck"`
+// Optional args require the user the input `--<key> <value>` so the following would require `--message "Good Luck"`
         this.messageArg = this.withOptionalArg("message", "Message to print while healing", ArgTypes.STRING);
 
         // No type needed due to being a bool
@@ -230,7 +225,7 @@ public class HealPlayerCommand extends AbstractTargetPlayerCommand {
             commandContext.sendMessage(Message.raw("We are debugging"));
         }
 
-        // Health is stored in a generic stat map to allowing mods/future contect to easily add more stats if desired.
+        // Health is stored in a generic stat map to allowing mods/future content to easily add more stats if desired.
         EntityStatMap stats = store.getComponent(ref, EntityStatMap.getComponentType());
         int healthIdx = DefaultEntityStatTypes.getHealth();
         EntityStatValue health = stats.get(healthIdx);
@@ -252,7 +247,7 @@ public class HealPlayerCommand extends AbstractTargetPlayerCommand {
 
 ## Argument Validators
 
-Argument validators are a way to check the command before the command gets executed. They are added with the `addValidator` method on an argument when calling `withXxxArg`. They provide a nice output to the user when an input value is invalid.
+Argument validators are a way to check the command before the command gets executed. They are added with the `addValidator` method on an argument when calling `withXxxArg`. They provide a nice output to the user when an input value is invalid. There are some common validators provided in the `Validators` class such as `greaterThan`, `lessThan`, and `or`, `max`, `range`, etc.
 
 ```java
 ...
@@ -260,18 +255,59 @@ Argument validators are a way to check the command before the command gets execu
     OptionalArg<Integer> healAmount = withOptionalArg("amount", "Heal Amount", ArgTypes.INTEGER)
         .addValidator(Validators.greaterThan(0))
         .addValidator(Validators.lessThan(1000));
-
-    // Custom check example
-    OptionalArg<Integer> healAmount = withOptionalArg("amount", "Heal Amount", ArgTypes.INTEGER)
-            .addValidator( value -> {
-                if (value != null && value <= 0) {
-                    return ValidationResult.error("ammount argument must be a positive number");
-                }
-                return ValidationResult.success();
-            });
 ...
 ```
 
+### Custom Validators
+
+You can also create custom validators by implementing the `com.hypixel.hytale.codec.validation.Validator` interface. The interfaces forces you to implement the `accept` and `updateSchema` method. The `accept` method takes in the argument value and validates it. If the validation fails, you can use the `fail` method of the `com.hypixel.hytale.codec.validation.ValidationResults` class to return an error message.
+The `updateSchema` method is used to update the schema of the command argument. This is used for commands that have dynamic schemas based on the input value. For example, if you have a command that takes in a player name as an argument, you can use the `updateSchema` method to update the schema to include a list of online players for validation.
+
+Here is an example of a custom validator that checks if a string value is equal to a banned word. In this example, the banned word is "badword". If the input value is "badword", the validator will fail and return an error message.
+
+```java
+import com.hypixel.hytale.codec.schema.SchemaContext;
+import com.hypixel.hytale.codec.schema.config.Schema;
+import com.hypixel.hytale.codec.validation.ValidationResults;
+import com.hypixel.hytale.codec.validation.Validator;
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+
+public class MyCustomValidator implements Validator<String> {
+    @Nonnull
+    private final String value;
+
+    public MyCustomValidator(@Nonnull String value) {
+        this.value = value;
+    }
+
+    @Override
+    public void accept(@Nullable String input, @Nonnull ValidationResults results) {
+        if (this.value.equalsIgnoreCase(input)) {
+            results.fail("The given role has been banned.");
+        }
+    }
+
+    @Override
+    public void updateSchema(SchemaContext context, @Nonnull Schema target) {
+        // This method can be used to update the schema of the command argument. This is useful for commands that have dynamic schemas based on the input value. For example, if you have a command that takes in a player name as an argument, you can use the `updateSchema` method to update the schema to include a list of online players for validation.
+        throw new UnsupportedOperationException("Not implemented yet.");
+    }
+}
+```
+
+After the custom validator is created, you can add it to an argument like the following example. In this example, we add the `MyCustomValidator` to a string argument called "role". If the user inputs "badword" as the role, the command will fail and return the error message defined in the `MyCustomValidator`.
+
+```java
+    ...
+    // Custom validator example
+    String bannedRole = "badword";
+
+    OptionalArg<String> roleArg = withOptionalArg("role", "Role to assign", ArgTypes.STRING)
+        .addValidator(new MyCustomValidator(bannedRole));
+    ...
+```
+
 ---
 
 ## Permissions
@@ -312,7 +348,7 @@ This allows the server to control who has access to specific commands. You add t
 
 If you want variants of the same command without doing argument parsing you can instead use `addUsageVariant(new OtherCommandClass())` in the original commands constructor.
 
-The only difference is in the `OtherCommandClass()` constrcutor you don't pass the command name to the super class.
+The only difference is in the `OtherCommandClass()` constructor you don't pass the command name to the super class.
 
 <Callout type="info">
   You can also use `addAliases("some_alias", "some_other_alias")` as a way to add shorthand or other ways to write the same command.
@@ -387,7 +423,7 @@ public class AdminCommand extends AbstractCommandCollection {
     public AdminCommand () {
         super("admin", "Admin commands");
         addSubCommand(new UserCommandCollection());
-        addSybCommand(new ServerCommandCollection);
+        addSubCommand(new ServerCommandCollection);
     }
 }
 ```
@@ -417,5 +453,5 @@ public class MyPlugin extends JavaPlugin {
 
 ## Video Link
 
-_Special Thanks to [TroubleDev](https://www.youtube.com/@TroubleDEV) for his excelent video guide on all of these features._
+_Special Thanks to [TroubleDev](https://www.youtube.com/@TroubleDEV) for his excellent video guide on all of these features._
 _Video Link: [TroubleDev - Hytale's Command API Explained](https://www.youtube.com/watch?v=KnmhG9MDMgo)_
diff --git a/content/docs/ja-JP/guides/plugin/creating-events.mdx b/content/docs/ja-JP/guides/plugin/creating-events.mdx
index 95863990..d3f0925d 100644
--- a/content/docs/ja-JP/guides/plugin/creating-events.mdx
+++ b/content/docs/ja-JP/guides/plugin/creating-events.mdx
@@ -1,6 +1,6 @@
 ---
-title: Creating Events
-description: Learn how to create custom events for your Hytale mod.
+title: Creating Events Listeners
+description: Learn how to create event listeners for your Hytale mod.
 authors:
   - name: Neil Revin
     url: https://itsneil.dev
@@ -10,7 +10,7 @@ authors:
 
 ## Event Class
 
-You can import a Event class and create a function with the Event as a argument. [Click here](../../server/events) to look at all available events.
+You can import an Event class and create a function with the Event as an argument. [Click here](../../server/events) to look at all available events.
 
 Example plugin when a player is ready (joins a server):
 
diff --git a/content/docs/ja-JP/guides/plugin/item-registry.mdx b/content/docs/ja-JP/guides/plugin/item-registry.mdx
new file mode 100644
index 00000000..9a0fd53a
--- /dev/null
+++ b/content/docs/ja-JP/guides/plugin/item-registry.mdx
@@ -0,0 +1,95 @@
+---
+title: Working with the Item Registry
+description: Learn how to access and query the game's item registry to list all items, check if items exist, and retrieve item properties.
+authors:
+  - name: Denis
+---
+
+In this guide, you'll learn how to work with Hytale's Item Registry system. This is useful when you need to programmatically list all available items, validate item IDs, or retrieve item properties at runtime.
+
+## Prerequisites
+
+Before diving in, you should be familiar with:
+
+- [Setting up your development environment](./setting-up-env)
+- [Creating commands](./creating-commands) (optional, for testing)
+
+## Required Imports
+
+To work with the Item Registry, you'll need the following imports:
+
+```java
+import com.hypixel.hytale.assetstore.map.DefaultAssetMap;
+import com.hypixel.hytale.server.core.asset.type.item.config.Item;
+```
+
+## Getting the Item Registry
+
+The Item Registry is accessed through the `Item.getAssetMap()` method, which returns a `DefaultAssetMap<String, Item>` containing all registered items in the game:
+
+```java
+DefaultAssetMap<String, Item> itemMap = Item.getAssetMap();
+```
+
+## Listing All Items
+
+To iterate through all items in the registry, you can get the underlying map and loop through its entries:
+
+```java
+DefaultAssetMap<String, Item> itemMap = Item.getAssetMap();
+var map = itemMap.getAssetMap();
+
+for (var entry : map.entrySet()) {
+    String itemId = String.valueOf(entry.getKey());
+    Item item = entry.getValue();
+    
+    // Do something with the item
+    LOGGER.atInfo().log("Item ID: " + itemId);
+}
+```
+
+You can also get the total count of registered items:
+
+```java
+int totalItems = map.size();
+```
+
+## Checking if an Item Exists
+
+To check if a specific item exists in the registry, use `getAsset()` and verify the result:
+
+```java
+public boolean itemExists(String itemId) {
+    var assetMap = Item.getAssetMap();
+    if (assetMap != null) {
+        Item item = assetMap.getAsset(itemId);
+        return item != null && item != Item.UNKNOWN;
+    }
+    return false;
+}
+```
+
+<Callout type="info">
+  The `Item.UNKNOWN` constant represents an invalid or unrecognized item. Always check for both `null` and `Item.UNKNOWN` when validating items.
+</Callout>
+
+## Accessing Item Properties
+
+Once you have an `Item` instance, you can access various properties:
+
+```java
+var assetMap = Item.getAssetMap();
+Item item = assetMap.getAsset("Soil_Grass");
+
+if (item != null && item != Item.UNKNOWN) {
+    String id = item.getId(); // Soil_Grass
+    int maxStack = item.getMaxStack(); // 100
+    boolean isBlock = item.hasBlockType(); // true
+    boolean isConsumable = item.isConsumable(); // false
+}
+```
+
+## Related Guides
+
+- [Inventory Management](./inventory-management) - Learn how to add and remove items from player inventories
+- [Create Custom Item and Interaction](./item-interaction) - Learn how to create your own custom items
diff --git a/content/docs/ja-JP/guides/plugin/permission-management.mdx b/content/docs/ja-JP/guides/plugin/permission-management.mdx
index 6b7cfd46..55f06101 100644
--- a/content/docs/ja-JP/guides/plugin/permission-management.mdx
+++ b/content/docs/ja-JP/guides/plugin/permission-management.mdx
@@ -10,132 +10,569 @@ authors:
     link: https://discord.com/users/292656109939064833
   - name: Ivan
     link: https://discord.com/users/505770451218333717
+  - name: ZenithDevHQ
+    link: https://github.com/ZenithDevHQ
 ---
 
-In this guide, you'll learn how to manage permission nodes and groups in your Hytale plugin.
+In this guide, you'll learn how to manage permission nodes and groups in your Hytale plugin. Permissions control what actions players can perform on your server, from basic commands to advanced administrative functions.
 
-## The `PermissionsModule` class
+## What Are Permissions?
 
-The `PermissionsModule` class is responsible for managing permission nodes and groups in your plugin. It provides methods to check, grant and revoke permissions and groups for players. It allows the following operations
+Permissions are string identifiers that control access to features and commands. When a player tries to perform an action (like using a command), the server checks if they have the required permission.
 
-- Add permissions to user
-- Remove permissions from user
-- Add permissions to group (this also creates the group if it doesn't exist)
-- Remove permissions from group
-- Add user to group
-- Remove user from group
-- List all groups for a user
-- Check if a user has a permission (it checks both user and group permissions for the given player UUID)
+**Example permission nodes:**
 
-With this class you cannot:
+- `hytale.command.gamemode` - Permission to use the gamemode command
+- `hytale.editor.brush.use` - Permission to use brush tools
+- `myplugin.teleport.home` - A custom permission for your plugin
 
-- List all defined groups
-- Remove a group
+Permissions follow a hierarchical naming pattern: `namespace.category.action`
 
-### Adding Permission Nodes
+## Key Concepts
 
-You need a `Set<String>` containing all the permission nodes you want to add, these are added on top of the already existing permission nodes the user may have, it is not a replacement.
+Before diving into code, let's understand the core concepts:
+
+| Concept             | Description                                                                |
+| ------------------- | -------------------------------------------------------------------------- |
+| **Permission Node** | A string like `myplugin.feature.use` that represents a specific permission |
+| **Group**           | A named collection of permissions (e.g., "Admin", "VIP", "Default")        |
+| **Provider**        | The backend that stores and retrieves permissions                          |
+| **Wildcard**        | A pattern like `*` or `myplugin.*` that matches multiple permissions       |
+
+### How Permissions Are Checked
+
+When checking if a player has a permission, Hytale follows this order:
+
+1. **User's direct permissions** - Permissions granted directly to the player
+2. **Group permissions** - Permissions from groups the player belongs to
+3. **Virtual groups** - Game-mode-based permissions (e.g., Creative mode grants builder tools)
+4. **Default value** - Falls back to `false` if no match found
+
+<Callout type="info">
+  The first definitive match wins. If a player has a permission granted at the user level, group permissions won't override it.
+</Callout>
+
+---
+
+## The `PermissionsModule` Class
+
+The `PermissionsModule` class is the central hub for managing permissions. Access it using the singleton pattern:
 
 ```java
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.addUserPermission(playerUUID, permissions);
 ```
 
-### Removing Permission Nodes
+### Available Operations
+
+The module supports these operations:
+
+| Operation                     | Method                                          |
+| ----------------------------- | ----------------------------------------------- |
+| Add permissions to user       | `addUserPermission(uuid, permissions)`          |
+| Remove permissions from user  | `removeUserPermission(uuid, permissions)`       |
+| Add permissions to group      | `addGroupPermission(groupName, permissions)`    |
+| Remove permissions from group | `removeGroupPermission(groupName, permissions)` |
+| Add user to group             | `addUserToGroup(uuid, groupName)`               |
+| Remove user from group        | `removeUserFromGroup(uuid, groupName)`          |
+| Get user's groups             | `getGroupsForUser(uuid)`                        |
+| Check permission              | `hasPermission(uuid, permissionNode)`           |
+
+<Callout type="warning">
+  The module does **not** support:
+
+  - Listing all defined groups
+  - Deleting a group entirely
+
+  Groups are implicitly created when you first add permissions to them.
+</Callout>
+
+---
 
-Same as above, we just use the `removeUserPermission` method instead to remove permission nodes.
+## Checking Permissions
+
+The most common operation is checking if a player has a permission.
+
+### Basic Permission Check
+
+```java
+// Returns true if player has the permission, false otherwise
+boolean canUse = PermissionsModule.get().hasPermission(playerUUID, "myplugin.feature.use");
+
+if (canUse) {
+    // Player has permission, allow the action
+} else {
+    // Player lacks permission, deny or show error
+}
+```
+
+### Permission Check with Default Value
+
+You can specify what to return when no permission is explicitly set:
+
+```java
+// Returns true by default if no explicit permission is found
+boolean canUse = PermissionsModule.get().hasPermission(playerUUID, "myplugin.feature.use", true);
+```
+
+This is useful for features that should be enabled by default but can be revoked.
+
+### Using PermissionHolder Interface
+
+Players and command senders implement `PermissionHolder`, allowing direct checks:
+
+```java
+// In a command or event handler where you have access to the player
+if (player.hasPermission("myplugin.admin.manage")) {
+    // Player has admin permission
+}
+```
+
+---
+
+## Managing User Permissions
+
+### Adding Permissions to a User
+
+Permissions are additive - new permissions are added on top of existing ones, not replaced.
+
+```java
+PermissionsModule perms = PermissionsModule.get();
+
+// Add a single permission
+perms.addUserPermission(playerUUID, Set.of("myplugin.vip.chat"));
+
+// Add multiple permissions at once
+Set<String> newPerms = Set.of(
+    "myplugin.vip.chat",
+    "myplugin.vip.fly",
+    "myplugin.vip.kit"
+);
+perms.addUserPermission(playerUUID, newPerms);
+```
+
+### Removing Permissions from a User
 
 ```java
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.removeUserPermission(playerUUID, permissions);
+
+// Remove specific permissions
+Set<String> toRemove = Set.of("myplugin.vip.fly");
+perms.removeUserPermission(playerUUID, toRemove);
 ```
 
-### Add permissions to group
+---
+
+## Managing Groups
+
+Groups let you assign a collection of permissions to multiple players. This is more manageable than assigning permissions individually.
+
+### Adding Permissions to a Group
+
+If the group doesn't exist, it will be created automatically.
 
 ```java
-String groupName = "testGroup";
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.addGroupPermission(groupName, permissions);
+
+// Create/update the "VIP" group with permissions
+Set<String> vipPerms = Set.of(
+    "myplugin.vip.chat",
+    "myplugin.vip.fly",
+    "myplugin.vip.kit"
+);
+perms.addGroupPermission("VIP", vipPerms);
 ```
 
-### Remove permissions from group
+### Removing Permissions from a Group
 
 ```java
-String groupName = "testGroup";
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.removeGroupPermission(groupName, permissions);
+
+// Remove specific permissions from the group
+Set<String> toRemove = Set.of("myplugin.vip.fly");
+perms.removeGroupPermission("VIP", toRemove);
 ```
 
-### Add user to group
+### Adding a User to a Group
 
 ```java
-String groupName = "testGroup";
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.addUserToGroup(playerUUID, groupName);
+
+// Add player to the VIP group - they now have all VIP permissions
+perms.addUserToGroup(playerUUID, "VIP");
 ```
 
-### Remove user from group
+### Removing a User from a Group
 
 ```java
-String groupName = "testGroup";
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.removeUserFromGroup(playerUUID, groupName);
+
+// Remove player from VIP group
+perms.removeUserFromGroup(playerUUID, "VIP");
 ```
 
-### List all groups for a user
+### Getting a User's Groups
 
 ```java
 PermissionsModule perms = PermissionsModule.get();
-perms.getGroupsForUser(playerUUID);
+
+// Get all groups the player belongs to
+Set<String> groups = perms.getGroupsForUser(playerUUID);
+
+for (String group : groups) {
+    System.out.println("Player is in group: " + group);
+}
 ```
 
-### Check Permission Nodes
+---
+
+## Built-in Groups
+
+Hytale includes two default groups:
+
+| Group     | Default Permissions   | Purpose                           |
+| --------- | --------------------- | --------------------------------- |
+| `OP`      | `*` (all permissions) | Server operators with full access |
+| `Default` | None                  | Base group for all players        |
+
+Players without any explicit group assignment are automatically part of the `Default` group.
 
-To check if a player has a specific permission node, you can use the `hasPermission` method.
+---
+
+## Wildcards
+
+Wildcards let you grant or deny multiple permissions with a single pattern.
+
+### Wildcard Patterns
+
+| Pattern             | Meaning                                          |
+| ------------------- | ------------------------------------------------ |
+| `*`                 | Grants **all** permissions                       |
+| `myplugin.*`        | Grants all permissions starting with `myplugin.` |
+| `-*`                | Denies **all** permissions                       |
+| `-myplugin.admin.*` | Denies all admin permissions in your plugin      |
+
+### Example: Admin Group with Wildcards
 
 ```java
-boolean hasPermission = PermissionsModule.hasPermission(playerUUID, "permission.node");
+// Grant all permissions to admins
+perms.addGroupPermission("Admin", Set.of("*"));
+
+// Grant all plugin permissions to moderators
+perms.addGroupPermission("Moderator", Set.of("myplugin.*"));
+
+// Grant all permissions except admin commands
+perms.addGroupPermission("Helper", Set.of(
+    "*",
+    "-myplugin.admin.*"  // Deny admin permissions
+));
 ```
 
-## Additional: Defining your own provider for permissions and groups
+<Callout type="warning">
+  Negation permissions (starting with `-`) take precedence at each level. Use them carefully to avoid accidentally blocking permissions.
+</Callout>
+
+---
+
+## Built-in Permission Nodes
+
+Hytale provides constants for common permissions in the `HytalePermissions` class:
+
+### Command Permissions
+
+```java
+// Generate permission for a command
+String perm = HytalePermissions.fromCommand("gamemode");
+// Result: "hytale.command.gamemode"
+
+// Generate permission for a subcommand
+String perm = HytalePermissions.fromCommand("gamemode", "creative");
+// Result: "hytale.command.gamemode.creative"
+```
+
+### Common Permission Nodes
+
+| Permission                    | Description                  |
+| ----------------------------- | ---------------------------- |
+| `hytale.command.op.add`       | Add players to OP group      |
+| `hytale.command.op.remove`    | Remove players from OP group |
+| `hytale.editor.brush.use`     | Use brush tools              |
+| `hytale.editor.prefab.use`    | Use prefabs                  |
+| `hytale.editor.selection.use` | Use selection tools          |
+| `hytale.editor.history`       | Undo/redo operations         |
+| `hytale.camera.flycam`        | Use fly camera mode          |
+
+---
+
+## Listening to Permission Events
+
+You can react to permission changes using Hytale's event system.
+
+### Available Events
+
+| Event                                            | Triggered When                   |
+| ------------------------------------------------ | -------------------------------- |
+| `PlayerPermissionChangeEvent.PermissionsAdded`   | Permissions added to a user      |
+| `PlayerPermissionChangeEvent.PermissionsRemoved` | Permissions removed from a user  |
+| `PlayerGroupEvent.Added`                         | User added to a group            |
+| `PlayerGroupEvent.Removed`                       | User removed from a group        |
+| `GroupPermissionChangeEvent.Added`               | Permissions added to a group     |
+| `GroupPermissionChangeEvent.Removed`             | Permissions removed from a group |
 
-The PermissionsModule also enables us to define our own PermissionProvider's, this can be useful for:
+### Example: Reacting to Permission Changes
 
-- Cross server permission systems
-- Implementing features missing in the `HytalePermissionsProvider` like permission expiry
+```java
+public class PermissionListener {
+
+    public static void onPermissionsAdded(PlayerPermissionChangeEvent.PermissionsAdded event) {
+        UUID playerUUID = event.getPlayerUuid();
+        Set<String> added = event.getAddedPermissions();
+
+        System.out.println("Permissions added to " + playerUUID + ": " + added);
 
-To implement our PermissionProvider, first we need to define a provider class that implements PermissionProvider:
+        // Maybe notify the player or update cached data
+    }
+
+    public static void onGroupAdded(PlayerGroupEvent.Added event) {
+        UUID playerUUID = event.getPlayerUuid();
+        String groupName = event.getGroupName();
+
+        System.out.println("Player " + playerUUID + " joined group: " + groupName);
+    }
+}
+```
+
+### Registering the Events
 
 ```java
-public class DatabasePermissionProvider implements PermissionProvider
+public class MyPlugin extends JavaPlugin {
+
+    @Override
+    public void setup() {
+        EventRegistry events = this.getEventRegistry();
+
+        events.registerGlobal(
+            PlayerPermissionChangeEvent.PermissionsAdded.class,
+            PermissionListener::onPermissionsAdded
+        );
+
+        events.registerGlobal(
+            PlayerGroupEvent.Added.class,
+            PermissionListener::onGroupAdded
+        );
+    }
+}
 ```
 
-Then we just implement the required methods using a database implementation.
+---
+
+## Creating a Custom Permission Provider
+
+For advanced use cases, you can create your own permission provider. This is useful for:
+
+- Database-backed permissions (MySQL, MongoDB, etc.)
+- Cross-server permission synchronization
+- Custom features like permission expiry or contexts
+
+### Implementing PermissionProvider
+
+```java
+public class DatabasePermissionProvider implements PermissionProvider {
+
+    @Nonnull
+    @Override
+    public String getName() {
+        return "DatabasePermissionProvider";
+    }
+
+    // User permission methods
+    @Override
+    public void addUserPermissions(@Nonnull UUID uuid, @Nonnull Set<String> permissions) {
+        // Save to your database
+    }
+
+    @Override
+    public void removeUserPermissions(@Nonnull UUID uuid, @Nonnull Set<String> permissions) {
+        // Remove from your database
+    }
+
+    @Override
+    public Set<String> getUserPermissions(@Nonnull UUID uuid) {
+        // Query your database
+        return Set.of();
+    }
+
+    // Group permission methods
+    @Override
+    public void addGroupPermissions(@Nonnull String group, @Nonnull Set<String> permissions) {
+        // Save to your database
+    }
+
+    @Override
+    public void removeGroupPermissions(@Nonnull String group, @Nonnull Set<String> permissions) {
+        // Remove from your database
+    }
+
+    @Override
+    public Set<String> getGroupPermissions(@Nonnull String group) {
+        // Query your database
+        return Set.of();
+    }
+
+    // User-group membership methods
+    @Override
+    public void addUserToGroup(@Nonnull UUID uuid, @Nonnull String group) {
+        // Save to your database
+    }
+
+    @Override
+    public void removeUserFromGroup(@Nonnull UUID uuid, @Nonnull String group) {
+        // Remove from your database
+    }
+
+    @Override
+    public Set<String> getGroupsForUser(@Nonnull UUID uuid) {
+        // Query your database
+        return Set.of("Default");
+    }
+}
+```
 
 <Callout type="warning">
-  Hytale will try to use the first available permissions provider to add/remove gamemode groups (i.e. `Creative`, `Adventure`).
+  Hytale automatically assigns players to game-mode groups (like `Creative` or `Adventure`) using the first available provider.
+
+  If your provider throws an error when the group doesn't exist, the player will be disconnected! Always handle missing groups gracefully.
+</Callout>
+
+### Registering Your Provider
 
-  If your provider throws an error (for instance, if the group does not exist) when the server is preparing the player, the player will be disconnected.
+```java
+public class MyPlugin extends JavaPlugin {
+
+    @Override
+    public void setup() {
+        // Add your provider alongside the default one
+        PermissionsModule.get().addProvider(new DatabasePermissionProvider());
+    }
+}
+```
+
+The `PermissionsModule` aggregates permissions from all registered providers. This means:
+
+- Permission checks query all providers
+- Write operations (add/remove) use the **first** provider
+
+### Replacing the Default Provider
+
+If you want full control, you can remove the default provider:
+
+```java
+public class MyPlugin extends JavaPlugin {
+
+    @Override
+    public void setup() {
+        PermissionsModule perms = PermissionsModule.get();
+
+        // Remove the default provider FIRST
+        perms.removeProvider(perms.getFirstPermissionProvider());
+
+        // Then add your provider
+        perms.addProvider(new DatabasePermissionProvider());
+    }
+}
+```
+
+<Callout type="info">
+  When you remove the default provider, the `/op self` command will stop working since it checks for provider tampering.
 </Callout>
 
-We can then register the provider using the built-in permission module:
+---
+
+## Best Practices
+
+### Permission Naming Conventions
+
+Follow the pattern: `namespace.category.action`
 
 ```java
-PermissionsModule.get().addProvider(new DatabasePermissionProvider());
+// Good - clear hierarchy
+"myplugin.admin.ban"
+"myplugin.user.teleport.home"
+"myplugin.vip.chat.color"
+
+// Bad - unclear structure
+"myplugin_ban"
+"teleport"
+"vipChatColor"
 ```
 
-Please note that the `HytalePermissionsProvider` will still be enabled alongside your provider.
-The `PermissionsModule` will aggregate groups and permissions from all available providers.
+### Use Constants for Permissions
 
-If you want to disable the default `HytalePermissionsProvider`, you can use:
+Define your permissions as constants to avoid typos:
 
 ```java
-// put this **before** you add your provider
-PermissionsModule.get().removeProvider(PermissionsModule.get().getFirstPermissionProvider());
+public final class MyPermissions {
+    public static final String ADMIN_BAN = "myplugin.admin.ban";
+    public static final String ADMIN_KICK = "myplugin.admin.kick";
+    public static final String USER_HOME = "myplugin.user.home";
+    public static final String VIP_FLY = "myplugin.vip.fly";
+}
+
+// Usage
+if (player.hasPermission(MyPermissions.ADMIN_BAN)) {
+    // ...
+}
 ```
+
+### Don't Over-Permission
+
+Only create permissions for actions that genuinely need access control. Not everything needs a permission check.
+
+### Thread Safety
+
+If you create a custom provider, ensure it's thread-safe. Permission checks can occur from multiple threads simultaneously. Use `ReadWriteLock` or `ConcurrentHashMap` for your data structures.
+
+---
+
+## In-Game Commands
+
+Hytale provides built-in commands for managing permissions:
+
+### `/op` Command
+
+| Command               | Description                                                        |
+| --------------------- | ------------------------------------------------------------------ |
+| `/op self`            | Toggle your own OP status (singleplayer or with `--allow-op` flag) |
+| `/op add <player>`    | Add a player to the OP group                                       |
+| `/op remove <player>` | Remove a player from the OP group                                  |
+
+### `/perm` Command
+
+Use `/perm --help` in-game for full usage. Common operations:
+
+| Command                                  | Description                   |
+| ---------------------------------------- | ----------------------------- |
+| `/perm user list <uuid>`                 | List user's permissions       |
+| `/perm user add <uuid> <perm>`           | Add permission to user        |
+| `/perm user remove <uuid> <perm>`        | Remove permission from user   |
+| `/perm user group list <uuid>`           | List user's groups            |
+| `/perm user group add <uuid> <group>`    | Add user to group             |
+| `/perm user group remove <uuid> <group>` | Remove user from group        |
+| `/perm group list <group>`               | List group's permissions      |
+| `/perm group add <group> <perm>`         | Add permission to group       |
+| `/perm group remove <group> <perm>`      | Remove permission from group  |
+| `/perm test <perm>`                      | Test if you have a permission |
+
+---
+
+## Summary
+
+You've learned how to:
+
+- **Check permissions** using `PermissionsModule.hasPermission()`
+- **Manage user permissions** with `addUserPermission()` and `removeUserPermission()`
+- **Work with groups** using `addGroupPermission()`, `addUserToGroup()`, etc.
+- **Use wildcards** like `*` and `myplugin.*` for bulk permissions
+- **Listen to events** for permission changes
+- **Create custom providers** for database-backed permissions
+
+For more advanced permission systems with features like inheritance, expiry, and contexts, we're looking into expanding this guide with advanced permission management techniques in the future.
diff --git a/content/docs/ja-JP/guides/plugin/setting-up-env.mdx b/content/docs/ja-JP/guides/plugin/setting-up-env.mdx
index d2718098..5be5e9e0 100644
--- a/content/docs/ja-JP/guides/plugin/setting-up-env.mdx
+++ b/content/docs/ja-JP/guides/plugin/setting-up-env.mdx
@@ -4,6 +4,10 @@ description: Learn how to set up your development environment for modding Hytale
 authors:
   - name: Neil Revin
     link: https://itsneil.dev
+  - name: Marcel-TO
+    url: https://marcel-to.net
+  - name: Ádám Liszkai
+    link: https://adaliszk.dev
 ---
 
 This guide will walk you through setting up a complete development environment for Hytale modding, including all necessary tools and dependencies.
@@ -19,24 +23,73 @@ Before we begin, make sure you have:
 
 ## Required Software
 
-### 1. Java Development Kit (JDK)
+### Integrated Development Environment (IDE)
 
+We recommend IntelliJ IDEA Community Edition for Hytale modding. If you use IntelliJ IDEA, **almost everything is built-in**. You can clone a template, open a new project, and start working right away!
+
+1. Download from [JetBrains website](https://www.jetbrains.com/idea/download/)
+2. Install with default settings
+3. Launch and complete the initial setup wizard
+
+When opening a project, wait for indexing to finish, then start coding.
+Now, IDEA may say "No JDK configured" at the top of the source file you have.
+In that case, you can click Download JDK and choose JetBrains JDK 25.
+
+<Callout type="success">
+  If IDEA opened the project without errors, your environment is ready.
+</Callout>
+
+More details by [JetBrains](https://www.jetbrains.com/help/idea/2026.1/run-for-the-first-time.html)
+help page, where we recommend that you also check the
+[SDK configuration](https://www.jetbrains.com/help/idea/2026.1/sdk.html) guide.
+
+<Callout type="info">
+  We recommened following
+  [TheNullicorn's](https://gist.github.com/TheNullicorn/90a619796c40f20ae1fcf13094c1a57d) guide to ensure
+  you are using the correct `Nonnull` in your projects.
+</Callout>
+
+#### What the IDE Does for You
+
+When opened in IntelliJ IDEA, the project automatically:
+
+- Detects and configures Gradle or Maven
+- Downloads all dependencies
+- Sets up project structure and classpaths
+- Configures run/build tasks
+
+You do **not** need to manually install or configure Maven or Gradle if you stay inside the IDE.
+
+Skip to the [Setting Up Your Workspace](#setting-up-your-workspace).
+
+### Manual Setup: Java Development Kit (JDK)
+
+For any other setup, you will need to install and configure your system to have and load Java.
 Hytale modding requires Java 25 or later. We recommend using OpenJDK.
 
-#### Windows
+#### Windows via Installer
 
 1. Download OpenJDK 25 from [Adoptium](https://adoptium.net/)
 2. Run the installer with default settings
+   - Optionally enable feature `Set or Override JAVA_HOME variable` to resolve version related build issues with your project.
 3. Verify installation by opening Command Prompt and running:
 
+#### Windows via Scoop
+
+1. Install Scoop via PowerShell using [scoop.sh](https://scoop.sh/)
+2. Install OpenJDK 25:
+
 ```bash
-java -version
+scoop bucket add java
+scoop install java/openjdk25
 ```
 
 #### macOS
 
+1. Install Brew via Terminal using [brew.sh](https://brew.sh)
+2. Install JDK via Homebrew:
+
 ```bash
-# Using Homebrew
 brew install openjdk@25
 ```
 
@@ -51,22 +104,41 @@ brew install openjdk@25
 
 #### Linux (Ubuntu/Debian)
 
+1. Install JDK via the built-in package repository:
+
 ```bash
 sudo apt update
 sudo apt install openjdk-25-jdk
 ```
 
-### 2. Integrated Development Environment (IDE)
+### Verify installation:
 
-We recommend IntelliJ IDEA Community Edition for Hytale modding.
+Run the following command to see what version of Java you have:
 
-1. Download from [JetBrains website](https://www.jetbrains.com/idea/download/)
-2. Install with default settings
-3. Launch and complete the initial setup wizard
+```bash
+java -version
+```
+
+### Java Build Tool (Optional)
+
+We recommend using a Gradle Wrapper for managing dependencies and building your Hytale plugins. It provides benefits by eliminating the need for a system-wide Gradle installation and ensuring consistent Gradle versions across different environments. (Alternatively you can use Maven, but this guide focuses on Gradle since it is the default for our plugin template.)
+
+The plugin template in the following sections includes a Gradle Wrapper, so you can skip this step if you plan to use the template.
+
+#### Choosing Gradle (if not using the template)
+
+If you prefer to install Gradle manually, follow these steps:
 
-### 3) Java Build Tool
+1. Visit the official website: https://gradle.org/releases/
+2. Download the newest gradle binary: `gradle-9.3.1-bin.zip` (Binary zip archive)
+3. Unzip it
+4. Add the `gradle-9.3.1/bin/` folder to your PATH
+
+You can now try the command `gradle -version` to verify Gradle is installed correctly. Make sure to do this in a fresh new terminal instead of one you had opened from before!
+
+#### Choosing Maven (if not using the template)
 
-We recommend using Apache Maven for managing dependencies and building your Hytale plugins. (Alternatively you can use Gradle, but this guide focuses on Maven.)
+If you prefer to use Maven instead of Gradle, follow these steps to install Maven:
 
 1. Visit the official website: https://maven.apache.org/download.cgi
 2. Download this file: `apache-maven-3.9.12-bin.zip` (Binary zip archive)
@@ -89,22 +161,61 @@ cd MyFirstMod
 
 If you don't have Git installed, you can download the ZIP file from the repository page and extract it to a folder named `MyFirstMod`.
 
-### 2. Open Plugin in your IDEA
+### 2. Open Plugin in your IDE
 
-1. Open IntelliJ IDEA
+1. Open Your IDE (e.g., IntelliJ IDEA)
 2. Click "Open" and navigate to your `MyFirstMod` directory
-3. IntelliJ will automatically detect it as a Maven project
+3. Most IDEs like IntelliJ will automatically detect it as a Gradle project
 4. Wait for the project to index and dependencies to download
 
-<Callout type="info">
-  We recommened following [this](https://gist.github.com/TheNullicorn/90a619796c40f20ae1fcf13094c1a57d) guide to ensure you are using the correct `Nonnull` in your projects.
-</Callout>
+## Alternate Approach: Hytale Dependency
+
+If you prefer to set up your project from scratch without using the template and importing the hytale dependencies manually, ensure your build configuration includes the Hytale repositories and dependencies:
+
+For Gradle, add the following to your `build.gradle.kts`:
+
+```kotlin
+repositories {
+    mavenCentral()
+    maven {
+        name = "hytale"
+        url = uri("https://maven.hytale.com/release") // Or "hytale-pre-release" for pre-release versions
+    }
+}
+dependencies {
+    // + here means the latest version, but you can hard-wire any known version!
+    implementation("com.hypixel.hytale:Server:+")
+}
+```
+
+For Maven, add the following to your `pom.xml`:
+
+```xml
+<project>
+    <repositories>
+        <repository>
+            <id>hytale-release</id> <!-- Or "hytale-pre-release" for pre-release versions -->
+            <url>https://maven.hytale.com/release</url> <!-- Or "https://maven.hytale.com/pre-release" -->
+        </repository>
+    </repositories>
+
+    <dependencies>
+        <dependency>
+            <groupId>com.hypixel.hytale</groupId>
+            <artifactId>Server</artifactId>
+            <!-- Replace with latest version, Hytale provides jars for the last five releases -->
+            <version>LATEST_VERSION_HERE</version>
+            <scope>provided</scope>
+        </dependency>
+    </dependencies>
+</project>
+```
 
 ## Next Steps
 
 Now that you have your development environment set up with the plugin template:
 
-1. **Customize the template** - Edit the `pom.xml` and `manifest.json` file to change your mod's name and details
+1. **Customize the template** - Edit the `settings.gradle.kts`, `build.gradle.kts` and `manifest.json` file to change your mod's name and details
 2. **Explore the code structure** - Familiarize yourself with the template's organization
 3. **Start modding** - Begin writing your first Hytale plugin!
 
diff --git a/content/docs/ja-JP/guides/plugin/spawning-entities.mdx b/content/docs/ja-JP/guides/plugin/spawning-entities.mdx
index e12c0aea..15be2fb3 100644
--- a/content/docs/ja-JP/guides/plugin/spawning-entities.mdx
+++ b/content/docs/ja-JP/guides/plugin/spawning-entities.mdx
@@ -36,7 +36,7 @@ Store<EntityStore> store = world.getEntityStore().getStore();
 
 ## Creating Entities
 
-Once you have the `EntityStore` instance, you can start to create a entity and give it components. Entities are just instances of `Holder<EntityStore>` with several components attached to them.
+Once you have the `EntityStore` instance, you can start to create an entity and give it components. Entities are just instances of `Holder<EntityStore>` with several components attached to them.
 
 <Callout type="warning">
   To interact with the `World` instance, some methods require you to run the code inside the world's execution context.
@@ -118,3 +118,48 @@ Finally, we can add the entity to the world by calling the `addEntity` method on
 ```java
 store.addEntity(holder, AddReason.SPAWN);
 ```
+
+## Making the entity persist
+
+Hytale automatically saves all entities, but the `NetworkId` component (required for players to be able to see the entity) needs to be manually added every time the entity is loaded.
+
+### Using a system
+
+If you have a component that is unique to your entities, this can be done by creating and registering a custom system as follows:
+
+```java
+public class AddNetworkIdToMyEntitySystem extends HolderSystem<EntityStore> {
+    private final ComponentType<EntityStore, MyEntityComponent> myEntityComponentType = MyEntityComponent.getComponentType();
+    private final ComponentType<EntityStore, NetworkId> networkIdComponentType = NetworkId.getComponentType();
+    private final Query<EntityStore> query = Query.and(this.myEntityComponentType, Query.not(this.networkIdComponentType));
+
+    @Override
+    public void onEntityAdd(@NotNull Holder<EntityStore> holder, @NotNull AddReason reason, @NotNull Store<EntityStore> store) {
+        if (!holder.getArchetype().contains(NetworkId.getComponentType())) {
+            holder.addComponent(NetworkId.getComponentType(), new NetworkId(store.getExternalData().takeNextNetworkId()));
+        }
+    }
+
+    @Override
+    public void onEntityRemoved(@NotNull Holder<EntityStore> holder, @NotNull RemoveReason reason, @NotNull Store<EntityStore> store) {}
+
+    @Override
+    public @Nullable Query<EntityStore> getQuery() {
+        return query;
+    }
+}
+```
+
+In your plugin's `setup()` function
+
+```java
+this.getEntityStoreRegistry().registerSystem(new AddNetworkIdToMyEntitySystem())
+```
+
+### Using PropComponent
+
+Alternatively you can add `PropComponent` to your entity. Hytale adds `PropComponent` to entities spawned with the Entity Tool, and such entities automatically get `NetworkId` and `PrefabCopyableComponent` (which makes the entity work with prefabs).
+
+<Callout type="warning">
+  There is no guarantee, that Hytale will not add some other behavior to this component in the future, which may break your entity, so be careful if you decide to rely on it.
+</Callout>
diff --git a/content/docs/ja-JP/guides/plugin/store-persistent-data.mdx b/content/docs/ja-JP/guides/plugin/store-persistent-data.mdx
new file mode 100644
index 00000000..1071dff3
--- /dev/null
+++ b/content/docs/ja-JP/guides/plugin/store-persistent-data.mdx
@@ -0,0 +1,171 @@
+---
+title: Storing Persistent Data on the Player
+description: Learn how to save and load persistent data using Components
+authors:
+  - name: Neil Revin
+    url: https://itsneil.dev/
+  - name: ArcticDev
+    url: https://github.com/ArcticRaven
+  - name: oskarscot
+    url: https://oskar.scot
+  - name: JammingEng
+    url: https://github.com/JammingEnd
+---
+
+Here is how to store persistent data using a custom component on a Player.
+
+## Build your Component Class
+
+Creating a custom component class leverages the Component system made with the ECS architecture in mind. For more information on Components, check out the [ECS Guide](../ecs/hytale-ecs-theory#components).
+
+Start by creating your custom component class. This will be extremely similar to how regular components are created, however we'll setup a custom Codec so the server can translate this data to BSON, or the server's internal json encoder.
+
+<Callout type="info">
+  Each variable you want to store in your component must have its own Codec field defined in the BuilderCodec.
+  For more information on how to create custom Codecs, check out the [ECS Codec Guide](../ecs/hytale-ecs-theory#codec).
+</Callout>
+
+```java
+public class YourPlayerData implements Component<EntityStore> {
+
+    // define some vars!
+    private int someInteger;
+    private String someString;
+    private Map<String, String> someMap;
+
+    public static final BuilderCodec<YourPlayerData> CODEC =
+            BuilderCodec.builder(YourPlayerData.class, YourPlayerData::new)
+            .append(new KeyedCodec<>("SomeInteger", Codec.INTEGER),
+                    (data, value) -> data.someInteger = value, // setter
+                    data -> data.someInteger) // getter
+            .addValidator(Validators.nonNull())
+            .add()
+            .append(new KeyedCodec<>("SomeString", Codec.STRING),
+                    (data, value) -> data.someString = value, // setter
+                    data -> data.someString) // getter
+            .add()
+            .append(new KeyedCodec<>("SomeMap",
+                            new MapCodec<>(Codec.STRING, HashMap::new, false)),
+                    (data, value) -> data.someMap = value, // setter
+                    data -> data.someMap) // getter
+            .add()
+            .build();
+
+
+
+    // Getters and Setters are for the purpose of this example omitted.
+
+    // constructor
+    public YourPlayerData() {
+        this.someInteger = 0;
+        this.someString = "";
+        this.someMap = new HashMap<>();
+    }
+
+    // copy constructor for cloning
+    public YourPlayerData(YourPlayerData clone) {
+        this.someInteger = clone.someInteger;
+        this.someString = clone.someString;
+        this.someMap = clone.someMap;
+    }
+
+    @Nonnull
+    @Override
+    public Component<EntityStore> clone() {
+        return new YourPlayerData(this);
+    }
+}
+```
+
+## Register your Component
+
+Inside your main class's `setup()` method, register your new Component.
+
+```java
+public class YourPlugin extends JavaPlugin {
+
+    private ComponentType<EntityStore, YourPlayerData> yourPlayerDataComponent;
+
+    public YourPlugin(@Nonnull JavaPluginInit init) {
+        super(init);
+    }
+
+    @Override
+    protected void setup(){
+        this.yourPlayerDataComponent = this.getEntityStoreRegistry().registerComponent(
+            YourPlayerData.class,
+            "YourPlayerDataComponent",
+            YourPlayerData.CODEC
+        );
+    }
+
+    public ComponentType<EntityStore, YourPlayerData> getYourPlayerDataComponent() {
+        return this.yourPlayerDataComponent;
+    }
+}
+```
+
+## Using your Component
+
+To use your newly created component, you can add the Component to a player using the `addComponent` method, although this only adds it temporarily, meaning when the player/entity leaves the world, the component is removed. You can use `putComponent` to ensure the component persists between sessions.
+
+```java
+// You will need the Ref and Store to apply components
+private void someEntryMethod(@Nonnull Ref<EntityStore> ref, @Nonnull Store<EntityStore> store)
+{
+       // Any entity will work, for now we will use the player
+      Player player = (Player) store.getComponent(ref, Player.getComponentType());
+
+      // since we're using putComponent, it could be useful to check if it already exists on the player in case we want to update it
+     if(store.getComponent(ref, YourPlugin.instance().getYourPlayerDataComponent()) != null)
+     {
+          // here we implement logic that updates the component
+         var comp = store.getComponent(ref, YourPlugin.instance().getYourPlayerDataComponent())
+         // declare public fields or methods in the component class
+         comp.SomeString = "An Updated Field";
+     } else {
+          // Here we put the component
+          var myCustomComp = new CustomComponent();
+          // declare public fields or methods in the component class
+          myCustomComp.SomeString = "Edited String";
+
+          // putComponent allows you to insert declared objects
+          store.putComponent(ref, YourPlugin.instance().getYourPlayerDataComponent(), myCustomComp);
+     }
+}
+```
+
+## Using your Data
+
+Your component will be stored within the `Store<EntityStore>` when added to the player. In the provided example,
+we'll fetch this data off the player using the `ensureAndGetComponent()` method, which will add the component to
+the player if it does not exist with the default values.
+
+```java
+public class IncompleteCustomCommand extends AbstractPlayerCommand {
+
+    public IncompleteCustomCommand() {
+        super("nope", "don't use this command");
+    }
+
+    @Override
+    protected void execute(
+        @NonNullDecl CommandContext commandContext,
+        @NonNullDecl Store<EntityStore> store,
+        @NonNullDecl Ref<EntityStore> ref,
+        @NonNullDecl PlayerRef playerRef,
+        @NonNullDecl World world
+    ) {
+        YourPlayerData customData = store.ensureAndGetComponent(ref, YourPlugin.instance().getYourPlayerDataComponent());
+        // ensureAndGetComponent adds the component to the ref, with the default values defined inside your component.
+ 		// use your data
+    }
+}
+```
+
+And that's it! Your data will now be saved and loaded automatically with the player.
+
+Using custom components to store persistent data on players is a powerful way to maintain state across sessions.
+By following the steps outlined above, you can easily create, register, and utilize your own data structures within the Hytale ECS framework.
+This approach ensures that your data is seamlessly integrated with the game's existing systems.
+For more information about Hytale's Entity Component System visit the [Hytale ECS Theory](https://hytalemodding.dev/en/docs/guides/ecs/hytale-ecs-theory) guide.
diff --git a/content/docs/ja-JP/guides/plugin/teleporting-players.mdx b/content/docs/ja-JP/guides/plugin/teleporting-players.mdx
index 57cee77f..32ce0435 100644
--- a/content/docs/ja-JP/guides/plugin/teleporting-players.mdx
+++ b/content/docs/ja-JP/guides/plugin/teleporting-players.mdx
@@ -1,26 +1,32 @@
 ---
 title: Teleporting the player
 description: Learn how to teleport the player.
+authors:
+  - name: oskarscot
+    url: https://oskar.scot
 ---
 
-To teleport players in Hytale, you will need to get a `World` object so we can safely run the teleport on the world thread. The world thread manages all entity updates, so modifying entities off-thread can crash the server or cause inconsistent state.
-Next, we get the entity store and make a `Teleport` object.
-We add a `Teleport` component to the player’s entity reference in the entity store. This triggers the teleportation logic for that player.
+Teleporting players in Hytale works by simply attaching a `Teleport` component to a player with the desired world and transform.
+You can only trigger teleports from a world where the player is currently present.
+Teleport itself is a component but it also provides factory methods to configure the Teleport. Just as with any entity component, an EntityStore and a Ref to the EntityStore is required
+
+We can create a simple teleport utility like this:
 
 ```java
-public static void teleportPlayer(Player player, int x, int y, int z) {
-        World world = player.getWorld();
-        if (world == null) return;
-        world.execute(() -> {
-            if (player.getReference() == null) return;
-            Store<EntityStore> store = player.getReference().getStore();
-            Teleport teleport = Teleport.createForPlayer(world,
-                new Vector3d(x ,y, z), // Target position
-                new Vector3f(0, 0, 0)  // Target rotation (pitch, yaw, roll)
-            );
+public static void teleportPlayer(Ref<EntityStore> ref, Store<EntityStore> store, World targetWorld, double x, double y, double z) {                                                                                       
+    Transform transform = new Transform(x, y, z);                                                                                                                           
+    Teleport teleport = Teleport.createForPlayer(targetWorld, transform);                                                                                                   
+    store.addComponent(ref, Teleport.getComponentType(), teleport);                                                                                                         
+}  
+```
 
-            store.addComponent(player.getReference(), Teleport.getComponentType(), teleport);
-        });
+A `Transform` is a representation of a position Vector3d and rotation Vector3f which works in the following way:
 
-}
+```java
+Transform transform = new Transform(
+    new Vector3d(x, y, z),      // Position
+    new Rotation(yaw, pitch, 0) // Rotation, last value seems to always be 0
+);
+Teleport teleport = Teleport.createForPlayer(targetWorld, transform);
+store.addComponent(ref, Teleport.getComponentType(), teleport);
 ```
diff --git a/content/docs/ja-JP/guides/plugin/tracking-mod-analytics-with-hstats.mdx b/content/docs/ja-JP/guides/plugin/tracking-mod-analytics-with-hstats.mdx
new file mode 100644
index 00000000..45c022e0
--- /dev/null
+++ b/content/docs/ja-JP/guides/plugin/tracking-mod-analytics-with-hstats.mdx
@@ -0,0 +1,65 @@
+---
+title: Tracking Mod Analytics with HStats
+description: Learn how you can track Analytics for your Hytale Mod for Free using hstats.dev
+authors:
+  - name: Al3x
+    url: https://hstats.dev
+---
+
+In this guide, you will learn how to integrate HStats into your Plugin/Mod which will allow you to track how many Servers are using it along with other stats.
+
+<Callout type="info">
+  HStats is a third-party tool and is not affiliated with HytaleModding or Hypixel Studios
+</Callout>
+
+# Step 1: Register your Mod to HStats
+
+Before you touch any code, you will need to add your mod to the HStats website which will give you a UUID for your mod.
+
+- Create or Login to an Account on https://hstats.dev
+- Navigate to the dashboard page (https://hstats.dev/dashboard)
+- On the left, type in your mod's name and click "Add Mod"
+- Keep note of the UUID generated for later.
+
+# Step 2: Add the HStats Class to Your Project
+
+To keep things simple, HStats uses a single Java class file that handles everything for you.
+
+- Download / Copy the File from the GitHub page (https://github.com/hstats-dev/HStatsExamplePlugin/blob/main/src/main/java/com/al3x/HStats.java)
+- Paste into your Project. You should now have a HStats.java file somewhere in your projects directory.
+- Update the package name from com.al3x to whatever fits your project.
+
+# Step 3: Initialize HStats in your code
+
+You only need to add one line of code to your mod's setup method in your main class to start tracking.
+
+`new HStats("YOUR-MOD-UUID", "1.0.0");`
+
+Replace `YOUR-MOD-UUID` with the Mod UUID we made note of earlier and change the `1.0.0` version to whatever version your mod is currently on.
+
+Your setup method should now look something like this:
+
+```java
+@Override
+protected void setup() {
+  super.setup();
+  new HStats("c34a2b2a-afd8-4d6a-821e-7a63e12c5ea6", "1.0.0");
+}
+```
+
+# Extras
+
+Your done! Your mod should now be listed under the Mods page (https://hstats.dev/mods) as well as under your dashboard.
+
+Servers using your mod should now post updates about every minute to HStats which you can view in the Dashboard.
+
+### Embeds
+
+HStats allows you to generate an Embed Card that you can place on your CurseForge or GitHub page. This is useful for server owners to be able to see how many other servers are using your mod.
+
+- In your dashboard, scroll down to the Embed Card section.
+- Customize the appearance (Light/Dark mode, layout, etc).
+- Copy the generated URL to display your "Active Servers" and "Players Online" live on your mod's description page
+
+Heres an example of what they look like:
+![HStats Example](https://api.hstats.dev/api/embed/d52fa672-6966-47b2-b501-1a11bddebac3/card.svg?theme=light\&layout=compact\&size=md\&show_id=true\&dark=false)
diff --git a/content/docs/ja-JP/guides/plugin/world-gen.mdx b/content/docs/ja-JP/guides/plugin/world-gen.mdx
index 4c23b0c9..7b193ffd 100644
--- a/content/docs/ja-JP/guides/plugin/world-gen.mdx
+++ b/content/docs/ja-JP/guides/plugin/world-gen.mdx
@@ -100,7 +100,7 @@ Biome biome = biomeGen.generateBiomeAt(zoneResult, seed, x, z);
 
 ### Zone & Cave Integration
 
-Each zone defines it's own cave patterns:
+Each zone defines its own cave patterns:
 
 ```java
 Zone zone = /* ... */;
diff --git a/content/docs/ja-JP/guides/prefabs.mdx b/content/docs/ja-JP/guides/prefabs.mdx
index 83f6bafe..effc4025 100644
--- a/content/docs/ja-JP/guides/prefabs.mdx
+++ b/content/docs/ja-JP/guides/prefabs.mdx
@@ -14,7 +14,7 @@ authors:
 プレハブについて理解すべきいくつかの基本的な概念があります。
 
 - ユーザーは、プレハブ編集ワールドを介してプレハブを操作します。
-- プレハブはゲーム世界における物理的な構造であり、JSON ファイルとして保存されます。
+- Prefabs are the physical structures in the game world, and are saved as JSON files.
 
 ## プレハブの作り方
 
@@ -38,51 +38,51 @@ authors:
 この一覧では、各コマンドの詳細なオプションについては説明しません。 コマンドの最後に `--help` フラグを追加することで利用可能なオプションの一覧を表示できます。 例: `/prefab save --help`\
 また、 `/help` コマンドを使用してコマンドのヘルプ画面を表示し、 `prefab` や `editprefab` の項目から詳細を確認することもできます。
 
-###
+### `/prefab`
 
 このコマンドを使うと、既存のプレハブファイルを操作することができます。
 
 サブコマンド:
 
--
+- `save`
   - プレハブをファイルシステムに保存します。
--
+- `load`
   - プレハブをゲームにロードします。
--
+- `delete`
   - プレハブをファイルシステムから削除します。
--
+- `list`
   - ファイルシステム内のプレハブの一覧を表示します。
 
-###
+### `/editprefab`
 
 `/editprefab` コマンドは、プレハブが持っているゲーム内の物理的な構造を作成または編集するために使用されます。\
 (訳注: 翻訳時点で、 `/editprefab` コマンドを使うには OP 権限が必要です。シングルプレイの場合、 `/op` コマンドで OP 権限を獲得可能です。)
 
 サブコマンド:
 
--
+- `exit`
   - 現在のプレハブ編集ワールドを終了します。
--
+- `load`
   - 新しいプレハブ編集ワールドを作成し、そこに既存のプレハブを貼り付けます。
--
+- `new`
   - 新しいプレハブを0から作成するために、プレハブ編集ワールドを作成します。
--
+- `select`
   - プレイヤーが見ているプレハブ領域を選択します (200ブロック以内) 。
--
+- `save`
   - 既存の領域または現在選択している領域を使って現在のプレハブを保存します。
--
+- `saveui`
   - 現在のワールドのセーブUIを開き、ワールド内の全てのプレハブを操作できるようにします。
--
+- `kill`
   - 現在選択されているプレハブ内のすべてのエンティティをデスポーン (削除) します。
--
+- `saveas`
   - 選択したプレハブを新しいファイルに保存します。
--
+- `setbox`
   - 現在選択されているプレハブのバウンディングボックスを設定します。
--
+- `info`
   - 現在選択されているプレハブの一般的な情報を表示します。
--
+- `tp`
   - 現在の編集ワールド内のプレハブにテレポートするためのテレポートUIを開きます。
--
+- `modified`
   - 現在の編集ワールド内の、保存されていない変更を含むプレハブの一覧が表示されます。
 
 # 既知の問題
diff --git a/content/docs/ja-JP/official-documentation/custom-ui/common-styling.mdx b/content/docs/ja-JP/official-documentation/custom-ui/common-styling.mdx
new file mode 100644
index 00000000..c36e3e3a
--- /dev/null
+++ b/content/docs/ja-JP/official-documentation/custom-ui/common-styling.mdx
@@ -0,0 +1,50 @@
+---
+title: Common Styling
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# Common Styling
+
+## Common UI Styling Library
+
+This document describes the shared UI components and styles defined in `Common.ui`.
+
+---
+
+### Styles
+
+We are providing some styles that can be re-used in any custom UI that, provide a cohesive UI experience with the core game UI. These styles are available in the `Common.ui` file.
+
+You can find a list of all the styles defined with live examples by running the `/ui-gallery` command ingame.
+
+<Callout type="warning">
+  This command is not available yet, but will be in a future patch.
+</Callout>
+
+![Gallery](/assets/official-documentation/ui/gallery.png)
+
+### Importing
+
+To use these styles in your UI file:
+
+```
+$Common = "Common.ui";
+
+// Then reference styles and components:
+$Common.@TextButton { @Text = "My Button"; }
+$Common.@Container { ... }
+```
+
+<Callout type="info">
+  The `Common.ui` file is at `Common/UI/Custom/Common.ui` within the Hytale pack. If your custom ui document is in a subfolder of `Common/UI/Custom/`, reference it via relative path traversal:
+
+  ```
+  $Common = "../Common.ui";
+  ```
+
+  You can find more info about paths [here](markup#path).
+</Callout>
diff --git a/content/docs/ja-JP/official-documentation/custom-ui/index.mdx b/content/docs/ja-JP/official-documentation/custom-ui/index.mdx
new file mode 100644
index 00000000..f94c4e88
--- /dev/null
+++ b/content/docs/ja-JP/official-documentation/custom-ui/index.mdx
@@ -0,0 +1,125 @@
+---
+title: Custom UI
+icon: LayoutDashboard
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# Custom UI
+
+## What is Custom UI?
+
+Custom UI is Hytale's framework for creating **custom user interfaces** controlled by the game server. Unlike the built-in Client UI (which is part of the game client and cannot be modified), Server UI allows you to create interactive screens and HUD overlays through Java plugins and asset packs.
+
+As a modder, Custom UI gives you the power to:
+
+- **Create custom interactive pages** - Shop interfaces, quest dialogs, server settings menus, admin panels
+- **Add custom HUD overlays** - Quest trackers, status displays, custom health bars, server information
+- **Design with markup** - Use `.ui` files to define reusable UI templates
+- **Handle user interactions** - Respond to button clicks, form submissions, and other events
+- **Localize your UI** - Support multiple languages using the game's translation system
+
+## How Custom UI Fits Into Hytale's UI
+
+Hytale's user interface is divided into two main categories:
+
+### Client UI (Not Moddable)
+
+Built-in interfaces controlled by the C# game client:
+
+- Main menu and settings
+- Character creation
+- Built-in HUD (health, hotbar, chat)
+- Inventory and crafting screens
+- Development tools
+
+**You cannot modify these** - they are part of the core game client.
+
+### In-Game UI (Moddable via Server)
+
+Server-controlled interfaces that you can create and customize:
+
+#### Custom Pages
+
+Full-screen interactive overlays that appear during gameplay:
+
+- Can be dismissed by the player (ESC key)
+- Capture all input (keyboard and mouse)
+- Support loading states while waiting for server responses
+- Perfect for: shops, dialogs, menus, configuration screens
+
+#### Custom HUDs
+
+Persistent overlay elements drawn on top of the game world:
+
+- Display-only (no user interaction)
+- Always visible during gameplay
+- Lightweight and non-intrusive
+- Perfect for: quest objectives, status indicators, server info panels
+
+## Architecture Overview
+
+Server UI uses a **command-based architecture**:
+
+```
+┌─────────────────────┐         ┌──────────────────────┐
+│   Java Server       │         │    C# Client         │
+│   (Your Plugin)     │         │    (Game)            │
+├─────────────────────┤         ├──────────────────────┤
+│                     │         │                      │
+│ InteractiveCustomUI │         │   CustomPage or      │
+│ Page                │         │   CustomHud          │
+│   ↓ build()         ├────────→│     ↓ Apply          │
+│ UICommandBuilder    │         │   Element Tree       │
+│   - append()        │         │     ↓ Layout         │
+│   - set()           │         │   Rendered UI        │
+│   - clear()         │         │                      │
+│                     │         │                      │
+│ ↓ handleDataEvent() │← Events │   User Interaction   │
+│   Process input     │         │   (click, type, etc) │
+│   sendUpdate()      │         │                      │
+└─────────────────────┘         └──────────────────────┘
+```
+
+**The flow:**
+
+1. Your Java code builds UI using `UICommandBuilder`
+2. Commands are sent to the client as data
+3. Client parses `.ui` markup files and creates visual elements
+4. User interacts with the UI
+5. Events are sent back to your Java code
+6. You process events and send updates back
+
+## Key Principles
+
+### Declarative, Not Imperative
+
+You don't create UI objects directly. Instead, you send **commands** that describe what you want:
+
+- "Append this button template to that container"
+- "Set this label's text to 'Hello World'"
+- "Clear all children from this list"
+
+### Asset-Driven
+
+UI structure is defined in `.ui` markup files (assets), not hardcoded in Java. This enables:
+
+- Designers to modify layouts without touching code
+- Reusable UI components
+- Consistent visual language
+
+### Event-Driven
+
+User interactions trigger events that flow back to your server code. You register event bindings and handle them in `handleDataEvent()`.
+
+### Selector-Based
+
+You target specific UI elements using **selectors:**
+
+- `#MyButton` - Element with ID "MyButton"
+- `#List[0]` - First child of element "List"
+- `#List[0] #Title` - Element with ID "Title" in the first child of element "List"
+- `#Label.TextColor` - The TextColor property of element "Label"
diff --git a/content/docs/ja-JP/official-documentation/custom-ui/layout.mdx b/content/docs/ja-JP/official-documentation/custom-ui/layout.mdx
new file mode 100644
index 00000000..0a24ca09
--- /dev/null
+++ b/content/docs/ja-JP/official-documentation/custom-ui/layout.mdx
@@ -0,0 +1,492 @@
+---
+title: Layout
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# Layout
+
+The layout system determines how UI elements are positioned and sized on screen. Understanding layout is crucial for creating well-structured, responsive interfaces.
+
+## Layout Fundamentals
+
+Every UI element has:
+
+- **Container Rectangle** - The space allocated by the parent
+- **Anchor** - How the element positions/sizes itself within the container
+- **Padding** - Inner spacing that affects child layout
+- **LayoutMode** - How the element arranges its children (if it's a container)
+
+```
+┌─────────────────────────────────────┐
+│  Container Rectangle (from parent)  │
+│  ┌───────────────────────────────┐  │
+│  │  Anchored Rectangle           │  │
+│  │  ┌─────────────────────────┐  │  │
+│  │  │ Padding                 │  │  │
+│  │  │  ┌───────────────────┐  │  │  │
+│  │  │  │  Content Area     │  │  │  │
+│  │  │  └───────────────────┘  │  │  │
+│  │  └─────────────────────────┘  │  │
+│  └───────────────────────────────┘  │
+└─────────────────────────────────────┘
+```
+
+## Anchor
+
+`Anchor` controls how an element positions and sizes itself within its container rectangle.
+
+### Fixed Size
+
+```
+Button {
+    Anchor: (Width: 200, Height: 40);
+}
+```
+
+Creates a 200×40 pixel button.
+
+### Positioning
+
+```
+Label {
+    Anchor: (Top: 10, Left: 20, Width: 100, Height: 30);
+}
+```
+
+- **Top**: 10 pixels from container's top edge
+- **Left**: 20 pixels from container's left edge
+- **Width**: 100 pixels wide
+- **Height**: 30 pixels tall
+
+### Anchoring to Edges
+
+```
+Button {
+    Anchor: (Bottom: 10, Right: 10, Width: 100, Height: 30);
+}
+```
+
+Anchors the button to the bottom-right corner, 10 pixels from each edge.
+
+### Stretching
+
+```
+Group {
+    Anchor: (Top: 0, Bottom: 0, Left: 0, Right: 0);
+}
+```
+
+Stretches to fill the entire container (all edges at 0 pixels).
+
+**Shorthand:**
+
+```
+Group {
+    Anchor: (Full: 0);
+}
+```
+
+### Mixed Anchoring
+
+```
+Panel {
+    Anchor: (Top: 10, Bottom: 10, Left: 20, Width: 300);
+}
+```
+
+- Fixed width of 300 pixels
+- Stretches vertically between top and bottom edges
+- 10 pixels from top and bottom
+- 20 pixels from left
+
+## Padding
+
+`Padding` creates inner spacing, affecting where children are positioned.
+
+### Uniform Padding
+
+```
+Group {
+    Padding: (Full: 20);
+}
+```
+
+20 pixels of padding on all sides.
+
+### Directional Padding
+
+```
+Group {
+    Padding: (Top: 10, Bottom: 20, Left: 15, Right: 15);
+}
+```
+
+Different padding per edge.
+
+### Shorthand
+
+```
+// Horizontal and vertical
+Group {
+    Padding: (Horizontal: 20, Vertical: 10);
+}
+
+// Equivalent to:
+// Top: 10, Bottom: 10, Left: 20, Right: 20
+```
+
+### Effect on Children
+
+```
+Group {
+    Anchor: (Width: 200, Height: 100);
+    Padding: (Full: 10);
+
+    Label {
+        Anchor: (Full: 0);
+    }
+}
+```
+
+The label fills the group, but there's a 10-pixel gap on all sides due to padding.
+
+```
+┌──────────────────────┐
+│ Group (200×100)      │
+│  ┌────────────────┐  │
+│  │ Label          │  │ ← 10px padding all around
+│  │                │  │
+│  └────────────────┘  │
+└──────────────────────┘
+```
+
+## LayoutMode
+
+`LayoutMode` determines how a container arranges its children.
+
+### Top (Vertical Stack)
+
+```
+Group {
+    LayoutMode: Top;
+
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+}
+```
+
+Children stack vertically from top to bottom:
+
+```
+┌──────────┐
+│ Button 1 │
+├──────────┤
+│ Button 2 │
+├──────────┤
+│ Button 3 │
+└──────────┘
+
+
+```
+
+Each child's `Anchor.Bottom` adds spacing between elements:
+
+```
+Button { Anchor: (Height: 30, Bottom: 10); }  // 10px gap after this button
+```
+
+### Bottom (Vertical Stack)
+
+```
+Group {
+    LayoutMode: Bottom;
+
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+}
+```
+
+Children stack vertically from top to bottom but aligned to the bottom edge of the parent:
+
+```
+
+
+
+┌──────────┐
+│ Button 1 │
+├──────────┤
+│ Button 2 │
+├──────────┤
+│ Button 3 │
+└──────────┘
+```
+
+### Left (Horizontal Stack)
+
+```
+Group {
+    LayoutMode: Left;
+
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+}
+```
+
+Children arrange horizontally from left to right:
+
+```
+┌────────┬────────┬────────┐
+│ Button │ Button │ Button │
+│   1    │   2    │   3    │
+└────────┴────────┴────────┘
+```
+
+Use `Anchor.Right` for spacing between elements.
+
+### Right (Horizontal Stack)
+
+```
+Group {
+    LayoutMode: Right;
+
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+}
+```
+
+Children arrange horizontally from left to right but aligned to the right side of the parent:
+
+```
+                                                                 ┌────────┬────────┬────────┐
+                                                                 │ Button │ Button │ Button │
+                                                                 │   1    │   2    │   3    │
+                                                                 └────────┴────────┴────────┘
+```
+
+### Center
+
+```
+Group {
+    LayoutMode: Center;
+
+    Group #Dialog {
+        Anchor: (Width: 400, Height: 300);
+    }
+}
+```
+
+Centers the children horizontally.
+
+### Middle
+
+```
+Group {
+    LayoutMode: Middle;
+
+    Group #Dialog {
+        Anchor: (Width: 400, Height: 300);
+    }
+}
+```
+
+Centers the children vertically.
+
+### CenterMiddle (Horizontal Stack, Fully Centered)
+
+```
+Group {
+    LayoutMode: CenterMiddle;
+
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+}
+```
+
+Children stack horizontally from left to right, centered both horizontally and vertically within the parent:
+
+```
+┌────────────────────────────────────────────┐
+│                                            │
+│                                            │
+│         ┌──────┐ ┌──────┐ ┌──────┐         │
+│         │  B1  │ │  B2  │ │  B3  │         │
+│         └──────┘ └──────┘ └──────┘         │
+│                                            │
+│                                            │
+└────────────────────────────────────────────┘
+```
+
+---
+
+### MiddleCenter (Vertical Stack, Fully Centered)
+
+```
+Group {
+    LayoutMode: MiddleCenter;
+
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+}
+```
+
+Children stack vertically from top to bottom, centered both horizontally and vertically within the parent:
+
+```
+┌────────────────────────────────────────────┐
+│                                            │
+│              ┌──────────┐                  │
+│              │ Button 1 │                  │
+│              ├──────────┤                  │
+│              │ Button 2 │                  │
+│              ├──────────┤                  │
+│              │ Button 3 │                  │
+│              └──────────┘                  │
+│                                            │
+└────────────────────────────────────────────┘
+```
+
+---
+
+### Full
+
+```
+Group {
+    LayoutMode: Full;
+
+    Label {
+        Anchor: (Top: 20, Left: 20, Width: 100, Height: 30);
+    }
+}
+```
+
+Children use absolute positioning via their `Anchor` properties.
+
+### TopScrolling
+
+```
+Group {
+    LayoutMode: TopScrolling;
+    ScrollbarStyle: $Common.@DefaultScrollbar;
+
+    // ... many children
+}
+```
+
+Like `Top`, but adds a scrollbar if content exceeds container height.
+
+Or use `BottomScrolling` for bottom-aligned content.
+
+### LeftScrolling
+
+```
+Group {
+    LayoutMode: LeftScrolling;
+    ScrollbarStyle: $Common.@DefaultScrollbar;
+
+    // ... many children
+}
+```
+
+Like `Left`, but adds a scrollbar for horizontal scrolling.
+
+Or use `RightScrolling` for right-aligned content.
+
+### LeftCenterWrap (Wrapping Horizontal Stack, Horizontally Centered)
+
+```
+Group {
+    LayoutMode: LeftCenterWrap;
+
+    Button { Anchor: (Width: 80, Height: 30); }
+    Button { Anchor: (Width: 80, Height: 30); }
+    Button { Anchor: (Width: 80, Height: 30); }
+    Button { Anchor: (Width: 80, Height: 30); }
+    Button { Anchor: (Width: 80, Height: 30); }
+}
+```
+
+Children flow left to right. When there's no more horizontal space, they wrap to the next row. Each row is horizontally centered within the parent:
+
+```
+┌────────────────────────────────────────────┐
+│                                            │
+│       ┌──────┐ ┌──────┐ ┌──────┐           │
+│       │  B1  │ │  B2  │ │  B3  │           │
+│       └──────┘ └──────┘ └──────┘           │
+│            ┌──────┐ ┌──────┐               │
+│            │  B4  │ │  B5  │               │
+│            └──────┘ └──────┘               │
+│                                            │
+└────────────────────────────────────────────┘
+```
+
+## FlexWeight
+
+`FlexWeight` distributes remaining space among children.
+
+```
+Group {
+    LayoutMode: Left;
+    Anchor: (Width: 400);
+
+    Button {
+        Anchor: (Width: 100);
+    }
+
+    Group {
+        FlexWeight: 1;  // Takes all remaining space
+    }
+
+    Button {
+        Anchor: (Width: 100);
+    }
+}
+```
+
+Result:
+
+- First button: 100px
+- Middle group: 200px (400 - 100 - 100 = 200)
+- Last button: 100px
+
+### Multiple FlexWeights
+
+```
+Group {
+    LayoutMode: Left;
+    Anchor: (Width: 600);
+
+    Group { FlexWeight: 1; }
+    Group { FlexWeight: 2; }
+    Group { FlexWeight: 1; }
+}
+```
+
+Remaining space (600px) is split:
+
+- First group: 600 × (1/4) = 150px
+- Second group: 600 × (2/4) = 300px
+- Third group: 600 × (1/4) = 150px
+
+## Visibility
+
+```
+Button #HiddenButton {
+    Visible: false;
+}
+```
+
+**Effect:**
+
+- Element and its children are not displayed
+- Element is **not included in layout** (doesn't take up space)
diff --git a/content/docs/ja-JP/official-documentation/custom-ui/markup.mdx b/content/docs/ja-JP/official-documentation/custom-ui/markup.mdx
new file mode 100644
index 00000000..564110ed
--- /dev/null
+++ b/content/docs/ja-JP/official-documentation/custom-ui/markup.mdx
@@ -0,0 +1,226 @@
+---
+title: Markup
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# Markup
+
+## Markup
+
+An element is the basic building block of a user interface. There are various types of elements with different properties, which are documented below.
+
+Here's what the syntax looks like:
+
+```
+// Basic declaration of an element
+// with its Anchor property set to attach on all sides of its parent
+// with 10 pixels of margin
+Group { Anchor: (Left: 10, Top: 10, Right: 10, Bottom: 10); }
+
+Group { Anchor: (Full: 10); } // More concise version
+
+// Declaration of a Label with a name
+// (can be used to access the element from game code)
+Label #MyLabel {
+  Style: LabelStyle(FontSize: 16); // or just Style: (FontSize: 16), type can be inferred.
+  Text: "Hi! I am text.";
+}
+
+// Declaration of a Group containing 2 children
+// You can use FlexWeight to distribute any left-over space after explicit widths/heights have been subtracted
+Group {
+  LayoutMode: Left;
+  Label { Text: "Child 1"; FlexWeight: 2; }
+  Label { Text: "Child 2"; FlexWeight: 1; }
+}
+```
+
+### Documents
+
+A UI document (_.ui_ file) contains trees of elements. There can be multiple root elements.
+
+### Named Expressions
+
+Named expressions can be declared at any level of a document (including at the root) and will be scoped to that subtree, though they need to be declared at the top of the block.
+
+```
+// Example of named expressions, declared and used with @ prefix
+@Title = "Hytale";
+@ExtraSpacing = 5;
+
+Label {
+  Text: @Title;
+  Style: (LetterSpacing: 2 + @ExtraSpacing);
+}
+```
+
+You can use the spread operator `...` to reuse a named expression while overriding some of its fields:
+
+```
+@MyBaseStyle = LabelStyle(FontSize: 24, LetterSpacing: 2);
+
+Label {
+  Style: (...@MyBaseStyle, FontSize: 36);
+}
+```
+
+You can even layer multiple named expressions like so:
+
+```
+@TitleStyle = LabelStyle(FontSize: 24, HorizontalAlignment: Center);
+@SpacedTextStyle = LabelStyle(LetterSpacing: 2);
+
+Label {
+  Style: (...@BigTextStyle, ...@SpacedTextStyle);
+}
+```
+
+#### Document references
+
+A document can reference another document and access its named expressions.
+
+```
+// Document references are defined with $ prefix
+$Common = "../Common.ui";
+
+TextButton {
+  Style: $Common.@DefaultButtonStyle;
+}
+```
+
+### Templates
+
+You can declare a reusable bit of interface as a named expression and then instantiate it as many times as you want in the tree while customizing it.
+
+You can override local named expressions as well as insert additional children at any point in the template tree. However, local named expressions must be defined at the very top of the block, before properties and child elements.
+
+```
+// This is the template
+@Row = Group {
+  Anchor: (Height: 50);
+  Label #Label { Anchor: (Left: 0, Width: 100); Text: @LabelText; }
+  Group #Content { Anchor: (Left: 100); }
+};
+
+// Here we'll be using it twice in the document tree
+Group #Rows {
+  LayoutMode: TopScrolling;
+
+  @Row #MyFirstRow {
+    @LabelText = "First row";
+    #Content { TextInput {} }
+  }
+
+  @Row #MySecondRow {
+    @LabelText = "Second row";
+  }
+}
+```
+
+### Property Types
+
+#### Basic Types
+
+- **Boolean**
+  - `Visible: false;`
+  - `Visible: true;`
+- **Int**
+  - `Height: 20;`
+- **Float, Double, Decimal**
+  - `Min: 0.2;`
+- **String**
+  - `Text: "Hi!";`
+- **Char**
+  - `PasswordChar: "*";`
+  - _Note: The syntax is the same as a string, however a value of this type cannot contain more than one character!_
+- **Color**
+  - `Background: #ffffff;`&#x20;
+- **Objects**
+  - `Style: (Background: #ffffff)`
+- **Array**&#x20;
+  - `TextSpans: [(Text: "Hi", IsBold: true)]`
+
+#### Translations
+
+Translation keys can be referenced anywhere in markup where you can provide a string, and they are then converted to a string when an element gets instantiated.
+
+**Example:**
+
+```
+Label {
+  Text: %ui.general.cancel;
+}
+```
+
+#### Colors
+
+A color literal can be written as follows:
+
+- `#rrggbb`: 6-digit hexadecimal representation for red, green, blue (fully opaque)
+- `#rrggbb(a.a)`: 6-digit hexadecimal representation for red, green, blue with alpha between 0 and 1
+- `#rrggbbaa`: 8-digit hexadecimal representation for red, green, blue and alpha
+
+```
+Group {
+  Background: #000000(0.3);
+}
+```
+
+<Callout>
+  The `#rrggbb(a.a)` format is prefered over the `#rrggbbaa` format for
+  readability reasons.
+</Callout>
+
+#### Font Name
+
+Font names can be referenced directly by their string ID. Internally this is using a custom type called `UIFontName`, however strings will be converted automatically to this type in markup.
+
+```
+Label {
+  Text: "Hi";
+  Style: (FontName: "Secondary");
+}
+```
+
+**Available Font Names**
+
+- _Default_ - This is the default font that is used for most text and is always used unless a different option has been specified
+- _Secondary_ - This font is mostly used for headlines or elements that are supposed to stick out
+- _Mono_ - This is only used for development; For things such as profiling or error overlays.
+
+#### Path
+
+We can reference other UI assets with the `UIPath` type. Similar to `UIFontName`_,_ Strings are automatically converted to a `UIPath`. Paths are always relative to the file where they have been declared in. Looking up _MyButton.png_ in _Menu/MyAwesomeMenu.ui_ will result in _Menu/MyButton.png_. If you want to reference a file that is in a parent folder you can go back one directory by writing two dots (_../MyButton.png_).
+
+The markup syntax of a `UIPath` is the same as a String. (e.g. `Path: "Test.png"`)
+
+Here are some more examples:
+
+| UIPath             | .ui File                              | Resulting Path    |
+| ------------------ | ------------------------------------- | ----------------- |
+| MyButton.png       | Menu/MyAwesomeMenu.ui                 | Menu/MyButton.png |
+| ../MyButton.png    | Menu/MyAwesomeMenu.ui                 | MyButton.png      |
+| ../../MyButton.png | Menu/Popup/Templates/MyAwesomeMenu.ui | Menu/MyButton.png |
+
+#### Objects
+
+Objects contain a set of properties. In this example we are assigning an Anchor object to the _Anchor_ property:
+
+```
+Group {
+  Anchor: (
+   Height: 10,
+   Width: 20
+ );
+}
+```
+
+You can find all objects that can be used in markup [here](type-documentation#elements).
+
+## Visual Studio Code Extension
+
+There is an official extension for Visual Studio Code which adds syntax highlighting for .ui files. You can find it [here](https://marketplace.visualstudio.com/items?itemName=HypixelStudiosCanadaInc.vscode-hytaleui).
diff --git a/content/docs/ja-JP/official-documentation/custom-ui/type-documentation/index.mdx b/content/docs/ja-JP/official-documentation/custom-ui/type-documentation/index.mdx
new file mode 100644
index 00000000..69cea406
--- /dev/null
+++ b/content/docs/ja-JP/official-documentation/custom-ui/type-documentation/index.mdx
@@ -0,0 +1,127 @@
+---
+title: Type Documentation
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# Type Documentation
+
+This is a generated list of UI elements accessible by markup. More information about the User Interface framework can be found in the main documentation.
+
+## Elements
+
+- [ActionButton](type-documentation/elements/actionbutton)
+- [AssetImage](type-documentation/elements/assetimage)
+- [BackButton](type-documentation/elements/backbutton)
+- [BlockSelector](type-documentation/elements/blockselector)
+- [Button](type-documentation/elements/button)
+- [CharacterPreviewComponent](type-documentation/elements/characterpreviewcomponent)
+- [CheckBox](type-documentation/elements/checkbox)
+- [CheckBoxContainer](type-documentation/elements/checkboxcontainer)
+- [CircularProgressBar](type-documentation/elements/circularprogressbar)
+- [CodeEditor](type-documentation/elements/codeeditor)
+- [ColorOptionGrid](type-documentation/elements/coloroptiongrid)
+- [ColorPicker](type-documentation/lements/colorpicker)
+- [ColorPickerDropdownBox](type-documentation/elements/colorpickerdropdownbox)
+- [CompactTextField](type-documentation/elements/compacttextfield)
+- [DropdownBox](type-documentation/elements/dropdownbox)
+- [DropdownEntry](type-documentation/elements/dropdownentry)
+- [DynamicPane](type-documentation/elements/dynamicpane)
+- [DynamicPaneContainer](type-documentation/elements/dynamicpanecontainer)
+- [FloatSlider](type-documentation/elements/floatslider)
+- [FloatSliderNumberField](type-documentation/elements/floatslidernumberfield)
+- [Group](type-documentation/elements/group)
+- [HotkeyLabel](type-documentation/elements/hotkeylabel)
+- [ItemGrid](type-documentation/elements/itemgrid)
+- [ItemIcon](type-documentation/elements/itemicon)
+- [ItemPreviewComponent](type-documentation/elements/itempreviewcomponent)
+- [ItemSlot](type-documentation/elements/itemslot)
+- [ItemSlotButton](type-documentation/elements/itemslotbutton)
+- [Label](type-documentation/elements/label)
+- [LabeledCheckBox](type-documentation/elements/labeledcheckbox)
+- [MenuItem](type-documentation/elements/menuitem)
+- [MultilineTextField](type-documentation/elements/multilinetextfield)
+- [NumberField](type-documentation/elements/numberfield)
+- [Panel](type-documentation/elements/panel)
+- [ProgressBar](type-documentation/elements/progressbar)
+- [ReorderableList](type-documentation/elements/reorderablelist)
+- [ReorderableListGrip](type-documentation/elements/reorderablelistgrip)
+- [SceneBlur](type-documentation/elements/sceneblur)
+- [Slider](type-documentation/elements/slider)
+- [SliderNumberField](type-documentation/elements/slidernumberfield)
+- [Sprite](type-documentation/elements/sprite)
+- [TabButton](type-documentation/elements/tabbutton)
+- [TabNavigation](type-documentation/elements/tabnavigation)
+- [TextButton](type-documentation/elements/textbutton)
+- [TextField](type-documentation/elements/textfield)
+- [TimerLabel](type-documentation/elements/timerlabel)
+- [ToggleButton](type-documentation/elements/togglebutton)
+
+## Property Types
+
+- [Anchor](type-documentation/property-types/anchor)
+- [BlockSelectorStyle](type-documentation/property-types/blockselectorstyle)
+- [ButtonSounds](type-documentation/property-types/buttonsounds)
+- [ButtonStyle](type-documentation/property-types/buttonstyle)
+- [ButtonStyleState](type-documentation/property-types/buttonstylestate)
+- [CheckBoxStyle](type-documentation/property-types/checkboxstyle)
+- [CheckBoxStyleState](type-documentation/property-types/checkboxstylestate)
+- [ClientItemStack](type-documentation/property-types/clientitemstack)
+- [ColorOptionGridStyle](type-documentation/property-types/coloroptiongridstyle)
+- [ColorPickerDropdownBoxStateBackground](type-documentation/property-types/colorpickerdropdownboxstatebackground)
+- [ColorPickerDropdownBoxStyle](type-documentation/property-types/colorpickerdropdownboxstyle)
+- [ColorPickerStyle](type-documentation/property-types/colorpickerstyle)
+- [DropdownBoxSearchInputStyle](type-documentation/property-types/dropdownboxsearchinputstyle)
+- [DropdownBoxSounds](type-documentation/property-types/dropdownboxsounds)
+- [DropdownBoxStyle](type-documentation/property-types/dropdownboxstyle)
+- [InputFieldButtonStyle](type-documentation/property-types/inputfieldbuttonstyle)
+- [InputFieldDecorationStyle](type-documentation/property-types/inputfielddecorationstyle)
+- [InputFieldDecorationStyleState](type-documentation/property-types/inputfielddecorationstylestate)
+- [InputFieldIcon](type-documentation/property-types/inputfieldicon)
+- [InputFieldStyle](type-documentation/property-types/inputfieldstyle)
+- [ItemGridSlot](type-documentation/property-types/itemgridslot)
+- [ItemGridStyle](type-documentation/property-types/itemgridstyle)
+- [LabeledCheckBoxStyle](type-documentation/property-types/labeledcheckboxstyle)
+- [LabeledCheckBoxStyleState](type-documentation/property-types/labeledcheckboxstylestate)
+- [LabelSpan](type-documentation/property-types/labelspan)
+- [LabelStyle](type-documentation/property-types/labelstyle)
+- [NumberFieldFormat](type-documentation/property-types/numberfieldformat)
+- [Padding](type-documentation/property-types/padding)
+- [PatchStyle](type-documentation/property-types/patchstyle)
+- [PopupStyle](type-documentation/property-types/popupstyle)
+- [ScrollbarStyle](type-documentation/property-types/scrollbarstyle)
+- [SliderStyle](type-documentation/property-types/sliderstyle)
+- [SoundStyle](type-documentation/property-types/soundstyle)
+- [SpriteFrame](type-documentation/property-types/spriteframe)
+- [SubMenuItemStyle](type-documentation/property-types/submenuitemstyle)
+- [SubMenuItemStyleState](type-documentation/property-types/submenuitemstylestate)
+- [Tab](type-documentation/property-types/tab)
+- [TabNavigationStyle](type-documentation/property-types/tabnavigationstyle)
+- [TabStyle](type-documentation/property-types/tabstyle)
+- [TabStyleState](type-documentation/property-types/tabstylestate)
+- [TextButtonStyle](type-documentation/property-types/textbuttonstyle)
+- [TextButtonStyleState](type-documentation/property-types/textbuttonstylestate)
+- [TextTooltipStyle](type-documentation/property-types/texttooltipstyle)
+- [ToggleButtonStyle](type-documentation/property-types/togglebuttonstyle)
+- [ToggleButtonStyleState](type-documentation/property-types/togglebuttonstylestate)
+
+## Enums
+
+- [ActionButtonAlignment](type-documentation/enums/actionbuttonalignment)
+- [CodeEditorLanguage](type-documentation/enums/codeeditorlanguage)
+- [ColorFormat](type-documentation/enums/colorformat)
+- [DropdownBoxAlign](type-documentation/enums/dropdownboxalign)
+- [InputFieldButtonSide](type-documentation/enums/inputfieldbuttonside)
+- [InputFieldIconSide](type-documentation/enums/inputfieldiconside)
+- [ItemGridInfoDisplayMode](type-documentation/enums/itemgridinfodisplaymode)
+- [LabelAlignment](type-documentation/enums/labelalignment)
+- [LayoutMode](type-documentation/enums/layoutmode)
+- [MouseWheelScrollBehaviourType](type-documentation/enums/mousewheelscrollbehaviourtype)
+- [ProgressBarAlignment](type-documentation/enums/progressbaralignment)
+- [ProgressBarDirection](type-documentation/enums/progressbardirection)
+- [ResizeType](type-documentation/enums/resizetype)
+- [TimerDirection](type-documentation/enums/timerdirection)
+- [TooltipAlignment](type-documentation/enums/tooltipalignment)
diff --git a/content/docs/ja-JP/official-documentation/npc/2-getting-started-with-templates.mdx b/content/docs/ja-JP/official-documentation/npc/2-getting-started-with-templates.mdx
index 91081ca1..99d078e0 100644
--- a/content/docs/ja-JP/official-documentation/npc/2-getting-started-with-templates.mdx
+++ b/content/docs/ja-JP/official-documentation/npc/2-getting-started-with-templates.mdx
@@ -9,7 +9,7 @@ authors:
 
 There are no hard and fast rules for making a start on a template. I like to duplicate **BlankTemplate** and start from there because it already provides the basic structure of the file.
 
-This leaves me with the following template (`Template_Goblin_Ogre.json`): (note: the file could be looking different in the current version of the game)
+This leaves me with the following template (`Template_Goblin_Ogre.json`): (**note: the file could be looking different in the current version of the game**)
 
 ```json
 {
@@ -33,7 +33,7 @@ This leaves me with the following template (`Template_Goblin_Ogre.json`): (note:
     }
   },
   "Appearance": { "Compute": "Appearance" },
-  "DropList": { "Compute": "Droplist" },
+  "DropList": { "Compute": "DropList" },
   "MaxHealth": { "Compute": "MaxHealth" },
   "MotionControllerList": [
     {
@@ -65,10 +65,10 @@ And the following variant (`Goblin_Ogre.json`) next to the template. There's a t
   "Type": "Variant",
   "Reference": "Template_Goblin_Ogre",
   "Modify": {
-    "Appearance": "Goblin_Ogre",
+    "Appearance": "Goblin",
     "MaxHealth": 124
   }
 }
 ```
 
-Our artists have defined the `Goblin_Ogre` appearance already so I'm going to use that.
+Our artists have not yet finished animations for the `Goblin_Ogre`, for that sake of the tutorial I am going to use appearance `Goblin`, because it offers a more complete set of animations that we will need.
diff --git a/content/docs/ja-JP/official-documentation/worldgen/pack-tutorial/asset-packs.mdx b/content/docs/ja-JP/official-documentation/worldgen/pack-tutorial/asset-packs.mdx
index 38809fad..dcf1f3b9 100644
--- a/content/docs/ja-JP/official-documentation/worldgen/pack-tutorial/asset-packs.mdx
+++ b/content/docs/ja-JP/official-documentation/worldgen/pack-tutorial/asset-packs.mdx
@@ -9,13 +9,13 @@ authors:
 
 <OfficialDocumentationNotice />
 
-# How to modify Hytale
+# How to modify Hytale?
 
-## What's an Asset Pack
+## What's an Asset Pack?
 
-Hytales gameplay is driven by assets in the game that can be modified by creators. Asset Packs are our solution to let you override or add features to the base game with your own work. These can in the form of zip files of folders, which contain a custom set of assets. This is not the only way for a creator to change Hytale but this is the most accessible form.;
+Hytales gameplay is driven by assets in the game that can be modified by creators. Asset Packs are our solution to let you override or add features to the base game with your own work. These can be the form of zip files of folders, which contain a custom set of assets. This is not the only way for a creator to change Hytale but this is the most accessible form.;
 
-### How do I make an Asset Pack
+### How do I make an Asset Pack?
 
 <video controls className="my-6 aspect-video w-full rounded-lg border">
   <source src="https://cdn.internal.hytalemodding.dev/guides/official/how-to-asset-pack.mp4" type="video/mp4" />
@@ -48,7 +48,7 @@ An asset pack is typically a zip or folder, with a `manifest.json` inside. This
 }
 ```
 
-### Where are they stored
+### Where are they stored?
 
 Asset Packs are stored with other mods in the Mods folder.
 
@@ -76,7 +76,7 @@ C:\Users\<user>\AppData\Roaming\Hytale\UserData\Saves\New World 5\mods
 
 When you have Asset Packs or Mods installed, these will appear in the New World menu under the Options menu.;
 
-### How do I change an existing asset
+### How do I change an existing asset?
 
 <video controls className="my-6 aspect-video w-full rounded-lg border">
   <source src="https://cdn.internal.hytalemodding.dev/guides/official/how-to-asset.mp4" type="video/mp4" />
diff --git a/content/docs/ja-JP/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx b/content/docs/ja-JP/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx
index 44528376..24e628b5 100644
--- a/content/docs/ja-JP/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx
+++ b/content/docs/ja-JP/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx
@@ -106,7 +106,7 @@ If a BaseHeight is provided, the TopY and BottomY values are relative to the Bas
 
 Applies a Material Provider slot on a set of horizontal stripes of blocks of varying thickness and position. Below is an example image of basalt stripes into a stone cliff.
 
-{/* ![](https://540086904-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F7KAmBkOg6d13nZCkf9ku%2Fuploads%2FbcxO9LpArn8gPCaBwFg5%2Funknown.png?alt=media&token=1c72b67a-8253-4d03-8c64-1ad5f6830050) */}
+![Example of basalt stripes](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/basalt-stripes-example.png)
 
 #### Parameters:
 
diff --git a/content/docs/ja-JP/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx b/content/docs/ja-JP/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx
index 5e34acd4..a4418473 100644
--- a/content/docs/ja-JP/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx
+++ b/content/docs/ja-JP/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx
@@ -294,7 +294,7 @@ Combines all the positions into a single Positioins field.
 
 ---
 
-### SimpleHoritontal
+### SimpleHorizontal
 
 Keeps only the positions that are within the provided range.
 
diff --git a/content/docs/ja-JP/official-documentation/worldgen/worldgen-tutorial/README.mdx b/content/docs/ja-JP/official-documentation/worldgen/worldgen-tutorial/README.mdx
new file mode 100644
index 00000000..5f66d245
--- /dev/null
+++ b/content/docs/ja-JP/official-documentation/worldgen/worldgen-tutorial/README.mdx
@@ -0,0 +1,166 @@
+---
+title: How to edit and create Biomes
+description: Explores where world generation assets can be found and how to edit them.
+---
+
+### Where are the Assets
+
+World generation assets are kept in the HytaleGenerator directory within the assets.
+
+```
+/Server/HytaleGenerator/
+```
+
+<div className="flex flex-row rounded-lg border p-4">
+  <div className="flex-1/2 border-r pr-4">
+    ```
+    /Biomes
+    ```
+
+    Biome assets, with content configurations.
+  </div>
+
+  <div className="flex-1/2 pl-4">
+    ```
+    /WorldStructure
+    ```
+
+    Generator files that define which biomes spawn together.
+  </div>
+</div>
+
+<div className="flex flex-row rounded-lg border p-4">
+  <div className="flex-1/2 border-r pr-4">
+    ```
+    /Density
+    ```
+
+    Density assets that can be referenced by any other assets.
+  </div>
+
+  <div className="flex-1/2 pl-4">
+    ```
+    /Assignments
+    ```
+
+    Prop assets that can be referenced by any Biome assets.
+  </div>
+</div>
+
+***
+
+An example of this structure can be found bellow, packed in an asset pack with the instance configuration.
+
+[https://drive.google.com/file/d/1sIz_CluANIIe3n8vNiOi-4PQdeqCO0qY/view?usp=drive_link](https://drive.google.com/file/d/1sIz_CluANIIe3n8vNiOi-4PQdeqCO0qY/view?usp=drive_link)
+
+<Callout>
+  Ensure you place your asset pack in the correct directory, under Mods.
+</Callout>
+
+### How to visit our worlds
+
+https://drive.google.com/file/d/1BJurxyj-taE-PXWm04bk7Dl6X7ZHTH92/view?usp=sharing
+
+#### Requirements
+
+- You must be an **Operator** in the world.
+  - To do this, run <mark style="color:$danger;">`/op self`</mark>
+- You must be in **Creative mode**.
+  - Press the <mark style="color:$danger;">`O`</mark> key, O for Orange.&#x20;
+
+The generation assets define a set of generators but on their own you cannot visit these. Currently you require an Instance with a generator that will allow you to visit your work.
+
+```
+/Server/Instances/
+```
+
+Instances are separate worlds that players can join using the `/instances` command. Each instance has an `Instance.bson` configuration asset that specifies which generator to use, among other worldly settings.
+
+```json
+{
+  "WorldGen": {
+    "Type": "HytaleGenerator",
+    "WorldStructure": "Basic",
+    "playerSpawn" : {
+      "X" : 123,
+      "Y" : 480,
+      "Z" : 10000,
+      "Pitch" : 0,
+      "Yaw" : 0,
+      "Roll" : 0
+    }
+  }
+}
+```
+
+<Callout>
+  You can create custom instances for different world structures and biomes as you need them.
+</Callout>
+
+### How to edit Biomes
+
+<video>
+  <source src="https://cdn.internal.hytalemodding.dev/guides/official/How-to-edit-Biomes.mp4" type="video/mp4" />
+</video>
+
+We currently use the Hytale Node Editor when editing world generation assets. This can be accessed while in-game from the Content Creation menu when pressing B. The node editor is then found under the asset editor dropdown on the upper left.&#x20;
+
+![Node Editor 1](/assets/official-documentation/worldgen/worldgen-tutorial/biomes/node-editor-1.png)
+
+Once you have the Hytale Node Editor open, through the file menu you can open Biomes by navigating to the Biomes directory and selecting one from your pack.&#x20;
+
+```
+/Server/HytaleGenerator/Biomes/
+```
+
+### Biome Asset Structure
+
+Every Biome has a root Biome node, this node splits into 5 structures. This is covered briefly but more information on each field can be found on the World Generation Concepts page.
+
+![Node Editor 2](/assets/official-documentation/worldgen/worldgen-tutorial/biomes/node-editor-2.png)
+
+<Callout>
+  Each biome is for the most part self contained, meaning it has control over what appears with the biome. The only exception to this are Base Heights.
+</Callout>
+
+<Tabs>
+  <Tab value="Terrain">
+    Mathematical function nodes that calculate the physical shape of the Biome's terrain.
+  </Tab>
+
+  <Tab value="Materials">
+    Logical nodes that determine what materials (blocks) make up a Biome's terrain.
+  </Tab>
+
+  <Tab value="Props">
+    Function nodes that add objects like prefabs and decorations to the terrain.
+  </Tab>
+
+  <Tab value="Environments">
+    Logical nodes that determine the environment asset at a given coordinate within the biome. This asset determines things like weather, NPC spawns, and sounds.
+  </Tab>
+
+  <Tab value="Tints">
+    Logical function nodes that determine a colour code that can be used by certain blocks in the world. Typically this will be grasses and soils.
+  </Tab>
+</Tabs>
+
+### How to preview your work
+
+[https://drive.google.com/file/d/1mNcHn9LhFnWDF0DzWFH6_YllmKAUvUry/view?t=6](https://drive.google.com/file/d/1mNcHn9LhFnWDF0DzWFH6_YllmKAUvUry/view?t=6)
+
+Once you are in an Instance world with the Hytale Generator active you will only be able to see your work by generating new chunks. There are a few ways to do this.
+
+The viewport command selects an area around the Player that will live reload as you make changes to the generator.&#x20;
+
+```
+/viewport --radius 5 
+```
+
+You can also create a new world to show your changes.&#x20;
+
+```
+/instances spawn <instance> 
+```
+
+The last option is to simply fly south, new chunks will generate with the changes made.
diff --git a/content/docs/ja-JP/quick-start.mdx b/content/docs/ja-JP/quick-start.mdx
index 0acd10fd..38c90802 100644
--- a/content/docs/ja-JP/quick-start.mdx
+++ b/content/docs/ja-JP/quick-start.mdx
@@ -9,3 +9,8 @@ Hytale Mod開発ドキュメントへようこそ！ ここでは、Hytale用の
 * [開発環境の構築](./guides/plugin/setting-up-env)
 * [Entity Component System (ECS)](./guides/ecs/entity-component-system)
 * [Publishing your mod](./publishing)
+
+### Useful Links
+
+* [Kaupenjoe's Modding Videos](https://www.youtube.com/@ModdingByKaupenjoe)
+* [TroubleDEV's Modding Videos](https://www.youtube.com/@TroubleDEV)
diff --git a/content/docs/ja-JP/server/argtypes.mdx b/content/docs/ja-JP/server/argtypes.mdx
new file mode 100644
index 00000000..e54a442e
--- /dev/null
+++ b/content/docs/ja-JP/server/argtypes.mdx
@@ -0,0 +1,61 @@
+---
+title: ArgTypes
+description: Available ArgTypes
+icon: List
+full: true
+authors:
+  - name: Valeena
+---
+
+| Name                        | Target Class                           | Description                                                                                                                               |   |
+| :-------------------------- | :------------------------------------- | :---------------------------------------------------------------------------------------------------------------------------------------- | - |
+| Boolean                     | java.lang.Boolean                      | A 'true' or 'false' input                                                                                                                 |   |
+| Integer                     | java.lang.Integer                      | A whole number                                                                                                                            |   |
+| String                      | java.lang.String                       | Words, text, numbers, letters. To input more than one word at a time, you may need to wrap it with double quotes (`"my fancy sentence"`). |   |
+| Float                       | java.lang.Float                        | A floating-pointer number                                                                                                                 |   |
+| Double                      | java.lang.Double                       | A decimal number                                                                                                                          |   |
+| UUID                        | java.util.UUID                         | A UUID (Universally Unique IDentifier)                                                                                                    |   |
+| Player_UUID                 | java.util.UUID                         | A UUID or an online player username                                                                                                       |   |
+| Game_Profile_Lookup_Async   | ProfileServiceClient.PublicGameProfile | A player UUID or username. If not found locally, performs a remote lookup via the Profile Service.                                        |   |
+| Relative_Double_Coord       | Coord                                  | An x, y, or z coordinate as a decimal, optionally relative by specifying a tilde (~) in front of the number                               |   |
+| Relative_Int_Coord          | IntCoord                               | An x, y, or z coordinate as a whole number, optionally relative by specifying a tilde (~) in front of the number                          |   |
+| Relative_Integer            | RelativeInteger                        | A tilde to mark an integer relative to a base                                                                                             |   |
+| Relative_Float              | RelativeFloat                          | A tilde to mark a float relative to a base                                                                                                |   |
+| Player_Ref                  | PlayerRef                              | A UUID or an online player's username                                                                                                     |   |
+| World                       | World                                  | A world folder name                                                                                                                       |   |
+| Model_Asset                 | ModelAsset                             | A reference to an Asset of type Model                                                                                                     |   |
+| Weather_Asset               | Weather                                | A reference to an Asset of type Weather                                                                                                   |   |
+| Interaction_Asset           | Interaction                            | A reference to an Asset of type Interaction                                                                                               |   |
+| Root_Interaction_Asset      | RootInteraction                        | A reference to an Asset of type Root Interaction                                                                                          |   |
+| Effect_Asset                | EntityEffect                           | A refernece to an Asset of type EntityEffect                                                                                              |   |
+| Environment_Asset           | Environment                            | A reference to an Asset of type Environment                                                                                               |   |
+| Item_Asset                  | Item                                   | A reference to an Asset of type Item                                                                                                      |   |
+| Block_Type_Asset            | BlockType                              | A reference to an Asset of type BlockType                                                                                                 |   |
+| Particle_System             | ParticleSystem                         | A reference to an Asset of type ParticleSystem                                                                                            |   |
+| Hitbox_Collision_Config     | HitboxCollisionConfig                  | A reference to an Asset of type HitboxCollisionConfig                                                                                     |   |
+| Repulsion_Config            | RepulsionConfig                        | A reference to an Asset of type RepulsionConfig                                                                                           |   |
+| Sound_Event_Asset           | SoundEvent                             | A reference to an Asset of type SoundEvent                                                                                                |   |
+| Ambiance_Fx_Asset           | AmbianceFX                             | A reference to an Asset of type AmbianceFX                                                                                                |   |
+| Sound_Category              | SoundCategory                          | A sound category (sfx, music, ambient, ui)                                                                                                |   |
+| Entity_ID                   | `ArgWrapper<EntityWrappedArg, UUID>`   | A UUID representing an entity id                                                                                                          |   |
+| Integer_Comparison_Operator | IntegerComparisonOperator              | A mathematical sign for integer comparison                                                                                                |   |
+| Integer_Operation           | IntegerOperation                       | A mathematical sign for performing an operation                                                                                           |   |
+| Int_Range                   | `Pair<Integer, Integer>`               | Two integers representing a minimum and maximum of a range                                                                                |   |
+| Relative_Int_Range          | RelativeIntRange                       | Two integers representing a minimum and maximum of a range                                                                                |   |
+| Vector2I                    | Vector2i                               | Two integers, generally corresponding to x/z axis                                                                                         |   |
+| Vector3I                    | Vector3i                               | Three integers, generally corresponding to x/y/z axis                                                                                     |   |
+| Relative_Vector3I           | RelativeVector3i                       | Three optionally relative integers, generally corresponding to x/y/z axis                                                                 |   |
+| Relative_Block_Position     | RelativeIntPosition                    | A position with three integer coordinates, representing a block's location in world space.                                                |   |
+| Relative_Position           | Relative                               | A position with three decimal coordinates, representing a location in world space.                                                        |   |
+| Relative_Chunk_Position     | RealtiveChunkPosition                  | A position with two integer coordinates (x, z), representing a chunk's location.                                                          |   |
+| Rotation                    | Vector3f                               | A rotation with three coordinates, representing the pitch, yaw, and roll respectively                                                     |   |
+| Block_Type_Key              | String                                 | A block type                                                                                                                              |   |
+| Block_ID                    | Integer                                | A block type, converted to an int id                                                                                                      |   |
+| Color                       | Integer                                | A color value in hex format, hex integer, or decimal integer                                                                              |   |
+| Weighted_Block_Type         | `Pair<Integer, String>`                | A weight corresponding to a blocktype                                                                                                     |   |
+| Weighted_Block_Entry        | String                                 | A block with optional weight prefix                                                                                                       |   |
+| Block_Pattern               | BlockPattern                           | A list of blocks with optional weights                                                                                                    |   |
+| Individual_Block_Mask       | BlockMask                              | Create a block mask using symbols and block names                                                                                         |   |
+| Block_Mask                  | BlockMask                              | A tick rate value (e.g., 30tps, 33ms, or 30)                                                                                              |   |
+| Tick_Rate                   | Integer                                | A list of block masks that combine together                                                                                               |   |
+| Game_Mode                   | GameMode                               | GameMode                                                                                                                                  |   |
diff --git a/content/docs/ja-JP/server/entities.mdx b/content/docs/ja-JP/server/entities.mdx
index 96a78039..28efb652 100644
--- a/content/docs/ja-JP/server/entities.mdx
+++ b/content/docs/ja-JP/server/entities.mdx
@@ -7,435 +7,435 @@ full: true
 
 このページには、AssetMap 内のキーとして使用できるすべてのエンティティのリストが含まれています。
 
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
+- Antelope
+- Archaeopteryx
+- Armadillo
+- Arrow_Crossbow_Signature
+- Arrow_Crude
+- Arrow_Fire
+- Arrow_Frost
+- Arrow_Iron
+- Arrow_Ricochet
+- Arrow_Ricochet_Signature
+- Arrow_Shortbow_Signature
+- Arrow_Vamp
+- Arrow_Vamp_Signature
+- Axe_Bone
+- Axe_Stone_Trork
+- Bat
+- Bat_Ice
+- Bear_Grizzly
+- Bear_Polar
+- Bison
+- Bison_Calf
+- Bluebird
+- Bluegill
+- Boar
+- Boar_Piglet
+- Boat
+- Bomb
+- Bomb_Fire_Goblin
+- Bomb_Fire_Goblin_Dud
+- Bomb_Large_Fire_Goblin
+- Bomb_Popberry
+- Bomb_Potion_Poison
+- Boy_Trail
+- Bramblekin
+- Bramblekin_Shaman
+- Bullet_Blunderbuss
+- Bunny
+- Cactee
+- Cactee_Spike
+- Calf
+- Camel
+- Camel_Calf
+- Cat
+- Catfish
+- Chick
+- Chick_Desert
+- Chicken
+- Chicken_Desert
+- Chicken_Undead
+- Clownfish
+- Corgi
+- Cow
+- Cow_Undead
+- Crab
+- Crawler_Void
+- Crocodile
+- Crossbow_Turret
+- Crossbow_Turret_Item_Projectile
+- Crow
+- Dagger_Adamantite
+- Dagger_Bone
+- Dagger_Bronze
+- Dagger_Bronze_Ancient
+- Dagger_Cobalt
+- Dagger_Copper
+- Dagger_Crude
+- Dagger_Doomed
+- Dagger_Fang_Doomed
+- Dagger_Iron
+- Dagger_Mithril
+- Dagger_Onyxium
+- Dagger_Stone_Trork
+- Dagger_Thorium
+- Debug
+- Deer_Doe
+- Deployable_Fire_Trap
+- Deployable_Fire_Trap_Preview
+- Dog
+- Dragon_Fire
+- Dragon_Frost
+- Dragon_Void
+- Duck
+- Eel_Moray
+- Egg
+- Emberwulf
+- Eye_Void
+- Eye_Void_Blast
+- Fen_Stalker
+- Feran
+- Feran_Burrower
+- Feran_Civilian
+- Feran_Cub
+- Feran_Longtooth
+- Feran_Sharptooth
+- Feran_Windwalker
+- Feran_Windwalker_Wind_Burst
+- Feran_Windwalker_Wind_Vortex
+- Finch_Green
+- Fireball
+- Flamingo
+- Fox
+- Frog_Blue
+- Frog_Green
+- Frog_Orange
+- Frostgill
+- Gecko
+- Ghoul
+- Goat
+- Goat_Kid
+- Goblin
+- Goblin_Boss
+- Goblin_Duke
+- Goblin_Duke_Large
+- Goblin_Hermit
+- Goblin_Lobber
+- Goblin_Miner
+- Goblin_Ogre
+- Goblin_Scrapper
+- Goblin_Thief
+- Golem_Crystal_Earth
+- Golem_Crystal_Flame
+- Golem_Crystal_Frost
+- Golem_Crystal_Sand
+- Golem_Crystal_Thunder
+- Golem_Firesteel
+- Golem_Guardian_Void
+- Grooble
+- Hatworm
+- Hawk
+- Healing_Totem
+- Healing_Totem_Projectile
+- Hedera
+- Horse
+- Horse_Foal
+- Horse_Skeleton
+- Horse_Skeleton_Armored
+- Hound_Bleached
+- Hyena
+- Ice_Ball
+- Ice_Bolt
+- Ingredient_Poop
+- Jellyfish_Blue
+- Jellyfish_Cyan
+- Jellyfish_Green
+- Jellyfish_Man_Of_War
+- Jellyfish_Red
+- Jellyfish_Yellow
+- Klops
+- Klops_Gentleman
+- Klops_Merchant
+- Klops_Miner
+- Kunai
+- Kweebec_Rootling
+- Kweebec_Sapling
+- Kweebec_Sapling_Brown
+- Kweebec_Sapling_Christmas_Blue
+- Kweebec_Sapling_Christmas_Green
+- Kweebec_Sapling_Christmas_Pink
+- Kweebec_Sapling_Green
+- Kweebec_Sapling_HardHat
+- Kweebec_Sapling_Orange
+- Kweebec_Sapling_Pink
+- Kweebec_Sapling_Razorleaf
+- Kweebec_Sapling_Red
+- Kweebec_Sapling_Treesinger
+- Kweebec_Sapling_Yellow
+- Kweebec_Seedling
+- Kweebec_Sproutling
+- Kweebec_Sproutling_Blue
+- Kweebec_Sproutling_Lime
+- Lamb
+- Larva_Silk
+- Larva_Void
+- Leopard_Snow
+- Lizard_Sand
+- Lobster
+- Mannequin
+- Meerkat
+- Minecart
+- Minnow
+- Model_Bee_Swarm
+- Model_Deer_Stag
+- Molerat
+- Moose_Bull
+- Moose_Cow
+- Mosshorn
+- Mosshorn_Plain
+- Mouflon
+- Mouflon_Lamb
+- Mouse
+- Mushee
+- NPC_Elf
+- NPC_Path_Marker
+- NPC_Santa
+- NPC_Sound_Shoe
+- NPC_Spawn_Marker
+- Necromancer_Void
+- Objective_Location_Marker
+- Outlander
+- Outlander_Berserker
+- Outlander_Brute
+- Outlander_Cultist
+- Outlander_Hunter
+- Outlander_Marauder
+- Outlander_Peon
+- Outlander_Priest
+- Outlander_Sorcerer
+- Outlander_Stalker
+- Owl_Brown
+- Owl_Snow
+- Parrot
+- Penguin
+- Pig
+- Pig_Undead
+- Pig_Wild
+- Pigeon
+- Piglet
+- Piglet_Wild
+- Pike
+- Piranha
+- Piranha_Black
+- Player
+- PlayerTestModel_G
+- PlayerTestModel_V
+- Projectile
+- Pterodactyl
+- Pufferfish
+- Rabbit
+- Ram
+- Ram_Lamb
+- Raptor_Cave
+- Rat
+- Raven
+- Reindeer_Christmas
+- Rex_Cave
+- Rubble_Aqua
+- Rubble_Basalt
+- Rubble_Calcite
+- Rubble_Default
+- Rubble_Ice
+- Rubble_Marble
+- Rubble_Quartzite
+- Rubble_Sandstone
+- Rubble_Sandstone_Red
+- Rubble_Sandstone_White
+- Rubble_Shale
+- Rubble_Slate
+- Rubble_Stone
+- Rubble_Stone_Mossy
+- Rubble_Volcanic
+- Salmon
+- Saurian
+- Saurian_Hunter
+- Saurian_Rogue
+- Saurian_Warrior
+- Scarak_Broodmother
+- Scarak_Broodmother_Young
+- Scarak_Defender
+- Scarak_Fighter
+- Scarak_Fighter_Royal_Guard
+- Scarak_Louse
+- Scarak_Seeker
+- Scarak_Seeker_Spitball
+- Scorpion
+- Shadow_Knight
+- Shark_Hammerhead
+- Sheep
+- Shellfish_Lava
+- Showcase_Cobalt_Gear
+- Showcase_Copper_Gear
+- Showcase_Iron_Gear
+- Showcase_Iron_TargetDummy_1
+- Showcase_Mannequin_Heal
+- Showcase_Mannequin_Inv_Portal
+- Showcase_Mannequin_Inv_Sphere
+- Showcase_Mannequin_Lightning
+- Showcase_Mannequin_Sitting
+- Showcase_Onyxium_Gear
+- Showcase_Prisma_Gear
+- Showcase_Skeleton_Assasin
+- Showcase_Skeleton_Dead
+- Showcase_Skeleton_Guard
+- Showcase_Skeleton_Tank
+- Showcase_Wooden_Gear
+- Skeleton
+- Skeleton_Archer
+- Skeleton_Archmage
+- Skeleton_Burnt_Alchemist
+- Skeleton_Burnt_Archer
+- Skeleton_Burnt_Gunner
+- Skeleton_Burnt_Knight
+- Skeleton_Burnt_Lancer
+- Skeleton_Burnt_Praetorian
+- Skeleton_Burnt_Soldier
+- Skeleton_Burnt_Wizard
+- Skeleton_Fighter
+- Skeleton_Frost_Archer
+- Skeleton_Frost_Archmage
+- Skeleton_Frost_Fighter
+- Skeleton_Frost_Knight
+- Skeleton_Frost_Mage
+- Skeleton_Frost_Ranger
+- Skeleton_Frost_Scout
+- Skeleton_Frost_Soldier
+- Skeleton_Incandescent_Fighter
+- Skeleton_Incandescent_Footman
+- Skeleton_Incandescent_Head
+- Skeleton_Incandescent_Mage
+- Skeleton_Knight
+- Skeleton_Mage
+- Skeleton_Mage_Corruption_Orb
+- Skeleton_Pirate_Captain
+- Skeleton_Pirate_Gunner
+- Skeleton_Pirate_Striker
+- Skeleton_Ranger
+- Skeleton_Sand_Archer
+- Skeleton_Sand_Archmage
+- Skeleton_Sand_Assassin
+- Skeleton_Sand_Guard
+- Skeleton_Sand_Mage
+- Skeleton_Sand_Ranger
+- Skeleton_Sand_Scout
+- Skeleton_Sand_Soldier
+- Skeleton_Scout
+- Skeleton_Soldier
+- Skrill
+- Skrill_Chick
+- Slothian
+- Slothian_Elder
+- Slothian_Kid
+- Slothian_Monk
+- Slothian_Scout
+- Slothian_Villager
+- Slothian_Warrior
+- Slowness_Totem
+- Slowness_Totem_Projectile
+- Slug_Magma
+- Snail_Frost
+- Snail_Magma
+- Snake_Cobra
+- Snake_Marsh
+- Snake_Rattle
+- Snapdragon
+- Snapjaw
+- Spark_Living
+- Sparrow
+- Spawn_Void
+- Spear_Adamantite
+- Spear_Adamantite_Saurian
+- Spear_Bone
+- Spear_Bronze
+- Spear_Cobalt
+- Spear_Copper
+- Spear_Crude
+- Spear_Double_Incandescent
+- Spear_Iron
+- Spear_Leaf
+- Spear_Mithril
+- Spear_Onyxium
+- Spear_Scrap
+- Spear_Stone_Trork
+- Spear_Thorium
+- Spear_Tribal
+- Spectre_Void
+- Spider
+- Spider_Cave
+- Spirit_Ember
+- Spirit_Frost
+- Spirit_Root
+- Spirit_Thunder
+- Squirrel
+- Swarm_Bees
+- Sword_Charged_Test
+- Tang_Blue
+- Tang_Chevron
+- Tang_Lemon_Peel
+- Tang_Sailfin
+- Tank
+- Temple_Mithril_Guard
+- Test_Platform
+- Tetrabird
+- Tiger_Sabertooth
+- Toad_Rhino
+- Toad_Rhino_Magma
+- Tornado
+- Tortoise
+- Trash
+- Trillodon
+- Trilobite
+- Trilobite_Black
+- Trork
+- Trork_Brawler
+- Trork_Chieftain
+- Trork_Christmas
+- Trork_Doctor_Witch
+- Trork_Guard
+- Trork_Hunter
+- Trork_Mauler
+- Trork_Sentry
+- Trork_Shaman
+- Trork_Warrior
+- Trout_Rainbow
+- Tuluk
+- Tuluk_Fisherman
+- Turkey
+- Turkey_Chick
+- Vulture
+- Warp
+- Warrior_Quest
+- Warthog
+- Warthog_Piglet
+- Werewolf
+- Whale_Humpback
+- Wolf_Black
+- Wolf_Outlander_Priest
+- Wolf_Outlander_Sorcerer
+- Wolf_Trork_Hunter
+- Wolf_Trork_Shaman
+- Wolf_White
+- Woodpecker
+- Wraith
+- Wraith_Lantern
+- Wurmling_Frost
+- Yeti
+- Zombie
+- Zombie_Aberrant
+- Zombie_Aberrant_Big
+- Zombie_Aberrant_Small
+- Zombie_Burnt
+- Zombie_Frost
+- Zombie_Sand
+- Zombie_Werewolf
diff --git a/content/docs/ja-JP/server/events.mdx b/content/docs/ja-JP/server/events.mdx
index bbd928e0..5fc933b8 100644
--- a/content/docs/ja-JP/server/events.mdx
+++ b/content/docs/ja-JP/server/events.mdx
@@ -1,7 +1,7 @@
 ---
 title: イベント
 description: Hytale 内の全てのイベントの一覧
-icon: ""
+icon: List
 full: true
 ---
 
@@ -53,51 +53,51 @@ full: true
 - PlayerRefEvent
   - PlayerDisconnectEvent
 - PlayerSetupConnectEvent
--
--
-  -
--
--
--
--
--
--
-  -
-  -
-  -
--
+- PlayerSetupDisconnectEvent
+- PluginEvent
+  - PluginSetupEvent
+- ~~PrepareUniverseEvent~~ DEPRECATED
+- ShutdownEvent
+- SingleplayerRequestAccessEvent
+- TreasureChestOpeningEvent
+- WindowCloseEvent
+- WorldEvent
+  - AddWorldEvent
+  - RemoveWorldEvent
+  - StartWorldEvent
+- WorldPathChangedEvent
 
-##
+## IAsyncEvent
 
--
--
--
--
+- AssetEditorFetchAutoCompleteDataEvent
+- AssetEditorRequestDataSetEvent
+- PlayerChatEvent
+- SendCommonAssetsEvent
 
-##
+## EcsEvent
 
--
-  -
-  -
-  -
-  -
-  -
-    -
-    -
-  -
-  -
-  -
-    -
-    -
-  -
-  -
-  -
-  -
--
-  -
--
-  -
--
--
-  -
-  -
+- CancellableEcsEvent
+  - BreakBlockEvent
+  - ChangeGameModeEvent
+  - ChunkSaveEvent
+  - ChunkUnloadEvent
+  - CraftRecipeEvent
+    - Post
+    - Pre
+  - Damage
+  - DamageBlockEvent
+  - DropItemEvent
+    - Drop
+    - PlayerRequest
+  - InteractivelyPickupItemEvent
+  - PlaceBlockEvent
+  - PrefabPasteEvent
+  - SwitchActiveSlotEvent
+- DiscoverInstanceEvent
+  - Display
+- DiscoverZoneEvent
+  - Display
+- MoonPhaseChangeEvent
+- UseBlockEvent
+  - Post
+  - Pre
diff --git a/content/docs/ja-JP/server/interaction-reference.mdx b/content/docs/ja-JP/server/interaction-reference.mdx
new file mode 100644
index 00000000..6c0d01b3
--- /dev/null
+++ b/content/docs/ja-JP/server/interaction-reference.mdx
@@ -0,0 +1,1586 @@
+---
+title: Interactions
+description: A list of most Interaction types provided by Hypixel, along with the meaning of their fields, and how they fit together.
+icon: List
+authors:
+  - name: Stephen Baynham
+    url: https://github.com/cannibalvox
+---
+
+### The Interaction Base Type
+
+All interactions of every type below are inherited from Interaction and have these fields.
+
+**Interaction Fields**
+
+| Field Name                | Type                                                                 | Required? | Notes                                                                                                                                                                                                                       |
+| ------------------------- | -------------------------------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| ViewDistance              | `Double`<br />(Default: 96.0)                                        | **No**    | Distance in blocks at which other players can see the effects from this interaction.                                                                                                                                        |
+| Effects                   | `InteractionEffects`                                                 | **No**    | Sound, animations, and particle effects that should trigger when this interaction begins executing.                                                                                                                         |
+| HorizontalSpeedMultiplier | `Float`<br />(Default: 1.0)                                          | **No**    | Multiplier applied to the User entity's movement speed while this interaction is executing                                                                                                                                  |
+| RunTime                   | `Float`                                                              | **No**    | If provided, this interaction will continue executing for at least this long before the interaction chain moves onto the next interaction.                                                                                  |
+| CancelOnItemChange        | `Boolean`<br />(Default: true)                                       | **No**    | If true, this interaction will be cancelled if the User entity's held item changes during execution. This can happen either due to the selected hotbar slot changing or the contents of the item's inventory slot changing. |
+| Rules                     | `InteractionRules`                                                   | **Yes**   | If provided, adds additional limitations and cancellation conditions to this interaction.                                                                                                                                   |
+| Settings                  | `Map`<br />(Key Type: `GameMode`, Value Type: `InteractionSettings`) | **No**    | If provided, adds additional per-GameMode settings to the interaction.                                                                                                                                                      |
+| Camera                    | `InteractionCameraSettings`                                          | **No**    | Arrays of camera motion keyframes for cutscenes and reveals.                                                                                                                                                                |
+
+**GameMode Values**
+
+- `Creative`: The game is currently in Creative Mode
+- `Adventure`: The game is currently in Adventure Mode
+
+**InteractionEffects Fields**
+
+| Field Name               | Type                                              | Required? | Notes                                                                                                                                                 |
+| ------------------------ | ------------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Particles                | `Array`<br />(Element Type: `ModelParticle`)      | **No**    | Particle systems to activate when this interaction begins if the player is in third-person mode.                                                      |
+| FirstPersonParticles     | `Array`<br />(Element Type: `ModelParticle`)      | **No**    | Particle systems to activate when this interaction begins if the player is in first-person mode.                                                      |
+| WorldSoundEventId        | `Asset`<br />(Asset Type: `SoundEvent`)           | **No**    | A sound to play in the world at the User entity's location when this interaction begins.<br />**The SoundEvent must be single-channel (mono) sound.** |
+| LocalSoundEventId        | `Asset`<br />(Asset Type: `SoundEvent`)           | **No**    | A 2D sound to play for the User entity when this interaction begins. Ignored if the User entity is not a player.                                      |
+| Trails                   | `Array`<br />(Element Type: `ModelTrail`)         | **No**    | Trail effects to activate on the User entity when this interaction begins.                                                                            |
+| WaitForAnimationToFinish | `Boolean`<br />(Default: false)                   | **No**    | If true, this interaction will continue executing for at least the length of any animations in this InteractionEffects object.                        |
+| ItemPlayerAnimationsId   | `Asset`<br />(Asset Type: `ItemPlayerAnimations`) | **No**    | If provided, the User entity will use this ItemPlayerAnimations set while this interaction is executing.                                              |
+| ItemAnimationId          | `String`                                          | **No**    | Id of an animation to trigger when this interaction begins executing.<br />**This animation id is not validated on server start.**                    |
+| ClearAnimationOnFinish   | `Boolean`<br />(Default: false)                   | **No**    | If true, animations triggered by this interaction will be halted when the interaction completes.                                                      |
+| ClearSoundEventOnFinish  | `Boolean`<br />(Default: false)                   | **No**    | If true, sounds triggered by this interaction will be halted when the interaction completes.                                                          |
+| CameraEffect             | `Asset`<br />(Asset Type: `CameraEffect` )        | **No**    | If provided, the CameraEffect will be applied while this interaction is executing.                                                                    |
+| MovementEffects          | `MovementEffects`                                 | **No**    | If provided, apply the movement effects to the User entity while this interaction is executing.                                                       |
+| StartDelay               | `Float`<br />(Default: 0.0f)                      | **No**    | The interaction will wait this many seconds before triggering the effects in this object.                                                             |
+
+**InteractionRules Fields**
+
+| Field Name          | Type                                                                                                | Required? | Notes                                                                                                                                                                                                                                     |
+| ------------------- | --------------------------------------------------------------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| BlockedBy           | `Array`<br />(Element Type: `InteractionType`)<br />(Default: Based on the chain's InteractionType) | **No**    | If provided, this RootInteraction cannot be executed while interaction chains of the provided types are executing.<br />**This field only functions for rules attached to a RootInteraction. It has no effect on an Interaction.**        |
+| Blocking            | `Array`<br />(Element Type: `InteractionType`)                                                      | **No**    | If provided, interaction chains with the specified InteractionTypes cannot be executed while this interaction is executing.                                                                                                               |
+| InterruptedBy       | `Array`<br />(Element Type: `InteractionType`)                                                      | **No**    | If provided, interaction chains with the specified InteractionTypes will cancel this interaction chain when they execute.<br />**This field only functions for rules attached to a RootInteraction. It has no effect on an Interaction.** |
+| Interrupting        | `Array`<br />(Element Type: `InteractionType`)                                                      | **No**    | If provided, interaction chains with the specified InteractionTypes will be canceled when this interaction begins.                                                                                                                        |
+| BlockedByBypass     | `String`                                                                                            | **No**    | If provided, this RootInteraction cannot be blocked by interaction chains whose RootInteraction has this value as an asset tag.                                                                                                           |
+| BlockingBypass      | `String`                                                                                            | **No**    | If provided, this interaction will not block RootInteractions that have the this value as an asset tag.                                                                                                                                   |
+| InterruptedByBypass | `String`                                                                                            | **No**    | If provided, this RootInteraction cannot be canceled by RootInteractions that have this value as an asset tag.                                                                                                                            |
+| InterruptingBypass  | `String`                                                                                            | **No**    | If provided, this interaction will not cancel interaction chains whose RootInteraction has this value as an asset tag.                                                                                                                    |
+
+**InteractionType Values**
+
+- `Primary`
+- `Secondary`
+- `Ability1`
+- `Ability2`
+- `Ability3`
+- `Use`
+- `Pick`
+- `Pickup`
+- `CollisionEnter`
+- `CollisionLeave`
+- `Collision`
+- `EntityStatEffect`
+- `SwapTo`
+- `SwapFrom`
+- `Death`
+- `Wielding`
+- `ProjectileSpawn`
+- `ProjectileHit`
+- `ProjectileMiss`
+- `ProjectileBounce`
+- `Held`
+- `HeldOffhand`
+- `Equipped`
+- `Dodge`
+- `GameModeSwap`
+
+**InteractionSettings Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                        |
+| ---------------- | ------------------------------- | --------- | -------------------------------------------------------------------------------------------- |
+| AllowSkipOnClick | `Boolean`<br />(Default: false) | **No**    | If true, the user will be able to skip this interaction by clicking shortly after it starts. |
+
+**InteractionCameraSettings Fields**
+
+| Field Name  | Type                                             | Required? | Notes                                                                                                                                                           |
+| ----------- | ------------------------------------------------ | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| FirstPerson | `Array`<br />(Element Type: `InteractionCamera`) | **No**    | A list of camera keyframes to be played if the player is in first-person.<br />**The time of each keyframe must be after the keyframe before it in the array.** |
+| ThirdPerson | `Array`<br />(Element Type: `InteractionCamera`) | **No**    | A list of camera keyframes to be played if the player is in third-person.<br />**The time of each keyframe must be after the keyframe before it in the array.** |
+
+**InteractionCamera Fields**
+
+| Field Name | Type                         | Required? | Notes                                                                                                                                       |
+| ---------- | ---------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------- |
+| Time       | `Float`<br />(Default: 0.1f) | **No**    | How long after the interaction begins executing that the camera should arrive at this keyframe.<br />**Cannot be less than or equal to 0.** |
+| Position   | `Vector3`                    | **Yes**   | Where the camera should be located when it arrives at this keyframe.                                                                        |
+| Rotation   | `Direction`                  | **Yes**   | Where the camera should be pointing when it arrives at this keyframe.                                                                       |
+
+### SimpleInteraction
+
+Most interaction types below are inherited from SimpleInteraction and have these
+fields.  If a type does not have these fields, the documentation will mention it.
+
+The purpose of SimpleInteraction is to facilitate Interaction chaining by taking different paths
+based on whether the Interaction succeeded or failed.  The circumstances under which
+a given Interaction fails are generally type-specific (and described in the documentation
+below), but all interactions will be marked failed if they are cancelled via one of the
+many, many mechanisms for doing so.
+
+It is valid to create an interaction asset of type "Simple", which can be valuable when you want to use the
+interaction fields with no additional functionality.
+
+**SimpleInteraction Fields**
+
+| Field Name | Type                                     | Required? | Notes                                                                                          |
+| ---------- | ---------------------------------------- | --------- | ---------------------------------------------------------------------------------------------- |
+| Next       | `Asset`<br />(Asset Type: `Interaction`) | **No**    | After this Interaction has finished, "Next" will be executed if this Interaction did not fail. |
+| Failed     | `Asset`<br />(Asset Type: `Interaction`) | **No**    | After this Interaction has finished, "Failed" will be executed if this Interaction failed.     |
+
+## Flow Control
+
+These are interaction types used to control the flow of an interaction chain and allow interactions
+to be composed into more complex behaviors.  These interaction types generally do not pertain to
+the game and instead pertain to the interaction system itself.
+
+### Condition
+
+This interaction will fail if one of the fields is provided but does not match the current state.
+
+**Condition Fields**
+
+| Field Name       | Type       | Required? | Notes                                                                                                                                                                                    |
+| ---------------- | ---------- | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| RequiredGameMode | `GameMode` | **No**    | If provided, the interaction will fail if the current GameMode does not match the provided value.                                                                                        |
+| Jumping          | `Boolean`  | **No**    | If provided, the interaction will fail if the player's Jumping state does not match the provided value. (i.e. if True, the player must be jumping, if False, the player must not be)     |
+| Swimming         | `Boolean`  | **No**    | If provided, the interaction will fail if the player's Swimming state does not match the provided value. (i.e. if True, the player must be swimming, if False, the player must not be)   |
+| Crouching        | `Boolean`  | **No**    | If provided, the interaction will fail if the player's Crouching state does not match the provided value. (i.e. if True, the player must be crouching, if False, the player must not be) |
+| Running          | `Boolean`  | **No**    | If provided, the interaction will fail if the player's Running state does not match the provided value. (i.e. if True, the player must be running, if False, the player must not be)     |
+| Flying           | `Boolean`  | **No**    | If provided, the interaction will fail if the player's Flying state does not match the provided value. (i.e. if True, the player must be flying, if False, the player must not be)       |
+
+**GameMode Values**
+
+- `Creative`: The game is currently in Creative Mode
+- `Adventure`: The game is currently in Adventure Mode
+
+### FirstClick
+
+This interaction does not inherit from SimpleInteraction and therefore has no Next or Failed fields.
+
+This interaction has two fields that each contain a reference to an Interaction: Click and Hold.  If the root interaction
+of the chain was initiated by a client button/key press (or simulated NPC input) and the input was a tap, then
+the Click interaction is run. if it was a longer press, then the Hold interaction is run.
+
+As a minor implementation detail, this interaction is internally marked as failed when the Hold path is followed.
+This generally shouldn't matter.  If the interaction was not initiated by a key press at all, the Click path will be followed,
+but it seems risky to rely on that behavior.
+
+**FirstClick Fields**
+
+| Field Name | Type                                     | Required? | Notes                                                                                                                                                    |
+| ---------- | ---------------------------------------- | --------- | -------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Click      | `Asset`<br />(Asset Type: `Interaction`) | **No**    | If provided and the root interaction of the chain was initiated by button/key press, this interaction is executed next if the press was a quick tap.     |
+| Hold       | `Asset`<br />(Asset Type: `Interaction`) | **No**    | If provided and the root interaction of the chain was initiated by a button/key press, this interaction is executed next if the press was a longer hold. |
+
+### Interrupt
+
+This interaction can be used to cancel one or more running interaction chains on an entity and **all forked interaction
+chains those chains have spawned that are still currently running**.  All interaction chains canceled in this manner will be marked as
+Failed, which may have additional implications if the canceled chains are themselves forked from
+other chains that are still running.
+
+**Interrupt Fields**
+
+| Field Name     | Type                                           | Required? | Notes                                                                                                                                                                                               |
+| -------------- | ---------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Entity         | `InteractionTarget`<br />(Default: User)       | **Yes**   | The entity that is the owner of the target interaction chains.  This field can indicate the Owner, User, or Target of this interaction chain.                                                       |
+| InterruptTypes | `Array`<br />(Element Type: `InteractionType`) | **No**    | A set of InteractionTypes that are to be interrupted. Only interactions of these types are affected. If null, all types will be interrupted.<br />**(Note: An empty set will interrupt NO TYPES.)** |
+| RequiredTag    | `String`                                       | **No**    | An asset tag that, if provided, the RootInteraction of the interaction chain must have in order to be canceled.                                                                                     |
+| ExcludedTag    | `String`                                       | **No**    | An asset tag that, if provided, the RootInteraction of the interaction chain must not have in order to be canceled.                                                                                 |
+
+**InteractionTarget Values**
+
+- `User` - The user of this interaction chain. The entity whose actions caused this interaction chain to be executed. This is usually the same as the Owner.
+- `Owner` - The owner of this interaction chain. The entity upon whom this interaction chain is executing.
+- `Target` - The entity target of this interaction chain, if any.  This value is mutable (and can therefore come from many places) but most commonly, it is an entity the User was targeting when this interaction chain began executing.
+
+**InteractionType Values**
+
+- `Primary`
+- `Secondary`
+- `Ability1`
+- `Ability2`
+- `Ability3`
+- `Use`
+- `Pick`
+- `Pickup`
+- `CollisionEnter`
+- `CollisionLeave`
+- `Collision`
+- `EntityStatEffect`
+- `SwapTo`
+- `SwapFrom`
+- `Death`
+- `Wielding`
+- `ProjectileSpawn`
+- `ProjectileHit`
+- `ProjectileMiss`
+- `ProjectileBounce`
+- `Held`
+- `HeldOffhand`
+- `Equipped`
+- `Dodge`
+- `GameModeSwap`
+
+### Parallel
+
+This interaction does not inherit from SimpleInteraction and therefore has no Next or Failed fields.
+
+This interaction has a field `Interactions` that is an array of RootInteraction assets. The list must contain at least
+two RootInteractions.  This interaction will fork all of its children except for the first into their
+own interaction chains and immediately complete. After this interaction completes, this interaction chain will
+execute the first RootInteraction in the `Interactions` list.
+
+This interaction does not have any failure conditions and is indifferent to the fate of the forked interaction chains.
+
+**Parallel Fields**
+
+| Field Name   | Type                                                | Required? | Notes                                                         |
+| ------------ | --------------------------------------------------- | --------- | ------------------------------------------------------------- |
+| Interactions | `AssetArray`<br />(Element Type: `RootInteraction`) | **Yes**   | An array of RootInteractions that will be forked or executed. |
+
+### Repeat
+
+This interaction has a field `ForkInteractions` that is an asset of type RootInteraction. This interaction will fork that
+RootInteraction into its own interaction chain and then wait for it to complete. If the RootInteraction fails, this
+interaction will complete immediately and be marked failed. Otherwise, the RootInteraction will be forked and run again,
+up to a specified total number of times.
+
+**Repeat Fields**
+
+| Field Name       | Type                                                                                   | Required? | Notes                                                                                                                                                                                                              |
+| ---------------- | -------------------------------------------------------------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| ForkInteractions | `Asset`<br />(Asset Type: `RootInteraction`)                                           | **Yes**   | A RootInteraction that will be forked.                                                                                                                                                                             |
+| Repeat           | `Integer`<br />(Default: 1)<br />**Must be -1 or a positive integer. 0 is not valid.** | **No**    | The total number of times to fork ForkInteractions. If -1 is provided, ForkInteractions will continue being forked and executed indefinitely, until this interaction is cancelled or until ForkInteractions fails. |
+
+### Replace
+
+This interaction does not inherit from SimpleInteraction and therefore has no Next or Failed fields.
+
+This interaction uses the InteractionVars system that is avaiable for items. InteractionVars are RootInteractions that
+can be attached to an Item asset with a name.
+
+This interaction specifies a var name, and if this interaction chain was executed through
+an item and that item has an InteractionVar of the same name, then this interaction will immediately execute
+the RootInteraction on the var.  Otherwise, it will execute the default RootInteraction specified in this interaction.
+If no default is specified, then this interaction will be marked as failed.
+
+**Replace Fields**
+
+| Field Name   | Type                                         | Required? | Notes                                                                                                                                                                                                           |
+| ------------ | -------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Var          | `String`                                     | **Yes**   | The name of the InteractionVar to execute.                                                                                                                                                                      |
+| DefaultValue | `Asset`<br />(Asset Type: `RootInteraction`) | **No**    | The RootInteraction to execute if the owning item does not have an InteractionVar by the specified name. If not provided, the interaction will be marked as failed instead.                                     |
+| DefaultOk    | `Boolean`<br />(Default: false)              | **No**    | If false, then an angry message will be printed to the server logs if the owning item does not have an InteractionVar by the specified name.  The functioning of this interaction will be otherwise unaffected. |
+
+### RunRootInteraction
+
+This interaction immediately executes the provided RootInteraction as part of this interaction chain. This interaction
+does not have any failure conditions.
+
+**RunRootInteraction Fields**
+
+| Field Name      | Type                                         | Required? | Notes                           |
+| --------------- | -------------------------------------------- | --------- | ------------------------------- |
+| RootInteraction | `Asset`<br />(Asset Type: `RootInteraction`) | **Yes**   | The RootInteraction to execute. |
+
+### Selector
+
+This interaction will execute a Selector to find entities and/or blocks (depending on the Selector) and fork off an
+interaction chain for each located entity or block. This interaction will not wait for those interaction chains
+to complete and is indifferent to their fate. The forked interaction chains will use the located entity/block as
+their target entity/target block. Each entity or block will only fork one interaction chain over the life of this
+interaction.  The Selector is guaranteed to run once for each execution of this interaction, but some Selectors
+are intended to be run over a period of time and sweep across an area to locate targets. In order to use those Selectors
+properly, you will need to extend the execution time of this interaction using `RunTime` or `WaitForAnimationToFinish`.
+The Selector will be executed repeatedly over the lifetime of the interaction.
+
+If the Selector is configured to locate entities, you can add additional sets of entity matching rules. If a located entity
+matches one of the rules, the matching RootInteraction will be forked instead of the standard `HitEntity` RootInteraction.
+
+Entities located by the Selector will be ignored if they do not have a NetworkId, if they are dead, or if they are invulnerable.
+The only exception to this rule is that players in Creative Mode that are marked to receive hits will not be ignored.
+
+This interaction's failure conditions are configurable via the `FailOn` field. You can configure this interaction to never
+fail, to fail if the Selector does not locate any blocks before this interaction finishes executing, to fail if the
+Selector does not locate any entities before this interaction finishes executing, or to fail in either case.
+
+**Selector Fields**
+
+| Field Name     | Type                                         | Required? | Notes                                                                                                                                                                                                                                     |
+| -------------- | -------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Selector       | `Selector`                                   | **Yes**   | The Selector is executed at least once and may be executed repeatedly to locate blocks and/or entities in an area.                                                                                                                        |
+| HitEntity      | `Asset`<br />(Asset Type: `RootInteraction`) | **No**    | If included and the `Selector` locates an entity that does not match any `HitEntityRules`, this RootInteraction will be forked into a new interaction chain with the located entity as the target entity.                                 |
+| HitEntityRules | `Array`<br />(Element Type: `HitEntity`)     | **No**    | If included, these rules will be matched against any entity located by the `Selector`. If an entity matches a set of rules, the RootInteraction associated with the rules will be forked instead of the standard `HitEntity` interaction. |
+| HitBlock       | `Asset`<br />(Asset Type: `RootInteraction`) | **No**    | If included and the `Selector` locates a block, this RootInteraction will be forked into a new interaction chain with the located block as the block target.                                                                              |
+| FailOn         | `FailOnType`<br />(Default: `Neither`)       | **No**    | Defines under what circumstances this interaction will fail.  It can be marked to fail when it completes without locating any blocks, it can be marked to fail when it completes without locating any entities, both, or neither.         |
+| IgnoreOwner    | `Boolean`<br />(Default: true)               | **No**    | If true, the Selector will not locate the User entity of this interaction.                                                                                                                                                                |
+
+**HitEntity Fields**
+
+| Field Name | Type                                         | Required? | Notes                                                                                                 |
+| ---------- | -------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------- |
+| Matchers   | `Array`<br />(Element Type: `EntityMatcher`) | **Yes**   | A set of rules that an entity must match. An entity must successful match all rules to be considered. |
+| Next       | `Asset`<br />(Asset Type: `RootInteraction`) | **Yes**   | The RootInteraction to fork if an entity matches all rules.                                           |
+
+**EntityMatcher Fields**
+
+| Field Name | Type                            | Required? | Notes                                                                                                     |
+| ---------- | ------------------------------- | --------- | --------------------------------------------------------------------------------------------------------- |
+| Type       | `String`                        | **Yes**   | If provided, specifies a type of EntityMatcher to use. Each matcher type may come with additional fields. |
+| Invert     | `Boolean`<br />(Default: false) | **No**    | If true, an entity must fail this rule for it to be marked as succeeded.                                  |
+
+**EntityMatcher Type: Player**
+
+This EntityMatcher will succesfully match the entity only if they are a player.
+
+**EntityMatcher Type: Vulnerable**
+
+This Entitymatcher will successfully match the entity only if they are not marked as invulnerable.
+
+**FailOnType Values**
+
+- `Neither`
+- `Entity`
+- `Block`
+- `Either`
+
+### Serial
+
+This interaction does not inherit from SimpleInteraction and therefore has no Next or Failed fields.
+
+This interaction has a field `Interactions` which is a list of Interaction assets. This interaction immediately
+completes and the interaction chain continues by executing the interactions in the list one at a time. This
+interaction does not have any failure conditions.
+
+**Serial Fields**
+
+| Field Name   | Type                                            | Required? | Notes                                      |
+| ------------ | ----------------------------------------------- | --------- | ------------------------------------------ |
+| Interactions | `AssetArray`<br />(Element Type: `Interaction`) | **Yes**   | An array of Interaction assets to execute. |
+
+## Cooldowns
+
+RootInteractions interface with a complex cooldown system that can be used for a variety of purposes. Aside from simply
+adding an important aspect of resource management to your game design, cooldowns can be used to ensure that click-activated
+interaction chains don't repeatedly spam if the player holds down the input.
+
+By default, every RootInteraction has a cooldown timer that is keyed to the RootInteraction name, and by default, it
+will launch a cooldown of 0.35 seconds when activated by client input.  Otherwise, no cooldown will be activated.  However,
+by configuring your RootInteraction, you can change the key for the cooldown (so that multiple RootInteractions can share
+a single cooldown), set the cooldown timer to whatever you like, and configure multiple charges that can build up over time
+to allow the entity to activate the RootInteraction multiple times before being forced to pause.
+
+One important concept to keep in mind is the difference between **cooldown** and **charge time**.  The cooldown, if any,
+is activated each time a RootInteraction triggers, even if the player has more available charges. If the RootInteraction
+is configured to use charges, then they will gradually build up over time. In order for a RootInteraction to be activated,
+the cooldown (if any) must be expired, and the RootInteraction must have at least one charge (if it has been
+configured to use charges).
+
+Bear in mind that the entire Cooldown configuration is shared between different RootInteractions with the same cooldown id.
+If you activate an ability with 5 charges and a short cooldown and then another ability with a much longer cooldown and no
+charges, the second ability will use the cooldown properties of the first ability until/unless the first ability finishes
+charging and is cleared from the system.  You should generally only have multiple RootInteractions share a cooldown id
+if they have the same configuration.
+
+The interactions below interact with the cooldown system to allow you to manipulate cooldowns via the interaction system. By
+using these interactions, you can have several interaction chains with different cooldown configurations share cooldowns
+that are checked and activated as part of the interaction chain itself, or have some components of an interaction change
+use a second cooldown separate from the main one.
+
+### CooldownCondition
+
+**CooldownCondition Fields**
+
+This interaction will fail if the specified cooldown id is on cooldown for the User entity.  This interaction will only
+function for players- the interaction will always succeed for NPCs.  In order for this interaction to succeed, the
+cooldown, if any, must have expired and at least one charge, if any, must have filled.
+
+| Field Name | Type     | Required? | Notes                     |
+| ---------- | -------- | --------- | ------------------------- |
+| Id         | `String` | **Yes**   | The cooldown id to check. |
+
+### IncrementCooldown
+
+**IncrementCooldown Fields**
+
+This interaction will modify a cooldown that is currently active on the User entity, allowing charges and remaining
+cooldown to be modified.
+Despite its name, this interaction can be used to reduce a cooldown as well as increase it. If the cooldown is not
+currently active, this interaction will have no effect. The interaction has no special failure conditions.
+
+| Field Name        | Type                        | Required? | Notes                                                                                                                                                                                                                                                                                     |
+| ----------------- | --------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Id                | `String`                    | **No**    | If provided, the cooldown id of the cooldown to be manipulated. If not provided, the cooldown id of the current chain's RootInteraction will be used.                                                                                                                                     |
+| Time              | `Float`<br />(Default: 0.0) | **No**    | The amount to increase the remaining cooldown by. Can be negative. The remaining cooldown time will not be reduced below zero or increased above the maximum cooldown time.                                                                                                               |
+| ChargeTime        | `Float`<br />(Default: 0.0) | **No**    | The amount to increase the remaining time until the next charge is filled by. Can be negative. The remaining charge time cannot be reduced below zero or increased above the maximum cooldown time. **This will not work on abilities that have a maximum of 1 charge, for some reason.** |
+| Charge            | `Integer`<br />(Default: 0) | **No**    | The amount to increase the number of charges by. Can be negative. The number of charges cannot be reduced below 0 or increased above the maximum.                                                                                                                                         |
+| InterruptRecharge | `Boolean`(Default: false)   | **No**    | If true and `Charge` is not 0, will reset the remaining time to the next charge to the maximum value after changing the charge count.                                                                                                                                                     |
+
+### ResetCooldown
+
+This interaction will trigger a cooldown on the User entity with a specified configuration. The charges will be refilled
+but the cooldown will be immediately triggered.  The mechanisms for deciding on the configuration are a little bit complicated.
+You may specify a cooldown configuration via the `Cooldown` field. If you do not include an `Id` field, then the
+interaction chain's RootInteraction will be used for any field not specified in the configuration. If there is an active
+cooldown under the specified `Id` (or under the RootInteraction's cooldown id if none is specified) then the fields
+from that active cooldown will overwrite data in the RootInteraction's cooldown, but not data in your `Cooldown` field.
+
+**ResetCooldown Fields**
+
+| Field Name | Type                  | Required? | Notes                                                        |
+| ---------- | --------------------- | --------- | ------------------------------------------------------------ |
+| Cooldown   | `InteractionCooldown` | **No**    | A cooldown configuration to use for the new, reset cooldown. |
+
+**InteractionCooldown Fields**
+
+| Field Name        | Type                                 | Required? | Notes                                                                                                                                                                                                 |
+| ----------------- | ------------------------------------ | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Id                | `String`                             | **No**    | The cooldown id to use for this cooldown. If not provided, the RootInteraction's cooldown id will be used, if any.                                                                                    |
+| Cooldown          | `Float`<br />(Default: 0.0)          | **No**    | The duration of the cooldown, in seconds.                                                                                                                                                             |
+| Charges           | `Array`<br />(Element Type: `Float`) | **No**    | If provided, a list of how many charges this cooldown can build, and how long each charge takes to build, in seconds.                                                                                 |
+| InterruptRecharge | `Boolean`<br />(Default: false)      | **No**    | If true, the charge time will be reset when the number of charges changes.                                                                                                                            |
+| ClickBypass       | `Boolean`<br />(Default: false)      | **No**    | If true, RootInteractions keyed to this cooldown can still be activated when it is on cooldown provided that the RootInteraction was triggered by a distinct key or mouse button press on the client. |
+
+### TriggerCooldown
+
+This interaction is similar to ResetCooldown, except instead of refilling the cooldown's charges, one charge will be deducted
+as normal.
+
+**TriggerCooldown Fields**
+
+| Field Name | Type                  | Required? | Notes                                                        |
+| ---------- | --------------------- | --------- | ------------------------------------------------------------ |
+| Cooldown   | `InteractionCooldown` | **No**    | A cooldown configuration to use for the new, reset cooldown. |
+
+**InteractionCooldown Fields**
+
+| Field Name        | Type                                 | Required? | Notes                                                                                                                                                                                                 |
+| ----------------- | ------------------------------------ | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Id                | `String`                             | **No**    | The cooldown id to use for this cooldown. If not provided, the RootInteraction's cooldown id will be used, if any.                                                                                    |
+| Cooldown          | `Float`<br />(Default: 0.0)          | **No**    | The duration of the cooldown, in seconds.                                                                                                                                                             |
+| Charges           | `Array`<br />(Element Type: `Float`) | **No**    | If provided, a list of how many charges this cooldown can build, and how long each charge takes to build, in seconds.                                                                                 |
+| InterruptRecharge | `Boolean`<br />(Default: false)      | **No**    | If true, the charge time will be reset when the number of charges changes.                                                                                                                            |
+| ClickBypass       | `Boolean`<br />(Default: false)      | **No**    | If true, RootInteractions keyed to this cooldown can still be activated when it is on cooldown provided that the RootInteraction was triggered by a distinct key or mouse button press on the client. |
+
+## Combo Chains
+
+Hytale additionally comes with a rich "combo chaining" system, which allows several inputs in a row to result in different
+attacks and special moves.  Rather than being attached to the RootInteraction like the cooldown system, these are
+primarily driven by the `Chaining` interaction.
+
+### Chaining
+
+This interaction does not inherit from SimpleInteraction and therefore has no Failed field. Its Next field works differently
+from most interaction types.
+
+Chaining is a type of flow control interaction- each time a Chaining interaction with the same `ChainId` is called, a single
+interaction in the `Next` list is chosen and the others are ignored. The first time the `ChainId` is used, the first
+interaction in the list is chosen, the next time the second, etc. Once the end of the list is reached, the first
+interaction will be chosen again.
+
+Bear in mind: the progress through the Next list is based on the **ChainId**, not the interaction!  That means that two
+different Chaining interactions can share a single combo chain. You could have a pair of daggers that attacks with
+the left when the left mouse button is clicked and with the right when the right mouse button is clicked.  You could give
+both interaction chains a Chaining interaction with the same `ChainId` and three `Next` entries that do a light-light-heavy
+combo.  Each specific hit would occur with either the left or the right knife based on which button you clicked, but
+the combo would be otherwise identical regardless of which you chose.
+
+The Chaining interaction also has a concept called "flags".  It is possible to attach named flags to a `ChainId` by using
+the ChainFlag interaction.  Then, you specify the flag name in Chaining's `Flags` field. If a Flag is active when the
+Chaining interaction is run, the Flag's interaction will be run instead of the appropriate interaction in `Next`.
+Bear in mind: the entity's progress through the `Next` list still advances, the resulting `Next` interaction is just not
+run.  Only one flag can be active at a time.
+
+Lastly, it is possible to cancel the entity's progress through the combo chain and reset them to the first interaction in
+the list. This can be done with the CancelChain interaction, but it will also happen automatically if the player does
+not trigger an interaction with the ChainId for the specified ChainingAllowance.  When either of these happen, all flags will be
+canceled as well.
+
+All of these effects are triggered on the User entity only. Non-players can use the chaining system, but Flags do not currently
+work for non-players.  This interaction has no special failure conditions.
+
+**Chaining Fields**
+
+| Field Name        | Type                                                       | Required? | Notes                                                                                                                                                                                                                       |
+| ----------------- | ---------------------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| ChainId           | `String`                                                   | **No**    | If provided, acts as a key that multiple Chaining interactions can use to share combo chain progress and flags. If not provided, a unique ChainId will be generated for this interaction.                                   |
+| ChainingAllowance | `Double`<br />(Default: 0.0)                               | **No**    | If, at the time this interaction is triggered, it has been this long in seconds since the last time a Chaining interaction with the same ChainId was executed, all state for this ChainId will be cleared before execution. |
+| Next              | `AssetArray`<br />(Element Type: `Interaction`)            | **Yes**   | A list of interactions to cycle between each time this interaction is run.                                                                                                                                                  |
+| Flags             | `Map`<br />(Key Type: `String`, Value Type: `Interaction`) | **No**    | A map of flag names to interactions to run if the flag is active when this interaction executes.                                                                                                                            |
+
+### CancelChain
+
+This interaction resets all progress and flag data on the User entity for the provided `ChainId`.  The next time a Chaining
+interaction is called for the provided `ChainId`, it will begin at the first interaction in the `Next` list. This
+interaction has no special failure conditions.
+
+**CancelChain Fields**
+
+| Field Name | Type     | Required? | Notes                                 |
+| ---------- | -------- | --------- | ------------------------------------- |
+| ChainId    | `String` | **Yes**   | A ChainId whose data should be reset. |
+
+### ChainFlag
+
+This interaction activates a flag on the User entity for the provided `ChainId`, which can be used to change behavior the
+next time a Chaining interaction with this `ChainId` is run. This will overwrite any flag that has
+already been raised. This interaction will have no effect for non-players. This interaction has no special failure
+conditions.
+
+| Field Name | Type     | Required? | Notes                                        |
+| ---------- | -------- | --------- | -------------------------------------------- |
+| ChainId    | `String` | **Yes**   | A ChainId on whom the flag should be raised. |
+| Flag       | `String` | **Yes**   | The name of the flag to raise.               |
+
+## Charging
+
+A unique flow-control interaction that is frequently used is the Charging interaction.  It is a flow-control interaction
+that delays while the input button used to trigger the interaction chain is held.  When it is released (or the interaction
+is forced to end), the interaction chain can continue with a different interaction based on how long the input was held
+for.
+
+These interactions are all related by either being the Charging interaction, or other interaction types that inherit the
+Charging interaction's behavior.
+
+### Charging
+
+This interaction does not inherit from SimpleInteraction and therefore its Next field works different from most interactions.
+This interaction adds its own Failed field which works the same way that SimpleInteraction's does.
+
+This interaction only works properly when its interaction chain was triggered by a client key or button press (or
+NPC-simulated equivalent). This interaction will continue executing for as long as the key or button press is held (with
+some exceptions, covered below) by the User entity.  Like other interactions, it has a `Next` field indicating which interaction to execute
+after this one, but the field is a map from `Float` values to `Interaction` assets. When this interaction ends, either
+due to the input being released or the charge duration completing, this interaction will determine the largest `Float` key that is less
+than the amount of time in seconds that the interaction was executing for.  The Interaction mapped to that key will be
+executed next.
+
+The interaction includes some cancellation conditions that are specific to this interaction. For instance, the interaction
+has a `CancelOnOtherClick` field that matches the field on RootInteraction. If it is active on this interaction but not
+the RootInteraction, then clicking while charging will cancel this interaction (and execute the `Failed` interaction rather
+than any of the `Next` interactions) but otherwise continue the interaction chain.
+
+Another valuable feature Charging has is the `Forks` field.  For input-triggered interactions that are triggered while the
+Charging interaction is executing, you can add an entry for the relevant InteractionType to this field and instead of
+triggering the usual interaction chain based on held item, targeted block, etc. the RootInteraction specified in the
+`Forks` field will be triggered.  This can unlock rich attack modes and behaviors. For instance, having a shield bash attack
+triggered off left click while blocking, or a special attack that triggers when both mouse buttons are pressed at the
+same time.
+
+There are two modes of operation for the Charging interaction. One is to have the ability charge for as long
+as the input is held and only end execution when the entity releases the input.  Bows in the main Hytale game work
+that way.  That is accomplished by setting `AllowIndefiniteHold` to true.  Another mode of operation is to have the
+interaction complete execution when the execution time has surpassed the largest key value in the `Next` field and
+immediately begin executing the Interaction mapped to that key.  Food in the main Hytale game work like this.  It
+is accomplished by setting `AllowIndefiniteHold` to false.
+
+One pitfall to be careful of when setting `AllowIndefiniteHold` to false is the way it interacts with cooldowns.\
+Normally, input-initiated interaction chains start a 0.35s cooldown on the triggered RootInteraction that prevents
+holding the mouse button from immediately spamming a new interaction when the first one completes.  However, if the
+duration of a Charging interaction is longer than 0.35s, then the cooldown will have already completed when the
+interaction chain finishes, which will often result in a new execution beginning immediately before the player can
+stop pressing the mouse button.  One solution for this problem is to add a `Simple` interaction to the end of your
+interaction chain with a `RunTime` of 0.35s to simulate the cooldown.  Alternatively, you can add a longer cooldown
+(the maximum duration of your Charging interaction plus 0.35s) to the RootInteraction. However, the longer cooldown is
+not always desirable, as the interaction may have ended prematurely, resulting in an unusually long lockout between
+executions.
+
+**Charging Fields**
+
+| Field Name                         | Type                                                                    | Required? | Notes                                                                                                                                                                                                                                                                                                                                                                                       |
+| ---------------------------------- | ----------------------------------------------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| FailOnDamage                       | `Boolean`<br />(Default: false)                                         | **No**    | If true, this interaction will fail and end immediately if the User entity takes any damage while it is executing.                                                                                                                                                                                                                                                                          |
+| CancelOnOtherClick                 | `Boolean`<br />(Default: true)                                          | **No**    | If true, this interaction will fail and end immediately if the User entity sends another button or key press while it is executing.                                                                                                                                                                                                                                                         |
+| Forks                              | `Map`<br />(Key Type: `InteractionType`, Value Type: `RootInteraction`) | **No**    | A map of InteractionType to RootInteraction. If entity input triggers the InteractionType while this interaction is executing, the mapped RootInteraction will be forked into its own interaction chain. This will happen instead of the usual handling for that InteractionType.  This fork will occur even if `CancelOnOtherClick` is set to true.                                        |
+| Failed                             | `Asset`<br />(Asset Type: `Interaction`)                                | **No**    | After this Interaction has finished, "Failed" will be executed if this Interaction failed.                                                                                                                                                                                                                                                                                                  |
+| AllowIndefiniteHold                | `Boolean`<br />(Default: false)                                         | **No**    | If true, this interaction will continue executing for as long as the User entity continues to hold the input. If false, execution will end as soon as the execution time in seconds reaches the largest key value in the `Next` map.                                                                                                                                                        |
+| DisplayProgress                    | `Boolean`<br />(Default: true)                                          | **No**    | If true, players executing this interaction will see a progress bar will be displayed below their cursor indicating how close to reaching the highest key value in `Next` they are.                                                                                                                                                                                                         |
+| Next                               | `Map`<br />(Key Type: `Float`, Value Type: `Interaction`)               | **No**    | A map from `Float` to `Interaction`.  When this interaction successfully finishes executing (either because the input was released or because the maximum duration was reached), this interaction will find the `Float` value with the largest duration in seconds that is less than the amount of time this interaction executed for. That key's mapped Interaction will then be executed. |
+| MouseSensitivityAdjustmentTarget   | `Float`<br />(Default: 1.0)                                             | **No**    | While charging, this mouse sensitivity multiplier will gradually be applied.                                                                                                                                                                                                                                                                                                                |
+| MouseSensitivityAdjustmentDuration | `Float`<br />(Default: 1.0)                                             | **No**    | Duration in seconds. After this many seconds, `MouseSensitivityAdjustmentTarget` will be fully applied to the mouse sensitivity.                                                                                                                                                                                                                                                            |
+| Delay                              | `ChargingDelay`                                                         | **No**    | Settings that allow charging progress to be pushed back when the User entity takes damage.                                                                                                                                                                                                                                                                                                  |
+
+**ChargingDelay Fields**
+
+| Field Name    | Type                        | Required? | Notes                                                                                                                                                                                                                                                                     |
+| ------------- | --------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| MinHealth     | `Float`<br />(Default: 0.0) | **No**    | Damage taken as a percentage of entity health (0.0-1.0). If a hit deals less than this much damage, no pushback will be applied.  If a hit deals exactly this much damage, `MinDelay` seconds worth of pushback will be applied.                                          |
+| MaxHealth     | `Float`<br />(Default: 0.0) | **No**    | Damage taken as a percentage of entity health (0.0-1.0). If a hit deals at least this much damage, `MaxDelay` seconds worth of pushback will be applied.                                                                                                                  |
+| MinDelay      | `Float`<br />(Default: 0)   | **No**    | The amount of pushback, in seconds, to apply if the entity takes a hit that deals `MinHealth` damage. The amount of pushback applied by a hit is a gradiant between `MinDelay` and `MaxDelay` based on the amount of damage between `MinHealth` and `MaxHealth`.          |
+| MaxDelay      | `Float`<br />(Default: 0)   | **No**    | The amount of pushback, in seconds, to apply if the entity takes a hit that deals at least `MaxHealth` damage. The amount of pushback applied by a hit is a gradiant between `MinDelay` and `MaxDelay` based on the amount of damage between `MinHealth` and `MaxHealth`. |
+| MaxTotalDelay | `Float`<br />(Deault: 0)    | **No**    | The maximum amount of pushback the entity can receive over the course of a single charge, regardless of how many times they are hit.                                                                                                                                      |
+
+**InteractionType Values**
+
+- `Primary`
+- `Secondary`
+- `Ability1`
+- `Ability2`
+- `Ability3`
+- `Use`
+- `Pick`
+- `Pickup`
+- `CollisionEnter`
+- `CollisionLeave`
+- `Collision`
+- `EntityStatEffect`
+- `SwapTo`
+- `SwapFrom`
+- `Death`
+- `Wielding`
+- `ProjectileSpawn`
+- `ProjectileHit`
+- `ProjectileMiss`
+- `ProjectileBounce`
+- `Held`
+- `HeldOffhand`
+- `Equipped`
+- `Dodge`
+- `GameModeSwap`
+
+### Wielding
+
+This interaction is inherited from Charging rather than SimpleInteraction.  However, its `Failed` and `Next` fields function
+identically to SimpleInteraction.  It does not inherit all fields from Charging, so be sure to pay close attention to
+the field list below.
+
+This interaction drives most blocking behavior in the game. While this interaction is executing, attacks made against
+the Owner entity will (conditionally) trigger effects defined in this interaction.  Unlike the Charging interaction,
+this interaction can always execute indefinitely and will only end when it fails or when the input is released.
+
+One option available in Wielding is `AngledWielding`, which allows damage and knockback modifiers to only be applied
+depending on the direction the attack against the Owner entity is coming from.  The AngledWielding type has a
+field `Angle` which determines which direction the protection points relative to the player (0 is the player's
+front), and `AngleDistance` which determines how wide the cone of protection extends around the player.  Block effects
+from this interaction (such as `BlockedEffects`, `BlockedInteractions`, and `StaminaCost`) will only apply if
+the DamageCause matches `DamageModifiers` OR if the DamageCause matches `AngledWielding.DamageModifiers` and
+the source of the damage matches `Angle` and `AngleDistance`.  It is possible for damage and knockback multipliers
+specified on both this interaction's modifier fields and `AngledWielding`'s modifier fields to stack, if both
+have entries for the same DamageCause.
+
+This interaction will only have an effect on damage taken by one of the DamageCause entries in `DamageModifiers` or
+`AngledWielding.DamageModifiers`.  If a DamageCause is in `DamageModifiers`, then the block effect will be triggered
+and the damage modifier applied regardless of what direction the Owner entity is attacked from.  If a DamageCause is in
+`AngledWielding.DamageModifiers`, then the damage modifier is only applied if the
+
+\*\* Wielding Fields\*\*
+
+| Field Name          | Type                                                                    | Required? | Notes                                                                                                                                                                                                                                                                                                                                                                                                      |
+| ------------------- | ----------------------------------------------------------------------- | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| FailOnDamage        | `Boolean`<br />(Default: false)                                         | **No**    | If true, this interaction will fail and end immediately if the User entity takes any damage while it is executing.                                                                                                                                                                                                                                                                                         |
+| CancelOnOtherClick  | `Boolean`<br />(Default: true)                                          | **No**    | If true, this interaction will fail and end immediately if the User entity sends another button or key press while it is executing.                                                                                                                                                                                                                                                                        |
+| Forks               | `Map`<br />(Key Type: `InteractionType`, Value Type: `RootInteraction`) | **No**    | A map of InteractionType to RootInteraction. If entity input triggers the InteractionType while this interaction is executing, the mapped RootInteraction will be forked into its own interaction chain. This will happen instead of the usual handling for that InteractionType.  This fork will occur even if `CancelOnOtherClick` is set to true (after which this interaction chain will be canceled). |
+| Next                | `Asset`<br />(Asset Type: `Interaction`)                                | **No**    | After this interaction has finished, "Next" will be executed if this interaction did not fail.                                                                                                                                                                                                                                                                                                             |
+| Failed              | `Asset`<br />(Asset Type: `Interaction`)                                | **No**    | After this interaction has finished, "Failed" will be executed if this interaction failed.                                                                                                                                                                                                                                                                                                                 |
+| DamageModifiers     | `Map`<br />(Key Type: `DamageCause`, Value Type: `Float`)               | **No**    | A map from DamageCause to Float, where the Float is multiplied against any damage received from the mapped DamageCause while this interaction is executing.                                                                                                                                                                                                                                                |
+| KnockbackModifiers  | `Map`<br />(Key Type: `DamageCause`, Value Type: `Float`)               | **No**    | A map from DamageCause to Float, where the Float is multiplied against any knockback force received from the mapped DamageCause while this interaction is executing.                                                                                                                                                                                                                                       |
+| AngledWielding      | `AngledWielding`                                                        | **No**    | Configuration to only trigger block effects from certain angles.                                                                                                                                                                                                                                                                                                                                           |
+| StaminaCost         | `StaminaCost`                                                           | **No**    | If the Owner entity receives damage that matches `DamageModifiers` or `AngledWielding` while this interaction is executing, then the entity's stamina will be deducted according to this configuration.                                                                                                                                                                                                    |
+| BlockedEffects      | `DamageEffects`                                                         | **No**    | If the Owner entity receives damage that matches `DamageModifiers` or `AngledWielding` while this interaction is executing, then these effects will be applied to the instance of damage.                                                                                                                                                                                                                  |
+| BlockedInteractions | `Asset`<br />(Asset Type: `RootInteraction`)                            | **No**    | If the Owner entity receives damage that matches `DamageModifiers` or `AngledWielding` while this interaction is executing, then this RootInteraction will be launched as a brand new interaction chain with the Owner entity as both Owner and User, and the attacker as the Target entity.  This new interaction chain is, notably, brand new, **not** forked from the current one.                      |
+
+**AngledWielding Fields**
+
+| Field Name         | Type                                                      | Required? | Notes                                                                                                                                                                                                            |
+| ------------------ | --------------------------------------------------------- | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Angle              | `Float`<br />(Default: 0.0)                               | **No**    | Angle in degrees relative to the Owner entity where the angled protection is centered. 0.0 means pointed towards the front of the Owner entity.                                                                  |
+| AngleDistance      | `Float`<br />(Default: 0.0)                               | **No**    | Angle in degrees indicating how wide the cone of protection is.                                                                                                                                                  |
+| DamageModifiers    | `Map`<br />(Key Type: `DamageCause`, Value Type: `Float`) | **No**    | A map from DamageCause to Float, where the Float is multiplied against any damage received from the mapped DamageCause received from within the cone of protection while this interaction is executing.          |
+| KnockbackModifiers | `Map`<br />(Key Type: `DamageCause`, Value Type: `Float`) | **No**    | A map from DamageCause to Float, where the Float is multiplied against any knockback force received from the mapped DamageCause received from within the cone of protection while this interaction is executing. |
+
+**StaminaCost Fields**
+
+| Field Name | Type                                             | Required? | Notes                                                                                                                                                                                                                                                |
+| ---------- | ------------------------------------------------ | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| CostType   | `CostType`<br />(Default: `MaxHealthPercentage`) | **No**    | How to calculate stamina consumed by blocking from the raw pre-block damage. If `Damage`, then the stamina consumed will be `rawDamage / Value`. If `MaxHealthPercentage`, then the stamina consumed will be `rawDamage / (EntityMaxHealth * Value)` |
+| Value      | `Float`<br />(Default: 0.04)                     | **No**    | The value to use in the `CostType` formula.                                                                                                                                                                                                          |
+
+**DamageEffects Fields**
+
+| Field Name             | Type                                         | Required? | Notes                                                                           |
+| ---------------------- | -------------------------------------------- | --------- | ------------------------------------------------------------------------------- |
+| ModelParticles         | `Array`<br />(Element Type: `ModelParticle`) | **No**    | Particle systems to trigger in the first-person view.                           |
+| WorldParticles         | `Array`<br />(Element Type: `WorldParticle`) | **No**    | Particle systems to trigger in the third-person view.                           |
+| LocalSoundEventId      | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | 2D sound to play locally to the attacking entity if they are a player.          |
+| WorldSoundEventId      | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | Sound to play in the world at the Owner entity's location.                      |
+| PlayerSoundEventId     | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | 2D sound to play locally to the Owner entity if they are a player.              |
+| ViewDistance           | `Double`<br />(Default: 75.0)                | **No**    | Distance at which these effects should play for other players.                  |
+| Knockback              | `Knockback`                                  | **No**    | The properties of the knockback that will be applied.                           |
+| CameraEffect           | `Asset`<br />(Asset Type: `CameraEffect`)    | **No**    | CameraEffect to briefly apply locally to the Owner entity if they are a player. |
+| StaminaDrainMultiplier | `Float`<br />(Default: 1.0)                  | **No**    | This multiplier is applied to the `StaminaCost`, if any.                        |
+
+**Knockback Fields**
+
+| Field Name     | Type                                       | Required? | Notes                                                                                                                      |
+| -------------- | ------------------------------------------ | --------- | -------------------------------------------------------------------------------------------------------------------------- |
+| Type           | `String`                                   | **No**    | If provided, specifies a type of knockback to use. Each knockback type may come with additional fields.                    |
+| Force          | `Double`<br />(Default: 0.0)               | **No**    | The amount of force to apply to the Owner entity.                                                                          |
+| Duration       | `Double`<br />(Default: 0.0)               | **No**    | If 0.0, apply the force as a single impulse.  If more, continuously apply the force over a period of time.                 |
+| VelocityType   | `ChangeVelocityType`<br />(Default: `Add`) | **No**    | How to apply the force, either adding it to the entity's current velocity, or setting the velocity to the knockback force. |
+| VelocityConfig | `VelocityConfig`                           | **No**    | Characteristics of friction as the Owner entity is thrown by this knockback.                                               |
+
+**Knockback Type: Force**
+
+Apply the calculated knockback force along the provided direction.
+
+| Field Name | Type                         | Required? | Notes                                                                                |
+| ---------- | ---------------------------- | --------- | ------------------------------------------------------------------------------------ |
+| Direction  | `Vector3`<br />(Default: Up) | **No**    | Which direction the player should be flung, relative to the direction of the attack. |
+
+**Knockback Type: Point**
+
+Apply the calculated knockback force laterally along the XZ plane, plus provided Y velocity.
+
+| Field Name | Type                        | Required? | Notes                                                                                                   |
+| ---------- | --------------------------- | --------- | ------------------------------------------------------------------------------------------------------- |
+| OffsetX    | `Integer`<br />(Default: 0) | **No**    | Offset the source position of the knockback left or right perpendicular to the direction of the attack. |
+| OffsetZ    | `Integer`<br />(Default: 0) | **No**    | Offset the source position of the knockback, forward or backward along the directon of the attack.      |
+| RotateY    | `Integer`<br />(Default: 0) | **No**    | Rotate the knockback direction around the Y axis, where 0 is the default attack direction.              |
+| VelocityY  | `Float`<br />(Default: 0.0) | **No**    | Add vertical velocity to the knockback force after the direction and force has been calculated.         |
+
+**Knockback Type: Directional**
+
+Apply the calculated knockback force along the attack direction, removing any vertical component and replacing it with a provided Y velocity.
+
+| Field Name | Type                      | Required? | Notes                                                                                                                                            |
+| ---------- | ------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------ |
+| RelativeX  | `Float`<br />(Default: 0) | **No**    | Apply additional force left or right perpendicular to the direction of the attack. The additional force is multiplied by the knockback strength. |
+| RelativeZ  | `Float`<br />(Default: 0) | **No**    | Apply additional force forward or backward along the attack direction. The additional force is multiplied by the knockback strength.             |
+| VelocityY  | `Float`<br />(Default: 0) | **No**    | Replace the vertical velocity of the knockback with this value.  This value is not multiplied by knockback strength.                             |
+
+**VelocityConfig Fields**
+
+| Field Name          | Type                                              | Required? | Notes                                                                                                                                                                                           |
+| ------------------- | ------------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| GroundResistance    | `Float`<br />(Default: 0.82)                      | **No**    | The minimum amount of friction applied when the entity is in contact with the ground.  1.0 = no friction, 0.0 = total friction                                                                  |
+| GroundResistanceMax | `Float`<br />(Default: 0.0)                       | **No**    | The maximum amount of friction applied when the entity is in contact with the ground.  1.0 = no friction, 0.0 = total friction                                                                  |
+| AirResistance       | `Float`<br />(Default: 0.96)                      | **No**    | The minimum amount of friction applied when the entity is in the air. 1.0 = no friction, 0.0 = total friction                                                                                   |
+| AirResistanceMax    | `Float`<br />(Default: 0.0)                       | **No**    | The maximum amount of friction applied when the entity is in the air. 1.0 = no friction, 0.0 = total friction                                                                                   |
+| Threshold           | `Float`<br />(Default: 1.0)                       | **No**    | The speed at which the maximum amount of friction will be applied to the entity. The amount of friction applied will increase from minimum to maximum as the entity moves from 0 to this speed. |
+| Style               | `VelocityThresholdStyle`<br />(Default: `Linear`) | **No**    | The curve that friction follows as the entity's speed increases toward the `Threshold`.                                                                                                         |
+
+**CostType Values**
+
+- `MaxHealthPercentage`
+- `Damage`
+
+**ChangeVelocityType Values**
+
+- `Add`
+- `Set`
+
+**VelocityThresholdStyle Values**
+
+- `Linear`
+- `Exp`
+
+## Blocks
+
+These are interaction types meant to reason about and modify blocks in the world.  The most important concept unique
+to these interactions is the Block Target.  Like the Entity Target, it is mutable and can come from many places.
+However, for interaction chains initiated by the client, the block target will initially be the block that the player's cursor was
+over, if any.
+
+Additionally, for interaction chains initiated by the client, the client will send along which face of the block is targeted,
+which is used by a few block-related interactions.
+It is left up to each interaction type that cares about block faces as to how to handle this behavior for simulated input
+(i.e. NPCs initiating chains that are normally initated by the client).  At the time of this writing, all block-related
+interactions choose the top face where relevant in simulated input.
+
+### BlockCondition
+
+This interaction has a field `Matchers` which specifies certain conditions, such as block type, state, etc.  This
+interaction fails if the current target block does not match all of them.
+
+**BlockCondition Fields**
+
+| Field Name       | Type                                        | Required? | Notes                                                                                                                                                                                                                                                                                                                                   |
+| ---------------- | ------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false)             | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction.                                                                                                                                                                                                       |
+| Matchers         | `Array`<br />(Element Type: `BlockMatcher`) | **Yes**   | A list of conditions that the target block must match or this condition will fail.<br />**Note: This field is technically not required but there is a bug that makes it dangerous to not provide at the time of this writing.**<br />**Note: If no conditions are added to this array, the interaction will fail, counterintuitively.** |
+
+**BlockMatcher Fields**
+
+| Field Name | Type                       | Required? | Notes                                                                          |
+| ---------- | -------------------------- | --------- | ------------------------------------------------------------------------------ |
+| Block      | `BlockIdMatcher`           | **No**    | If provided, requires the block itself match some set of conditions.           |
+| Face       | `BlockFace`                | **No**    | If provided and not 'None', requires a specific block face be targeted.        |
+| StaticFace | `Boolean` (Default: false) | **No**    | If false, the face condition will be adjusted by the block's current rotation. |
+
+**BlockFace Values**
+
+- `Up`
+- `Down`
+- `North`
+- `South`
+- `East`
+- `West`
+- `None`
+
+**BlockIdMatcher Fields**
+
+| Field Name | Type                                   | Required? | Notes                                                                      |
+| ---------- | -------------------------------------- | --------- | -------------------------------------------------------------------------- |
+| Id         | `Asset`<br />(Asset Type: `BlockType`) | **No**    | If provided, the block must match the specified `BlockType`.               |
+| State      | `String`                               | **No**    | If provided, the block's current state must match the provided state name. |
+| Tag        | `String`                               | **No**    | If provided, the block type's asset tags must contain the provided tag.    |
+
+### DestroyCondition
+
+This interaction fails if the current User entity cannot destroy the current target blcok.
+
+**DestroyCondition Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+
+### PlacementCountCondition
+
+This interaction accepts the name of a BlockType that has the TrackedPlacement BlockEntity. The interaction will fail if the number of
+blocks of the provided BlockType in the world do not match the provided condition.
+
+**PlacementCountCondition Fields**
+
+| Field Name | Type                           | Required? | Notes                                                                                                                                                                                                                                                           |
+| ---------- | ------------------------------ | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Block      | `String`                       | **Yes**   | The BlockType to examine. The number of instances of the BlockType in the world will be compared to Value.<br />**Note: The specified BlockType must have the TrackedPlacement BlockEntity. Otherwise, the number of blocks in the world will always be zero.** |
+| Value      | `Integer`<br />(Default: 0)    | **No**    | The value to compare the number of blocks in the world with.                                                                                                                                                                                                    |
+| LessThan   | \`Boolean<br />(Default: true) | **No**    | If true, the interaction will fail if the number of blocks in the world is greater than or equal to Value. If false, the interaction will fail if the number of blocks in the world is less than or equal to Value.                                             |
+
+### BreakBlock
+
+This interaction attempts to break the target block while acting as the User entity. The User entity must be a player. It
+is not guaranteed to work, depending on world settings and the User entity's current state, it may not work.  If it
+fails, it will fail the interaction under some circumstances, but not others.
+
+**Note: In particular, if `Harvest`=false and the player is in Survival mode, the player will simply execute a damage operation
+against the block. Even when the Tool field is specified, the player's currently-held item can impact the results in unintuitive
+ways.**
+
+This interaction will fail if there is no block target, if `Harvest`=true and the
+block is not harvestable, or if the world settings prevent the Harvest/Break operation.
+It will generally not fail otherwise, even if the block was not broken or damaged.
+The block will generally break every time if `Harvest`=true or the player is in
+Creative mode.
+
+**BreakBlock Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                                                                                                                                                                                                  |
+| ---------------- | ------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction.                                                                                                                                                                      |
+| Harvest          | `Boolean` (Default: false)      | **No**    | If true, harvest the block and deposit the drops in the player's inventory. This operation will generally always succeed.  If false, this interaction will effectively perform whatever action would have occurred if the player had left-clicked the block.                                           |
+| Tool             | `String`                        | **No**    | If `Harvest`=true, the player is in Survival mode, and this field is provided, then the break operation will be performed as though with this tool type.<br />**This field mostly doesn't work.  Your held item will be used for most block damage calculations regardless of this field's contents.** |
+| MatchTool        | `Boolean` (Default: false)      | **No**    | If true, `Harvest`=true, the player is in Survival mode, and `Tool` is provided, block breaking will be prevented unless `Tool` is a valid gathering tool for the target block. The interaction will not be failed, even if block breaking is prevented in this manner.                                |
+
+### ChangeBlock
+
+This interaction requires a mapping from one or more current BlockTypes to one or more target BlockTypes.  If the
+target block is one of the key BlockTypes, then it will be changed to the mapped target BlockType.  If the current
+BlockType of the target block does not appear as a key in the Changes field, then this interaction fails.
+
+**ChangeBlock Fields**
+
+| Field Name        | Type                                                        | Required? | Notes                                                                                                                             |
+| ----------------- | ----------------------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget  | `Boolean`<br />(Default: false)                             | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+| Changes           | `Map`<br />(Key Type: `BlockType`, Value Type: `BlockType`) | **No**    | A list of potential block type changes, with each entry having a current and new BlockType id.                                    |
+| WorldSoundEventId | `Asset`<br />(Asset Type: `SoundEvent`)                     | **No**    | If provided, this SoundEvent is played in the world at the position of the block if the block successfully changes.               |
+| RequireNotBroken  | `Boolean`<br />(Default: false)                             | **No**    | If true, this interaction will fail if the player's held item is broken (durability 0), and the block change will not take place. |
+
+### ChangeState
+
+This interaction requires a mapping from one or more current block state names to one or more state names. If the
+target block is in one of the key block states, then it will be changed to the mapped target blocks tate. If the
+current block state of the target block does nto appear as a key in the Changes field, then this interaction fails.
+
+All blocks start out with a null state by default.  This null state can be referenced by the key "default" and the block
+can be returned to that state with the value "default".
+
+**ChangeState Fields**
+
+| Field Name       | Type                                                  | Required? | Notes                                                                                                                                          |
+| ---------------- | ----------------------------------------------------- | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false)                       | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction.              |
+| Changes          | `Map`<br />(Key Type: `String`, Value Type: `String`) | **No**    | A list of potential block state changes, with each entry having a current and new state name.                                                  |
+| UpdateBlockState | `Boolean`<br />(Default: false)                       | **No**    | If true, performs a full refresh of the block's BlockEntity component and notifies nearby players as though a full block type change occurred. |
+
+### CycleBlockGroup
+
+This interaction will attempt to change the target block to the next block type in one of the BlockGroups it belongs to.
+If the block type belongs to multiple BlockGroups, which one is used is effectively arbitrary. The User entity must be
+a player. If the block cannot be changed for any reason (entity not a player, no block target, block does not belong
+to a BlockGroup, etc.). If the block is the only entry in the BlockGroup, this interaction will succeed and the block
+will be considered changed despite nothing happening.  Unlike most other block-changing interactions, this one will
+fail if the world settings prevent players from breaking blocks.
+
+**This interaction always reduces the player's held item's durability by a single 'hit' worth of damage if the block
+changes. There is no way to prevent it. The block type will change and the interaction will succeed even if the player's
+held item is broken, however.**
+
+**CycleBlockGroup Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+
+### DestroyBlock
+
+This interaction destroys the target block without dropping anything.  It will successfully destroy the block if the
+target block exists and this interaction has no failure conditions.
+
+**This interaction has no additional fields.**
+
+### PickBlock
+
+This interaction is effectively equivalent to using the middle mouse button in creative mode. In survival mode, the
+block's item will be moved to the user's current active hotbar slot if it is in the player's inventory.  This
+interaction is performed entirely on the client and cannot be performed by non-players.  It is unclear if this
+interaction has failure conditions.
+
+**PickBlock Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+
+### PlaceBlock
+
+This interaction is effectively identical to a right clicking while holding a block in their hand, with some
+additional options. For one, it can be executed with any LivingEntity as the User entity. For another, it has some
+useful fields.  For the most part, though, it follows the same behaviors and rules as any ordinary block placement
+by a player.
+
+It's not clear under what circumstances this interaction can fail. The server will not fail the interaction under any
+special circumstances (including when there is no target block, or when `BlockTypeToPlace` is not provided and the
+LivingEntity is not holding a block). However, the client is very involved with the function of this interaction and
+its behavior is unknown.
+
+**PlaceBlock Fields**
+
+| Field Name         | Type                                   | Required? | Notes                                                                                                                                                                                                                                                                                                                                                           |
+| ------------------ | -------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| BlockTypeToPlace   | `Asset`<br />(Asset Type: `BlockType`) | **No**    | If provided, the block placed by this interaction will be the specified BlockType. If not provided, the User entity's held item will be used, instead, if it is a block.                                                                                                                                                                                        |
+| RemoveItemInHand   | `Boolean`<br />(Default: True)         | **No**    | If true and the User entity is not a player in Creative mode, the item in the player's hand must match the block being placed and one quantity will be removed for each block placed. If the item does not match, the block cannot be placed.  If false, the player's hand item is ignored entirely.\*\*                                                        |
+| AllowDragPlacement | `Boolean`<br />(Default: True)         | **No**    | If true and the interaction was triggered on the client by a player, then the player can hold the input that was used to activate this interaction chain and move the mouse around in order to execute this interaction repeatedly and place several blocks. The interaction chain will not move onto the next interaction until the player releases the input. |
+
+### RunOnBlockTypes
+
+This interaction retrieves all blocks within a provided radius of the User entity. For each block that matches any of
+the provided BlockSets, a new interaction chain will be forked that uses the matching block as the target block.
+This interaction will continue executing until all forked interaction chains have completed.  The interaction will fail if no
+blocks within the radius match the provided BlockSets or if all of the forked interaction chains fail.
+
+**RunOnBlockTypes Fields**
+
+| Field Name   | Type                                         | Required?        | Notes                                                                                                                                                                                                                                                                                      |
+| ------------ | -------------------------------------------- | ---------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| Range        | `Integer`                                    | **Yes**          | The spherical radius around the User entity to search for blocks. Must be at least 1.                                                                                                                                                                                                      |
+| BlockSets    | `AssetArray`<br />(Element Type: `BlockSet`) | **No**           | A list of BlockSets to match nearby blocks again. Only blocks that match any of the BlockSets will have interaction chains forked for them.                                                                                                                                                |
+| MaxCount     | `Integer`                                    | **Yes**          | The maximum number of blocks that will be located with the search. Further blocks will be ignored. If there are more matching blocks within the radius than this number, the specific set of blocks that will be found is completely arbitrary and may change from execution to execution. |
+| Interactions | `Asset`<br />(Asset Type: `RootInteraction`) | **No, but yes.** | The RootInteraction that will be forked for each matching block.  This interaction will not fail to validate if it is missing, but every execution of this interaction will fail.                                                                                                          |
+
+### UseBlock
+
+If the target block has an interaction for this interaction chain's interaction type, execute it immediately as part of
+this interaction chain. The execution will be wrapped in UseBlockEvent.Pre and UseBlockEvent.Post events, and cancellations
+of the UserBlockEvent.Pre event are respected. The User entity is considered the triggering entity for both events.
+
+If the target block does not have an interaction for this interaction chain's interaction type, this interaction fails.
+
+**This interaction has no additional fields.**
+
+## Items
+
+These are interactions intended to interface with an entity's inventory. There is no concept of an "item target",
+unfortunately, so these generally either interact with the entity's held item or the entity's inventory at a high level.
+
+### AddItem
+
+Adds a specified quantity of a specified item to the User entity's inventory, preferring to add it to the
+entity's hotbar where possible. This interaction will have no effect on User entities that are not LivingEntities.
+This interaction has no failure states.
+
+**Note: This interaction has a bug in its field validators that will cause interactions that reference items declared
+in the same mod to fail validation on startup.  Additionally, this interaction has a bug that will cause it to
+fail and have no effect if the User entity has no block target. Use ModifyInventory instead.**
+
+**AddItem Fields**
+
+| Field Name       | Type                              | Required? | Notes                                                                                                                             |
+| ---------------- | --------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false)   | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+| ItemId           | `Asset`<br />(Asset Type: `Item`) | **Yes**   | The item id of the item to add to the player's inventory.                                                                         |
+| Quantity         | `Integer`<br />(Default: 0)       | **No**    | The quantity of the item to add to the player's inventory.                                                                        |
+
+### CheckUniqueItemUsage
+
+This interaction will check whether it has run once for the User entity with their currently-held item before. If it hasn't,
+it will succeed. If it has, it will fail. It will also fail if the User entity is not a player. The interaction will record
+the item id of the User entity's currently-held item on success, ensuring it cannot be successfully run with that player
+and item id combination again.
+
+**This interaction has no additional fields.**
+
+### ChangeActiveSlot
+
+This interaction does not inherit from SimpleInteraction and therefore has no Next or Failed fields.  The `CancelOnItemChange`
+field is ignored for this interaction and is always treated as false. This interaction will set the User entity's currently-
+active hotbar slot to the specified slot index. If none is specified, the interaction chain's target slot will be used,
+if any. Otherwise, slot 0 will be used.  If a slot is specified and it is already active, then this interaction will
+have no effect, but if no slot is specified and the interaction chain's target slot is already active, the logic in
+the next paragraph will still be executed. This interaction will also have no effect if the User entity is not a
+LivingEntity.
+
+Once the slot has changed, a new SwapTo interaction chain will be forked off for the selected slot.
+If a target slot was specified, then the interaction chain's current target slot will be set to the specified slot, as will
+the forked SwapTo interaction chain. If this interaction chain was initiated by a player swapping an item into or out of
+an occupied active hotbar slot, then the swap will be executed after the slot is changed and before the SwapTo
+interaction is forked. Not running this interaction in the resulting SwapFrom interaction chain is a way for the server
+to cancel players performing these sorts of swap interactions. The default behavior for these swap interactions is that
+the SwapFrom interaction chain will be initiated with the currently-active-slot as the target slot. As a result, the
+target slot will usually not change when this interaction runs, it merely exists as a signal for the server to continue the
+item swap.
+
+**ChangeActiveSlot Fields**
+
+| Field Name | Type      | Required? | Notes                                                                                                                                                                                                     |
+| ---------- | --------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| TargetSlot | `Integer` | **No**    | If not provided, indicates the slot the player's active hotbar slot should be changed to.  Otherwise, the interaction chain's target slot will be used (which is usually the already-active hotbar slot). |
+
+### EquipItem
+
+This interaction will equip the User entity's currently-held item into the appropriate armor slot, if it is armor. The
+interaction will fail if the item is armor but it cannot be equipped for some reason. The interaction will succeed but
+take no action if the User entity cannot equip armor or if the item is not armor.
+
+**This interaction has no additional fields.**
+
+### IncreaseBackpackCapacity
+
+This interaction will increase the User entity's backpack size by the provided amount.  **It will additionally remove one
+quantity from the player's currently-held item. There is no way to prevent this.**  This interaction will have no effect
+if the User entity is not a player.  This interaction has no special failure conditions, even if the User entity
+is not a player, or the player is not currently holding an item.
+
+| Field Name | Type                        | Required? | Notes                                                                                   |
+| ---------- | --------------------------- | --------- | --------------------------------------------------------------------------------------- |
+| Capacity   | `Integer`<br />(Default: 1) | **No**    | The additional backpack capacity to add to the player. **Must be between 1 and 32767.** |
+
+### ModifyInventory
+
+This interaction attempts to perform one or more inventory-modifying actions against the User entity. The User entity must
+be a player. If they are not, no actions will be performed, but the interaction will not fail. Any item removals performed
+by this interaction, either as a result of `ItemToRemove` or `AdjustHeldItemQuantity`, are both atomic (meaning the entire
+quantity must be removed, or none) and required (meaning that the interaction will fail and no further actions taken if
+the removal fails for any reason).  Item additions performed by this interaction, either as a result of `ItemToAdd` or
+`AdjustHeldItemQuantity` will drop excess items on the ground near the player if necesary and continue on.
+
+This interaction first executes the item removal in `ItemToRemove`, if any, then adjusts the held item as specified by
+`AdjustHeldItemQuantity`, if provided, then executes the item addition in `ItemToAdd`, if any, and then finally executes
+the damage/healing of the held item in `AdjustHeldItemDurability`, if provided.
+
+**ModifyDurability Fields**
+
+| Field Name               | Type                            | Required? | Notes                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
+| ------------------------ | ------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| RequiredGameMode         | `GameMode`                      | **No**    | If provided, only execute the inventory-modifying actions if the player is in the provided GameMode. The interaction will not fail if the GameMode doesn't match.                                                                                                                                                                                                                                                                                                                                                                               |
+| ItemToRemove             | `ItemStack`                     | **No**    | If provided, a matching item will be removed in the provided quantity. If there is no matching item in the player inventory in the required quantity, then the interaction will fail and further actions will not be executed.                                                                                                                                                                                                                                                                                                                  |
+| AdjustHeldItemQuantity   | `Integer`<br />(Default: 0)     | **No**    | The player's held item, if any, will have its quantity will be modified by the provided amount- subtracted from if this number is negative or added to if this item is positive.  If the player has no held item, then this field will have no effect regardless of its value and the interaction will NOT fail.  If the player's inventory does not have sufficient quantity of items to support the removal, this interaction will fail and further actions will not be executed. Excess items will be dropped on the ground near the player. |
+| ItemToAdd                | `ItemStack`                     | **No**    | If provided, the ItemStack will be added to the player's inventory. Excess items will be dropped on the ground near the player.                                                                                                                                                                                                                                                                                                                                                                                                                 |
+| AdjustHeldItemDurability | `Double`<br />(Default: 0.0)    | **No**    | The player's held item, if any, will have its durability adjusted by the specified amount.  The durability cannot go below 0 or raise above the item's maximum durability. Invalid durability values in this field will not cause the interaction to fail. Neither will it fail if the player has no held item.                                                                                                                                                                                                                                 |
+| BrokenItem               | `String`                        | **No**    | This field should contain an ItemId, but it is not validated by the server on startup, so be careful.  This field can have the value of "Empty" to specify no item, or an empty hand. If specified and the `AdjustHeldItemDurability` operation reduces the player's held item to 0 durability, the player's held item is changed to this ItemId. If the inventory replacement fails, this interaction will fail.                                                                                                                               |
+| NotifyOnBreak            | `Boolean`<br />(Default: false) | **No**    | If true and the `AdjustHeldItemDurability` operation reduces the player's held item to 0 durability, this interaction will perform the usual audiovisual feedback of a broken tool. It will play the usual tool breaking sound and send the player a text message in chat that their item has broken.                                                                                                                                                                                                                                           |
+| NotifyOnBreakMessage     | `String`                        | **No**    | If provided, and `NotifyOnBreak` is true, when the player is notified of a broken tool by this interaction, the message sent to their chat will instead be the translation key specified by this field. The translation key supports the templating parameter `{itemName}`. See the translation key `server.general.repair.itemBroken_Hoe` for an example.                                                                                                                                                                                      |
+
+**GameMode Values**
+
+- `Creative`: The game is currently in Creative Mode
+- `Adventure`: The game is currently in Adventure Mode
+
+**ItemStack Fields**
+
+| Field Name                   | Type                              | Required? | Notes                                                                                |
+| ---------------------------- | --------------------------------- | --------- | ------------------------------------------------------------------------------------ |
+| Id                           | `Asset`<br />(Asset Type: `Item`) | **Yes**   | The id of the Item asset this stack contains.                                        |
+| Quantity                     | `Integer`<br />(Default: 1)       | **No**    | The number of items in this stack.<br />**Must be greater than 0.**                  |
+| Durability                   | `Double`<br />(Default: 0.0)      | **No**    | The durability of the item stack.<br />**Cannot be negative.**                       |
+| MaxDurability                | `Double`<br />(Default: 0.0)      | **No**    | The maximum durability of the item this stack contains.<br />**Cannot be negative.** |
+| Metadata                     | `Bson Document`                   | **No**    | If provided, applies the bson to the item stack metadata.                            |
+| OverrideDroppedItemAnimation | `Boolean`\*(Default: false)       | **No**    | ???                                                                                  |
+
+### PickupItem
+
+This interaction will attempt to pick up the User entity's current target entity and add it to their inventory. It will
+fail if the User entity is not a player, if they do not have a target entity, or if the target entity is not an item
+located in the world.  It will not fail if the player simply cannot pick up the item.
+
+**This interaction has no additional fields.**
+
+### RefillContainer
+
+This interaction will fail if the User entity is not a player. The interaction will draw a ray from the player's head
+down their look direction until the edge of the player's held item's interaction range or until the first solid block.
+The nearest fluid block of a type listed in this interaction's `States` map will result in the one of the player's
+currently-held items being converted to the fluid's related item state.  If the `States` map indicates a durability
+for the new item state, then the converted item will use that durability. If the item is already in the fluid's related
+item state, then this interaction will fail if the player's held item is already at maximum durability (unless the
+`States` map indicates a durability value greater than the item's maximum, in which case the interaction will succeed
+but the item will not change).  Otherwise, the durability listed for the fluid in the `States` map will be added to the
+item's current durability.
+
+If the interaction has not failed by this point, the fluid block in the world may be transformed to a different type if one is listed
+in the `States` map.
+
+If any part of this process does not proceed for any reason (for instance, if the player is not holding an item),
+then this interaction will fail.
+
+**RefillContainer Fields**
+
+| Field Name | Type                                                       | Required? | Notes                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| ---------- | ---------------------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| States     | `Map`<br />(Key Type: `String`, Value Type: `RefillState`) | **Yes**   | A map from item state names to `RefillState` objects, which contain information such as acceptable fluid block types, durability increases, and what fluid type to convert the targeted fluid block to after refill, if any. If the player targets a fluid block that matches one of the fluid types in the `RefillState`, the item will be converted to the keyed item state and the `RefillState` will be used to decide what happens next. |
+
+**RefillState Fields**
+
+| Field Name     | Type                                  | Required? | Notes                                                                                                                                                                                                                                                                                                                           |
+| -------------- | ------------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| AllowedFluids  | `Array`<br />(Element Type: `String`) | **Yes**   | If any of these fluids are targeted by the player, the player's held item will be converted to the keyed item state and `Durability` and `TransformFluid` will be used.                                                                                                                                                         |
+| Durability     | `Double`<br />(Default: -1.0)         | **No**    | If the player's held item changes item states, this value is the new item's durability, unless it is negative, in which case the item will begin at full durability. If the player's held item is already in the item state, and the item is not already at full durability, this value will be added to the item's durability. |
+| TransformFluid | `String`                              | **No**    | If provided, this field is a fluid id that the targeted fluid block should be transformed to if the player's held item is successfully updated.                                                                                                                                                                                 |
+
+## Entities
+
+### DamageEntity
+
+This interaction does not inherit from SimpleInteraction, but adds its own Next and Failed fields that
+work similarly.
+
+This interaction will cause the User entity to damage the Target entity.  It has the capability to apply different
+damage based on the direction of the attack or what body part was targeted by the User entity, with each possibility
+providing different damage calculations, effects, and Next interaction. If multiple entires match the attack, `TargetedDamage`
+(body part damage) takes highest priority, then the first matching `AngledDamage` in the list, then the default
+damage in the base interaction fields.  It is possible for elements of these different damage priorities to be taken peacemeal if higher-priority
+damage fields do not overwrite lower-priority damage fields. For instance,
+damage calculation could be taken from `TargetedDamage`, the damage effects could be taken from the first matching
+`AngledDamage`, and the Next interaction coming from the default damage field.
+
+If all damage dealt by this interaction is cancelled, then this interaction will fail, and the `Failed` interaction
+will be executed next in the chain. If any damage dealt by this interaction is blocked, then this interaction will
+succeed, but the `Blocked` interaction wil lbe executed next in the chain. Otherwise, the highest-precedent matching
+`Next` interaction that you provide will be executed.  For instance, if you provide `Next` interactions for all
+`TargetedDamage` and `AngledDamage` entries, and one in the interaction's `Next` field, then a headshot could result
+in a unique `Next` interaction being executed, even if there is a matching `AngledDamage` entry. However, if you leave
+the `Next` interaction out of your `TargetedDamage` entries, a special `Next` interaction for backstabs could be
+executed.  Otherwise, the `Next` field in the root of the interaction will be executed instead.
+
+DamageEntity has an unusual relationship with `RunTime`. This interaction always ends immediately after its first tick,
+regardless of the status of `RunTime` or `WaitForAnimationToFinish`.  However, if damage dealt by this interaction is
+calculated as `DamageCalculatorType` `Dps`, then the `RunTime` will be used to determine the precise amount of damage to
+deal. If `RunTime` is 0, then no damage will be dealt.
+
+**DamageEntity Fields**
+
+| Field Name       | Type                                                          | Required?                                                                                                                    | Notes                                                                                                                                                                                                                                                                                                                                                                         |
+| ---------------- | ------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| DamageCalculator | `DamageCalculator`                                            | **No**                                                                                                                       | If provided, describes the damage amounts and types to apply to the Target entity.                                                                                                                                                                                                                                                                                            |
+| DamageEffects    | `DamageEffects`                                               | **No**                                                                                                                       | If provided, describes particles, sounds, knockback, etc. to apply to the target entity on damage.                                                                                                                                                                                                                                                                            |
+| Next             | `Asset`<br />(Asset Type: `Interaction`)                      | **No**  After this interaction has finished, "Next" will be executed if damage was dealt to the target and none was blocked. |                                                                                                                                                                                                                                                                                                                                                                               |
+| AngledDamage     | `Array`<br />(Element Type: `AngledDamage`)                   | **No**                                                                                                                       | If provided, allows alternative `DamageCalculator`, `DamageEffects`, and `Next` entries for attacks that approach the target from certain angles.                                                                                                                                                                                                                             |
+| TargetedDamage   | `Map`<br />(Key Type: `String`, Value Type: `TargetedDamage`) | **Yes**                                                                                                                      | This field must be provided, but is not required to have any entries.  This is a map from body part names to `TargetedDamage` values. Hypixel only uses one body part name: `Head`, and it is not clear whether there are others.  If provided, allows alternative `DamageCalculator`, `DamageEffects`, and `Next` entries for attacks that damage specific enemy body parts. |
+| EntityStatsOnHit | `Array`<br />(Element Type: `EntityStatOnHit`)                | **No**                                                                                                                       | If provided, allows this attack to reduce enemy stats other than health.  Each individual damage application dealt by the same ability will apply stat reductions, at diminishing returns. All damage dealt in interaction chains forked by a Selector interaction will share the number of hits across all targets.                                                          |
+| Failed           | `Asset`<br />(Asset Type: `Interaction`)                      | **No**                                                                                                                       | After this interaction has finished, "Failed" will be executed if no damage hits were applied to the player, or if all damage hits were cancelled.                                                                                                                                                                                                                            |
+| Blocked          | `Asset`<br />(Asset Type: `Interaction`)                      | **No**                                                                                                                       | After this interaction has finished, "Blocked" will be executed if any damage hits were blocked by the target.                                                                                                                                                                                                                                                                |
+
+**DamageCalculator Fields**
+
+| Field Name                | Type                                                      | Required? | Notes                                                                                                                                                                                                                                                 |
+| ------------------------- | --------------------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Type                      | `DamageCalculatorType`<br />(Default: Absolute)           | **No**    | Whether the damage being applied is `Absolute` or \`Dps'.                                                                                                                                                                                             |
+| Class                     | `DamageClass`<br />(Default: Unknown)                     | **No**    | The type of attack producing the damage. Some weapon systems apply equipment modifiers based on this value.                                                                                                                                           |
+| BaseDamage                | `Map`<br />(Key Type: `DamageCause`, Value Type: `Float`) | **No**    | A set of DamageCauses and how much base damage is dealt for each.                                                                                                                                                                                     |
+| SequentialModifierStep    | `Float`<br />(Default: 0.0)                               | **No**    | Value between 0.0-1.0. Each additional hit from a single ability will have its damage reduced by this much as a percentage. All damage dealt in interaction chains forked by a Selector interaction will share the number of hits across all targets. |
+| SequentialModifierMinimum | `Float`<br />(Default: 0.0)                               | **No**    | Value between 0.0-1.0. `SequentialModifierStep` cannot reduce damage below this percentage regardless of the number of hits.                                                                                                                          |
+| RandomPercentageModifier  | `Float`<br />(Default: 0.0)                               | **No**    | A random value between +/- this amount multiplied by the base damage will be added to the base damage.                                                                                                                                                |
+
+**DamageEffects Fields**
+
+| Field Name             | Type                                         | Required? | Notes                                                                                   |
+| ---------------------- | -------------------------------------------- | --------- | --------------------------------------------------------------------------------------- |
+| ModelParticles         | `Array`<br />(Element Type: `ModelParticle`) | **No**    | Particle systems to trigger in the first-person view.                                   |
+| WorldParticles         | `Array`<br />(Element Type: `WorldParticle`) | **No**    | Particle systems to trigger in the third-person view.                                   |
+| LocalSoundEventId      | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | 2D sound to play locally to the attacking entity if they are a player.                  |
+| WorldSoundEventId      | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | Sound to play in the world at the Target entity's location.                             |
+| PlayerSoundEventId     | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | 2D sound to play locally to the Target entity if they are a player.                     |
+| ViewDistance           | `Double`<br />(Default: 75.0)                | **No**    | Distance at which these effects should play for other players.                          |
+| Knockback              | `Knockback`                                  | **No**    | The properties of the knockback that will be applied.                                   |
+| CameraEffect           | `Asset`<br />(Asset Type: `CameraEffect`)    | **No**    | CameraEffect to briefly apply locally to the Target entity if they are a player.        |
+| StaminaDrainMultiplier | `Float`<br />(Default: 1.0)                  | **No**    | This multiplier is applied to the stamina cost incurred by the target blocking, if any. |
+
+**AngledDamage Fields**
+
+| Field Name       | Type                                     | Required? | Notes                                                                                                                                                                                                     |
+| ---------------- | ---------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| AngleDistance    | `Float`<br />(Default: 0)                | **No**    | The width in degrees of the matching arc around the Target entity. If the attack against the Target originates from within the arc, then the properties below will be applied to the attack, if provided. |
+| Angle            | `Float`<br />(Default: 0.0)              | **No**    | The angle in degrees around the Target entity at which the matching arc is centered.                                                                                                                      |
+| DamageCalculator | `DamageCalculator`                       | **No**    | If provided and the attack against the Target entity originates from within the provided arc, this DamageCalculator will override the interaction's `DamageCalculator` field.                             |
+| DamageEffects    | `DamageEffects`                          | **No**    | If provided and the attack against the Target entity originates from within the provided arc, this DamageEffects will override the interaction's `DamageEffects` field.                                   |
+| Next             | `Asset`<br />(Asset Type: `Interaction`) | **No**    | If provided and the attack against the Target entity originates from within the provided arc, this Interaction will override the interaction's `Next` field.                                              |
+
+**TargetedDamage Fields**
+
+| Field Name       | Type                                     | Required? | Notes                                                                                                                                                                                            |
+| ---------------- | ---------------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| DamageCalculator | `DamageCalculator`                       | **No**    | If provided and this TargetedDamage was matched, this DamageCalculator will override the interaction's `DamageCalculator` field and the `DamageCalculator` field of any matching `AngledDamage`. |
+| DamageEffects    | `DamageEffects`                          | **No**    | If provided and this TargetedDamage was matched, this DamageEffects will override the interaction's `DamageEffects` field and the `DamageEffects` field of any matching `AngledDamage`.          |
+| Next             | `Asset`<br />(Asset Type: `Interaction`) | **No**    | If provided and this TargetedDamage was matched, this Interaction will override the interaction's `Next` field and the `Next` field of any matching `AngledDamage`.                              |
+
+**EntityStatOnHit Fields**
+
+| Field Name                  | Type                                                                       | Required? | Notes                                                                                                                                                                                                                                                                                        |
+| --------------------------- | -------------------------------------------------------------------------- | --------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| EntityStatId                | `Asset`<br />(AssetType: `EntityStatType`)                                 | **Yes**   | Which entity stat to affect.                                                                                                                                                                                                                                                                 |
+| Amount                      | `Float`<br />(Default: 0.0)                                                | **No**    | How much of the stat to apply for each damage application. Use negative numbers to reduce stats.                                                                                                                                                                                             |
+| MultipliersPerEntitiesHit   | `Array`<br />(Element Type: `Float`, Default: `[1.0, 0.6, 0.4, 0.2, 0.1]`) | **No**    | The diminishing returns curve to be applied for multiple damage applications by the same ability. Each hit's stat impact will be multiplied by the next value in the list.  If there are more hits than array elements, subsequent hits will be multiplied by `MultiplierPerExtraEntityHit`. |
+| MultiplierPerExtraEntityHit | `Float`<br />(Default: 0.05)                                               | **No**    | If an ability carries out more damage applications than there are elements in the `MultipliersPerEntitiesHit` array, then subsequent stat values will be multiplied by this number.                                                                                                          |
+
+**Knockback Fields**
+
+| Field Name     | Type                                       | Required? | Notes                                                                                                                      |
+| -------------- | ------------------------------------------ | --------- | -------------------------------------------------------------------------------------------------------------------------- |
+| Type           | `String`                                   | **No**    | If provided, specifies a type of knockback to use. Each Target type may come with additional fields.                       |
+| Force          | `Double`<br />(Default: 0.0)               | **No**    | The amount of force to apply to the Owner entity.                                                                          |
+| Duration       | `Double`<br />(Default: 0.0)               | **No**    | If 0.0, apply the force as a single impulse.  If more, continuously apply the force over a period of time.                 |
+| VelocityType   | `ChangeVelocityType`<br />(Default: `Add`) | **No**    | How to apply the force, either adding it to the entity's current velocity, or setting the velocity to the knockback force. |
+| VelocityConfig | `VelocityConfig`                           | **No**    | Characteristics of friction as the Owner entity is thrown by this knockback.                                               |
+
+**Knockback Type: Force**
+
+Apply the calculated knockback force along the provided direction.
+
+| Field Name | Type                         | Required? | Notes                                                                                |
+| ---------- | ---------------------------- | --------- | ------------------------------------------------------------------------------------ |
+| Direction  | `Vector3`<br />(Default: Up) | **No**    | Which direction the entity should be flung, relative to the direction of the attack. |
+
+**Knockback Type: Point**
+
+Apply the calculated knockback force laterally along the XZ plane, plus provided Y velocity.
+
+| Field Name | Type                        | Required? | Notes                                                                                                   |
+| ---------- | --------------------------- | --------- | ------------------------------------------------------------------------------------------------------- |
+| OffsetX    | `Integer`<br />(Default: 0) | **No**    | Offset the source position of the knockback left or right perpendicular to the direction of the attack. |
+| OffsetZ    | `Integer`<br />(Default: 0) | **No**    | Offset the source position of the knockback, forward or backward along the directon of the attack.      |
+| RotateY    | `Integer`<br />(Default: 0) | **No**    | Rotate the knockback direction around the Y axis, where 0 is the default attack direction.              |
+| VelocityY  | `Float`<br />(Default: 0.0) | **No**    | Add vertical velocity to the knockback force after the direction and force has been calculated.         |
+
+**Knockback Type: Directional**
+
+Apply the calculated knockback force along the attack direction, removing any vertical component and replacing it with a provided Y velocity.
+
+| Field Name | Type                      | Required? | Notes                                                                                                                                            |
+| ---------- | ------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------ |
+| RelativeX  | `Float`<br />(Default: 0) | **No**    | Apply additional force left or right perpendicular to the direction of the attack. The additional force is multiplied by the knockback strength. |
+| RelativeZ  | `Float`<br />(Default: 0) | **No**    | Apply additional force forward or backward along the attack direction. The additional force is multiplied by the knockback strength.             |
+| VelocityY  | `Float`<br />(Default: 0) | **No**    | Replace the vertical velocity of the knockback with this value.  This value is not multiplied by knockback strength.                             |
+
+**VelocityConfig Fields**
+
+| Field Name          | Type                                              | Required? | Notes                                                                                                                                                                                           |
+| ------------------- | ------------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| GroundResistance    | `Float`<br />(Default: 0.82)                      | **No**    | The minimum amount of friction applied when the entity is in contact with the ground.  1.0 = no friction, 0.0 = total friction                                                                  |
+| GroundResistanceMax | `Float`<br />(Default: 0.0)                       | **No**    | The maximum amount of friction applied when the entity is in contact with the ground.  1.0 = no friction, 0.0 = total friction                                                                  |
+| AirResistance       | `Float`<br />(Default: 0.96)                      | **No**    | The minimum amount of friction applied when the entity is in the air. 1.0 = no friction, 0.0 = total friction                                                                                   |
+| AirResistanceMax    | `Float`<br />(Default: 0.0)                       | **No**    | The maximum amount of friction applied when the entity is in the air. 1.0 = no friction, 0.0 = total friction                                                                                   |
+| Threshold           | `Float`<br />(Default: 1.0)                       | **No**    | The speed at which the maximum amount of friction will be applied to the entity. The amount of friction applied will increase from minimum to maximum as the entity moves from 0 to this speed. |
+| Style               | `VelocityThresholdStyle`<br />(Default: `Linear`) | **No**    | The curve that friction follows as the entity's speed increases toward the `Threshold`.                                                                                                         |
+
+**DamageCalculatorType Values**
+
+- `Absolute`
+- `Dps`
+
+**DamageClass Values**
+
+- `Unknown`
+- `Light`
+- `Charged`
+- `Signature`
+
+**ChangeVelocityType Values**
+
+- `Add`
+- `Set`
+
+**VelocityThresholdStyle Values**
+
+- `Linear`
+- `Exp`
+
+### LaunchProjectile
+
+This is just a worse version of Projectile and is slated to be removed.  Use Projectile.
+
+### Projectile
+
+This interaction will spawn a new projectile at the User entity's eye position that will travel in its look direction.
+
+| Field Name | Type                                          | Required? | Notes                                                  |
+| ---------- | --------------------------------------------- | --------- | ------------------------------------------------------ |
+| Config     | `Asset`<br />(Asset Type: `ProjectileConfig`) | **No**    | Configuration describing the projectile to be spawned. |
+
+### RemoveEntity
+
+Despawns the specified entity from the world. This interaction will have no effect if the specified entity is a player. This
+interaction has no special failure conditions.
+
+| Field Name | Type                                     | Required? | Notes                  |
+| ---------- | ---------------------------------------- | --------- | ---------------------- |
+| Entity     | `InteractionTarget`<br />(Default: User) | **No**    | The entity to despawn. |
+
+**InteractionTarget Values**
+
+- `User` - The user of this interaction chain. The entity whose actions caused this interaction chain to be executed. This is usually the same as the Owner.
+- `Owner` - The owner of this interaction chain. The entity upon whom this interaction chain is executing.
+- `Target` - The entity target of this interaction chain, if any.  This value is mutable (and can therefore come from many places) but most commonly, it is an entity the User was targeting when this interaction chain began executing.
+
+### SendMessage
+
+This interaction sends a message to the Owner entity if that entity can receive messages.  Otherwise, the message
+is written to the server logs.  If the entity is a player, the message will appear in the player's chat window.
+
+\*\*SendMessage
+
+| Field Name | Type     | Required? | Notes                                                                                                                 |
+| ---------- | -------- | --------- | --------------------------------------------------------------------------------------------------------------------- |
+| Message    | `String` | **No**    | A text message to be sent to the Owner entity.  If this field is not provided, `Key` is used instead.                 |
+| Key        | `String` | **No**    | A translation key for a message to be sent to the Owner entity. If `Message` is provided, then this field is ignored. |
+
+### UseEntity
+
+This interaction is not in use by Hypixel and has some unusual qualities that mean it probably won't do what you want it
+to.  Do not use it.
+
+This interaction will retrieve the entity currently targeted by the client (NOT the interaction chain's current Target
+entity) and execute that entity's RootInteraction for this interaction chain's current interaction type. The
+RootInteraction will be executed as part of this current interaction chain. None of the properties of this interaction
+chain will be modified.
+
+This interaction will fail if the client is not currently targeting an entity, or if no interaction for the current
+interaction type exists on the entity.
+
+## Stats
+
+Hytale's resource system has been written about fairly extensively.  You can use these interactions to modify stats in
+response to actions or use stats as a cost for abilities.
+
+### ChangeStat
+
+This interaction applies a set of raw stat changes to the User entity. It has no special failure conditions.
+
+| Field Name    | Type                                                         | Required? | Notes                                                                                                                                                                                                                      |
+| ------------- | ------------------------------------------------------------ | --------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| StatModifiers | `Map`<br />(Key Type: `EntityStatType`, Value Type: `Float`) | **Yes**   | A set of stats to modify and what value to apply to them.                                                                                                                                                                  |
+| ValueType     | `ValueType`<br />(Default: Absolute)                         | **No**    | Whether the values in the `StatModifiers` map represent flat values to apply to the stat total, or percentages (0.0-100.0). Percentage values are percentage of the difference between the maximum and minimum stat value. |
+| Behaviour     | `ChangeStatBehavior`<br />(Default: Add)                     | **No**    | Whether the values in the `StatModifiers` map represent deltas to add into the User entity's current stat values, or fixed values to set the entity's stats to.                                                            |
+
+**ValueType Values**
+
+- `Absolute`
+- `Percent`
+
+**ChangeStatBehaviour Values**
+
+- `Add`
+- `Set`
+
+### ChangeStatWithModifier
+
+This interaction is like ChangeStat, except an armor stat modifier can be chosen which will apply bonuses and penalties
+to a stat from the User entity's equipped armor before it is applied.
+
+| Field Name            | Type                                                         | Required? | Notes                                                                                                                                                                                                                      |
+| --------------------- | ------------------------------------------------------------ | --------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| StatModifiers         | `Map`<br />(Key Type: `EntityStatType`, Value Type: `Float`) | **Yes**   | A set of stats to modify and what value to apply to them.                                                                                                                                                                  |
+| ValueType             | `ValueType`<br />(Default: Absolute)                         | **No**    | Whether the values in the `StatModifiers` map represent flat values to apply to the stat total, or percentages (0.0-100.0). Percentage values are percentage of the difference between the maximum and minimum stat value. |
+| Behaviour             | `ChangeStatBehavior`<br />(Default: Add)                     | **No**    | Whether the values in the `StatModifiers` map represent deltas to add into the User entity's current stat values, or fixed values to set the entity's stats to.                                                            |
+| InteractionModifierId | `InteractionModifierId`                                      | **Yes**   | The armor interaction modifier to apply bonuses and penalties for.                                                                                                                                                         |
+
+**ValueType Values**
+
+- `Absolute`
+- `Percent`
+
+**ChangeStatBehaviour Values**
+
+- `Add`
+- `Set`
+
+**InteractionModifierId Values**
+
+- `Dodge`
+
+### StatsCondition
+
+This interaction will fail if the User entity cannot afford the specified stats costs, or if it does not have the
+requested stats.
+
+| Field Name | Type                                                         | Required? | Notes                                                                                                                                                                                    |
+| ---------- | ------------------------------------------------------------ | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Costs      | `Map`<br />(Key Type:` EntityStatType`, Value Type: `Float`) | **Yes**   | A set of costs that the User entity needs to be able to afford for this interaction to succeed.                                                                                          |
+| ValueType  | `ValueType`<br />(Default: Absolute)                         | **No**    | Whether the values in the `Costs` map represetn flat values or percentages (0.0-100.0).  Percentage values are percentage of the difference between the maximum and minimum value.       |
+| LessThan   | `Boolean`<br />(Default: false)                              | **No**    | If true, this interaction will fail unless the User entity's current stat values are at or **below** the specified levels.  If false, they must be at or **above** the specified levels. |
+| Lenient    | `Boolean`<br />(Default: false)                              | **No**    | If true and `LessThan` is true, and a player's minimum stat value is below zero, then the player can afford a stat cost if the current value of a stat if above 0.                       |
+
+**ValueType Values**
+
+- `Absolute`
+- `Percent`
+
+### StatsConditionWithModifier
+
+This interaction is like StatsCondition, except an armor stat modifier can be chosen which will apply bonuses and penalties
+to a stat's cost from the User entity's equipped armor before it is compared.
+
+| Field Name            | Type                                                         | Required? | Notes                                                                                                                                                                                    |
+| --------------------- | ------------------------------------------------------------ | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Costs                 | `Map`<br />(Key Type:` EntityStatType`, Value Type: `Float`) | **Yes**   | A set of costs that the User entity needs to be able to afford for this interaction to succeed.                                                                                          |
+| ValueType             | `ValueType`<br />(Default: Absolute)                         | **No**    | Whether the values in the `Costs` map represetn flat values or percentages (0.0-100.0).  Percentage values are percentage of the difference between the maximum and minimum value.       |
+| LessThan              | `Boolean`<br />(Default: false)                              | **No**    | If true, this interaction will fail unless the User entity's current stat values are at or **below** the specified levels.  If false, they must be at or **above** the specified levels. |
+| Lenient               | `Boolean`<br />(Default: false)                              | **No**    | If true and `LessThan` is true, and a player's minimum stat value is below zero, then the player can afford a stat cost if the current value of a stat if above 0.                       |
+| InteractionModifierId | `InteractionModifierId`                                      | **Yes**   | The armor interaction modifier to apply bonuses and penalties for.                                                                                                                       |
+
+**ValueType Values**
+
+- `Absolute`
+- `Percent`
+
+**InteractionModifierId Values**
+
+- `Dodge`
+
+## EntityEffects
+
+EntityEffects are buff or debuff effects that can be applied to a LivingEntity.  These can have a variety of effects from
+movement speed changes to periodic damage.
+
+### EffectCondition
+
+This interaction will fail if the specified entity's EntityEffects do not match the provided conditions.
+
+**EffectCondition Fields**
+
+| Field Name      | Type                                             | Required? | Notes                                                                                                                                                                                                             |
+| --------------- | ------------------------------------------------ | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Entity          | `InteractionTarget`<br />(Default: User)         | **Yes**   | The entity to examine for EntityEffects. This field can indicate the Owner, User, or Target of this interaction chain.                                                                                            |
+| Match           | `Match`<br />(Default: All)                      | **No**    | If `All`, then this interaction will fail if any EntityEffect in the `EntityEffectIds` is not on the specified entity. If `None`, then this interaction will fail if any EntityEffect IS on the specified entity. |
+| EntityEffectIds | `AssetArray`<br />(Element Type: `EntityEffect`) | **Yes**   | The set of EntityEffects to check against the specified entity and `Match`.                                                                                                                                       |
+
+**InteractionTarget Values**
+
+- `User` - The user of this interaction chain. The entity whose actions caused this interaction chain to be executed. This is usually the same as the Owner.
+- `Owner` - The owner of this interaction chain. The entity upon whom this interaction chain is executing.
+- `Target` - The entity target of this interaction chain, if any.  This value is mutable (and can therefore come from many places) but most commonly, it is an entity the User was targeting when this interaction chain began executing.
+
+**Match Values**
+
+- `All` - All EntityEffects must be on the specified entity for this interaction to succeed.
+- `None` - None of the EntityEffects must be on the specified entity for this interaction to succeed.
+
+### ApplyEffect
+
+This interaction will apply the specified EntityEffect to the specified Entity.  It has no special failure conditions.
+
+**ApplyEffect Fields**
+
+| Field Name | Type                                      | Required? | Notes                                                                                                                  |
+| ---------- | ----------------------------------------- | --------- | ---------------------------------------------------------------------------------------------------------------------- |
+| Entity     | `InteractionTarget`<br />(Default: User)  | **Yes**   | The entity to apply the EntityEffect to. This field can indicate the Owner, User, or Target of this interaction chain. |
+| EffectId   | `Asset`<br />(Asset Type: `EntityEffect`) | **Yes**   | The effect to apply.                                                                                                   |
+
+**InteractionTarget Values**
+
+- `User` - The user of this interaction chain. The entity whose actions caused this interaction chain to be executed. This is usually the same as the Owner.
+- `Owner` - The owner of this interaction chain. The entity upon whom this interaction chain is executing.
+- `Target` - The entity target of this interaction chain, if any.  This value is mutable (and can therefore come from many places) but most commonly, it is an entity the User was targeting when this interaction chain began executing.
+
+### ClearEntityEffect
+
+This interaction will remove the specified EntityEffect from the specified Entity. It has no special failure conditions.
+It will not fail if the Entity does not have the EntityEffect.
+
+**ClearEntityEffect Fields**
+
+| Field Name | Type                                      | Required? | Notes                                                                                                                     |
+| ---------- | ----------------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------- |
+| Entity     | `InteractionTarget`<br />(Default: User)  | **Yes**   | The entity to remove the EntityEffect from. This field can indicate the Owner, User, or Target of this interaction chain. |
+| EffectId   | `Asset`<br />(Asset Type: `EntityEffect`) | **Yes**   | The effect to remove.                                                                                                     |
+
+**InteractionTarget Values**
+
+- `User` - The user of this interaction chain. The entity whose actions caused this interaction chain to be executed. This is usually the same as the Owner.
+- `Owner` - The owner of this interaction chain. The entity upon whom this interaction chain is executing.
+- `Target` - The entity target of this interaction chain, if any.  This value is mutable (and can therefore come from many places) but most commonly, it is an entity the User was targeting when this interaction chain began executing.
+
+## Farming
+
+These are interaction types built to support the in-game farming system in Hytale. They are mostly block-related interactions
+with a few exceptions.
+
+### ChangeFarmingStage
+
+If the target block is a farming block, this interaction will attempt to modify the current farming stage in one of
+three ways.  The interaction can optionally specify which StageSet to use for the new stage. If it is not specified,
+the current StageSet will be used. If any part of the the process of changing the growth stage fails, this interaction
+will fail, with the one exception that attempting to set the stage to the crop's existing stage will have no effect but
+still succeed.
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                                                                                                                                                                          |
+| ---------------- | ------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction.                                                                                                                                              |
+| StageSet         | `String`                        | **No**    | If provided, set the block's current stage to one in the provided StageSet. Otherwise, use the crop's current StageSet.                                                                                                                                                        |
+| Increase         | `Integer`                       | **No**    | If provided, increase the current stage by the specified amount. If the specified stage does not exist, the block will be set to the closest extant stage.                                                                                                                     |
+| Decrease         | `Integer`                       | **No**    | If provided and `Increase` is not provided, decrease the current stage by the specified amount. If the specified stage does not exist, the block will be set to the closest extant stage.                                                                                      |
+| Stage            | `Integer`<br />(Default: -1)    | **No**    | If provided and `Increase`/`Decrease` are not provided, set the current stage to the specified stage. If this value is less than 0, set the current stage to the final growth stage. If the specified stage does not exist, the block will be set to the closest extant stage. |
+
+### FertilizeSoil
+
+If the target block is unfertilized tilled soil or a farming block on top of unfertilized tilled soil, fertilizes the soil.
+The interaction will fail otherwise.
+
+**FertilizeSoil Fields**
+
+| Field Name       | Type                                  | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false)       | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+| RefreshModifiers | `Array`<br />(Element Type: `String`) | **No**    | Does nothing.                                                                                                                     |
+
+### HarvestCrop
+
+This interaction will attempt to execute the harvest action on the current block target and add the crop's drops to the User entity's
+inventory.  The block will either be destroyed or set to its post-harvest growth stage, depending on the farming
+configuration of the block.  This will happen (and the player will receive the full harvest drops) regardless of the
+block's current growth stage. This interaction has no special failure conditions, even if the block target isn't a
+farming block or gathering isn't permitted in the current world, but nothing will occur in those cases.
+
+**HarvestCrop Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+
+### UseWateringCan
+
+If the target block is tilled soil or a farming block on top of tilled soil, waters the soil for the specified duration.
+The interaction will fail otherwise.
+
+**UseWateringCan Fields**
+
+| Field Name       | Type                                  | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false)       | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+| Duration         | `Integer`<br />(Default: 0)           | **No**    | The duration in seconds to water the soil for.                                                                                    |
+| RefreshModifiers | `Array`<br />(Element Type: `String`) | **No**    | Does nothing.                                                                                                                     |
diff --git a/content/docs/ja-JP/server/sounds.mdx b/content/docs/ja-JP/server/sounds.mdx
index d2aee671..7a35f0eb 100644
--- a/content/docs/ja-JP/server/sounds.mdx
+++ b/content/docs/ja-JP/server/sounds.mdx
@@ -53,1110 +53,1110 @@ full: true
 - SFX_Bat_Death
 - SFX_Bat_Hurt
 - SFX_Battleaxe_T1_Block_Impact
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
--
+- SFX_Battleaxe_T1_Impact
+- SFX_Battleaxe_T1_Launch
+- SFX_Battleaxe_T1_Launch_Local
+- SFX_Battleaxe_T1_Raise
+- SFX_Battleaxe_T1_Raise_Local
+- SFX_Battleaxe_T1_Shove
+- SFX_Battleaxe_T1_Shove_Local
+- SFX_Battleaxe_T1_Swing
+- SFX_Battleaxe_T1_Swing_Charged
+- SFX_Battleaxe_T1_Swing_Charged_Local
+- SFX_Battleaxe_T1_Swing_Down_Local
+- SFX_Battleaxe_T1_Swing_LR_Local
+- SFX_Battleaxe_T1_Swing_RL_Local
+- SFX_Battleaxe_T2_Impact
+- SFX_Battleaxe_T2_Raise
+- SFX_Battleaxe_T2_Raise_Local
+- SFX_Battleaxe_T2_Signature_End
+- SFX_Battleaxe_T2_Signature_End_Local
+- SFX_Battleaxe_T2_Signature_Swing
+- SFX_Battleaxe_T2_Signature_Swing_Local
+- SFX_Battleaxe_T2_Swing
+- SFX_Battleaxe_T2_Swing_Charged
+- SFX_Battleaxe_T2_Swing_Charged_Local
+- SFX_Battleaxe_T2_Swing_Down_Local
+- SFX_Battleaxe_T2_Swing_LR_Local
+- SFX_Battleaxe_T2_Swing_RL_Local
+- SFX_Bear_Grizzly_Alerted
+- SFX_Bear_Grizzly_Attack
+- SFX_Bear_Grizzly_Death
+- SFX_Bear_Grizzly_Hurt
+- SFX_Bear_Grizzly_Run
+- SFX_Bear_Grizzly_Sleep
+- SFX_Bear_Walk
+- SFX_Bench_Placeholder
+- SFX_Bison_Alerted
+- SFX_Bison_Death
+- SFX_Bison_Hurt
+- SFX_Bison_Idle
+- SFX_Bison_Run
+- SFX_Bison_Walk
+- SFX_Blunderbuss_Bullet_WhizBy
+- SFX_Blunderbuss_Fire
+- SFX_Blunderbuss_Fire_Local
+- SFX_Blunderbuss_Hit
+- SFX_Blunderbuss_Load
+- SFX_Blunderbuss_Load_Local
+- SFX_Blunderbuss_Miss
+- SFX_Blunderbuss_No_Ammo
+- SFX_Boar_Alerted
+- SFX_Boar_Death
+- SFX_Boar_Hurt
+- SFX_Boar_Run
+- SFX_Boar_Sleep
+- SFX_Boar_Walk
+- SFX_Bomb_Fire_Goblin_Bounce
+- SFX_Bomb_Fire_Goblin_Death
+- SFX_Bomb_Fire_Goblin_Hit
+- SFX_Bomb_Fire_Goblin_Miss
+- SFX_Bomb_Fuse
+- SFX_Bone_Break
+- SFX_Bone_Build
+- SFX_Bone_Hit
+- SFX_Bone_Land
+- SFX_Bone_Walk
+- SFX_Bow_No_Ammo
+- SFX_Bow_T1_Block_Impact
+- SFX_Bow_T1_Draw
+- SFX_Bow_T1_Draw_Local
+- SFX_Bow_T1_Raise
+- SFX_Bow_T1_Raise_Local
+- SFX_Bow_T1_Shoot
+- SFX_Bow_T1_Shoot_Local
+- SFX_Bow_T1_Swing
+- SFX_Bow_T1_Swing_Local
+- SFX_Bow_T2_Draw
+- SFX_Bow_T2_Draw_Local
+- SFX_Bow_T2_Shoot
+- SFX_Bow_T2_Shoot_Local
+- SFX_Bow_T2_Signature_Loop
+- SFX_Bow_T2_Signature_Loop_Local
+- SFX_Bow_T2_Signature_Nock
+- SFX_Bow_T2_Signature_Nock_Local
+- SFX_Bow_T2_Signature_Shoot
+- SFX_Bow_T2_Signature_Shoot_Local
+- SFX_Bramble_MoveIn
+- SFX_Branch_Break
+- SFX_Branch_Build
+- SFX_Branch_Hit
+- SFX_Branch_Land
+- SFX_Branch_Walk
+- SFX_Brazier_Break
+- SFX_Brazier_Build
+- SFX_Bunny_Alerted
+- SFX_Bunny_Death
+- SFX_Bunny_Hurt
+- SFX_Bush_Break
+- SFX_Bush_Hit
+- SFX_Bush_MoveIn
+- SFX_Cactus_Break
+- SFX_Cactus_Hit
+- SFX_Cactus_Large_Hit
+- SFX_Cactus_Small_Break
+- SFX_Cactus_Small_Hit
+- SFX_Calf_Hurt
+- SFX_Calf_Run
+- SFX_Calf_Walk
+- SFX_Camel_Alerted
+- SFX_Camel_Death
+- SFX_Camel_Hurt
+- SFX_Camel_Laydown
+- SFX_Camel_Run
+- SFX_Camel_Sleep
+- SFX_Camel_Wake
+- SFX_Camel_Walk
+- SFX_Campfire_Break
+- SFX_Campfire_Build
+- SFX_Campfire_Close_Local
+- SFX_Campfire_Default_Loop
+- SFX_Campfire_Open_Local
+- SFX_Campfire_Processing
+- SFX_Campfire_Processing_End
+- SFX_Campfire_Processing_Failed
+- SFX_Candle_Default_Loop
+- SFX_Candle_Off
+- SFX_Capture_Crate_Capture_Fail_Local
+- SFX_Capture_Crate_Capture_Succeed
+- SFX_Capture_Crate_Capture_Succeed_Local
+- SFX_Capture_Crate_Spawn_Fail_Local
+- SFX_Capture_Crate_Spawn_Succeed
+- SFX_Cauldron_Bubbling
+- SFX_Cauldron_Bubbling_Small
+- SFX_Chest_Legendary_Close_Player
+- SFX_Chest_Legendary_FirstOpen_Player
+- SFX_Chest_Legendary_Loop
+- SFX_Chest_Legendary_Open
+- SFX_Chest_Wooden_Close
+- SFX_Chest_Wooden_Open
+- SFX_Chest_Wooden_Open_Player
+- SFX_Chick_Alerted
+- SFX_Chick_Death
+- SFX_Chick_Hurt
+- SFX_Chicken_Alerted
+- SFX_Chicken_Death
+- SFX_Chicken_Flee
+- SFX_Chicken_Hurt
+- SFX_Chicken_Run
+- SFX_Chicken_Walk
+- SFX_Clay_Pot_Large_Break
+- SFX_Clay_Pot_Large_Build
+- SFX_Clay_Pot_Large_Hit
+- SFX_Clay_Pot_Large_Walk
+- SFX_Clay_Pot_Small_Break
+- SFX_Clay_Pot_Small_Build
+- SFX_Clay_Pot_Small_Hit
+- SFX_Clay_Pot_Small_Walk
+- SFX_Cloth_Break
+- SFX_Cloth_Build
+- SFX_Cloth_Hit
+- SFX_Cloth_Land
+- SFX_Cloth_Walk
+- SFX_Club_Meat_Impact
+- SFX_Club_Meat_Swing
+- SFX_Club_Special_Impact
+- SFX_Club_Special_Swing
+- SFX_Club_Steel_Impact
+- SFX_Club_Steel_Swing
+- SFX_Club_Wood_Impact
+- SFX_Club_Wood_Swing
+- SFX_Cocoon_Active
+- SFX_Cocoon_Break
+- SFX_Cocoon_Build
+- SFX_Cocoon_Hit
+- SFX_Cocoon_Walk
+- SFX_Coins_Land
+- SFX_Coins_Walk
+- SFX_Consume_Bread
+- SFX_Consume_Bread_Local
+- SFX_Cow_Alerted
+- SFX_Cow_Death
+- SFX_Cow_Hurt
+- SFX_Cow_Idle
+- SFX_Cow_Run
+- SFX_Cow_Sleep
+- SFX_Cow_Walk
+- SFX_Crawler_Void_Alerted
+- SFX_Crawler_Void_Alerted_02
+- SFX_Crawler_Void_Death
+- SFX_Crawler_Void_Despawn
+- SFX_Crawler_Void_Hurt
+- SFX_Crawler_Void_Run
+- SFX_Crawler_Void_Sleep
+- SFX_Crawler_Void_Spawn
+- SFX_Crawler_Void_Spawn_02
+- SFX_Crawler_Void_Walk
+- SFX_Creative_Play_Add_Mask
+- SFX_Creative_Play_Brush_Erase
+- SFX_Creative_Play_Brush_Mode
+- SFX_Creative_Play_Brush_Paint_Base
+- SFX_Creative_Play_Brush_Paint_Idle_Layer
+- SFX_Creative_Play_Brush_Paint_Move_Layer
+- SFX_Creative_Play_Brush_Shape
+- SFX_Creative_Play_Brush_Stamp
+- SFX_Creative_Play_Error
+- SFX_Creative_Play_Eyedropper_Select
+- SFX_Creative_Play_Paste
+- SFX_Creative_Play_Selection_Drag
+- SFX_Creative_Play_Selection_Place
+- SFX_Creative_Play_Selection_Scale
+- SFX_Creative_Play_Selection_Widget
+- SFX_Creative_Play_Set_Mask
+- SFX_Crocodile_Alerted
+- SFX_Crocodile_Death
+- SFX_Crocodile_Hurt
+- SFX_Crops_Grow
+- SFX_Crops_Grow_Stage_Complete
+- SFX_Crow_Death
+- SFX_Crow_Hurt
+- SFX_Crystal_Break
+- SFX_Crystal_Build
+- SFX_Crystal_Hit
+- SFX_Crystal_Walk
+- SFX_Daggers_T1_Guard
+- SFX_Daggers_T1_Guard_Local
+- SFX_Daggers_T1_Pounce
+- SFX_Daggers_T1_Pounce_Local
+- SFX_Daggers_T1_Slash_Impact
+- SFX_Daggers_T1_Stab_Double_Impact
+- SFX_Daggers_T1_Stab_Impact
+- SFX_Daggers_T1_Stab_Left_Local
+- SFX_Daggers_T1_Stab_Retreat
+- SFX_Daggers_T1_Stab_Retreat_Local
+- SFX_Daggers_T1_Stab_Right_Local
+- SFX_Daggers_T1_Swing
+- SFX_Daggers_T1_Swing_Double
+- SFX_Daggers_T1_Swing_Double_Local
+- SFX_Daggers_T1_Swing_LR_Local
+- SFX_Daggers_T1_Swing_RL_Local
+- SFX_Daggers_T2_Guard
+- SFX_Daggers_T2_Guard_Local
+- SFX_Daggers_T2_Signature_P1
+- SFX_Daggers_T2_Signature_P1_Local
+- SFX_Daggers_T2_Signature_P2
+- SFX_Daggers_T2_Signature_P2_Local
+- SFX_Daggers_T2_Signature_P3
+- SFX_Daggers_T2_Signature_P3_Local
+- SFX_Daggers_T2_Slash_Impact
+- SFX_Daggers_T2_Stab_Double_Impact
+- SFX_Daggers_T2_Stab_Impact
+- SFX_Daggers_T2_Stab_Left_Local
+- SFX_Daggers_T2_Stab_Retreat
+- SFX_Daggers_T2_Stab_Retreat_Local
+- SFX_Daggers_T2_Stab_Right_Local
+- SFX_Daggers_T2_Swing
+- SFX_Daggers_T2_Swing_Double
+- SFX_Daggers_T2_Swing_Double_Local
+- SFX_Daggers_T2_Swing_LR_Local
+- SFX_Daggers_T2_Swing_RL_Local
+- SFX_Deer_Doe_Alerted
+- SFX_Deer_Doe_Death
+- SFX_Deer_Doe_Hurt
+- SFX_Deer_Doe_Run
+- SFX_Deer_Doe_Sleep
+- SFX_Deer_Stag_Alerted
+- SFX_Deer_Stag_Death
+- SFX_Deer_Stag_Hurt
+- SFX_Deer_Stag_Roar
+- SFX_Deer_Stag_Run
+- SFX_Deer_Stag_Sleep
+- SFX_Deer_Walk
+- SFX_Default_Break
+- SFX_Default_Build
+- SFX_Default_Clone
+- SFX_Default_Harvest
+- SFX_Default_Walk
+- SFX_Deployable_Totem_Heal_Despawn
+- SFX_Deployable_Totem_Heal_Effect_Local
+- SFX_Deployable_Totem_Heal_Spawn
+- SFX_Deployable_Totem_Slowing_Despawn
+- SFX_Deployable_Totem_Slowing_Effect_Local
+- SFX_Deployable_Totem_Slowing_Spawn
+- SFX_Dirt_Break
+- SFX_Dirt_Build
+- SFX_Dirt_Clone
+- SFX_Dirt_Hit
+- SFX_Dirt_Land
+- SFX_Dirt_Walk
+- SFX_Discovery_Z1_Medium
+- SFX_Discovery_Z1_Short
+- SFX_Discovery_Z2_Medium
+- SFX_Discovery_Z2_Short
+- SFX_Discovery_Z3_Medium
+- SFX_Discovery_Z3_Short
+- SFX_Discovery_Z4_Medium
+- SFX_Discovery_Z4_Short
+- SFX_Divine_Respawn
+- SFX_Door_Ancient_Close
+- SFX_Door_Ancient_Open
+- SFX_Door_Crude_Close
+- SFX_Door_Crude_Open
+- SFX_Door_Desert_Close
+- SFX_Door_Desert_Open
+- SFX_Door_Jungle_Close
+- SFX_Door_Jungle_Open
+- SFX_Door_Lumberjack_Close
+- SFX_Door_Lumberjack_Open
+- SFX_Door_Temple_Dark_Close
+- SFX_Door_Temple_Dark_Open
+- SFX_Door_Temple_Light_Close
+- SFX_Door_Temple_Light_Open
+- SFX_Door_Wooden_Close
+- SFX_Door_Wooden_Open
+- SFX_Drag_Armor_Cloth
+- SFX_Drag_Armor_Heavy
+- SFX_Drag_Armor_Leather
+- SFX_Drag_Blocks_Gravel
+- SFX_Drag_Blocks_Soft
+- SFX_Drag_Blocks_Splatty
+- SFX_Drag_Blocks_Stone
+- SFX_Drag_Blocks_Wood
+- SFX_Drag_Item_Default
+- SFX_Drag_Items_Bones
+- SFX_Drag_Items_Chest
+- SFX_Drag_Items_Clay
+- SFX_Drag_Items_Cloth
+- SFX_Drag_Items_Foliage
+- SFX_Drag_Items_Gadget
+- SFX_Drag_Items_Gems
+- SFX_Drag_Items_Ingots
+- SFX_Drag_Items_Leather
+- SFX_Drag_Items_Metal
+- SFX_Drag_Items_Paper
+- SFX_Drag_Items_Potion
+- SFX_Drag_Items_Seeds
+- SFX_Drag_Items_Shells
+- SFX_Drag_Items_Splatty
+- SFX_Drag_Weapon_Blade_Small
+- SFX_Drag_Weapon_Blunt_Large
+- SFX_Drag_Weapons_Arrows
+- SFX_Drag_Weapons_Blade_Large
+- SFX_Drag_Weapons_Blunt_Small
+- SFX_Drag_Weapons_Books
+- SFX_Drag_Weapons_Shield_Metal
+- SFX_Drag_Weapons_Shield_Wood
+- SFX_Drag_Weapons_Stone_Large
+- SFX_Drag_Weapons_Stone_Small
+- SFX_Drag_Weapons_Wand
+- SFX_Drag_Weapons_Wood
+- SFX_Dragon_Sleep
+- SFX_Drop_Armor_Cloth
+- SFX_Drop_Armor_Heavy
+- SFX_Drop_Armor_Leather
+- SFX_Drop_Blocks_Gravel
+- SFX_Drop_Blocks_Soft
+- SFX_Drop_Blocks_Splatty
+- SFX_Drop_Blocks_Stone
+- SFX_Drop_Blocks_Wood
+- SFX_Drop_Item_Default
+- SFX_Drop_Items_Bones
+- SFX_Drop_Items_Chest
+- SFX_Drop_Items_Clay
+- SFX_Drop_Items_Cloth
+- SFX_Drop_Items_Foliage
+- SFX_Drop_Items_Gadget
+- SFX_Drop_Items_Gems
+- SFX_Drop_Items_Ingots
+- SFX_Drop_Items_Leather
+- SFX_Drop_Items_Metal
+- SFX_Drop_Items_Paper
+- SFX_Drop_Items_Potion
+- SFX_Drop_Items_Seeds
+- SFX_Drop_Items_Shells
+- SFX_Drop_Items_Splatty
+- SFX_Drop_Weapon_Blade_Small
+- SFX_Drop_Weapon_Blunt_Large
+- SFX_Drop_Weapons_Arrows
+- SFX_Drop_Weapons_Blade_Large
+- SFX_Drop_Weapons_Blunt_Small
+- SFX_Drop_Weapons_Books
+- SFX_Drop_Weapons_Shield_Metal
+- SFX_Drop_Weapons_Shield_Wood
+- SFX_Drop_Weapons_Stone_Large
+- SFX_Drop_Weapons_Stone_Small
+- SFX_Drop_Weapons_Wand
+- SFX_Drop_Weapons_Wood
+- SFX_Duck_Alerted
+- SFX_Duck_Death
+- SFX_Duck_Hurt
+- SFX_Duck_Run
+- SFX_Effect_Burn_Local
+- SFX_Effect_Burn_World
+- SFX_Effect_Poison_Local
+- SFX_Effect_Poison_World
+- SFX_Egg_Hit
+- SFX_Egg_Miss
+- SFX_Eggsac_Active
+- SFX_Emberwulf_Alerted
+- SFX_Emberwulf_Attack_Bite
+- SFX_Emberwulf_Death
+- SFX_Emberwulf_Hurt
+- SFX_Emberwulf_Run
+- SFX_Emberwulf_Sleep
+- SFX_Emberwulf_Walk
+- SFX_Emit_Forgotten_Whispers
+- SFX_Emit_Lake_Water
+- SFX_Emit_Temple_Wisps
+- SFX_Emit_Tree_Creak
+- SFX_Emit_Wind_Grass
+- SFX_Emit_Wind_Gusts
+- SFX_Env_Emit_Fluid_Lava
+- SFX_Env_Emit_Fluid_Water
+- SFX_Env_Emit_Fluid_Water_Far
+- SFX_Env_Emit_Geyzer
+- SFX_Eye_Void_Alerted
+- SFX_Eye_Void_Attack_Blast
+- SFX_Eye_Void_Attack_Summon
+- SFX_Eye_Void_Death
+- SFX_Eye_Void_Fly_Movement
+- SFX_Eye_Void_Hurt
+- SFX_Eye_Void_Idle
+- SFX_Fen_Stalker_Alerted
+- SFX_Fen_Stalker_Attack_Swing
+- SFX_Fen_Stalker_Attack_Swipe
+- SFX_Fen_Stalker_Death
+- SFX_Fen_Stalker_Eat
+- SFX_Fen_Stalker_Eat_Finish
+- SFX_Fen_Stalker_Greet
+- SFX_Fen_Stalker_Hurt
+- SFX_Fen_Stalker_Run
+- SFX_Fen_Stalker_Scared
+- SFX_Fen_Stalker_Seek
+- SFX_Fen_Stalker_Sniff
+- SFX_Feran_Death
+- SFX_Fern_Break
+- SFX_Fern_MoveIn
+- SFX_Fireball_Bounce
+- SFX_Fireball_Death
+- SFX_Fireball_Miss
+- SFX_Fish_Death
+- SFX_Fish_Flee
+- SFX_Fish_Hurt
+- SFX_Flail_Charge
+- SFX_Flail_Charge_Local
+- SFX_Flail_Swing
+- SFX_Flail_Swing_Left_Local
+- SFX_Flail_Swing_Right_Local
+- SFX_Flame_Break
+- SFX_Flame_Build
+- SFX_Flame_Default_Loop
+- SFX_Flamingo_Alerted
+- SFX_Flamingo_Death
+- SFX_Flamingo_Fly
+- SFX_Flamingo_Hurt
+- SFX_Forgotten_Temple_Emit_Birds
+- SFX_Forgotten_Temple_Emit_Birds_Interior
+- SFX_Fox_Alerted
+- SFX_Fox_Death
+- SFX_Fox_Hurt
+- SFX_Fox_Run
+- SFX_Fox_Sleep
+- SFX_Frog_Alerted
+- SFX_Frog_Croak
+- SFX_Frog_Death
+- SFX_Frog_Hurt
+- SFX_Frog_Idle
+- SFX_Frog_Run
+- SFX_Furnace_Bench_Close
+- SFX_Furnace_Bench_Open
+- SFX_Furnace_Bench_Processing
+- SFX_Furnace_Bench_Processing_Complete
+- SFX_Furnace_Bench_Processing_End
+- SFX_Furnace_Bench_Processing_Failed
+- SFX_Gecko_Alerted
+- SFX_Gecko_Death
+- SFX_Gecko_Hurt
+- SFX_Gem_Break
+- SFX_Gem_Emit_Loop
+- SFX_Generic_Crafting_Failed
+- SFX_Glass_Break
+- SFX_Global_Weather_Thunder
+- SFX_Goat_Run
+- SFX_Goat_Walk
+- SFX_Goblin_Alerted
+- SFX_Goblin_Death
+- SFX_Goblin_Hurt
+- SFX_Goblin_Lobber_Bomb_Bounce
+- SFX_Goblin_Lobber_Bomb_Death
+- SFX_Goblin_Lobber_Bomb_Hit
+- SFX_Goblin_Lobber_Bomb_Miss
+- SFX_Goblin_Run
+- SFX_Goblin_Search
+- SFX_Golem_Earth_Alerted
+- SFX_Golem_Earth_Death
+- SFX_Golem_Earth_Hurt
+- SFX_Golem_Earth_Laydown
+- SFX_Golem_Earth_Slam
+- SFX_Golem_Earth_Slam_Impact
+- SFX_Golem_Earth_Spin
+- SFX_Golem_Earth_Stomp
+- SFX_Golem_Earth_Stomp_Impact
+- SFX_Golem_Earth_Swing
+- SFX_Golem_Earth_Swing_Impact
+- SFX_Golem_Earth_Wake
+- SFX_Golem_Firesteel_Alerted_01
+- SFX_Golem_Firesteel_Alerted_02
+- SFX_Golem_Firesteel_Death
+- SFX_Golem_Firesteel_Laydown
+- SFX_Golem_Firesteel_Wake
+- SFX_Golem_Frost_Alerted
+- SFX_Golem_Frost_Death
+- SFX_Golem_Frost_Hurt
+- SFX_Golem_Frost_Laydown
+- SFX_Golem_Frost_Slam
+- SFX_Golem_Frost_Slam_Impact
+- SFX_Golem_Frost_Spin
+- SFX_Golem_Frost_Stomp
+- SFX_Golem_Frost_Swing
+- SFX_Golem_Frost_Swing_Impact
+- SFX_Golem_Frost_Wake
+- SFX_Golem_Sand_Alerted
+- SFX_Golem_Sand_Death
+- SFX_Golem_Sand_Hurt
+- SFX_Golem_Sand_Laydown
+- SFX_Golem_Sand_Slam
+- SFX_Golem_Sand_Slam_Impact
+- SFX_Golem_Sand_Spin
+- SFX_Golem_Sand_Stomp
+- SFX_Golem_Sand_Stomp_Impact
+- SFX_Golem_Sand_Swing
+- SFX_Golem_Sand_Swing_Impact
+- SFX_Golem_Sand_Wake
+- SFX_Grass_Break
+- SFX_Grass_Build
+- SFX_Grass_Hit
+- SFX_Grass_Land
+- SFX_Grass_Walk
+- SFX_Gravel_Break
+- SFX_Gravel_Build
+- SFX_Gravel_Hit
+- SFX_Gravel_Land
+- SFX_Gravel_Walk
+- SFX_GunPvP_Assault_Rifle_Bullet_Death
+- SFX_GunPvP_Grenade_Frag_Bounce
+- SFX_GunPvP_Grenade_Frag_Death
+- SFX_GunPvP_Grenade_Frag_Hit
+- SFX_GunPvP_Grenade_Frag_Miss
+- SFX_GunPvP_Handgun_Bullet_Death
+- SFX_Gun_Fire
+- SFX_Hand_Crossbow_T1_Block_Impact
+- SFX_Hand_Crossbow_T1_Raise
+- SFX_Hand_Crossbow_T1_Raise_Local
+- SFX_Hand_Crossbow_T1_Shove
+- SFX_Hand_Crossbow_T1_Shove_Local
+- SFX_Hand_Crossbow_T2_Load
+- SFX_Hand_Crossbow_T2_Load_Local
+- SFX_Hand_Crossbow_T2_Reload_Start
+- SFX_Hand_Crossbow_T2_Reload_Start_Local
+- SFX_Handgun_Fire
+- SFX_Handgun_Fire_Local
+- SFX_Hatchet_T1_Swing_RL_Local
+- SFX_Hatchet_T2_Impact_Nice
+- SFX_Health_Potion_High_Drink
+- SFX_Health_Potion_High_Drink_Local
+- SFX_Health_Potion_Low_Drink
+- SFX_Health_Potion_Low_Drink_Local
+- SFX_Hedera_Scream
+- SFX_Hoe_T1_Swing_Down_Local
+- SFX_Hoe_T1_Till
+- SFX_Horse_Alerted
+- SFX_Horse_Death
+- SFX_Horse_Hurt
+- SFX_Horse_Idle
+- SFX_Horse_Sleep
+- SFX_Horse_Wake
+- SFX_Hyena_Alerted
+- SFX_Hyena_Death
+- SFX_Hyena_Hurt
+- SFX_Hyena_Idle
+- SFX_Ice_Ball_Death
+- SFX_Ice_Bolt_Death
+- SFX_Ice_Break
+- SFX_Ice_Build
+- SFX_Ice_Hit
+- SFX_Ice_Item_Impact
+- SFX_Ice_Item_Swing
+- SFX_Ice_Land
+- SFX_Ice_Walk
+- SFX_Incorrect_Tool
+- SFX_Item_Break
+- SFX_Item_Repair
+- SFX_Klops_Alerted
+- SFX_Klops_Death
+- SFX_Klops_Hurt
+- SFX_Klops_Idle
+- SFX_Klops_Run
+- SFX_Kweebec_Plushie_Impact
+- SFX_Lamb_Alerted
+- SFX_Lamb_Death
+- SFX_Lamb_Hurt
+- SFX_Larva_Alerted
+- SFX_Larva_Death
+- SFX_Larva_Despawn
+- SFX_Larva_Hurt
+- SFX_Larva_Spawn
+- SFX_LeavesGround_Break
+- SFX_LeavesGround_Hit
+- SFX_LeavesGround_Land
+- SFX_LeavesGround_Walk
+- SFX_Leaves_Break
+- SFX_Leaves_Hit
+- SFX_Leaves_Walk
+- SFX_Leopard_Snow_Alerted
+- SFX_Leopard_Snow_Death
+- SFX_Leopard_Snow_Hurt
+- SFX_Leopard_Snow_Run
+- SFX_Light_Melee_T1_Block
+- SFX_Light_Melee_T1_Guard_Hit
+- SFX_Light_Melee_T1_Impact
+- SFX_Light_Melee_T1_Lunge
+- SFX_Light_Melee_T1_Lunge_Charge
+- SFX_Light_Melee_T1_Shove
+- SFX_Light_Melee_T1_Swing
+- SFX_Light_Melee_T2_Block
+- SFX_Light_Melee_T2_Guard_Break
+- SFX_Light_Melee_T2_Guard_Hit
+- SFX_Light_Melee_T2_Lunge
+- SFX_Light_Melee_T2_Lunge_Charge
+- SFX_Light_Melee_T2_Swing
+- SFX_Longsword_Special_Impact
+- SFX_Longsword_Special_Swing
+- SFX_Longsword_Steel_Charged_Swing
+- SFX_Longsword_Steel_Impact
+- SFX_Longsword_Steel_Swing
+- SFX_Lumbermill_Bench_Close
+- SFX_Lumbermill_Bench_Open
+- SFX_Lumbermill_Bench_Processing
+- SFX_Mace_T1_Block_Impact
+- SFX_Mace_T1_Impact
+- SFX_Mace_T1_Raise
+- SFX_Mace_T1_Raise_Local
+- SFX_Mace_T1_Shove
+- SFX_Mace_T1_Shove_Local
+- SFX_Mace_T1_Swing
+- SFX_Mace_T1_Swing_Charged
+- SFX_Mace_T1_Swing_Charged_LR_Local
+- SFX_Mace_T1_Swing_Charged_RL_Local
+- SFX_Mace_T1_Swing_Charged_Up_Local
+- SFX_Mace_T1_Swing_LR_Local
+- SFX_Mace_T1_Swing_RL_Local
+- SFX_Mace_T1_Swing_Up_Local
+- SFX_Mace_T2_Impact
+- SFX_Mace_T2_Raise
+- SFX_Mace_T2_Raise_Local
+- SFX_Mace_T2_Signature_Impact
+- SFX_Mace_T2_Signature_Impact_Local
+- SFX_Mace_T2_Signature_Launch
+- SFX_Mace_T2_Signature_Launch_Local
+- SFX_Mace_T2_Swing
+- SFX_Mace_T2_Swing_Charged
+- SFX_Mace_T2_Swing_Charged_LR_Local
+- SFX_Mace_T2_Swing_Charged_RL_Local
+- SFX_Mace_T2_Swing_Charged_Up_Local
+- SFX_Mace_T2_Swing_LR_Local
+- SFX_Mace_T2_Swing_RL_Local
+- SFX_Mace_T2_Swing_Up_Local
+- SFX_Meerkat_Alerted
+- SFX_Meerkat_Death
+- SFX_Meerkat_Hurt
+- SFX_Meerkat_Idle
+- SFX_Memories_Unlock_Local
+- SFX_Metal_Break
+- SFX_Metal_Build
+- SFX_Metal_Hit
+- SFX_Metal_Land
+- SFX_Metal_Walk
+- SFX_Moose_Bull_Alerted
+- SFX_Mouse_Alerted
+- SFX_Mouse_Death
+- SFX_Mouse_Flee
+- SFX_Mouse_Hurt
+- SFX_Mouse_Run
+- SFX_Mouse_Sleep
+- SFX_Mud_Break
+- SFX_Mud_Build
+- SFX_Mud_Hit
+- SFX_Mud_Land
+- SFX_Mud_Walk
+- SFX_Mug_Fill
+- SFX_Mug_Fill_Local
+- SFX_Mushroom_Break
+- SFX_Mushroom_Harvest
+- SFX_Music_Ducking_2db
+- SFX_NPC_Unarmed_Impact
+- SFX_NPC_Unarmed_Swing
+- SFX_Ore_Break
+- SFX_Ore_Hit
+- SFX_Outlander_Hunter_Arrow_Hit
+- SFX_Outlander_Hunter_Arrow_Miss
+- SFX_Outlander_Hurt
+- SFX_Owl_Alerted
+- SFX_Owl_Death
+- SFX_Owl_Hurt
+- SFX_Pickaxe_T1_Swing_Down_Local
+- SFX_Pickaxe_T2_Impact_Nice
+- SFX_Pig_Alerted
+- SFX_Pig_Death
+- SFX_Pig_Hurt
+- SFX_Pig_Run
+- SFX_Pig_Walk
+- SFX_Pigeon_Death
+- SFX_Pigeon_Hurt
+- SFX_Piglet_Alerted
+- SFX_Piglet_Death
+- SFX_Piglet_Hurt
+- SFX_Piglet_Run
+- SFX_Pistol_Fire
+- SFX_Plant_Break
+- SFX_Plant_Hit
+- SFX_Plant_MoveIn
+- SFX_Player_Climb_Down
+- SFX_Player_Climb_Side
+- SFX_Player_Climb_Up
+- SFX_Player_Craft_Item_Inventory
+- SFX_Player_Death
+- SFX_Player_Death_Drown
+- SFX_Player_Death_Fall
+- SFX_Player_Drop_Item
+- SFX_Player_Fall
+- SFX_Player_Glide_Motion
+- SFX_Player_Glide_Stationary
+- SFX_Player_Grab_Item
+- SFX_Player_Hurt
+- SFX_Player_Hurt_Burn
+- SFX_Player_Hurt_Drowning
+- SFX_Player_Hurt_Fall
+- SFX_Player_Jump
+- SFX_Player_Mantle
+- SFX_Player_Pickup_Item
+- SFX_Player_Roll
+- SFX_Player_Slide
+- SFX_Player_Swim
+- SFX_Player_Swim_Fast
+- SFX_Player_Swim_Jump
+- SFX_Player_Unarmed_Swing_Left
+- SFX_Player_Unarmed_Swing_Right
+- SFX_Plushie_Break
+- SFX_Plushie_Build
+- SFX_Poop_Bounce
+- SFX_Poop_Break
+- SFX_Poop_Hit
+- SFX_Poop_Walk
+- SFX_Portal_Neutral
+- SFX_Portal_Neutral_Open
+- SFX_Portal_Neutral_Teleport_Local
+- SFX_Portal_Void
+- SFX_Potion_Drink_Success
+- SFX_Processing_Placeholder
+- SFX_Projectile_Poop_Hit
+- SFX_Rabbit_Alerted
+- SFX_Rabbit_Death
+- SFX_Rabbit_Hurt
+- SFX_Rabbit_Run
+- SFX_Rabbit_Sleep
+- SFX_Ram_Alerted
+- SFX_Ram_Death
+- SFX_Ram_Hurt
+- SFX_Ram_Run
+- SFX_Ram_Sleep
+- SFX_Raptor_Cave_Alerted
+- SFX_Raptor_Cave_Idle
+- SFX_Rat_Death
+- SFX_Rat_Hurt
+- SFX_Raven_Alerted
+- SFX_Raven_Death
+- SFX_Raven_Flee
+- SFX_Raven_Hurt
+- SFX_Reeds_MoveIn
+- SFX_Rifle_Fire
+- SFX_Rifle_Fire_Local
+- SFX_Rope_Break
+- SFX_Rope_Build
+- SFX_Rope_Land
+- SFX_Rope_Walk
+- SFX_Rotate_Pitch_Default
+- SFX_Rotate_Roll_Default
+- SFX_Rotate_Yaw_Default
+- SFX_Rubble_Bounce
+- SFX_Rubble_Hit
+- SFX_Sand_Break
+- SFX_Sand_Build
+- SFX_Sand_Hit
+- SFX_Sand_Land
+- SFX_Sand_Walk
+- SFX_Scarak_Fighter_Alerted
+- SFX_Scarak_Fighter_Death
+- SFX_Scarak_Fighter_Hurt
+- SFX_Scarak_Seeker_Alerted
+- SFX_Scarak_Seeker_Death
+- SFX_Scarak_Seeker_Hurt
+- SFX_Scarak_Seeker_Spitball_Death
+- SFX_Scarak_Spitball_Fire
+- SFX_Scorpion_Alerted
+- SFX_Scorpion_Death
+- SFX_Scorpion_Run
+- SFX_Scorpion_Threaten
+- SFX_Seeds_Place
+- SFX_Shark_Death
+- SFX_Shark_Dive
+- SFX_Shark_Hurt
+- SFX_Shark_Swim
+- SFX_Shears_Activate
+- SFX_Sheep_Alerted
+- SFX_Sheep_Death
+- SFX_Sheep_Hurt
+- SFX_Sheep_Run
+- SFX_Sheep_Sheared
+- SFX_Sheep_Walk
+- SFX_Shield_T1_Break
+- SFX_Shield_T1_Impact
+- SFX_Shield_T1_Raise
+- SFX_Shield_T1_Raise_Local
+- SFX_Shield_T1_Swing
+- SFX_Shield_T1_Swing_Local
+- SFX_Shield_T2_Impact
+- SFX_Shield_T2_Raise
+- SFX_Shield_T2_Raise_Local
+- SFX_Shield_T2_Swing
+- SFX_Shield_T2_Swing_Local
+- SFX_Shovel_T1_Swing_RL_Local
+- SFX_Shovel_T2_Impact_Nice
+- SFX_Skeleton_Alerted
+- SFX_Skeleton_Death_1
+- SFX_Skeleton_Death_2
+- SFX_Skeleton_Death_3
+- SFX_Skeleton_Death_4
+- SFX_Skeleton_Despawn_1
+- SFX_Skeleton_Despawn_2
+- SFX_Skeleton_Hurt
+- SFX_Skeleton_Mage_Spellbook_Charge
+- SFX_Skeleton_Mage_Spellbook_Impact
+- SFX_Skeleton_Praetorian_Alerted
+- SFX_Skeleton_Praetorian_Death_1
+- SFX_Skeleton_Praetorian_Death_2
+- SFX_Skeleton_Praetorian_Death_3
+- SFX_Skeleton_Praetorian_Death_4
+- SFX_Skeleton_Praetorian_Despawn_1
+- SFX_Skeleton_Praetorian_Despawn_2
+- SFX_Skeleton_Praetorian_Hurt
+- SFX_Skeleton_Praetorian_Run
+- SFX_Skeleton_Praetorian_Search_2
+- SFX_Skeleton_Praetorian_Spawn_1
+- SFX_Skeleton_Praetorian_Walk
+- SFX_Skeleton_Run
+- SFX_Skeleton_Search_2
+- SFX_Skeleton_Spawn_1
+- SFX_Skeleton_Spawn_2
+- SFX_Skeleton_Walk
+- SFX_Snake_Alerted
+- SFX_Snake_Death
+- SFX_Snake_Hurt
+- SFX_Snake_Idle
+- SFX_Snow_Break
+- SFX_Snow_Build
+- SFX_Snow_Hit
+- SFX_Snow_Land
+- SFX_Snow_Walk
+- SFX_Soft_Break
+- SFX_Soft_Build
+- SFX_Soft_Hit
+- SFX_Soft_Land
+- SFX_Soft_Walk
+- SFX_Spark_Living_Alerted
+- SFX_Spark_Living_Death
+- SFX_Sparrow_Alerted
+- SFX_Sparrow_Death
+- SFX_Sparrow_Hurt
+- SFX_Sparrow_Idle
+- SFX_Spawn_Void_Alerted
+- SFX_Spawn_Void_Attack
+- SFX_Spawn_Void_Death
+- SFX_Spawn_Void_Hurt
+- SFX_Spawn_Void_Run
+- SFX_Spear_Impact
+- SFX_Spear_Lunge
+- SFX_Spear_Lunge_Local
+- SFX_Spear_Miss
+- SFX_Spear_Projectile_Impact
+- SFX_Spear_Throw
+- SFX_Spear_Throw_Charge
+- SFX_Spear_Throw_Charge_Local
+- SFX_Spear_Throw_Local
+- SFX_Spider_Alerted
+- SFX_Spider_Death
+- SFX_Spider_Run
+- SFX_Spirit_Root_Alerted
+- SFX_Spirit_Root_Death_01
+- SFX_Spirit_Root_Death_02
+- SFX_Spirit_Root_Hurt
+- SFX_Spirit_Root_Spawn
+- SFX_Squirrel_Alerted
+- SFX_Squirrel_Death
+- SFX_Squirrel_Hurt
+- SFX_Squirrel_Run
+- SFX_Staff_Charged_Loop
+- SFX_Staff_Fire_Shoot
+- SFX_Staff_Flame_Consume_Charge_1
+- SFX_Staff_Flame_Consume_Charge_1_Local
+- SFX_Staff_Flame_Consume_Charge_2
+- SFX_Staff_Flame_Consume_Charge_2_Local
+- SFX_Staff_Flame_Consume_Charge_3
+- SFX_Staff_Flame_Consume_Charge_3_Local
+- SFX_Staff_Flame_Consume_Charge_4
+- SFX_Staff_Flame_Consume_Charge_4_Local
+- SFX_Staff_Flame_Fireball_Impact
+- SFX_Staff_Flame_Fireball_Launch
+- SFX_Staff_Flame_Fireball_Launch_Local
+- SFX_Staff_Flame_Flamethrower
+- SFX_Staff_Flame_Flamethrower_End
+- SFX_Staff_Flame_Flamethrower_End_Local
+- SFX_Staff_Flame_Flamethrower_Impact
+- SFX_Staff_Flame_Flamethrower_Local
+- SFX_Staff_Flame_Trap_Deploy
+- SFX_Staff_Flame_Trap_Despawn
+- SFX_Staff_Flame_Trap_Loop
+- SFX_Staff_Ice_Shoot
+- SFX_Stamina_Potion_Success
+- SFX_Sticks_Break
+- SFX_Stone_Break
+- SFX_Stone_Build
+- SFX_Stone_Coffin_Open_Close
+- SFX_Stone_Harvest
+- SFX_Stone_Hit
+- SFX_Stone_Land
+- SFX_Stone_Walk
+- SFX_Sword_T1_Block_Local
+- SFX_Sword_T1_Lunge_Charge_Local
+- SFX_Sword_T1_Lunge_Local
+- SFX_Sword_T1_Shove_Local
+- SFX_Sword_T1_Swing_Down_Local
+- SFX_Sword_T1_Swing_LR_Local
+- SFX_Sword_T1_Swing_RL_Local
+- SFX_Sword_T2_Block_Local
+- SFX_Sword_T2_Impact
+- SFX_Sword_T2_Lunge_Charge_Local
+- SFX_Sword_T2_Lunge_Local
+- SFX_Sword_T2_Signature_Part_1
+- SFX_Sword_T2_Signature_Part_1_Local
+- SFX_Sword_T2_Signature_Part_2
+- SFX_Sword_T2_Signature_Part_2_Local
+- SFX_Sword_T2_Swing_Down_Local
+- SFX_Sword_T2_Swing_LR_Local
+- SFX_Sword_T2_Swing_RL_Local
+- SFX_T1_Impact_Blunt
+- SFX_Tall_Grass_MoveIn
+- SFX_Test_Blip_A
+- SFX_Test_Blip_B
+- SFX_Test_Blip_C
+- SFX_Tetrabird_Alerted
+- SFX_Tetrabird_Death
+- SFX_Tetrabird_Flee
+- SFX_Tetrabird_Hurt
+- SFX_Tetrabird_Run
+- SFX_Tiger_Sabertooth_Alerted
+- SFX_Tiger_Sabertooth_Death
+- SFX_Tiger_Sabertooth_Hurt
+- SFX_Tiger_Sabertooth_Run
+- SFX_Toad_Rhino_Alerted
+- SFX_Toad_Rhino_Death
+- SFX_Toad_Rhino_Hurt
+- SFX_Toad_Rhino_Magma_Alerted
+- SFX_Toad_Rhino_Magma_Death
+- SFX_Toad_Rhino_Magma_Hurt
+- SFX_Toad_Rhino_Magma_Run
+- SFX_Toad_Rhino_Magma_Tongue_Impact
+- SFX_Toad_Rhino_Magma_Tongue_Whoosh
+- SFX_Toad_Rhino_Run
+- SFX_Toad_Rhino_Tongue_Impact
+- SFX_Toad_Rhino_Tongue_Whoosh
+- SFX_Tombstone_Break
+- SFX_Tool_T1_Swing
+- SFX_Tool_Watering_Can_Water
+- SFX_Torch_Break
+- SFX_Torch_Build
+- SFX_Torch_Default_Loop
+- SFX_Torch_Impact
+- SFX_Torch_Off
+- SFX_Torch_On_Loop
+- SFX_Torch_Swing
+- SFX_Torch_Swing_Left_Local
+- SFX_Torch_Swing_Right_Local
+- SFX_Tornado
+- SFX_Trashpile_Land
+- SFX_Trashpile_Walk
+- SFX_Trork_Alerted
+- SFX_Trork_Chieftain_Alerted
+- SFX_Trork_Chieftain_Death
+- SFX_Trork_Chieftain_Hurt
+- SFX_Trork_Chieftain_Run
+- SFX_Trork_Chieftain_Search
+- SFX_Trork_Death
+- SFX_Trork_Exertion
+- SFX_Trork_Hurt_01
+- SFX_Trork_Hurt_02
+- SFX_Trork_Run
+- SFX_Trork_Search
+- SFX_Trork_Sleep
+- SFX_Trork_Throwing_Axe
+- SFX_Unarmed_Impact
+- SFX_Unarmed_Swing
+- SFX_Unbreakable_Block
+- SFX_Vulture_Alerted
+- SFX_Vulture_Death
+- SFX_Vulture_Flee
+- SFX_Vulture_Hurt
+- SFX_Wand_Fire_Shoot
+- SFX_Wand_Ice_Shoot
+- SFX_Warthog_Alerted
+- SFX_Warthog_Death
+- SFX_Warthog_Hurt
+- SFX_Warthog_Piglet_Alerted
+- SFX_Warthog_Piglet_Death
+- SFX_Warthog_Piglet_Hurt
+- SFX_Warthog_Piglet_Run
+- SFX_Warthog_Run
+- SFX_Warthog_Sleep
+- SFX_Warthog_Walk
+- SFX_Water_MoveIn
+- SFX_Water_MoveOut
+- SFX_Weapon_Bench_Close
+- SFX_Weapon_Bench_Craft
+- SFX_Weapon_Bench_Open
+- SFX_Weapon_Charge_Swing
+- SFX_Web_MoveIn
+- SFX_Window_Break
+- SFX_Window_Stone_Break
+- SFX_Wisp_Lamp_Loop
+- SFX_Wolf_Alerted
+- SFX_Wolf_Death
+- SFX_Wolf_Hurt
+- SFX_Wolf_Run
+- SFX_Wolf_Sleep
+- SFX_Wood_Break
+- SFX_Wood_Build
+- SFX_Wood_Hit
+- SFX_Wood_Land
+- SFX_Wood_Walk
+- SFX_Woodpecker_Death
+- SFX_Woodpecker_Hurt
+- SFX_Workbench_Close
+- SFX_Workbench_Craft
+- SFX_Workbench_Open
+- SFX_Workbench_Upgrade_Complete_Default
+- SFX_Workbench_Upgrade_Start_Default
+- SFX_Yeti_Alerted
+- SFX_Z1_Emit_Forest_Autumn_Day_Birds
+- SFX_Z1_Emit_Forest_Autumn_Day_Insects
+- SFX_Z1_Emit_Forest_Autumn_Day_Wind
+- SFX_Z1_Emit_Forest_Azure_Day_Insects
+- SFX_Z1_Emit_Forest_Azure_Day_Wind
+- SFX_Z1_Emit_Forest_Gen_Day_Birds
+- SFX_Z1_Emit_Forest_Gen_Day_Insects
+- SFX_Z1_Emit_Forest_Gen_Day_Winds
+- SFX_Z1_Emit_Forest_Moss_Day_Birds
+- SFX_Z1_Emit_Forest_Moss_Day_Insects
+- SFX_Z1_Emit_Forest_Moss_Day_Wind
+- SFX_Z1_Emit_Forest_Night_Birds
+- SFX_Z1_Emit_Forest_Night_Insects
+- SFX_Z1_Emit_Forest_Night_Wind
+- SFX_Z1_Emit_Kweebec_Village_Wind
+- SFX_Z1_Emit_Mountain_Day_Birds
+- SFX_Z1_Emit_Plains_Gen_Day_Birds
+- SFX_Z1_Emit_Plains_Gen_Day_Insects
+- SFX_Z1_Emit_Plains_Gen_Day_Wind
+- SFX_Z1_Emit_Plains_Gen_Night_Birds
+- SFX_Z1_Emit_Plains_Gen_Night_Insects
+- SFX_Z1_Emit_Plains_Gen_Night_Wind
+- SFX_Z1_Emit_Shore_Day_Birds
+- SFX_Z1_Emit_Shore_Waves
+- SFX_Z1_Emit_Shore_Wind
+- SFX_Z1_Emit_Swamp_Day_Birds
+- SFX_Z1_Emit_Swamp_Day_Frogs
+- SFX_Z1_Emit_Swamp_Day_Insects
+- SFX_Z1_Emit_Swamp_Day_Wind
+- SFX_Z1_Emit_Swamp_Night_Frogs
+- SFX_Z1_Emit_Trork_Camp
+- SFX_Z1_Shore_Day_Birds
+- SFX_Z3_Emit_Cave_Ice_Crackle
+- SFX_Z3_Emit_Cave_Ice_Rumble
+- SFX_Z3_Emit_Cave_Ice_Stress
+- SFX_Z3_Emit_Cave_Snow_Crackle
+- SFX_Z3_Emit_Cave_Snow_Melt
+- SFX_Z3_Emit_Hedera_FX
+- SFX_Z3_Emit_Hedera_PlantRustle
+- SFX_Z3_Emit_Tree_Creak
+- SFX_Z3_Emit_Wind_Leaves
+- SFX_Z3_Emit_Wind_Leaves_Stereo
+- SFX_Z3_Forest_Day_Birds
+- SFX_Z3_Forest_Day_General
+- SFX_Z3_Forest_Night_Birds
+- SFX_Zombie_Alerted
+- SFX_Zombie_Attack_Bite
+- SFX_Zombie_Attack_Swing
+- SFX_Zombie_Death
+- SFX_Zombie_Despawn
+- SFX_Zombie_Hurt
+- SFX_Zombie_Pursuit
+- SFX_Zombie_ScratchBack
+- SFX_Zombie_Spawn
diff --git a/content/docs/lt-LT/contributing/pr-guidelines.mdx b/content/docs/lt-LT/contributing/pr-guidelines.mdx
index 7a251032..c226da04 100644
--- a/content/docs/lt-LT/contributing/pr-guidelines.mdx
+++ b/content/docs/lt-LT/contributing/pr-guidelines.mdx
@@ -19,6 +19,8 @@ To ensure a smooth and efficient review process, both contributors and reviewers
 4. **Code Quality**
    - Ensure your code follows the project's coding standards and best practices.
    - Include comments where necessary to explain complex logic.
+   - Always test your changes locally before submitting the PR to catch any issues early.
+   - Format your code using `bun format` to maintain consistency across the codebase.
 5. **Testing**
    - Test your changes thoroughly before submitting the PR.
    - If applicable, include unit tests or integration tests to verify your changes.
diff --git a/content/docs/lt-LT/contributing/translate.mdx b/content/docs/lt-LT/contributing/translate.mdx
new file mode 100644
index 00000000..c62ffdde
--- /dev/null
+++ b/content/docs/lt-LT/contributing/translate.mdx
@@ -0,0 +1,74 @@
+---
+title: Translate
+description: How to translate HytaleModding to your language
+---
+
+# Translating HytaleModding
+
+HytaleModding is translated with the help of the community using **Crowdin**. If you want to help translate or improve existing translations, this is the right place.
+
+## Steps to Translate
+
+All translations are managed **via Crowdin**.
+
+1. Visit [our Crowdin project](https://crowdin.com/project/hytalemodding) and log in if required.
+2. Click on your language.
+3. Click on the file/article you wish to translate. We recommend starting with Official Documentation, and then Server Plugin Documentation.
+4. Start translating!
+5. Approved translations will appear on the website.
+
+### Video Guide
+
+<iframe src="https://www.youtube.com/embed/NHiG1rDRgks" allowFullScreen />
+
+## How to discuss
+
+You can always report issues or discuss specific topics directly on Crowdin, but we recommend using Discord instead of the Crowdin comment system to keep everything organized in one place.
+
+1. Join [our Discord](https://discord.gg/hytalemodding)
+2. Open `#translations` channel. Here you can discuss or ask questions that are not related to a specific language.
+3. If you want to join a thread, you are required to run `/translator <your-language>` command here. The bot will add you to the thread for your language.
+
+## Translation Guidelines
+
+- You need to be confident in what you are translating. You should be able to read the text you just translated and understand the meaning of it very easily.
+- It should use the simplest form of language possible. Use English words if the translation is unknown to the majority in your country.
+- Use your imagination, trust yourself. Feel free to change any context as you wish as long as it can still get the same point across and is understandable.
+- These guidelines are more important than language-specific guidelines, but less important than Hytale terminology and rules.
+
+## What not to translate
+
+We request you all to not translate these specific sections of the website:
+
+### Callout types
+
+Callouts are the boxes that contain important information. We request you to not translate the types as they only work in English.
+
+**Example:**
+
+```mdx
+<Callout type="warning" title="Translate this title!">
+Translate the text inside the callout!
+</Callout>
+```
+
+In this example, please don't translate the word warning, the rest you can translate.
+
+### Icons
+
+Icon names must not be translated.
+They are technical identifiers mapped directly to existing icons. Translating them will break the icon rendering.
+
+```mdx
+icon: Globe
+```
+
+---
+
+{/* 
+For translators who will edit this page:
+
+- You are required to translate the Guidelines as they change.
+- General guidelines should be translated but not edited.
+- Learn how to use Markdown from writing_guides.mdx
+*/}
diff --git a/content/docs/lt-LT/established-information/server/content-categories/art-assets.mdx b/content/docs/lt-LT/established-information/server/content-categories/art-assets.mdx
index 39c2ed37..1e926874 100644
--- a/content/docs/lt-LT/established-information/server/content-categories/art-assets.mdx
+++ b/content/docs/lt-LT/established-information/server/content-categories/art-assets.mdx
@@ -14,7 +14,7 @@ Hytale provides comprehensive support for 3D modeling and texture art creation,
 Hytale uses **Blockbench** as the primary tool for 3D modeling and animation:
 
 * **Official support**: Used for "creating Hytale models, textures, and animations"
-* **Special plugin**: Hytale will have a dedicated Blockbench plugin, to be released ASAP
+* **Special plugin**: Hytale has a dedicated [Blockbench Plugin](https://www.blockbench.net/plugins/hytale_plugin).
 * **Direct compatibility**: The plugin allows creators to "create Hytale-compatible models, textures, and animations directly in Blockbench"
 * **Replaces legacy tools**: Fully replaces the old Hytale Model Maker to better support established creative workflows in the community
 * **Safety features**: Only allows you to add things compatible with the engine, so no need to worry about breaking anything
diff --git a/content/docs/lt-LT/guides/ecs/block-components.mdx b/content/docs/lt-LT/guides/ecs/block-components.mdx
new file mode 100644
index 00000000..ca68b38a
--- /dev/null
+++ b/content/docs/lt-LT/guides/ecs/block-components.mdx
@@ -0,0 +1,247 @@
+---
+title: Block Components
+description: Learn how to use the block components.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+  - name: oskarscot
+    link: https://oskar.scot
+---
+
+# Overview
+
+In this guide, you'll learn how to use block components to create a ticking block.
+
+<Callout>
+  For a more complete reference, you may also want to review FarmingSystems.Ticking, as much of the underlying logic is based on its implementation.
+</Callout>
+
+## Steps
+
+### 1. ExampleBlock - holds block behavior
+
+```java
+public class ExampleBlock implements Component<ChunkStore> {
+
+    public static final BuilderCodec CODEC = BuilderCodec.builder(ExampleBlock.class, ExampleBlock::new).build();
+
+    // Components usually require a copy constructor as well but since we don't actually hold any data in this component this is not neccessary
+    public ExampleBlock() { }
+
+    public static ComponentType getComponentType() {
+        return ExamplePlugin.get().getExampleBlockComponentType();
+    }
+
+    @Nullable
+    public Component<ChunkStore> clone() {
+        return new ExampleBlock();
+    }
+}
+```
+
+ExampleBlock is a custom component that stores the behavior and data for your ticking block. Here, it simply places an Ice Block at x + 1 relative to its current position when it ticks.
+
+---
+
+### 2. ExampleInitializer - marks blocks as ticking when placed
+
+```java
+public class ExampleInitializer extends RefSystem {
+
+    @Override
+    public void onEntityAdded(@Nonnull Ref ref, @Nonnull AddReason reason, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+        BlockModule.BlockStateInfo info = (BlockModule.BlockStateInfo) commandBuffer.getComponent(ref, BlockModule.BlockStateInfo.getComponentType());
+        if (info == null) return;
+
+        ExampleBlock generator = (ExampleBlock) commandBuffer.getComponent(ref, ExamplePlugin.get().getExampleBlockComponentType());
+        if (generator != null) {
+            int x = ChunkUtil.xFromBlockInColumn(info.getIndex());
+            int y = ChunkUtil.yFromBlockInColumn(info.getIndex());
+            int z = ChunkUtil.zFromBlockInColumn(info.getIndex());
+
+            WorldChunk worldChunk = (WorldChunk) commandBuffer.getComponent(info.getChunkRef(), WorldChunk.getComponentType());
+            if (worldChunk != null) {
+				worldChunk.setTicking(x, y, z, true);
+            }
+        }
+    }
+
+    @Override
+    public void onEntityRemove(@Nonnull Ref ref, @Nonnull RemoveReason reason, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+    }
+
+    @Override
+    public Query getQuery() {
+        return Query.and(BlockModule.BlockStateInfo.getComponentType(), ExamplePlugin.get().getExampleBlockComponentType());
+    }
+}
+```
+
+ExampleInitializer is a RefSystem that reacts when block entities with the ExampleBlock component are added or removed. This is crucial for marking blocks as ticking when they're first placed.
+
+**Key Points:**
+
+- Tells the game that this block should tick, allowing `ExampleSystem` to process it.
+
+```java
+worldChunk.setTicking(x, y, z, true);
+```
+
+---
+
+### 3. ExampleSystem - handles ticking
+
+```java
+public class ExampleSystem extends EntityTickingSystem {
+
+    public void tick(float dt, int index, @Nonnull ArchetypeChunk archetypeChunk, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+        BlockSection blocks = (BlockSection) archetypeChunk.getComponent(index, BlockSection.getComponentType());
+
+        assert blocks != null;
+
+        if (blocks.getTickingBlocksCountCopy() != 0) {
+            ChunkSection section = (ChunkSection) archetypeChunk.getComponent(index, ChunkSection.getComponentType());
+
+            assert section != null;
+
+            BlockComponentChunk blockComponentChunk = (BlockComponentChunk) commandBuffer.getComponent(section.getChunkColumnReference(), BlockComponentChunk.getComponentType());
+
+            assert blockComponentChunk != null;
+
+            blocks.forEachTicking(blockComponentChunk, commandBuffer, section.getY(), (blockComponentChunk1, commandBuffer1, localX, localY, localZ, blockId) -> {
+                Ref<ChunkStore> blockRef = blockComponentChunk.getEntityReference(ChunkUtil.indexBlockInColumn(localX, localY, localZ));
+                if (blockRef == null) {
+                    return BlockTickStrategy.IGNORED;
+                } else {
+                    ExampleBlock exampleBlock = (ExampleBlock) commandBuffer1.getComponent(blockRef, ExampleBlock.getComponentType());
+                    if (exampleBlock != null) {
+                        WorldChunk worldChunk = (WorldChunk) commandBuffer.getComponent(section.getChunkColumnReference(), WorldChunk.getComponentType());
+                        World world = worldChunk.getWorld();
+
+                        int globalX = localX + (worldChunk.getX() * 32);
+                        int globalZ = localZ + (worldChunk.getZ() * 32);
+
+                        // We need to execute setBlock on the world thread as you cannot call store functions from a system
+                        // This is because of the architecture of the server, depending on your needs you can also use the CommandBuffer
+                        world.execute(() -> {
+                            world.setBlock(globalX + 1, localY, globalZ, "Rock_Ice");
+                        });
+
+                        return BlockTickStrategy.CONTINUE;
+
+                    } else {
+                        return BlockTickStrategy.IGNORED;
+                    }
+                }
+            });
+        }
+    }
+
+    @Nullable
+    public Query getQuery() {
+        return Query.and(BlockSection.getComponentType(), ChunkSection.getComponentType());;
+    }
+}
+```
+
+ExampleSystem is an EntityTickingSystem that runs every tick to execute the logic for all ticking blocks with the ExampleBlock component.
+
+**Key Points:**
+
+- **Get the block component**
+
+```java
+ExampleBlock exampleBlock = (ExampleBlock) commandBuffer.getComponent(blockRef, ExampleBlock.getComponentType());
+```
+
+- **Convert local chunk coordinates to world coordinates**
+
+```java
+int globalX = localX + (worldChunk.getX() * 32);
+int globalZ = localZ + (worldChunk.getZ() * 32);
+```
+
+- **Run the block logic**
+
+```java
+exampleBlock.runBlockAction(globalX, localY, globalZ, worldChunk.getWorld());
+```
+
+- **Keep the block ticking in the next tick**
+
+```java
+return BlockTickStrategy.CONTINUE;
+```
+
+---
+
+### 4. ExamplePlugin - registers components and systems
+
+```java
+public class ExamplePlugin extends JavaPlugin {
+    protected static ExamplePlugin instance;
+    private static final HytaleLogger LOGGER = HytaleLogger.forEnclosingClass();
+    private ComponentType exampleBlockComponentType;
+
+    public static ExamplePlugin get() {
+        return instance;
+    }
+
+    public ExamplePlugin(@Nonnull JavaPluginInit init) {
+        super(init);
+        LOGGER.atInfo().log("Hello from " + this.getName() + " version " + this.getManifest().getVersion().toString());
+    }
+
+    @Override
+    protected void setup() {
+        instance = this;
+        LOGGER.atInfo().log("Setting up plugin " + this.getName());
+        this.exampleBlockComponentType = this.getChunkStoreRegistry().registerComponent(ExampleBlock.class, "ExampleBlock", ExampleBlock.CODEC);
+    }
+	
+	@Override
+	protected void start() {
+		this.getChunkStoreRegistry().registerSystem(new ExampleSystem());
+		this.getChunkStoreRegistry().registerSystem(new ExampleInitializer());
+	}
+
+    public ComponentType getExampleBlockComponentType() {
+        return this.exampleBlockComponentType;
+    }
+}
+```
+
+---
+
+### 5. Configure In-Game
+
+![block-component-1](/assets/guides/block-component-1.png)
+
+![block-component-2](/assets/guides/block-component-2.png)
+
+With this logic, the block will now continuously place an Ice Block at the coordinates x + 1 relative to its current position every time it ticks.
+
+---
+
+## Common Issues
+
+### NullPointerException on Startup
+
+**Error message:**
+
+```java
+java.lang.NullPointerException: Cannot invoke "com.hypixel.hytale.component.query.Query.validateRegistry(com.hypixel.hytale.component.ComponentRegistry)" because "query" is null
+```
+
+**Cause:**
+This error occurs when your module is loaded **before** the required Hytale modules.
+
+**Fix:**
+Add `EntityModule` and `BlockModule` as dependencies in your `manifest.json` to ensure proper load order.
+
+```json
+"Dependencies": {
+  "Hytale:EntityModule": "*",
+  "Hytale:BlockModule": "*"
+}
+```
diff --git a/content/docs/lt-LT/guides/ecs/hytale-ecs-theory.mdx b/content/docs/lt-LT/guides/ecs/hytale-ecs-theory.mdx
index 20c3a94d..52d8b1f5 100644
--- a/content/docs/lt-LT/guides/ecs/hytale-ecs-theory.mdx
+++ b/content/docs/lt-LT/guides/ecs/hytale-ecs-theory.mdx
@@ -29,7 +29,7 @@ for now this is the basic understanding for the `ChunkStore`. You can use it to
 
 ## Holder
 
-A Holder is essentially a blueprint for an entity. Before an entity exists in the Store (and thus in the world), is exists as a `Holder`. It collects and holds all the necessary components (data). You can compare it analogous to shopping cart. You grab all components you need and once you have everything, check out at the store which will take your cart and create a valid entity ID and hand you back a receipt (a Ref).
+A Holder is essentially a blueprint for an entity. Before an entity exists in the Store (and thus in the world), it exists as a `Holder`. It collects and holds all the necessary components (data). You can compare it analogous to shopping cart. You grab all components you need and once you have everything, check out at the store which will take your cart and create a valid entity ID and hand you back a receipt (a Ref).
 
 Let's take a look at an example: initializing players. In `Universe`, the `addPlayer` method demonstrates it perfectly.
 When a player connects, we don't immediately throw them into the ECS. We first construct their data in a Holder.
@@ -167,7 +167,7 @@ MyComponent comp = commandBuffer.getComponent(ref, componentType);
 
 Codecs handle serialization and deserialization of components. Hytale uses them to save and load entity data to and from disk as well as sending component data over the network. When creating a custom component, you must also create a corresponding Codec.
 
-There are mutliple Codec types already implemented in the default Codec Interface:
+There are multiple Codec types already implemented in the default Codec Interface:
 
 - Codec.STRING
 - Codec.BOOLEAN
@@ -215,7 +215,7 @@ This might seem tedious at first but it ensures that your component can be corre
   KeyedCodec<Integer> exampleInt = new KeyedCodec<Integer>("ExampleIntIdForCodec", Codec.INTEGER);
   ```
 
-- **Setter Function**: This is a lambda function that takes an instance of your component and returns the value of the field you want to serialize. For example, if you have a field called `myCustomField` in your custom component, your getter function would look like this:
+- **Setter Function**: This is a lambda function that takes an instance of your component + the value to set and sets the field value on the component. For example, if you have a field called `myCustomField` in your custom component, your setter function would look like this:
   ```java
   (data, value) -> data.myCustomField = value
   ```
@@ -276,7 +276,7 @@ public class PoisonComponent implements Component<EntityStore> {
 
 You can also add validators to your Codec fields to ensure that the data being serialized/deserialized meets certain criteria. For example, if you want to ensure that the `damagePerTick` field is always non-negative or the poison name is never null, you can add a validator like this:
 
-````java
+```java
 .append(
     new KeyedCodec<Float>("DamagePerTick", Codec.FLOAT),
     (data, value) -> data.damagePerTick = value,
@@ -292,14 +292,15 @@ You can also add validators to your Codec fields to ensure that the data being s
 )
 .addValidator(Validators.nonNull())
 .add()
+```
 
 ### Complex Codec Examples
 
-If you want to have a map inside your component, you can use the MapCodec class to build a KeyedCoded for it. Here's an example of how to create a Codec for a Map field:
+If you want to have a map inside your component, you can use the MapCodec class to build a KeyedCodec for it. Here's an example of how to create a Codec for a Map field:
 
 ```java
 var damagePerTick = new KeyedCodec<>("DamagePerTick", new MapCodec<>(Codec.FLOAT, HashMap<String, Float>::new));
-````
+```
 
 <Callout type="info">
   This also works with custom Objects as long as you have a Codec defined for the Object type.
diff --git a/content/docs/lt-LT/guides/java-basics/00-introduction.mdx b/content/docs/lt-LT/guides/java-basics/00-introduction.mdx
index a03ad638..b0130d74 100644
--- a/content/docs/lt-LT/guides/java-basics/00-introduction.mdx
+++ b/content/docs/lt-LT/guides/java-basics/00-introduction.mdx
@@ -7,7 +7,7 @@ Welcome to your journey into Java Programming! This guide is designed to introdu
 
 ## What is Java?
 
-Java is a powerful, object-oriented programming language created in 1995. It's one of the most popular programming languages in the world and is used for everything from mobile apps to enterprise software. Most importantly for us, it's the language Hytale uses for it's servers & modding API.
+Java is a powerful, object-oriented programming language created in 1995. It's one of the most popular programming languages in the world and is used for everything from mobile apps to enterprise software. Most importantly for us, it's the language Hytale uses for its servers & modding API.
 
 ## What You'll Learn
 
diff --git a/content/docs/lt-LT/guides/java-basics/02-operators.mdx b/content/docs/lt-LT/guides/java-basics/02-operators.mdx
index a132b1c0..18634665 100644
--- a/content/docs/lt-LT/guides/java-basics/02-operators.mdx
+++ b/content/docs/lt-LT/guides/java-basics/02-operators.mdx
@@ -119,7 +119,7 @@ String greetingWithName = "Hello, " + name + "!"; // "Hello, Alice!"
 
 ## Operator Precedence
 
-Operator Precendence means which operator gets evaluated first in an line of code. Think of it like BODMAS/PEMDAS in math!
+Operator Precedence means which operator gets evaluated first in an line of code. Think of it like BODMAS/PEMDAS in math!
 
 ```java
 int result = 10 + 5 * 2; // result is 20, not 30
diff --git a/content/docs/lt-LT/guides/java-basics/03-control-flow-if.mdx b/content/docs/lt-LT/guides/java-basics/03-control-flow-if.mdx
index b9d6c479..af2d1c22 100644
--- a/content/docs/lt-LT/guides/java-basics/03-control-flow-if.mdx
+++ b/content/docs/lt-LT/guides/java-basics/03-control-flow-if.mdx
@@ -7,7 +7,7 @@ Programs need to make decisions. If statements let your code choose different pa
 
 ## Basic If Statement
 
-The simplest form checks one condition;
+The simplest form checks one condition:
 
 ```java
 int health = 20;
diff --git a/content/docs/lt-LT/guides/java-basics/08-access-modifiers.mdx b/content/docs/lt-LT/guides/java-basics/08-access-modifiers.mdx
index af560932..da2bf33b 100644
--- a/content/docs/lt-LT/guides/java-basics/08-access-modifiers.mdx
+++ b/content/docs/lt-LT/guides/java-basics/08-access-modifiers.mdx
@@ -484,7 +484,7 @@ class Data {
     // Static member:
     // cannot access to non-static variables
     public static void bar() {
-        x = 100; // Error: non-static variable x cannot be renference from a static context
+        x = 100; // Error: non-static variable x cannot be referenced from a static context
         y = 100; // OK
     }
 }
@@ -504,7 +504,7 @@ Data.x = 1000; // Error: cannot access instanced variables in a static context
 
 ### Static Fields
 
-A static field represents a data member owned by the class type rather then the object. Static fields are also stored in a specific memory location that's been shared between all the object instances that are created.
+A static field represents a data member owned by the class type rather than the object. Static fields are also stored in a specific memory location that's been shared between all the object instances that are created.
 
 It is declared as following:
 
diff --git a/content/docs/lt-LT/guides/plugin/animated-block-textures.mdx b/content/docs/lt-LT/guides/plugin/animated-block-textures.mdx
new file mode 100644
index 00000000..42bfa51f
--- /dev/null
+++ b/content/docs/lt-LT/guides/plugin/animated-block-textures.mdx
@@ -0,0 +1,101 @@
+---
+title: Animated Block Textures
+description: Learn how to attach a .blockyanim to a block
+authors:
+  - name: Burkino
+---
+
+import { File, Folder, Files } from 'fumadocs-ui/components/files';
+
+So, you want to make your blocks feel more alive through animations, do you?\
+Now for the most part this is the exact same as [Creating custom blocks](./creating-block).
+![blue fire gif](/assets/guides/blue_fire.gif)
+
+## Prerequisites
+
+This is NOT a guide on animating or texturing or even using BlockBench, why? Because I don't know how to do that.\
+The only thing we will be doing is taking the fire texture, changing the color, and applying it to our new fire block.
+
+## Setup
+
+To start, you're obviously going to want to grab the `Common/VFX/Fire/Fire.png` file. How you do it is up to you, in the Asset Editor you'll need to switch to the Common tab.\
+I'll assume you know how colorize or change the hue of an image, so go ahead and do that now and save it as `Blue_Fire.png`.
+
+The other assets used in this guide are `Common/VFX/Fire/Fire.blockymodel` and `Common/Blocks/Animations/Fire/Fire_Burn.blockyanim` (both renamed to `Blue_Fire`) but since we won't be changing them it's probably fine to leave them. I will reference the `Blue_Fire` versions as a way to point out what should be custom assets.\
+I will also duplicate `Server/Item/Item/Deco/Deco_Fire.json` and call it `Deco_Blue_Fire.json`.
+
+## Applying the changes
+
+The `Deco_Blue_Fire` block is actually just a particle emitter, however we will not be using particles, so lets start by removing them in `Block > Particles`.\
+Next we want to set the Block Model (called `CustomModel` in JSON) to `VFX/Blue_Fire/Blue_Fire.blockymodel` and Block Model Textures (`CustomModelTexture` in JSON) to
+
+```json
+[
+    {
+        "Texture": "VFX/Blue_Fire/Blue_Fire.png",
+        "Weight": 1
+    }
+]
+```
+
+Finally, we will apply the .blockyanim to our model, this is done through the Block Model Animation property (`CustomModelAnimation` in JSON) and the value should be `Blocks/Animations/Blue_Fire/Blue_Fire_Burn.blockyanim`.
+
+## Final Code
+
+With that your new blue fire should be done. Here is the minimal JSON for our blue fire.\
+There is an additional `Looping` and `RequiresAlphaBlending` property that I have not gone over, however I hope it is self-explanatory.
+
+```json
+{
+  "BlockType": {
+    "DrawType": "Model",
+    "CustomModel": "VFX/Blue_Fire/Blue_Fire.blockymodel",
+    "CustomModelAnimation": "Blocks/Animations/Blue_Fire/Blue_Fire_Burn.blockyanim",
+    "CustomModelTexture": [
+      {
+        "Texture": "VFX/Blue_Fire/Blue_Fire.png",
+        "Weight": 1
+      }
+    ],
+    "Looping": true,
+    "RequiresAlphaBlending": false
+  },
+  "PlayerAnimationsId": "Block"
+}
+```
+
+<Files>
+  <Folder name="resources" defaultOpen>
+    <Folder name="Server" defaultOpen>
+      <Folder name="Item" defaultOpen>
+        <Folder name="Items" defaultOpen>
+          <Folder name="Deco" defaultOpen>
+            <File name="Deco_Blue_Fire.json" />
+          </Folder>
+        </Folder>
+      </Folder>
+    </Folder>
+
+    <Folder name="Common" defaultOpen>
+      <Folder name="Blocks" defaultOpen>
+        <Folder name="Animations" defaultOpen>
+          <Folder name="Blue_Fire" defaultOpen>
+            <File name="Blue_Fire_Burn.blockyanim" />
+          </Folder>
+        </Folder>
+      </Folder>
+
+      <Folder name="VFX" defaultOpen>
+        <Folder name="Blue_Fire" defaultOpen>
+          <File name="Blue_Fire.blockymodel" />
+
+          <File name="Blue_Fire.png" />
+        </Folder>
+      </Folder>
+    </Folder>
+  </Folder>
+</Files>
+
+## Next steps
+
+Now that you know how to attach an animation to a block, try adding it to a block state.
diff --git a/content/docs/lt-LT/guides/plugin/build-and-test.mdx b/content/docs/lt-LT/guides/plugin/build-and-test.mdx
index 0e7fe7eb..f37534c3 100644
--- a/content/docs/lt-LT/guides/plugin/build-and-test.mdx
+++ b/content/docs/lt-LT/guides/plugin/build-and-test.mdx
@@ -9,18 +9,18 @@ If you followed along with the [Setting Up Your Development Environment](./setti
 
 ## Building Your Mod
 
-In our case, we've **Maven** as the build system. Maven is a powerful build automation tool that manages dependencies, compiles your code, and packages everything into a distributable JAR file.
+In our case, we've **Gradle** as the build system. Gradle is a powerful build automation tool that manages dependencies, compiles your code, and packages everything into a distributable JAR file.
 
-### Understanding Maven
+### Understanding Gradle
 
-Maven uses a `pom.xml` file (Project Object Model) to define your project's configuration, dependencies, and build settings. You can learn more about Maven at the [official Apache Maven website](https://maven.apache.org/).
+Gradle can use a `build.gradle.kts` file (Kotlin DSL) to define your project's configuration, dependencies, and build settings. You can learn more about Gradle at the [official Gradle website](https://gradle.org/).
 
-### Building with Maven
+### Building with Gradle
 
 To build your mod, open a terminal in your project directory and run:
 
 ```bash
-mvn package
+./gradlew build
 ```
 
 This command will:
@@ -29,16 +29,35 @@ This command will:
 2. Run any tests (if present)
 3. Package everything into a JAR file
 
+<Callout type="info">
+  If you are using the plugin template from the [Setting Up Your Development Environment](./setting-up-env) guide, then the build script is already set up for you. It includes paths to your Hytale game library and handles the packaging of your mod, managing hytale dependencies and manifest changes.
+
+  If you have a different path to your Hytale installation, you may receive the following error:
+
+  ```bash
+  FAILURE: Build failed with an exception.
+
+  * What went wrong:
+  Failed to find Hytale at the expected location. Please make sure you have installed the game. The expected location can be changed using the hytale.home_path property. Currently looking in 'C:\Path\To\Hytale'
+  ```
+
+  You can change the path by adding a property to your `gradle.properties` file (if it doesn't exist, create it in the root of your project):
+
+  ```properties
+  hytale.home_path=C:\Correct\Path\To\Hytale
+  ```
+</Callout>
+
 ### Build Output
 
-Once the build completes successfully, your mod will be located in the `target` directory and named:
+Once the build completes successfully, your mod will be located in the `build/libs` directory and named:
 
 ```
-ExamplePlugin-1.0-SNAPSHOT.jar
+ExamplePlugin-1.0.jar
 ```
 
 <Callout type="info">
-  The exact name may vary depending on what you configured in your `pom.xml` file. Check the `artifactId` and `version` fields to see what your JAR will be named.
+  The exact name may vary depending on what you configured in your `build.gradle.kts` and `settings.gradle.kts` file. Check the `rootProject.name` and `version` fields to see what your JAR will be named.
 </Callout>
 
 ## Testing Your Mod
@@ -49,11 +68,11 @@ Now that you've built your mod, it's time to test it in Hytale!
 
 First, you need to find Hytale's mods directory:
 
-1. Press **Win + R** on your keyboard
-2. Type `%appdata%` and press Enter
-3. Navigate to: `Hytale\UserData\Mods`
+1. Go to your Hytale installation directory (The default location is usually in your AppData folder)
+   > On Windows, you can access it by clicking `windows + R` and typing `%appdata%`.
+2. Navigate to: `/UserData/Mods`
 
-The full path should look like:
+The default path would look like:
 
 ```
 C:\Users\YourUsername\AppData\Roaming\Hytale\UserData\Mods
@@ -65,7 +84,7 @@ C:\Users\YourUsername\AppData\Roaming\Hytale\UserData\Mods
 
 ### 2. Copy Your Mod
 
-Copy the `ExamplePlugin-1.0-SNAPSHOT.jar` file from your project's `target` directory into the `Mods` folder you just located.
+Copy the `ExamplePlugin-1.0.jar` file from your project's `build/libs` directory into the `Mods` folder you just located.
 
 ### 3. Launch Hytale and Verify
 
@@ -84,7 +103,7 @@ If your mod doesn't appear in the mods list:
 - Make sure the JAR file is in the correct `Mods` folder
 - Check that your `manifest.json` file is properly configured
 - Look for any error messages in the Hytale logs
-- Verify that you're using the correct version of Java and Maven
+- Verify that you're using the correct version of Java and Gradle
 
 ## Next Steps
 
diff --git a/content/docs/lt-LT/guides/plugin/creating-commands.mdx b/content/docs/lt-LT/guides/plugin/creating-commands.mdx
index d33597f3..08572f16 100644
--- a/content/docs/lt-LT/guides/plugin/creating-commands.mdx
+++ b/content/docs/lt-LT/guides/plugin/creating-commands.mdx
@@ -8,6 +8,8 @@ authors:
     url: https://oskar.scot
   - name: jacobwojoski
     url: https://github.com/jacobwojoski
+  - name: Marcel-TO
+    url: https://marcel-to.net
 ---
 
 In this guide, you will learn how to create custom commands for your Hytale mod.
@@ -36,7 +38,7 @@ The most basic command is an `AbstractAsyncCommand`. It has very minimal data av
   `AbstractAsyncCommand` runs on its own background thread. This means its execute is not tied to any world instance and because of this it can not edit any **Stores** or **Refs** without getting the desired world first. To access this data any of the other command types would be preferred and are likely what you will want to use instead.
 </Callout>
 
-The main purpose for a command like this would be for something that can happen everywhere and is not tied to a specific world. For example a `serverRules` command to tell the user thats running the command in chat what the servers rules are nomatter what world they are in.
+The main purpose for a command like this would be for something that can happen everywhere and is not tied to a specific world. For example a `serverRules` command to tell the user that's running the command in chat what the server's rules are no matter what world they are in.
 
 ```java
 // Command that can be run that lists the server rules in chat to the player
@@ -49,7 +51,7 @@ public class ServerRulesCommand extends AbstractAsyncCommand {
     }
 
     // Run the command
-    // conetext - info about who ran the command. Server console?, Some player?
+    // context - info about who ran the command. Server console?, Some player?
     @Override
     protected CompletableFuture<Void> executeAsync(@Nonnull CommandContext context) {
         context.sendMessage(Message.raw("The only rule is there are no rules."));
@@ -134,7 +136,7 @@ Uses a Ray to see what the player is looking at and tries to run the command on
 
 ## Adding Arguments
 
-Arguments are additional fields that the user can input when running a command. The different types of arguments along with small snipits and a large example can be seen below.
+Arguments are additional fields that the user can input when running a command. The different types of arguments along with small snippets and a large example can be seen below.
 
 ### Command Argument Types
 
@@ -163,14 +165,14 @@ this.messageArg = this.withOptionalArg("message", "Message to print while healin
 
 ### Default Arguments
 
-Adding a default argument has two additional arguemnt for the default value and default value description. You need to use `withDefaultArg` method.
+Adding a default argument has two additional argument for the default value and default value description. You need to use `withDefaultArg` method.
 
 ```java
 // args <Command String> <Description> <Default Value> <Desc of default value>
 this.healthArg = this.withDefaultArg("health", "Amount to heal player", ArgTypes.FLOAT, (float)100, "Desc of Default: 100");
 ```
 
-### Flag Arguemnts
+### Flag Arguments
 
 Similar as above but the flags return is either true if it exists or false if it does not. You need to use `withFlagArg` method.
 
@@ -181,20 +183,13 @@ this.debugArg = this.withFlagArg("debug", "Add debug logs");
 
 ### ArgTypes
 
-The following ArgTypes are available (only lists common types):
-
-- `ArgTypes.STRING`
-- `ArgTypes.INTEGER`
-- `ArgTypes.BOOLEAN`
-- `ArgTypes.FLOAT`
-- `ArgTypes.DOUBLE`
-- `ArgTypes.UUID`
+You can find all the available argument types on the [ArgTypes](../../argtypes) page.
 
 ### Example Command Arg Types
 
-Shows all Command arguemnt types with different various input types.
+Shows all Command argument types with different various input types.
 
-**NOTE:** When getting the value of an argument during execute you need to pass the context with `someArg.get(commandContext)`. Where `commandContext` is the first variable in the execute funtion.
+**NOTE:** When getting the value of an argument during execute you need to pass the context with `someArg.get(commandContext)`. Where `commandContext` is the first variable in the execute function.
 
 ```java
 // Example usage: /healplayer --health 50 --message "Feels Good" --debug
@@ -204,7 +199,7 @@ public class HealPlayerCommand extends AbstractTargetPlayerCommand {
     private final FlagArg debugArg;
 
     public HealPlayerCommand() {
-        super("healplayer", "Healing a player for an <input> ammount of HP (default: 100)");
+        super("healplayer", "Healing a player for an <input> amount of HP (default: 100)");
 
         // Abstract TargetPlayerCommand passes the player that ran the command by default and implements
         // the use of `--player <value>` to specify someone else
@@ -213,10 +208,10 @@ public class HealPlayerCommand extends AbstractTargetPlayerCommand {
         this.healthArg = this.withDefaultArg("health", "Amount to heal player", ArgTypes.FLOAT, (float)100, "Desc of Default: 100");
 
         // Or you could do the following making the health value required instead of with a default.
-        //    You would need to change the decleration to RequiredArg<Float>
+        //    You would need to change the declaration to RequiredArg<Float>
         // this.healthArg = this.withRequiredArg("health", "Amount to heal player", ArgTypes.FLOAT);
 
-        // Optional args reguare the user the input `--<key> <value>` so the following would require `--message "Good Luck"`
+// Optional args require the user the input `--<key> <value>` so the following would require `--message "Good Luck"`
         this.messageArg = this.withOptionalArg("message", "Message to print while healing", ArgTypes.STRING);
 
         // No type needed due to being a bool
@@ -230,7 +225,7 @@ public class HealPlayerCommand extends AbstractTargetPlayerCommand {
             commandContext.sendMessage(Message.raw("We are debugging"));
         }
 
-        // Health is stored in a generic stat map to allowing mods/future contect to easily add more stats if desired.
+        // Health is stored in a generic stat map to allowing mods/future content to easily add more stats if desired.
         EntityStatMap stats = store.getComponent(ref, EntityStatMap.getComponentType());
         int healthIdx = DefaultEntityStatTypes.getHealth();
         EntityStatValue health = stats.get(healthIdx);
@@ -252,7 +247,7 @@ public class HealPlayerCommand extends AbstractTargetPlayerCommand {
 
 ## Argument Validators
 
-Argument validators are a way to check the command before the command gets executed. They are added with the `addValidator` method on an argument when calling `withXxxArg`. They provide a nice output to the user when an input value is invalid.
+Argument validators are a way to check the command before the command gets executed. They are added with the `addValidator` method on an argument when calling `withXxxArg`. They provide a nice output to the user when an input value is invalid. There are some common validators provided in the `Validators` class such as `greaterThan`, `lessThan`, and `or`, `max`, `range`, etc.
 
 ```java
 ...
@@ -260,18 +255,59 @@ Argument validators are a way to check the command before the command gets execu
     OptionalArg<Integer> healAmount = withOptionalArg("amount", "Heal Amount", ArgTypes.INTEGER)
         .addValidator(Validators.greaterThan(0))
         .addValidator(Validators.lessThan(1000));
-
-    // Custom check example
-    OptionalArg<Integer> healAmount = withOptionalArg("amount", "Heal Amount", ArgTypes.INTEGER)
-            .addValidator( value -> {
-                if (value != null && value <= 0) {
-                    return ValidationResult.error("ammount argument must be a positive number");
-                }
-                return ValidationResult.success();
-            });
 ...
 ```
 
+### Custom Validators
+
+You can also create custom validators by implementing the `com.hypixel.hytale.codec.validation.Validator` interface. The interfaces forces you to implement the `accept` and `updateSchema` method. The `accept` method takes in the argument value and validates it. If the validation fails, you can use the `fail` method of the `com.hypixel.hytale.codec.validation.ValidationResults` class to return an error message.
+The `updateSchema` method is used to update the schema of the command argument. This is used for commands that have dynamic schemas based on the input value. For example, if you have a command that takes in a player name as an argument, you can use the `updateSchema` method to update the schema to include a list of online players for validation.
+
+Here is an example of a custom validator that checks if a string value is equal to a banned word. In this example, the banned word is "badword". If the input value is "badword", the validator will fail and return an error message.
+
+```java
+import com.hypixel.hytale.codec.schema.SchemaContext;
+import com.hypixel.hytale.codec.schema.config.Schema;
+import com.hypixel.hytale.codec.validation.ValidationResults;
+import com.hypixel.hytale.codec.validation.Validator;
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+
+public class MyCustomValidator implements Validator<String> {
+    @Nonnull
+    private final String value;
+
+    public MyCustomValidator(@Nonnull String value) {
+        this.value = value;
+    }
+
+    @Override
+    public void accept(@Nullable String input, @Nonnull ValidationResults results) {
+        if (this.value.equalsIgnoreCase(input)) {
+            results.fail("The given role has been banned.");
+        }
+    }
+
+    @Override
+    public void updateSchema(SchemaContext context, @Nonnull Schema target) {
+        // This method can be used to update the schema of the command argument. This is useful for commands that have dynamic schemas based on the input value. For example, if you have a command that takes in a player name as an argument, you can use the `updateSchema` method to update the schema to include a list of online players for validation.
+        throw new UnsupportedOperationException("Not implemented yet.");
+    }
+}
+```
+
+After the custom validator is created, you can add it to an argument like the following example. In this example, we add the `MyCustomValidator` to a string argument called "role". If the user inputs "badword" as the role, the command will fail and return the error message defined in the `MyCustomValidator`.
+
+```java
+    ...
+    // Custom validator example
+    String bannedRole = "badword";
+
+    OptionalArg<String> roleArg = withOptionalArg("role", "Role to assign", ArgTypes.STRING)
+        .addValidator(new MyCustomValidator(bannedRole));
+    ...
+```
+
 ---
 
 ## Permissions
@@ -312,7 +348,7 @@ This allows the server to control who has access to specific commands. You add t
 
 If you want variants of the same command without doing argument parsing you can instead use `addUsageVariant(new OtherCommandClass())` in the original commands constructor.
 
-The only difference is in the `OtherCommandClass()` constrcutor you don't pass the command name to the super class.
+The only difference is in the `OtherCommandClass()` constructor you don't pass the command name to the super class.
 
 <Callout type="info">
   You can also use `addAliases("some_alias", "some_other_alias")` as a way to add shorthand or other ways to write the same command.
@@ -387,7 +423,7 @@ public class AdminCommand extends AbstractCommandCollection {
     public AdminCommand () {
         super("admin", "Admin commands");
         addSubCommand(new UserCommandCollection());
-        addSybCommand(new ServerCommandCollection);
+        addSubCommand(new ServerCommandCollection);
     }
 }
 ```
@@ -417,5 +453,5 @@ public class MyPlugin extends JavaPlugin {
 
 ## Video Link
 
-_Special Thanks to [TroubleDev](https://www.youtube.com/@TroubleDEV) for his excelent video guide on all of these features._
+_Special Thanks to [TroubleDev](https://www.youtube.com/@TroubleDEV) for his excellent video guide on all of these features._
 _Video Link: [TroubleDev - Hytale's Command API Explained](https://www.youtube.com/watch?v=KnmhG9MDMgo)_
diff --git a/content/docs/lt-LT/guides/plugin/creating-events.mdx b/content/docs/lt-LT/guides/plugin/creating-events.mdx
index 95863990..d3f0925d 100644
--- a/content/docs/lt-LT/guides/plugin/creating-events.mdx
+++ b/content/docs/lt-LT/guides/plugin/creating-events.mdx
@@ -1,6 +1,6 @@
 ---
-title: Creating Events
-description: Learn how to create custom events for your Hytale mod.
+title: Creating Events Listeners
+description: Learn how to create event listeners for your Hytale mod.
 authors:
   - name: Neil Revin
     url: https://itsneil.dev
@@ -10,7 +10,7 @@ authors:
 
 ## Event Class
 
-You can import a Event class and create a function with the Event as a argument. [Click here](../../server/events) to look at all available events.
+You can import an Event class and create a function with the Event as an argument. [Click here](../../server/events) to look at all available events.
 
 Example plugin when a player is ready (joins a server):
 
diff --git a/content/docs/lt-LT/guides/plugin/item-registry.mdx b/content/docs/lt-LT/guides/plugin/item-registry.mdx
new file mode 100644
index 00000000..9a0fd53a
--- /dev/null
+++ b/content/docs/lt-LT/guides/plugin/item-registry.mdx
@@ -0,0 +1,95 @@
+---
+title: Working with the Item Registry
+description: Learn how to access and query the game's item registry to list all items, check if items exist, and retrieve item properties.
+authors:
+  - name: Denis
+---
+
+In this guide, you'll learn how to work with Hytale's Item Registry system. This is useful when you need to programmatically list all available items, validate item IDs, or retrieve item properties at runtime.
+
+## Prerequisites
+
+Before diving in, you should be familiar with:
+
+- [Setting up your development environment](./setting-up-env)
+- [Creating commands](./creating-commands) (optional, for testing)
+
+## Required Imports
+
+To work with the Item Registry, you'll need the following imports:
+
+```java
+import com.hypixel.hytale.assetstore.map.DefaultAssetMap;
+import com.hypixel.hytale.server.core.asset.type.item.config.Item;
+```
+
+## Getting the Item Registry
+
+The Item Registry is accessed through the `Item.getAssetMap()` method, which returns a `DefaultAssetMap<String, Item>` containing all registered items in the game:
+
+```java
+DefaultAssetMap<String, Item> itemMap = Item.getAssetMap();
+```
+
+## Listing All Items
+
+To iterate through all items in the registry, you can get the underlying map and loop through its entries:
+
+```java
+DefaultAssetMap<String, Item> itemMap = Item.getAssetMap();
+var map = itemMap.getAssetMap();
+
+for (var entry : map.entrySet()) {
+    String itemId = String.valueOf(entry.getKey());
+    Item item = entry.getValue();
+    
+    // Do something with the item
+    LOGGER.atInfo().log("Item ID: " + itemId);
+}
+```
+
+You can also get the total count of registered items:
+
+```java
+int totalItems = map.size();
+```
+
+## Checking if an Item Exists
+
+To check if a specific item exists in the registry, use `getAsset()` and verify the result:
+
+```java
+public boolean itemExists(String itemId) {
+    var assetMap = Item.getAssetMap();
+    if (assetMap != null) {
+        Item item = assetMap.getAsset(itemId);
+        return item != null && item != Item.UNKNOWN;
+    }
+    return false;
+}
+```
+
+<Callout type="info">
+  The `Item.UNKNOWN` constant represents an invalid or unrecognized item. Always check for both `null` and `Item.UNKNOWN` when validating items.
+</Callout>
+
+## Accessing Item Properties
+
+Once you have an `Item` instance, you can access various properties:
+
+```java
+var assetMap = Item.getAssetMap();
+Item item = assetMap.getAsset("Soil_Grass");
+
+if (item != null && item != Item.UNKNOWN) {
+    String id = item.getId(); // Soil_Grass
+    int maxStack = item.getMaxStack(); // 100
+    boolean isBlock = item.hasBlockType(); // true
+    boolean isConsumable = item.isConsumable(); // false
+}
+```
+
+## Related Guides
+
+- [Inventory Management](./inventory-management) - Learn how to add and remove items from player inventories
+- [Create Custom Item and Interaction](./item-interaction) - Learn how to create your own custom items
diff --git a/content/docs/lt-LT/guides/plugin/permission-management.mdx b/content/docs/lt-LT/guides/plugin/permission-management.mdx
index 6b7cfd46..55f06101 100644
--- a/content/docs/lt-LT/guides/plugin/permission-management.mdx
+++ b/content/docs/lt-LT/guides/plugin/permission-management.mdx
@@ -10,132 +10,569 @@ authors:
     link: https://discord.com/users/292656109939064833
   - name: Ivan
     link: https://discord.com/users/505770451218333717
+  - name: ZenithDevHQ
+    link: https://github.com/ZenithDevHQ
 ---
 
-In this guide, you'll learn how to manage permission nodes and groups in your Hytale plugin.
+In this guide, you'll learn how to manage permission nodes and groups in your Hytale plugin. Permissions control what actions players can perform on your server, from basic commands to advanced administrative functions.
 
-## The `PermissionsModule` class
+## What Are Permissions?
 
-The `PermissionsModule` class is responsible for managing permission nodes and groups in your plugin. It provides methods to check, grant and revoke permissions and groups for players. It allows the following operations
+Permissions are string identifiers that control access to features and commands. When a player tries to perform an action (like using a command), the server checks if they have the required permission.
 
-- Add permissions to user
-- Remove permissions from user
-- Add permissions to group (this also creates the group if it doesn't exist)
-- Remove permissions from group
-- Add user to group
-- Remove user from group
-- List all groups for a user
-- Check if a user has a permission (it checks both user and group permissions for the given player UUID)
+**Example permission nodes:**
 
-With this class you cannot:
+- `hytale.command.gamemode` - Permission to use the gamemode command
+- `hytale.editor.brush.use` - Permission to use brush tools
+- `myplugin.teleport.home` - A custom permission for your plugin
 
-- List all defined groups
-- Remove a group
+Permissions follow a hierarchical naming pattern: `namespace.category.action`
 
-### Adding Permission Nodes
+## Key Concepts
 
-You need a `Set<String>` containing all the permission nodes you want to add, these are added on top of the already existing permission nodes the user may have, it is not a replacement.
+Before diving into code, let's understand the core concepts:
+
+| Concept             | Description                                                                |
+| ------------------- | -------------------------------------------------------------------------- |
+| **Permission Node** | A string like `myplugin.feature.use` that represents a specific permission |
+| **Group**           | A named collection of permissions (e.g., "Admin", "VIP", "Default")        |
+| **Provider**        | The backend that stores and retrieves permissions                          |
+| **Wildcard**        | A pattern like `*` or `myplugin.*` that matches multiple permissions       |
+
+### How Permissions Are Checked
+
+When checking if a player has a permission, Hytale follows this order:
+
+1. **User's direct permissions** - Permissions granted directly to the player
+2. **Group permissions** - Permissions from groups the player belongs to
+3. **Virtual groups** - Game-mode-based permissions (e.g., Creative mode grants builder tools)
+4. **Default value** - Falls back to `false` if no match found
+
+<Callout type="info">
+  The first definitive match wins. If a player has a permission granted at the user level, group permissions won't override it.
+</Callout>
+
+---
+
+## The `PermissionsModule` Class
+
+The `PermissionsModule` class is the central hub for managing permissions. Access it using the singleton pattern:
 
 ```java
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.addUserPermission(playerUUID, permissions);
 ```
 
-### Removing Permission Nodes
+### Available Operations
+
+The module supports these operations:
+
+| Operation                     | Method                                          |
+| ----------------------------- | ----------------------------------------------- |
+| Add permissions to user       | `addUserPermission(uuid, permissions)`          |
+| Remove permissions from user  | `removeUserPermission(uuid, permissions)`       |
+| Add permissions to group      | `addGroupPermission(groupName, permissions)`    |
+| Remove permissions from group | `removeGroupPermission(groupName, permissions)` |
+| Add user to group             | `addUserToGroup(uuid, groupName)`               |
+| Remove user from group        | `removeUserFromGroup(uuid, groupName)`          |
+| Get user's groups             | `getGroupsForUser(uuid)`                        |
+| Check permission              | `hasPermission(uuid, permissionNode)`           |
+
+<Callout type="warning">
+  The module does **not** support:
+
+  - Listing all defined groups
+  - Deleting a group entirely
+
+  Groups are implicitly created when you first add permissions to them.
+</Callout>
+
+---
 
-Same as above, we just use the `removeUserPermission` method instead to remove permission nodes.
+## Checking Permissions
+
+The most common operation is checking if a player has a permission.
+
+### Basic Permission Check
+
+```java
+// Returns true if player has the permission, false otherwise
+boolean canUse = PermissionsModule.get().hasPermission(playerUUID, "myplugin.feature.use");
+
+if (canUse) {
+    // Player has permission, allow the action
+} else {
+    // Player lacks permission, deny or show error
+}
+```
+
+### Permission Check with Default Value
+
+You can specify what to return when no permission is explicitly set:
+
+```java
+// Returns true by default if no explicit permission is found
+boolean canUse = PermissionsModule.get().hasPermission(playerUUID, "myplugin.feature.use", true);
+```
+
+This is useful for features that should be enabled by default but can be revoked.
+
+### Using PermissionHolder Interface
+
+Players and command senders implement `PermissionHolder`, allowing direct checks:
+
+```java
+// In a command or event handler where you have access to the player
+if (player.hasPermission("myplugin.admin.manage")) {
+    // Player has admin permission
+}
+```
+
+---
+
+## Managing User Permissions
+
+### Adding Permissions to a User
+
+Permissions are additive - new permissions are added on top of existing ones, not replaced.
+
+```java
+PermissionsModule perms = PermissionsModule.get();
+
+// Add a single permission
+perms.addUserPermission(playerUUID, Set.of("myplugin.vip.chat"));
+
+// Add multiple permissions at once
+Set<String> newPerms = Set.of(
+    "myplugin.vip.chat",
+    "myplugin.vip.fly",
+    "myplugin.vip.kit"
+);
+perms.addUserPermission(playerUUID, newPerms);
+```
+
+### Removing Permissions from a User
 
 ```java
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.removeUserPermission(playerUUID, permissions);
+
+// Remove specific permissions
+Set<String> toRemove = Set.of("myplugin.vip.fly");
+perms.removeUserPermission(playerUUID, toRemove);
 ```
 
-### Add permissions to group
+---
+
+## Managing Groups
+
+Groups let you assign a collection of permissions to multiple players. This is more manageable than assigning permissions individually.
+
+### Adding Permissions to a Group
+
+If the group doesn't exist, it will be created automatically.
 
 ```java
-String groupName = "testGroup";
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.addGroupPermission(groupName, permissions);
+
+// Create/update the "VIP" group with permissions
+Set<String> vipPerms = Set.of(
+    "myplugin.vip.chat",
+    "myplugin.vip.fly",
+    "myplugin.vip.kit"
+);
+perms.addGroupPermission("VIP", vipPerms);
 ```
 
-### Remove permissions from group
+### Removing Permissions from a Group
 
 ```java
-String groupName = "testGroup";
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.removeGroupPermission(groupName, permissions);
+
+// Remove specific permissions from the group
+Set<String> toRemove = Set.of("myplugin.vip.fly");
+perms.removeGroupPermission("VIP", toRemove);
 ```
 
-### Add user to group
+### Adding a User to a Group
 
 ```java
-String groupName = "testGroup";
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.addUserToGroup(playerUUID, groupName);
+
+// Add player to the VIP group - they now have all VIP permissions
+perms.addUserToGroup(playerUUID, "VIP");
 ```
 
-### Remove user from group
+### Removing a User from a Group
 
 ```java
-String groupName = "testGroup";
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.removeUserFromGroup(playerUUID, groupName);
+
+// Remove player from VIP group
+perms.removeUserFromGroup(playerUUID, "VIP");
 ```
 
-### List all groups for a user
+### Getting a User's Groups
 
 ```java
 PermissionsModule perms = PermissionsModule.get();
-perms.getGroupsForUser(playerUUID);
+
+// Get all groups the player belongs to
+Set<String> groups = perms.getGroupsForUser(playerUUID);
+
+for (String group : groups) {
+    System.out.println("Player is in group: " + group);
+}
 ```
 
-### Check Permission Nodes
+---
+
+## Built-in Groups
+
+Hytale includes two default groups:
+
+| Group     | Default Permissions   | Purpose                           |
+| --------- | --------------------- | --------------------------------- |
+| `OP`      | `*` (all permissions) | Server operators with full access |
+| `Default` | None                  | Base group for all players        |
+
+Players without any explicit group assignment are automatically part of the `Default` group.
 
-To check if a player has a specific permission node, you can use the `hasPermission` method.
+---
+
+## Wildcards
+
+Wildcards let you grant or deny multiple permissions with a single pattern.
+
+### Wildcard Patterns
+
+| Pattern             | Meaning                                          |
+| ------------------- | ------------------------------------------------ |
+| `*`                 | Grants **all** permissions                       |
+| `myplugin.*`        | Grants all permissions starting with `myplugin.` |
+| `-*`                | Denies **all** permissions                       |
+| `-myplugin.admin.*` | Denies all admin permissions in your plugin      |
+
+### Example: Admin Group with Wildcards
 
 ```java
-boolean hasPermission = PermissionsModule.hasPermission(playerUUID, "permission.node");
+// Grant all permissions to admins
+perms.addGroupPermission("Admin", Set.of("*"));
+
+// Grant all plugin permissions to moderators
+perms.addGroupPermission("Moderator", Set.of("myplugin.*"));
+
+// Grant all permissions except admin commands
+perms.addGroupPermission("Helper", Set.of(
+    "*",
+    "-myplugin.admin.*"  // Deny admin permissions
+));
 ```
 
-## Additional: Defining your own provider for permissions and groups
+<Callout type="warning">
+  Negation permissions (starting with `-`) take precedence at each level. Use them carefully to avoid accidentally blocking permissions.
+</Callout>
+
+---
+
+## Built-in Permission Nodes
+
+Hytale provides constants for common permissions in the `HytalePermissions` class:
+
+### Command Permissions
+
+```java
+// Generate permission for a command
+String perm = HytalePermissions.fromCommand("gamemode");
+// Result: "hytale.command.gamemode"
+
+// Generate permission for a subcommand
+String perm = HytalePermissions.fromCommand("gamemode", "creative");
+// Result: "hytale.command.gamemode.creative"
+```
+
+### Common Permission Nodes
+
+| Permission                    | Description                  |
+| ----------------------------- | ---------------------------- |
+| `hytale.command.op.add`       | Add players to OP group      |
+| `hytale.command.op.remove`    | Remove players from OP group |
+| `hytale.editor.brush.use`     | Use brush tools              |
+| `hytale.editor.prefab.use`    | Use prefabs                  |
+| `hytale.editor.selection.use` | Use selection tools          |
+| `hytale.editor.history`       | Undo/redo operations         |
+| `hytale.camera.flycam`        | Use fly camera mode          |
+
+---
+
+## Listening to Permission Events
+
+You can react to permission changes using Hytale's event system.
+
+### Available Events
+
+| Event                                            | Triggered When                   |
+| ------------------------------------------------ | -------------------------------- |
+| `PlayerPermissionChangeEvent.PermissionsAdded`   | Permissions added to a user      |
+| `PlayerPermissionChangeEvent.PermissionsRemoved` | Permissions removed from a user  |
+| `PlayerGroupEvent.Added`                         | User added to a group            |
+| `PlayerGroupEvent.Removed`                       | User removed from a group        |
+| `GroupPermissionChangeEvent.Added`               | Permissions added to a group     |
+| `GroupPermissionChangeEvent.Removed`             | Permissions removed from a group |
 
-The PermissionsModule also enables us to define our own PermissionProvider's, this can be useful for:
+### Example: Reacting to Permission Changes
 
-- Cross server permission systems
-- Implementing features missing in the `HytalePermissionsProvider` like permission expiry
+```java
+public class PermissionListener {
+
+    public static void onPermissionsAdded(PlayerPermissionChangeEvent.PermissionsAdded event) {
+        UUID playerUUID = event.getPlayerUuid();
+        Set<String> added = event.getAddedPermissions();
+
+        System.out.println("Permissions added to " + playerUUID + ": " + added);
 
-To implement our PermissionProvider, first we need to define a provider class that implements PermissionProvider:
+        // Maybe notify the player or update cached data
+    }
+
+    public static void onGroupAdded(PlayerGroupEvent.Added event) {
+        UUID playerUUID = event.getPlayerUuid();
+        String groupName = event.getGroupName();
+
+        System.out.println("Player " + playerUUID + " joined group: " + groupName);
+    }
+}
+```
+
+### Registering the Events
 
 ```java
-public class DatabasePermissionProvider implements PermissionProvider
+public class MyPlugin extends JavaPlugin {
+
+    @Override
+    public void setup() {
+        EventRegistry events = this.getEventRegistry();
+
+        events.registerGlobal(
+            PlayerPermissionChangeEvent.PermissionsAdded.class,
+            PermissionListener::onPermissionsAdded
+        );
+
+        events.registerGlobal(
+            PlayerGroupEvent.Added.class,
+            PermissionListener::onGroupAdded
+        );
+    }
+}
 ```
 
-Then we just implement the required methods using a database implementation.
+---
+
+## Creating a Custom Permission Provider
+
+For advanced use cases, you can create your own permission provider. This is useful for:
+
+- Database-backed permissions (MySQL, MongoDB, etc.)
+- Cross-server permission synchronization
+- Custom features like permission expiry or contexts
+
+### Implementing PermissionProvider
+
+```java
+public class DatabasePermissionProvider implements PermissionProvider {
+
+    @Nonnull
+    @Override
+    public String getName() {
+        return "DatabasePermissionProvider";
+    }
+
+    // User permission methods
+    @Override
+    public void addUserPermissions(@Nonnull UUID uuid, @Nonnull Set<String> permissions) {
+        // Save to your database
+    }
+
+    @Override
+    public void removeUserPermissions(@Nonnull UUID uuid, @Nonnull Set<String> permissions) {
+        // Remove from your database
+    }
+
+    @Override
+    public Set<String> getUserPermissions(@Nonnull UUID uuid) {
+        // Query your database
+        return Set.of();
+    }
+
+    // Group permission methods
+    @Override
+    public void addGroupPermissions(@Nonnull String group, @Nonnull Set<String> permissions) {
+        // Save to your database
+    }
+
+    @Override
+    public void removeGroupPermissions(@Nonnull String group, @Nonnull Set<String> permissions) {
+        // Remove from your database
+    }
+
+    @Override
+    public Set<String> getGroupPermissions(@Nonnull String group) {
+        // Query your database
+        return Set.of();
+    }
+
+    // User-group membership methods
+    @Override
+    public void addUserToGroup(@Nonnull UUID uuid, @Nonnull String group) {
+        // Save to your database
+    }
+
+    @Override
+    public void removeUserFromGroup(@Nonnull UUID uuid, @Nonnull String group) {
+        // Remove from your database
+    }
+
+    @Override
+    public Set<String> getGroupsForUser(@Nonnull UUID uuid) {
+        // Query your database
+        return Set.of("Default");
+    }
+}
+```
 
 <Callout type="warning">
-  Hytale will try to use the first available permissions provider to add/remove gamemode groups (i.e. `Creative`, `Adventure`).
+  Hytale automatically assigns players to game-mode groups (like `Creative` or `Adventure`) using the first available provider.
+
+  If your provider throws an error when the group doesn't exist, the player will be disconnected! Always handle missing groups gracefully.
+</Callout>
+
+### Registering Your Provider
 
-  If your provider throws an error (for instance, if the group does not exist) when the server is preparing the player, the player will be disconnected.
+```java
+public class MyPlugin extends JavaPlugin {
+
+    @Override
+    public void setup() {
+        // Add your provider alongside the default one
+        PermissionsModule.get().addProvider(new DatabasePermissionProvider());
+    }
+}
+```
+
+The `PermissionsModule` aggregates permissions from all registered providers. This means:
+
+- Permission checks query all providers
+- Write operations (add/remove) use the **first** provider
+
+### Replacing the Default Provider
+
+If you want full control, you can remove the default provider:
+
+```java
+public class MyPlugin extends JavaPlugin {
+
+    @Override
+    public void setup() {
+        PermissionsModule perms = PermissionsModule.get();
+
+        // Remove the default provider FIRST
+        perms.removeProvider(perms.getFirstPermissionProvider());
+
+        // Then add your provider
+        perms.addProvider(new DatabasePermissionProvider());
+    }
+}
+```
+
+<Callout type="info">
+  When you remove the default provider, the `/op self` command will stop working since it checks for provider tampering.
 </Callout>
 
-We can then register the provider using the built-in permission module:
+---
+
+## Best Practices
+
+### Permission Naming Conventions
+
+Follow the pattern: `namespace.category.action`
 
 ```java
-PermissionsModule.get().addProvider(new DatabasePermissionProvider());
+// Good - clear hierarchy
+"myplugin.admin.ban"
+"myplugin.user.teleport.home"
+"myplugin.vip.chat.color"
+
+// Bad - unclear structure
+"myplugin_ban"
+"teleport"
+"vipChatColor"
 ```
 
-Please note that the `HytalePermissionsProvider` will still be enabled alongside your provider.
-The `PermissionsModule` will aggregate groups and permissions from all available providers.
+### Use Constants for Permissions
 
-If you want to disable the default `HytalePermissionsProvider`, you can use:
+Define your permissions as constants to avoid typos:
 
 ```java
-// put this **before** you add your provider
-PermissionsModule.get().removeProvider(PermissionsModule.get().getFirstPermissionProvider());
+public final class MyPermissions {
+    public static final String ADMIN_BAN = "myplugin.admin.ban";
+    public static final String ADMIN_KICK = "myplugin.admin.kick";
+    public static final String USER_HOME = "myplugin.user.home";
+    public static final String VIP_FLY = "myplugin.vip.fly";
+}
+
+// Usage
+if (player.hasPermission(MyPermissions.ADMIN_BAN)) {
+    // ...
+}
 ```
+
+### Don't Over-Permission
+
+Only create permissions for actions that genuinely need access control. Not everything needs a permission check.
+
+### Thread Safety
+
+If you create a custom provider, ensure it's thread-safe. Permission checks can occur from multiple threads simultaneously. Use `ReadWriteLock` or `ConcurrentHashMap` for your data structures.
+
+---
+
+## In-Game Commands
+
+Hytale provides built-in commands for managing permissions:
+
+### `/op` Command
+
+| Command               | Description                                                        |
+| --------------------- | ------------------------------------------------------------------ |
+| `/op self`            | Toggle your own OP status (singleplayer or with `--allow-op` flag) |
+| `/op add <player>`    | Add a player to the OP group                                       |
+| `/op remove <player>` | Remove a player from the OP group                                  |
+
+### `/perm` Command
+
+Use `/perm --help` in-game for full usage. Common operations:
+
+| Command                                  | Description                   |
+| ---------------------------------------- | ----------------------------- |
+| `/perm user list <uuid>`                 | List user's permissions       |
+| `/perm user add <uuid> <perm>`           | Add permission to user        |
+| `/perm user remove <uuid> <perm>`        | Remove permission from user   |
+| `/perm user group list <uuid>`           | List user's groups            |
+| `/perm user group add <uuid> <group>`    | Add user to group             |
+| `/perm user group remove <uuid> <group>` | Remove user from group        |
+| `/perm group list <group>`               | List group's permissions      |
+| `/perm group add <group> <perm>`         | Add permission to group       |
+| `/perm group remove <group> <perm>`      | Remove permission from group  |
+| `/perm test <perm>`                      | Test if you have a permission |
+
+---
+
+## Summary
+
+You've learned how to:
+
+- **Check permissions** using `PermissionsModule.hasPermission()`
+- **Manage user permissions** with `addUserPermission()` and `removeUserPermission()`
+- **Work with groups** using `addGroupPermission()`, `addUserToGroup()`, etc.
+- **Use wildcards** like `*` and `myplugin.*` for bulk permissions
+- **Listen to events** for permission changes
+- **Create custom providers** for database-backed permissions
+
+For more advanced permission systems with features like inheritance, expiry, and contexts, we're looking into expanding this guide with advanced permission management techniques in the future.
diff --git a/content/docs/lt-LT/guides/plugin/setting-up-env.mdx b/content/docs/lt-LT/guides/plugin/setting-up-env.mdx
index d2718098..5be5e9e0 100644
--- a/content/docs/lt-LT/guides/plugin/setting-up-env.mdx
+++ b/content/docs/lt-LT/guides/plugin/setting-up-env.mdx
@@ -4,6 +4,10 @@ description: Learn how to set up your development environment for modding Hytale
 authors:
   - name: Neil Revin
     link: https://itsneil.dev
+  - name: Marcel-TO
+    url: https://marcel-to.net
+  - name: Ádám Liszkai
+    link: https://adaliszk.dev
 ---
 
 This guide will walk you through setting up a complete development environment for Hytale modding, including all necessary tools and dependencies.
@@ -19,24 +23,73 @@ Before we begin, make sure you have:
 
 ## Required Software
 
-### 1. Java Development Kit (JDK)
+### Integrated Development Environment (IDE)
 
+We recommend IntelliJ IDEA Community Edition for Hytale modding. If you use IntelliJ IDEA, **almost everything is built-in**. You can clone a template, open a new project, and start working right away!
+
+1. Download from [JetBrains website](https://www.jetbrains.com/idea/download/)
+2. Install with default settings
+3. Launch and complete the initial setup wizard
+
+When opening a project, wait for indexing to finish, then start coding.
+Now, IDEA may say "No JDK configured" at the top of the source file you have.
+In that case, you can click Download JDK and choose JetBrains JDK 25.
+
+<Callout type="success">
+  If IDEA opened the project without errors, your environment is ready.
+</Callout>
+
+More details by [JetBrains](https://www.jetbrains.com/help/idea/2026.1/run-for-the-first-time.html)
+help page, where we recommend that you also check the
+[SDK configuration](https://www.jetbrains.com/help/idea/2026.1/sdk.html) guide.
+
+<Callout type="info">
+  We recommened following
+  [TheNullicorn's](https://gist.github.com/TheNullicorn/90a619796c40f20ae1fcf13094c1a57d) guide to ensure
+  you are using the correct `Nonnull` in your projects.
+</Callout>
+
+#### What the IDE Does for You
+
+When opened in IntelliJ IDEA, the project automatically:
+
+- Detects and configures Gradle or Maven
+- Downloads all dependencies
+- Sets up project structure and classpaths
+- Configures run/build tasks
+
+You do **not** need to manually install or configure Maven or Gradle if you stay inside the IDE.
+
+Skip to the [Setting Up Your Workspace](#setting-up-your-workspace).
+
+### Manual Setup: Java Development Kit (JDK)
+
+For any other setup, you will need to install and configure your system to have and load Java.
 Hytale modding requires Java 25 or later. We recommend using OpenJDK.
 
-#### Windows
+#### Windows via Installer
 
 1. Download OpenJDK 25 from [Adoptium](https://adoptium.net/)
 2. Run the installer with default settings
+   - Optionally enable feature `Set or Override JAVA_HOME variable` to resolve version related build issues with your project.
 3. Verify installation by opening Command Prompt and running:
 
+#### Windows via Scoop
+
+1. Install Scoop via PowerShell using [scoop.sh](https://scoop.sh/)
+2. Install OpenJDK 25:
+
 ```bash
-java -version
+scoop bucket add java
+scoop install java/openjdk25
 ```
 
 #### macOS
 
+1. Install Brew via Terminal using [brew.sh](https://brew.sh)
+2. Install JDK via Homebrew:
+
 ```bash
-# Using Homebrew
 brew install openjdk@25
 ```
 
@@ -51,22 +104,41 @@ brew install openjdk@25
 
 #### Linux (Ubuntu/Debian)
 
+1. Install JDK via the built-in package repository:
+
 ```bash
 sudo apt update
 sudo apt install openjdk-25-jdk
 ```
 
-### 2. Integrated Development Environment (IDE)
+### Verify installation:
 
-We recommend IntelliJ IDEA Community Edition for Hytale modding.
+Run the following command to see what version of Java you have:
 
-1. Download from [JetBrains website](https://www.jetbrains.com/idea/download/)
-2. Install with default settings
-3. Launch and complete the initial setup wizard
+```bash
+java -version
+```
+
+### Java Build Tool (Optional)
+
+We recommend using a Gradle Wrapper for managing dependencies and building your Hytale plugins. It provides benefits by eliminating the need for a system-wide Gradle installation and ensuring consistent Gradle versions across different environments. (Alternatively you can use Maven, but this guide focuses on Gradle since it is the default for our plugin template.)
+
+The plugin template in the following sections includes a Gradle Wrapper, so you can skip this step if you plan to use the template.
+
+#### Choosing Gradle (if not using the template)
+
+If you prefer to install Gradle manually, follow these steps:
 
-### 3) Java Build Tool
+1. Visit the official website: https://gradle.org/releases/
+2. Download the newest gradle binary: `gradle-9.3.1-bin.zip` (Binary zip archive)
+3. Unzip it
+4. Add the `gradle-9.3.1/bin/` folder to your PATH
+
+You can now try the command `gradle -version` to verify Gradle is installed correctly. Make sure to do this in a fresh new terminal instead of one you had opened from before!
+
+#### Choosing Maven (if not using the template)
 
-We recommend using Apache Maven for managing dependencies and building your Hytale plugins. (Alternatively you can use Gradle, but this guide focuses on Maven.)
+If you prefer to use Maven instead of Gradle, follow these steps to install Maven:
 
 1. Visit the official website: https://maven.apache.org/download.cgi
 2. Download this file: `apache-maven-3.9.12-bin.zip` (Binary zip archive)
@@ -89,22 +161,61 @@ cd MyFirstMod
 
 If you don't have Git installed, you can download the ZIP file from the repository page and extract it to a folder named `MyFirstMod`.
 
-### 2. Open Plugin in your IDEA
+### 2. Open Plugin in your IDE
 
-1. Open IntelliJ IDEA
+1. Open Your IDE (e.g., IntelliJ IDEA)
 2. Click "Open" and navigate to your `MyFirstMod` directory
-3. IntelliJ will automatically detect it as a Maven project
+3. Most IDEs like IntelliJ will automatically detect it as a Gradle project
 4. Wait for the project to index and dependencies to download
 
-<Callout type="info">
-  We recommened following [this](https://gist.github.com/TheNullicorn/90a619796c40f20ae1fcf13094c1a57d) guide to ensure you are using the correct `Nonnull` in your projects.
-</Callout>
+## Alternate Approach: Hytale Dependency
+
+If you prefer to set up your project from scratch without using the template and importing the hytale dependencies manually, ensure your build configuration includes the Hytale repositories and dependencies:
+
+For Gradle, add the following to your `build.gradle.kts`:
+
+```kotlin
+repositories {
+    mavenCentral()
+    maven {
+        name = "hytale"
+        url = uri("https://maven.hytale.com/release") // Or "hytale-pre-release" for pre-release versions
+    }
+}
+dependencies {
+    // + here means the latest version, but you can hard-wire any known version!
+    implementation("com.hypixel.hytale:Server:+")
+}
+```
+
+For Maven, add the following to your `pom.xml`:
+
+```xml
+<project>
+    <repositories>
+        <repository>
+            <id>hytale-release</id> <!-- Or "hytale-pre-release" for pre-release versions -->
+            <url>https://maven.hytale.com/release</url> <!-- Or "https://maven.hytale.com/pre-release" -->
+        </repository>
+    </repositories>
+
+    <dependencies>
+        <dependency>
+            <groupId>com.hypixel.hytale</groupId>
+            <artifactId>Server</artifactId>
+            <!-- Replace with latest version, Hytale provides jars for the last five releases -->
+            <version>LATEST_VERSION_HERE</version>
+            <scope>provided</scope>
+        </dependency>
+    </dependencies>
+</project>
+```
 
 ## Next Steps
 
 Now that you have your development environment set up with the plugin template:
 
-1. **Customize the template** - Edit the `pom.xml` and `manifest.json` file to change your mod's name and details
+1. **Customize the template** - Edit the `settings.gradle.kts`, `build.gradle.kts` and `manifest.json` file to change your mod's name and details
 2. **Explore the code structure** - Familiarize yourself with the template's organization
 3. **Start modding** - Begin writing your first Hytale plugin!
 
diff --git a/content/docs/lt-LT/guides/plugin/spawning-entities.mdx b/content/docs/lt-LT/guides/plugin/spawning-entities.mdx
index e12c0aea..15be2fb3 100644
--- a/content/docs/lt-LT/guides/plugin/spawning-entities.mdx
+++ b/content/docs/lt-LT/guides/plugin/spawning-entities.mdx
@@ -36,7 +36,7 @@ Store<EntityStore> store = world.getEntityStore().getStore();
 
 ## Creating Entities
 
-Once you have the `EntityStore` instance, you can start to create a entity and give it components. Entities are just instances of `Holder<EntityStore>` with several components attached to them.
+Once you have the `EntityStore` instance, you can start to create an entity and give it components. Entities are just instances of `Holder<EntityStore>` with several components attached to them.
 
 <Callout type="warning">
   To interact with the `World` instance, some methods require you to run the code inside the world's execution context.
@@ -118,3 +118,48 @@ Finally, we can add the entity to the world by calling the `addEntity` method on
 ```java
 store.addEntity(holder, AddReason.SPAWN);
 ```
+
+## Making the entity persist
+
+Hytale automatically saves all entities, but the `NetworkId` component (required for players to be able to see the entity) needs to be manually added every time the entity is loaded.
+
+### Using a system
+
+If you have a component that is unique to your entities, this can be done by creating and registering a custom system as follows:
+
+```java
+public class AddNetworkIdToMyEntitySystem extends HolderSystem<EntityStore> {
+    private final ComponentType<EntityStore, MyEntityComponent> myEntityComponentType = MyEntityComponent.getComponentType();
+    private final ComponentType<EntityStore, NetworkId> networkIdComponentType = NetworkId.getComponentType();
+    private final Query<EntityStore> query = Query.and(this.myEntityComponentType, Query.not(this.networkIdComponentType));
+
+    @Override
+    public void onEntityAdd(@NotNull Holder<EntityStore> holder, @NotNull AddReason reason, @NotNull Store<EntityStore> store) {
+        if (!holder.getArchetype().contains(NetworkId.getComponentType())) {
+            holder.addComponent(NetworkId.getComponentType(), new NetworkId(store.getExternalData().takeNextNetworkId()));
+        }
+    }
+
+    @Override
+    public void onEntityRemoved(@NotNull Holder<EntityStore> holder, @NotNull RemoveReason reason, @NotNull Store<EntityStore> store) {}
+
+    @Override
+    public @Nullable Query<EntityStore> getQuery() {
+        return query;
+    }
+}
+```
+
+In your plugin's `setup()` function
+
+```java
+this.getEntityStoreRegistry().registerSystem(new AddNetworkIdToMyEntitySystem())
+```
+
+### Using PropComponent
+
+Alternatively you can add `PropComponent` to your entity. Hytale adds `PropComponent` to entities spawned with the Entity Tool, and such entities automatically get `NetworkId` and `PrefabCopyableComponent` (which makes the entity work with prefabs).
+
+<Callout type="warning">
+  There is no guarantee, that Hytale will not add some other behavior to this component in the future, which may break your entity, so be careful if you decide to rely on it.
+</Callout>
diff --git a/content/docs/lt-LT/guides/plugin/store-persistent-data.mdx b/content/docs/lt-LT/guides/plugin/store-persistent-data.mdx
new file mode 100644
index 00000000..1071dff3
--- /dev/null
+++ b/content/docs/lt-LT/guides/plugin/store-persistent-data.mdx
@@ -0,0 +1,171 @@
+---
+title: Storing Persistent Data on the Player
+description: Learn how to save and load persistent data using Components
+authors:
+  - name: Neil Revin
+    url: https://itsneil.dev/
+  - name: ArcticDev
+    url: https://github.com/ArcticRaven
+  - name: oskarscot
+    url: https://oskar.scot
+  - name: JammingEng
+    url: https://github.com/JammingEnd
+---
+
+Here is how to store persistent data using a custom component on a Player.
+
+## Build your Component Class
+
+Creating a custom component class leverages the Component system made with the ECS architecture in mind. For more information on Components, check out the [ECS Guide](../ecs/hytale-ecs-theory#components).
+
+Start by creating your custom component class. This will be extremely similar to how regular components are created, however we'll setup a custom Codec so the server can translate this data to BSON, or the server's internal json encoder.
+
+<Callout type="info">
+  Each variable you want to store in your component must have its own Codec field defined in the BuilderCodec.
+  For more information on how to create custom Codecs, check out the [ECS Codec Guide](../ecs/hytale-ecs-theory#codec).
+</Callout>
+
+```java
+public class YourPlayerData implements Component<EntityStore> {
+
+    // define some vars!
+    private int someInteger;
+    private String someString;
+    private Map<String, String> someMap;
+
+    public static final BuilderCodec<YourPlayerData> CODEC =
+            BuilderCodec.builder(YourPlayerData.class, YourPlayerData::new)
+            .append(new KeyedCodec<>("SomeInteger", Codec.INTEGER),
+                    (data, value) -> data.someInteger = value, // setter
+                    data -> data.someInteger) // getter
+            .addValidator(Validators.nonNull())
+            .add()
+            .append(new KeyedCodec<>("SomeString", Codec.STRING),
+                    (data, value) -> data.someString = value, // setter
+                    data -> data.someString) // getter
+            .add()
+            .append(new KeyedCodec<>("SomeMap",
+                            new MapCodec<>(Codec.STRING, HashMap::new, false)),
+                    (data, value) -> data.someMap = value, // setter
+                    data -> data.someMap) // getter
+            .add()
+            .build();
+
+
+
+    // Getters and Setters are for the purpose of this example omitted.
+
+    // constructor
+    public YourPlayerData() {
+        this.someInteger = 0;
+        this.someString = "";
+        this.someMap = new HashMap<>();
+    }
+
+    // copy constructor for cloning
+    public YourPlayerData(YourPlayerData clone) {
+        this.someInteger = clone.someInteger;
+        this.someString = clone.someString;
+        this.someMap = clone.someMap;
+    }
+
+    @Nonnull
+    @Override
+    public Component<EntityStore> clone() {
+        return new YourPlayerData(this);
+    }
+}
+```
+
+## Register your Component
+
+Inside your main class's `setup()` method, register your new Component.
+
+```java
+public class YourPlugin extends JavaPlugin {
+
+    private ComponentType<EntityStore, YourPlayerData> yourPlayerDataComponent;
+
+    public YourPlugin(@Nonnull JavaPluginInit init) {
+        super(init);
+    }
+
+    @Override
+    protected void setup(){
+        this.yourPlayerDataComponent = this.getEntityStoreRegistry().registerComponent(
+            YourPlayerData.class,
+            "YourPlayerDataComponent",
+            YourPlayerData.CODEC
+        );
+    }
+
+    public ComponentType<EntityStore, YourPlayerData> getYourPlayerDataComponent() {
+        return this.yourPlayerDataComponent;
+    }
+}
+```
+
+## Using your Component
+
+To use your newly created component, you can add the Component to a player using the `addComponent` method, although this only adds it temporarily, meaning when the player/entity leaves the world, the component is removed. You can use `putComponent` to ensure the component persists between sessions.
+
+```java
+// You will need the Ref and Store to apply components
+private void someEntryMethod(@Nonnull Ref<EntityStore> ref, @Nonnull Store<EntityStore> store)
+{
+       // Any entity will work, for now we will use the player
+      Player player = (Player) store.getComponent(ref, Player.getComponentType());
+
+      // since we're using putComponent, it could be useful to check if it already exists on the player in case we want to update it
+     if(store.getComponent(ref, YourPlugin.instance().getYourPlayerDataComponent()) != null)
+     {
+          // here we implement logic that updates the component
+         var comp = store.getComponent(ref, YourPlugin.instance().getYourPlayerDataComponent())
+         // declare public fields or methods in the component class
+         comp.SomeString = "An Updated Field";
+     } else {
+          // Here we put the component
+          var myCustomComp = new CustomComponent();
+          // declare public fields or methods in the component class
+          myCustomComp.SomeString = "Edited String";
+
+          // putComponent allows you to insert declared objects
+          store.putComponent(ref, YourPlugin.instance().getYourPlayerDataComponent(), myCustomComp);
+     }
+}
+```
+
+## Using your Data
+
+Your component will be stored within the `Store<EntityStore>` when added to the player. In the provided example,
+we'll fetch this data off the player using the `ensureAndGetComponent()` method, which will add the component to
+the player if it does not exist with the default values.
+
+```java
+public class IncompleteCustomCommand extends AbstractPlayerCommand {
+
+    public IncompleteCustomCommand() {
+        super("nope", "don't use this command");
+    }
+
+    @Override
+    protected void execute(
+        @NonNullDecl CommandContext commandContext,
+        @NonNullDecl Store<EntityStore> store,
+        @NonNullDecl Ref<EntityStore> ref,
+        @NonNullDecl PlayerRef playerRef,
+        @NonNullDecl World world
+    ) {
+        YourPlayerData customData = store.ensureAndGetComponent(ref, YourPlugin.instance().getYourPlayerDataComponent());
+        // ensureAndGetComponent adds the component to the ref, with the default values defined inside your component.
+ 		// use your data
+    }
+}
+```
+
+And that's it! Your data will now be saved and loaded automatically with the player.
+
+Using custom components to store persistent data on players is a powerful way to maintain state across sessions.
+By following the steps outlined above, you can easily create, register, and utilize your own data structures within the Hytale ECS framework.
+This approach ensures that your data is seamlessly integrated with the game's existing systems.
+For more information about Hytale's Entity Component System visit the [Hytale ECS Theory](https://hytalemodding.dev/en/docs/guides/ecs/hytale-ecs-theory) guide.
diff --git a/content/docs/lt-LT/guides/plugin/teleporting-players.mdx b/content/docs/lt-LT/guides/plugin/teleporting-players.mdx
index 57cee77f..32ce0435 100644
--- a/content/docs/lt-LT/guides/plugin/teleporting-players.mdx
+++ b/content/docs/lt-LT/guides/plugin/teleporting-players.mdx
@@ -1,26 +1,32 @@
 ---
 title: Teleporting the player
 description: Learn how to teleport the player.
+authors:
+  - name: oskarscot
+    url: https://oskar.scot
 ---
 
-To teleport players in Hytale, you will need to get a `World` object so we can safely run the teleport on the world thread. The world thread manages all entity updates, so modifying entities off-thread can crash the server or cause inconsistent state.
-Next, we get the entity store and make a `Teleport` object.
-We add a `Teleport` component to the player’s entity reference in the entity store. This triggers the teleportation logic for that player.
+Teleporting players in Hytale works by simply attaching a `Teleport` component to a player with the desired world and transform.
+You can only trigger teleports from a world where the player is currently present.
+Teleport itself is a component but it also provides factory methods to configure the Teleport. Just as with any entity component, an EntityStore and a Ref to the EntityStore is required
+
+We can create a simple teleport utility like this:
 
 ```java
-public static void teleportPlayer(Player player, int x, int y, int z) {
-        World world = player.getWorld();
-        if (world == null) return;
-        world.execute(() -> {
-            if (player.getReference() == null) return;
-            Store<EntityStore> store = player.getReference().getStore();
-            Teleport teleport = Teleport.createForPlayer(world,
-                new Vector3d(x ,y, z), // Target position
-                new Vector3f(0, 0, 0)  // Target rotation (pitch, yaw, roll)
-            );
+public static void teleportPlayer(Ref<EntityStore> ref, Store<EntityStore> store, World targetWorld, double x, double y, double z) {                                                                                       
+    Transform transform = new Transform(x, y, z);                                                                                                                           
+    Teleport teleport = Teleport.createForPlayer(targetWorld, transform);                                                                                                   
+    store.addComponent(ref, Teleport.getComponentType(), teleport);                                                                                                         
+}  
+```
 
-            store.addComponent(player.getReference(), Teleport.getComponentType(), teleport);
-        });
+A `Transform` is a representation of a position Vector3d and rotation Vector3f which works in the following way:
 
-}
+```java
+Transform transform = new Transform(
+    new Vector3d(x, y, z),      // Position
+    new Rotation(yaw, pitch, 0) // Rotation, last value seems to always be 0
+);
+Teleport teleport = Teleport.createForPlayer(targetWorld, transform);
+store.addComponent(ref, Teleport.getComponentType(), teleport);
 ```
diff --git a/content/docs/lt-LT/guides/plugin/tracking-mod-analytics-with-hstats.mdx b/content/docs/lt-LT/guides/plugin/tracking-mod-analytics-with-hstats.mdx
new file mode 100644
index 00000000..45c022e0
--- /dev/null
+++ b/content/docs/lt-LT/guides/plugin/tracking-mod-analytics-with-hstats.mdx
@@ -0,0 +1,65 @@
+---
+title: Tracking Mod Analytics with HStats
+description: Learn how you can track Analytics for your Hytale Mod for Free using hstats.dev
+authors:
+  - name: Al3x
+    url: https://hstats.dev
+---
+
+In this guide, you will learn how to integrate HStats into your Plugin/Mod which will allow you to track how many Servers are using it along with other stats.
+
+<Callout type="info">
+  HStats is a third-party tool and is not affiliated with HytaleModding or Hypixel Studios
+</Callout>
+
+# Step 1: Register your Mod to HStats
+
+Before you touch any code, you will need to add your mod to the HStats website which will give you a UUID for your mod.
+
+- Create or Login to an Account on https://hstats.dev
+- Navigate to the dashboard page (https://hstats.dev/dashboard)
+- On the left, type in your mod's name and click "Add Mod"
+- Keep note of the UUID generated for later.
+
+# Step 2: Add the HStats Class to Your Project
+
+To keep things simple, HStats uses a single Java class file that handles everything for you.
+
+- Download / Copy the File from the GitHub page (https://github.com/hstats-dev/HStatsExamplePlugin/blob/main/src/main/java/com/al3x/HStats.java)
+- Paste into your Project. You should now have a HStats.java file somewhere in your projects directory.
+- Update the package name from com.al3x to whatever fits your project.
+
+# Step 3: Initialize HStats in your code
+
+You only need to add one line of code to your mod's setup method in your main class to start tracking.
+
+`new HStats("YOUR-MOD-UUID", "1.0.0");`
+
+Replace `YOUR-MOD-UUID` with the Mod UUID we made note of earlier and change the `1.0.0` version to whatever version your mod is currently on.
+
+Your setup method should now look something like this:
+
+```java
+@Override
+protected void setup() {
+  super.setup();
+  new HStats("c34a2b2a-afd8-4d6a-821e-7a63e12c5ea6", "1.0.0");
+}
+```
+
+# Extras
+
+Your done! Your mod should now be listed under the Mods page (https://hstats.dev/mods) as well as under your dashboard.
+
+Servers using your mod should now post updates about every minute to HStats which you can view in the Dashboard.
+
+### Embeds
+
+HStats allows you to generate an Embed Card that you can place on your CurseForge or GitHub page. This is useful for server owners to be able to see how many other servers are using your mod.
+
+- In your dashboard, scroll down to the Embed Card section.
+- Customize the appearance (Light/Dark mode, layout, etc).
+- Copy the generated URL to display your "Active Servers" and "Players Online" live on your mod's description page
+
+Heres an example of what they look like:
+![HStats Example](https://api.hstats.dev/api/embed/d52fa672-6966-47b2-b501-1a11bddebac3/card.svg?theme=light\&layout=compact\&size=md\&show_id=true\&dark=false)
diff --git a/content/docs/lt-LT/guides/plugin/world-gen.mdx b/content/docs/lt-LT/guides/plugin/world-gen.mdx
index 4c23b0c9..7b193ffd 100644
--- a/content/docs/lt-LT/guides/plugin/world-gen.mdx
+++ b/content/docs/lt-LT/guides/plugin/world-gen.mdx
@@ -100,7 +100,7 @@ Biome biome = biomeGen.generateBiomeAt(zoneResult, seed, x, z);
 
 ### Zone & Cave Integration
 
-Each zone defines it's own cave patterns:
+Each zone defines its own cave patterns:
 
 ```java
 Zone zone = /* ... */;
diff --git a/content/docs/lt-LT/guides/prefabs.mdx b/content/docs/lt-LT/guides/prefabs.mdx
index 08404b30..b1a55109 100644
--- a/content/docs/lt-LT/guides/prefabs.mdx
+++ b/content/docs/lt-LT/guides/prefabs.mdx
@@ -14,7 +14,7 @@ Prefabs are Hytale's way of creating reusable structures.
 There are a few fundamental concepts to understand about prefabs:
 
 - Users interact with prefabs via a prefab editing world.
-- Prefabs the physical structures in the game world, and are saved as JSON files.
+- Prefabs are the physical structures in the game world, and are saved as JSON files.
 
 ## How to Create a Prefab
 
diff --git a/content/docs/lt-LT/official-documentation/custom-ui/common-styling.mdx b/content/docs/lt-LT/official-documentation/custom-ui/common-styling.mdx
new file mode 100644
index 00000000..c36e3e3a
--- /dev/null
+++ b/content/docs/lt-LT/official-documentation/custom-ui/common-styling.mdx
@@ -0,0 +1,50 @@
+---
+title: Common Styling
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# Common Styling
+
+## Common UI Styling Library
+
+This document describes the shared UI components and styles defined in `Common.ui`.
+
+---
+
+### Styles
+
+We are providing some styles that can be re-used in any custom UI that, provide a cohesive UI experience with the core game UI. These styles are available in the `Common.ui` file.
+
+You can find a list of all the styles defined with live examples by running the `/ui-gallery` command ingame.
+
+<Callout type="warning">
+  This command is not available yet, but will be in a future patch.
+</Callout>
+
+![Gallery](/assets/official-documentation/ui/gallery.png)
+
+### Importing
+
+To use these styles in your UI file:
+
+```
+$Common = "Common.ui";
+
+// Then reference styles and components:
+$Common.@TextButton { @Text = "My Button"; }
+$Common.@Container { ... }
+```
+
+<Callout type="info">
+  The `Common.ui` file is at `Common/UI/Custom/Common.ui` within the Hytale pack. If your custom ui document is in a subfolder of `Common/UI/Custom/`, reference it via relative path traversal:
+
+  ```
+  $Common = "../Common.ui";
+  ```
+
+  You can find more info about paths [here](markup#path).
+</Callout>
diff --git a/content/docs/lt-LT/official-documentation/custom-ui/index.mdx b/content/docs/lt-LT/official-documentation/custom-ui/index.mdx
new file mode 100644
index 00000000..f94c4e88
--- /dev/null
+++ b/content/docs/lt-LT/official-documentation/custom-ui/index.mdx
@@ -0,0 +1,125 @@
+---
+title: Custom UI
+icon: LayoutDashboard
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# Custom UI
+
+## What is Custom UI?
+
+Custom UI is Hytale's framework for creating **custom user interfaces** controlled by the game server. Unlike the built-in Client UI (which is part of the game client and cannot be modified), Server UI allows you to create interactive screens and HUD overlays through Java plugins and asset packs.
+
+As a modder, Custom UI gives you the power to:
+
+- **Create custom interactive pages** - Shop interfaces, quest dialogs, server settings menus, admin panels
+- **Add custom HUD overlays** - Quest trackers, status displays, custom health bars, server information
+- **Design with markup** - Use `.ui` files to define reusable UI templates
+- **Handle user interactions** - Respond to button clicks, form submissions, and other events
+- **Localize your UI** - Support multiple languages using the game's translation system
+
+## How Custom UI Fits Into Hytale's UI
+
+Hytale's user interface is divided into two main categories:
+
+### Client UI (Not Moddable)
+
+Built-in interfaces controlled by the C# game client:
+
+- Main menu and settings
+- Character creation
+- Built-in HUD (health, hotbar, chat)
+- Inventory and crafting screens
+- Development tools
+
+**You cannot modify these** - they are part of the core game client.
+
+### In-Game UI (Moddable via Server)
+
+Server-controlled interfaces that you can create and customize:
+
+#### Custom Pages
+
+Full-screen interactive overlays that appear during gameplay:
+
+- Can be dismissed by the player (ESC key)
+- Capture all input (keyboard and mouse)
+- Support loading states while waiting for server responses
+- Perfect for: shops, dialogs, menus, configuration screens
+
+#### Custom HUDs
+
+Persistent overlay elements drawn on top of the game world:
+
+- Display-only (no user interaction)
+- Always visible during gameplay
+- Lightweight and non-intrusive
+- Perfect for: quest objectives, status indicators, server info panels
+
+## Architecture Overview
+
+Server UI uses a **command-based architecture**:
+
+```
+┌─────────────────────┐         ┌──────────────────────┐
+│   Java Server       │         │    C# Client         │
+│   (Your Plugin)     │         │    (Game)            │
+├─────────────────────┤         ├──────────────────────┤
+│                     │         │                      │
+│ InteractiveCustomUI │         │   CustomPage or      │
+│ Page                │         │   CustomHud          │
+│   ↓ build()         ├────────→│     ↓ Apply          │
+│ UICommandBuilder    │         │   Element Tree       │
+│   - append()        │         │     ↓ Layout         │
+│   - set()           │         │   Rendered UI        │
+│   - clear()         │         │                      │
+│                     │         │                      │
+│ ↓ handleDataEvent() │← Events │   User Interaction   │
+│   Process input     │         │   (click, type, etc) │
+│   sendUpdate()      │         │                      │
+└─────────────────────┘         └──────────────────────┘
+```
+
+**The flow:**
+
+1. Your Java code builds UI using `UICommandBuilder`
+2. Commands are sent to the client as data
+3. Client parses `.ui` markup files and creates visual elements
+4. User interacts with the UI
+5. Events are sent back to your Java code
+6. You process events and send updates back
+
+## Key Principles
+
+### Declarative, Not Imperative
+
+You don't create UI objects directly. Instead, you send **commands** that describe what you want:
+
+- "Append this button template to that container"
+- "Set this label's text to 'Hello World'"
+- "Clear all children from this list"
+
+### Asset-Driven
+
+UI structure is defined in `.ui` markup files (assets), not hardcoded in Java. This enables:
+
+- Designers to modify layouts without touching code
+- Reusable UI components
+- Consistent visual language
+
+### Event-Driven
+
+User interactions trigger events that flow back to your server code. You register event bindings and handle them in `handleDataEvent()`.
+
+### Selector-Based
+
+You target specific UI elements using **selectors:**
+
+- `#MyButton` - Element with ID "MyButton"
+- `#List[0]` - First child of element "List"
+- `#List[0] #Title` - Element with ID "Title" in the first child of element "List"
+- `#Label.TextColor` - The TextColor property of element "Label"
diff --git a/content/docs/lt-LT/official-documentation/custom-ui/layout.mdx b/content/docs/lt-LT/official-documentation/custom-ui/layout.mdx
new file mode 100644
index 00000000..0a24ca09
--- /dev/null
+++ b/content/docs/lt-LT/official-documentation/custom-ui/layout.mdx
@@ -0,0 +1,492 @@
+---
+title: Layout
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# Layout
+
+The layout system determines how UI elements are positioned and sized on screen. Understanding layout is crucial for creating well-structured, responsive interfaces.
+
+## Layout Fundamentals
+
+Every UI element has:
+
+- **Container Rectangle** - The space allocated by the parent
+- **Anchor** - How the element positions/sizes itself within the container
+- **Padding** - Inner spacing that affects child layout
+- **LayoutMode** - How the element arranges its children (if it's a container)
+
+```
+┌─────────────────────────────────────┐
+│  Container Rectangle (from parent)  │
+│  ┌───────────────────────────────┐  │
+│  │  Anchored Rectangle           │  │
+│  │  ┌─────────────────────────┐  │  │
+│  │  │ Padding                 │  │  │
+│  │  │  ┌───────────────────┐  │  │  │
+│  │  │  │  Content Area     │  │  │  │
+│  │  │  └───────────────────┘  │  │  │
+│  │  └─────────────────────────┘  │  │
+│  └───────────────────────────────┘  │
+└─────────────────────────────────────┘
+```
+
+## Anchor
+
+`Anchor` controls how an element positions and sizes itself within its container rectangle.
+
+### Fixed Size
+
+```
+Button {
+    Anchor: (Width: 200, Height: 40);
+}
+```
+
+Creates a 200×40 pixel button.
+
+### Positioning
+
+```
+Label {
+    Anchor: (Top: 10, Left: 20, Width: 100, Height: 30);
+}
+```
+
+- **Top**: 10 pixels from container's top edge
+- **Left**: 20 pixels from container's left edge
+- **Width**: 100 pixels wide
+- **Height**: 30 pixels tall
+
+### Anchoring to Edges
+
+```
+Button {
+    Anchor: (Bottom: 10, Right: 10, Width: 100, Height: 30);
+}
+```
+
+Anchors the button to the bottom-right corner, 10 pixels from each edge.
+
+### Stretching
+
+```
+Group {
+    Anchor: (Top: 0, Bottom: 0, Left: 0, Right: 0);
+}
+```
+
+Stretches to fill the entire container (all edges at 0 pixels).
+
+**Shorthand:**
+
+```
+Group {
+    Anchor: (Full: 0);
+}
+```
+
+### Mixed Anchoring
+
+```
+Panel {
+    Anchor: (Top: 10, Bottom: 10, Left: 20, Width: 300);
+}
+```
+
+- Fixed width of 300 pixels
+- Stretches vertically between top and bottom edges
+- 10 pixels from top and bottom
+- 20 pixels from left
+
+## Padding
+
+`Padding` creates inner spacing, affecting where children are positioned.
+
+### Uniform Padding
+
+```
+Group {
+    Padding: (Full: 20);
+}
+```
+
+20 pixels of padding on all sides.
+
+### Directional Padding
+
+```
+Group {
+    Padding: (Top: 10, Bottom: 20, Left: 15, Right: 15);
+}
+```
+
+Different padding per edge.
+
+### Shorthand
+
+```
+// Horizontal and vertical
+Group {
+    Padding: (Horizontal: 20, Vertical: 10);
+}
+
+// Equivalent to:
+// Top: 10, Bottom: 10, Left: 20, Right: 20
+```
+
+### Effect on Children
+
+```
+Group {
+    Anchor: (Width: 200, Height: 100);
+    Padding: (Full: 10);
+
+    Label {
+        Anchor: (Full: 0);
+    }
+}
+```
+
+The label fills the group, but there's a 10-pixel gap on all sides due to padding.
+
+```
+┌──────────────────────┐
+│ Group (200×100)      │
+│  ┌────────────────┐  │
+│  │ Label          │  │ ← 10px padding all around
+│  │                │  │
+│  └────────────────┘  │
+└──────────────────────┘
+```
+
+## LayoutMode
+
+`LayoutMode` determines how a container arranges its children.
+
+### Top (Vertical Stack)
+
+```
+Group {
+    LayoutMode: Top;
+
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+}
+```
+
+Children stack vertically from top to bottom:
+
+```
+┌──────────┐
+│ Button 1 │
+├──────────┤
+│ Button 2 │
+├──────────┤
+│ Button 3 │
+└──────────┘
+
+
+```
+
+Each child's `Anchor.Bottom` adds spacing between elements:
+
+```
+Button { Anchor: (Height: 30, Bottom: 10); }  // 10px gap after this button
+```
+
+### Bottom (Vertical Stack)
+
+```
+Group {
+    LayoutMode: Bottom;
+
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+}
+```
+
+Children stack vertically from top to bottom but aligned to the bottom edge of the parent:
+
+```
+
+
+
+┌──────────┐
+│ Button 1 │
+├──────────┤
+│ Button 2 │
+├──────────┤
+│ Button 3 │
+└──────────┘
+```
+
+### Left (Horizontal Stack)
+
+```
+Group {
+    LayoutMode: Left;
+
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+}
+```
+
+Children arrange horizontally from left to right:
+
+```
+┌────────┬────────┬────────┐
+│ Button │ Button │ Button │
+│   1    │   2    │   3    │
+└────────┴────────┴────────┘
+```
+
+Use `Anchor.Right` for spacing between elements.
+
+### Right (Horizontal Stack)
+
+```
+Group {
+    LayoutMode: Right;
+
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+}
+```
+
+Children arrange horizontally from left to right but aligned to the right side of the parent:
+
+```
+                                                                 ┌────────┬────────┬────────┐
+                                                                 │ Button │ Button │ Button │
+                                                                 │   1    │   2    │   3    │
+                                                                 └────────┴────────┴────────┘
+```
+
+### Center
+
+```
+Group {
+    LayoutMode: Center;
+
+    Group #Dialog {
+        Anchor: (Width: 400, Height: 300);
+    }
+}
+```
+
+Centers the children horizontally.
+
+### Middle
+
+```
+Group {
+    LayoutMode: Middle;
+
+    Group #Dialog {
+        Anchor: (Width: 400, Height: 300);
+    }
+}
+```
+
+Centers the children vertically.
+
+### CenterMiddle (Horizontal Stack, Fully Centered)
+
+```
+Group {
+    LayoutMode: CenterMiddle;
+
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+}
+```
+
+Children stack horizontally from left to right, centered both horizontally and vertically within the parent:
+
+```
+┌────────────────────────────────────────────┐
+│                                            │
+│                                            │
+│         ┌──────┐ ┌──────┐ ┌──────┐         │
+│         │  B1  │ │  B2  │ │  B3  │         │
+│         └──────┘ └──────┘ └──────┘         │
+│                                            │
+│                                            │
+└────────────────────────────────────────────┘
+```
+
+---
+
+### MiddleCenter (Vertical Stack, Fully Centered)
+
+```
+Group {
+    LayoutMode: MiddleCenter;
+
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+}
+```
+
+Children stack vertically from top to bottom, centered both horizontally and vertically within the parent:
+
+```
+┌────────────────────────────────────────────┐
+│                                            │
+│              ┌──────────┐                  │
+│              │ Button 1 │                  │
+│              ├──────────┤                  │
+│              │ Button 2 │                  │
+│              ├──────────┤                  │
+│              │ Button 3 │                  │
+│              └──────────┘                  │
+│                                            │
+└────────────────────────────────────────────┘
+```
+
+---
+
+### Full
+
+```
+Group {
+    LayoutMode: Full;
+
+    Label {
+        Anchor: (Top: 20, Left: 20, Width: 100, Height: 30);
+    }
+}
+```
+
+Children use absolute positioning via their `Anchor` properties.
+
+### TopScrolling
+
+```
+Group {
+    LayoutMode: TopScrolling;
+    ScrollbarStyle: $Common.@DefaultScrollbar;
+
+    // ... many children
+}
+```
+
+Like `Top`, but adds a scrollbar if content exceeds container height.
+
+Or use `BottomScrolling` for bottom-aligned content.
+
+### LeftScrolling
+
+```
+Group {
+    LayoutMode: LeftScrolling;
+    ScrollbarStyle: $Common.@DefaultScrollbar;
+
+    // ... many children
+}
+```
+
+Like `Left`, but adds a scrollbar for horizontal scrolling.
+
+Or use `RightScrolling` for right-aligned content.
+
+### LeftCenterWrap (Wrapping Horizontal Stack, Horizontally Centered)
+
+```
+Group {
+    LayoutMode: LeftCenterWrap;
+
+    Button { Anchor: (Width: 80, Height: 30); }
+    Button { Anchor: (Width: 80, Height: 30); }
+    Button { Anchor: (Width: 80, Height: 30); }
+    Button { Anchor: (Width: 80, Height: 30); }
+    Button { Anchor: (Width: 80, Height: 30); }
+}
+```
+
+Children flow left to right. When there's no more horizontal space, they wrap to the next row. Each row is horizontally centered within the parent:
+
+```
+┌────────────────────────────────────────────┐
+│                                            │
+│       ┌──────┐ ┌──────┐ ┌──────┐           │
+│       │  B1  │ │  B2  │ │  B3  │           │
+│       └──────┘ └──────┘ └──────┘           │
+│            ┌──────┐ ┌──────┐               │
+│            │  B4  │ │  B5  │               │
+│            └──────┘ └──────┘               │
+│                                            │
+└────────────────────────────────────────────┘
+```
+
+## FlexWeight
+
+`FlexWeight` distributes remaining space among children.
+
+```
+Group {
+    LayoutMode: Left;
+    Anchor: (Width: 400);
+
+    Button {
+        Anchor: (Width: 100);
+    }
+
+    Group {
+        FlexWeight: 1;  // Takes all remaining space
+    }
+
+    Button {
+        Anchor: (Width: 100);
+    }
+}
+```
+
+Result:
+
+- First button: 100px
+- Middle group: 200px (400 - 100 - 100 = 200)
+- Last button: 100px
+
+### Multiple FlexWeights
+
+```
+Group {
+    LayoutMode: Left;
+    Anchor: (Width: 600);
+
+    Group { FlexWeight: 1; }
+    Group { FlexWeight: 2; }
+    Group { FlexWeight: 1; }
+}
+```
+
+Remaining space (600px) is split:
+
+- First group: 600 × (1/4) = 150px
+- Second group: 600 × (2/4) = 300px
+- Third group: 600 × (1/4) = 150px
+
+## Visibility
+
+```
+Button #HiddenButton {
+    Visible: false;
+}
+```
+
+**Effect:**
+
+- Element and its children are not displayed
+- Element is **not included in layout** (doesn't take up space)
diff --git a/content/docs/lt-LT/official-documentation/custom-ui/markup.mdx b/content/docs/lt-LT/official-documentation/custom-ui/markup.mdx
new file mode 100644
index 00000000..564110ed
--- /dev/null
+++ b/content/docs/lt-LT/official-documentation/custom-ui/markup.mdx
@@ -0,0 +1,226 @@
+---
+title: Markup
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# Markup
+
+## Markup
+
+An element is the basic building block of a user interface. There are various types of elements with different properties, which are documented below.
+
+Here's what the syntax looks like:
+
+```
+// Basic declaration of an element
+// with its Anchor property set to attach on all sides of its parent
+// with 10 pixels of margin
+Group { Anchor: (Left: 10, Top: 10, Right: 10, Bottom: 10); }
+
+Group { Anchor: (Full: 10); } // More concise version
+
+// Declaration of a Label with a name
+// (can be used to access the element from game code)
+Label #MyLabel {
+  Style: LabelStyle(FontSize: 16); // or just Style: (FontSize: 16), type can be inferred.
+  Text: "Hi! I am text.";
+}
+
+// Declaration of a Group containing 2 children
+// You can use FlexWeight to distribute any left-over space after explicit widths/heights have been subtracted
+Group {
+  LayoutMode: Left;
+  Label { Text: "Child 1"; FlexWeight: 2; }
+  Label { Text: "Child 2"; FlexWeight: 1; }
+}
+```
+
+### Documents
+
+A UI document (_.ui_ file) contains trees of elements. There can be multiple root elements.
+
+### Named Expressions
+
+Named expressions can be declared at any level of a document (including at the root) and will be scoped to that subtree, though they need to be declared at the top of the block.
+
+```
+// Example of named expressions, declared and used with @ prefix
+@Title = "Hytale";
+@ExtraSpacing = 5;
+
+Label {
+  Text: @Title;
+  Style: (LetterSpacing: 2 + @ExtraSpacing);
+}
+```
+
+You can use the spread operator `...` to reuse a named expression while overriding some of its fields:
+
+```
+@MyBaseStyle = LabelStyle(FontSize: 24, LetterSpacing: 2);
+
+Label {
+  Style: (...@MyBaseStyle, FontSize: 36);
+}
+```
+
+You can even layer multiple named expressions like so:
+
+```
+@TitleStyle = LabelStyle(FontSize: 24, HorizontalAlignment: Center);
+@SpacedTextStyle = LabelStyle(LetterSpacing: 2);
+
+Label {
+  Style: (...@BigTextStyle, ...@SpacedTextStyle);
+}
+```
+
+#### Document references
+
+A document can reference another document and access its named expressions.
+
+```
+// Document references are defined with $ prefix
+$Common = "../Common.ui";
+
+TextButton {
+  Style: $Common.@DefaultButtonStyle;
+}
+```
+
+### Templates
+
+You can declare a reusable bit of interface as a named expression and then instantiate it as many times as you want in the tree while customizing it.
+
+You can override local named expressions as well as insert additional children at any point in the template tree. However, local named expressions must be defined at the very top of the block, before properties and child elements.
+
+```
+// This is the template
+@Row = Group {
+  Anchor: (Height: 50);
+  Label #Label { Anchor: (Left: 0, Width: 100); Text: @LabelText; }
+  Group #Content { Anchor: (Left: 100); }
+};
+
+// Here we'll be using it twice in the document tree
+Group #Rows {
+  LayoutMode: TopScrolling;
+
+  @Row #MyFirstRow {
+    @LabelText = "First row";
+    #Content { TextInput {} }
+  }
+
+  @Row #MySecondRow {
+    @LabelText = "Second row";
+  }
+}
+```
+
+### Property Types
+
+#### Basic Types
+
+- **Boolean**
+  - `Visible: false;`
+  - `Visible: true;`
+- **Int**
+  - `Height: 20;`
+- **Float, Double, Decimal**
+  - `Min: 0.2;`
+- **String**
+  - `Text: "Hi!";`
+- **Char**
+  - `PasswordChar: "*";`
+  - _Note: The syntax is the same as a string, however a value of this type cannot contain more than one character!_
+- **Color**
+  - `Background: #ffffff;`&#x20;
+- **Objects**
+  - `Style: (Background: #ffffff)`
+- **Array**&#x20;
+  - `TextSpans: [(Text: "Hi", IsBold: true)]`
+
+#### Translations
+
+Translation keys can be referenced anywhere in markup where you can provide a string, and they are then converted to a string when an element gets instantiated.
+
+**Example:**
+
+```
+Label {
+  Text: %ui.general.cancel;
+}
+```
+
+#### Colors
+
+A color literal can be written as follows:
+
+- `#rrggbb`: 6-digit hexadecimal representation for red, green, blue (fully opaque)
+- `#rrggbb(a.a)`: 6-digit hexadecimal representation for red, green, blue with alpha between 0 and 1
+- `#rrggbbaa`: 8-digit hexadecimal representation for red, green, blue and alpha
+
+```
+Group {
+  Background: #000000(0.3);
+}
+```
+
+<Callout>
+  The `#rrggbb(a.a)` format is prefered over the `#rrggbbaa` format for
+  readability reasons.
+</Callout>
+
+#### Font Name
+
+Font names can be referenced directly by their string ID. Internally this is using a custom type called `UIFontName`, however strings will be converted automatically to this type in markup.
+
+```
+Label {
+  Text: "Hi";
+  Style: (FontName: "Secondary");
+}
+```
+
+**Available Font Names**
+
+- _Default_ - This is the default font that is used for most text and is always used unless a different option has been specified
+- _Secondary_ - This font is mostly used for headlines or elements that are supposed to stick out
+- _Mono_ - This is only used for development; For things such as profiling or error overlays.
+
+#### Path
+
+We can reference other UI assets with the `UIPath` type. Similar to `UIFontName`_,_ Strings are automatically converted to a `UIPath`. Paths are always relative to the file where they have been declared in. Looking up _MyButton.png_ in _Menu/MyAwesomeMenu.ui_ will result in _Menu/MyButton.png_. If you want to reference a file that is in a parent folder you can go back one directory by writing two dots (_../MyButton.png_).
+
+The markup syntax of a `UIPath` is the same as a String. (e.g. `Path: "Test.png"`)
+
+Here are some more examples:
+
+| UIPath             | .ui File                              | Resulting Path    |
+| ------------------ | ------------------------------------- | ----------------- |
+| MyButton.png       | Menu/MyAwesomeMenu.ui                 | Menu/MyButton.png |
+| ../MyButton.png    | Menu/MyAwesomeMenu.ui                 | MyButton.png      |
+| ../../MyButton.png | Menu/Popup/Templates/MyAwesomeMenu.ui | Menu/MyButton.png |
+
+#### Objects
+
+Objects contain a set of properties. In this example we are assigning an Anchor object to the _Anchor_ property:
+
+```
+Group {
+  Anchor: (
+   Height: 10,
+   Width: 20
+ );
+}
+```
+
+You can find all objects that can be used in markup [here](type-documentation#elements).
+
+## Visual Studio Code Extension
+
+There is an official extension for Visual Studio Code which adds syntax highlighting for .ui files. You can find it [here](https://marketplace.visualstudio.com/items?itemName=HypixelStudiosCanadaInc.vscode-hytaleui).
diff --git a/content/docs/lt-LT/official-documentation/custom-ui/type-documentation/index.mdx b/content/docs/lt-LT/official-documentation/custom-ui/type-documentation/index.mdx
new file mode 100644
index 00000000..69cea406
--- /dev/null
+++ b/content/docs/lt-LT/official-documentation/custom-ui/type-documentation/index.mdx
@@ -0,0 +1,127 @@
+---
+title: Type Documentation
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# Type Documentation
+
+This is a generated list of UI elements accessible by markup. More information about the User Interface framework can be found in the main documentation.
+
+## Elements
+
+- [ActionButton](type-documentation/elements/actionbutton)
+- [AssetImage](type-documentation/elements/assetimage)
+- [BackButton](type-documentation/elements/backbutton)
+- [BlockSelector](type-documentation/elements/blockselector)
+- [Button](type-documentation/elements/button)
+- [CharacterPreviewComponent](type-documentation/elements/characterpreviewcomponent)
+- [CheckBox](type-documentation/elements/checkbox)
+- [CheckBoxContainer](type-documentation/elements/checkboxcontainer)
+- [CircularProgressBar](type-documentation/elements/circularprogressbar)
+- [CodeEditor](type-documentation/elements/codeeditor)
+- [ColorOptionGrid](type-documentation/elements/coloroptiongrid)
+- [ColorPicker](type-documentation/lements/colorpicker)
+- [ColorPickerDropdownBox](type-documentation/elements/colorpickerdropdownbox)
+- [CompactTextField](type-documentation/elements/compacttextfield)
+- [DropdownBox](type-documentation/elements/dropdownbox)
+- [DropdownEntry](type-documentation/elements/dropdownentry)
+- [DynamicPane](type-documentation/elements/dynamicpane)
+- [DynamicPaneContainer](type-documentation/elements/dynamicpanecontainer)
+- [FloatSlider](type-documentation/elements/floatslider)
+- [FloatSliderNumberField](type-documentation/elements/floatslidernumberfield)
+- [Group](type-documentation/elements/group)
+- [HotkeyLabel](type-documentation/elements/hotkeylabel)
+- [ItemGrid](type-documentation/elements/itemgrid)
+- [ItemIcon](type-documentation/elements/itemicon)
+- [ItemPreviewComponent](type-documentation/elements/itempreviewcomponent)
+- [ItemSlot](type-documentation/elements/itemslot)
+- [ItemSlotButton](type-documentation/elements/itemslotbutton)
+- [Label](type-documentation/elements/label)
+- [LabeledCheckBox](type-documentation/elements/labeledcheckbox)
+- [MenuItem](type-documentation/elements/menuitem)
+- [MultilineTextField](type-documentation/elements/multilinetextfield)
+- [NumberField](type-documentation/elements/numberfield)
+- [Panel](type-documentation/elements/panel)
+- [ProgressBar](type-documentation/elements/progressbar)
+- [ReorderableList](type-documentation/elements/reorderablelist)
+- [ReorderableListGrip](type-documentation/elements/reorderablelistgrip)
+- [SceneBlur](type-documentation/elements/sceneblur)
+- [Slider](type-documentation/elements/slider)
+- [SliderNumberField](type-documentation/elements/slidernumberfield)
+- [Sprite](type-documentation/elements/sprite)
+- [TabButton](type-documentation/elements/tabbutton)
+- [TabNavigation](type-documentation/elements/tabnavigation)
+- [TextButton](type-documentation/elements/textbutton)
+- [TextField](type-documentation/elements/textfield)
+- [TimerLabel](type-documentation/elements/timerlabel)
+- [ToggleButton](type-documentation/elements/togglebutton)
+
+## Property Types
+
+- [Anchor](type-documentation/property-types/anchor)
+- [BlockSelectorStyle](type-documentation/property-types/blockselectorstyle)
+- [ButtonSounds](type-documentation/property-types/buttonsounds)
+- [ButtonStyle](type-documentation/property-types/buttonstyle)
+- [ButtonStyleState](type-documentation/property-types/buttonstylestate)
+- [CheckBoxStyle](type-documentation/property-types/checkboxstyle)
+- [CheckBoxStyleState](type-documentation/property-types/checkboxstylestate)
+- [ClientItemStack](type-documentation/property-types/clientitemstack)
+- [ColorOptionGridStyle](type-documentation/property-types/coloroptiongridstyle)
+- [ColorPickerDropdownBoxStateBackground](type-documentation/property-types/colorpickerdropdownboxstatebackground)
+- [ColorPickerDropdownBoxStyle](type-documentation/property-types/colorpickerdropdownboxstyle)
+- [ColorPickerStyle](type-documentation/property-types/colorpickerstyle)
+- [DropdownBoxSearchInputStyle](type-documentation/property-types/dropdownboxsearchinputstyle)
+- [DropdownBoxSounds](type-documentation/property-types/dropdownboxsounds)
+- [DropdownBoxStyle](type-documentation/property-types/dropdownboxstyle)
+- [InputFieldButtonStyle](type-documentation/property-types/inputfieldbuttonstyle)
+- [InputFieldDecorationStyle](type-documentation/property-types/inputfielddecorationstyle)
+- [InputFieldDecorationStyleState](type-documentation/property-types/inputfielddecorationstylestate)
+- [InputFieldIcon](type-documentation/property-types/inputfieldicon)
+- [InputFieldStyle](type-documentation/property-types/inputfieldstyle)
+- [ItemGridSlot](type-documentation/property-types/itemgridslot)
+- [ItemGridStyle](type-documentation/property-types/itemgridstyle)
+- [LabeledCheckBoxStyle](type-documentation/property-types/labeledcheckboxstyle)
+- [LabeledCheckBoxStyleState](type-documentation/property-types/labeledcheckboxstylestate)
+- [LabelSpan](type-documentation/property-types/labelspan)
+- [LabelStyle](type-documentation/property-types/labelstyle)
+- [NumberFieldFormat](type-documentation/property-types/numberfieldformat)
+- [Padding](type-documentation/property-types/padding)
+- [PatchStyle](type-documentation/property-types/patchstyle)
+- [PopupStyle](type-documentation/property-types/popupstyle)
+- [ScrollbarStyle](type-documentation/property-types/scrollbarstyle)
+- [SliderStyle](type-documentation/property-types/sliderstyle)
+- [SoundStyle](type-documentation/property-types/soundstyle)
+- [SpriteFrame](type-documentation/property-types/spriteframe)
+- [SubMenuItemStyle](type-documentation/property-types/submenuitemstyle)
+- [SubMenuItemStyleState](type-documentation/property-types/submenuitemstylestate)
+- [Tab](type-documentation/property-types/tab)
+- [TabNavigationStyle](type-documentation/property-types/tabnavigationstyle)
+- [TabStyle](type-documentation/property-types/tabstyle)
+- [TabStyleState](type-documentation/property-types/tabstylestate)
+- [TextButtonStyle](type-documentation/property-types/textbuttonstyle)
+- [TextButtonStyleState](type-documentation/property-types/textbuttonstylestate)
+- [TextTooltipStyle](type-documentation/property-types/texttooltipstyle)
+- [ToggleButtonStyle](type-documentation/property-types/togglebuttonstyle)
+- [ToggleButtonStyleState](type-documentation/property-types/togglebuttonstylestate)
+
+## Enums
+
+- [ActionButtonAlignment](type-documentation/enums/actionbuttonalignment)
+- [CodeEditorLanguage](type-documentation/enums/codeeditorlanguage)
+- [ColorFormat](type-documentation/enums/colorformat)
+- [DropdownBoxAlign](type-documentation/enums/dropdownboxalign)
+- [InputFieldButtonSide](type-documentation/enums/inputfieldbuttonside)
+- [InputFieldIconSide](type-documentation/enums/inputfieldiconside)
+- [ItemGridInfoDisplayMode](type-documentation/enums/itemgridinfodisplaymode)
+- [LabelAlignment](type-documentation/enums/labelalignment)
+- [LayoutMode](type-documentation/enums/layoutmode)
+- [MouseWheelScrollBehaviourType](type-documentation/enums/mousewheelscrollbehaviourtype)
+- [ProgressBarAlignment](type-documentation/enums/progressbaralignment)
+- [ProgressBarDirection](type-documentation/enums/progressbardirection)
+- [ResizeType](type-documentation/enums/resizetype)
+- [TimerDirection](type-documentation/enums/timerdirection)
+- [TooltipAlignment](type-documentation/enums/tooltipalignment)
diff --git a/content/docs/lt-LT/official-documentation/npc/2-getting-started-with-templates.mdx b/content/docs/lt-LT/official-documentation/npc/2-getting-started-with-templates.mdx
index 91081ca1..99d078e0 100644
--- a/content/docs/lt-LT/official-documentation/npc/2-getting-started-with-templates.mdx
+++ b/content/docs/lt-LT/official-documentation/npc/2-getting-started-with-templates.mdx
@@ -9,7 +9,7 @@ authors:
 
 There are no hard and fast rules for making a start on a template. I like to duplicate **BlankTemplate** and start from there because it already provides the basic structure of the file.
 
-This leaves me with the following template (`Template_Goblin_Ogre.json`): (note: the file could be looking different in the current version of the game)
+This leaves me with the following template (`Template_Goblin_Ogre.json`): (**note: the file could be looking different in the current version of the game**)
 
 ```json
 {
@@ -33,7 +33,7 @@ This leaves me with the following template (`Template_Goblin_Ogre.json`): (note:
     }
   },
   "Appearance": { "Compute": "Appearance" },
-  "DropList": { "Compute": "Droplist" },
+  "DropList": { "Compute": "DropList" },
   "MaxHealth": { "Compute": "MaxHealth" },
   "MotionControllerList": [
     {
@@ -65,10 +65,10 @@ And the following variant (`Goblin_Ogre.json`) next to the template. There's a t
   "Type": "Variant",
   "Reference": "Template_Goblin_Ogre",
   "Modify": {
-    "Appearance": "Goblin_Ogre",
+    "Appearance": "Goblin",
     "MaxHealth": 124
   }
 }
 ```
 
-Our artists have defined the `Goblin_Ogre` appearance already so I'm going to use that.
+Our artists have not yet finished animations for the `Goblin_Ogre`, for that sake of the tutorial I am going to use appearance `Goblin`, because it offers a more complete set of animations that we will need.
diff --git a/content/docs/lt-LT/official-documentation/worldgen/pack-tutorial/asset-packs.mdx b/content/docs/lt-LT/official-documentation/worldgen/pack-tutorial/asset-packs.mdx
index 38809fad..dcf1f3b9 100644
--- a/content/docs/lt-LT/official-documentation/worldgen/pack-tutorial/asset-packs.mdx
+++ b/content/docs/lt-LT/official-documentation/worldgen/pack-tutorial/asset-packs.mdx
@@ -9,13 +9,13 @@ authors:
 
 <OfficialDocumentationNotice />
 
-# How to modify Hytale
+# How to modify Hytale?
 
-## What's an Asset Pack
+## What's an Asset Pack?
 
-Hytales gameplay is driven by assets in the game that can be modified by creators. Asset Packs are our solution to let you override or add features to the base game with your own work. These can in the form of zip files of folders, which contain a custom set of assets. This is not the only way for a creator to change Hytale but this is the most accessible form.;
+Hytales gameplay is driven by assets in the game that can be modified by creators. Asset Packs are our solution to let you override or add features to the base game with your own work. These can be the form of zip files of folders, which contain a custom set of assets. This is not the only way for a creator to change Hytale but this is the most accessible form.;
 
-### How do I make an Asset Pack
+### How do I make an Asset Pack?
 
 <video controls className="my-6 aspect-video w-full rounded-lg border">
   <source src="https://cdn.internal.hytalemodding.dev/guides/official/how-to-asset-pack.mp4" type="video/mp4" />
@@ -48,7 +48,7 @@ An asset pack is typically a zip or folder, with a `manifest.json` inside. This
 }
 ```
 
-### Where are they stored
+### Where are they stored?
 
 Asset Packs are stored with other mods in the Mods folder.
 
@@ -76,7 +76,7 @@ C:\Users\<user>\AppData\Roaming\Hytale\UserData\Saves\New World 5\mods
 
 When you have Asset Packs or Mods installed, these will appear in the New World menu under the Options menu.;
 
-### How do I change an existing asset
+### How do I change an existing asset?
 
 <video controls className="my-6 aspect-video w-full rounded-lg border">
   <source src="https://cdn.internal.hytalemodding.dev/guides/official/how-to-asset.mp4" type="video/mp4" />
diff --git a/content/docs/lt-LT/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx b/content/docs/lt-LT/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx
index 44528376..24e628b5 100644
--- a/content/docs/lt-LT/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx
+++ b/content/docs/lt-LT/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx
@@ -106,7 +106,7 @@ If a BaseHeight is provided, the TopY and BottomY values are relative to the Bas
 
 Applies a Material Provider slot on a set of horizontal stripes of blocks of varying thickness and position. Below is an example image of basalt stripes into a stone cliff.
 
-{/* ![](https://540086904-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F7KAmBkOg6d13nZCkf9ku%2Fuploads%2FbcxO9LpArn8gPCaBwFg5%2Funknown.png?alt=media&token=1c72b67a-8253-4d03-8c64-1ad5f6830050) */}
+![Example of basalt stripes](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/basalt-stripes-example.png)
 
 #### Parameters:
 
diff --git a/content/docs/lt-LT/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx b/content/docs/lt-LT/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx
index 5e34acd4..a4418473 100644
--- a/content/docs/lt-LT/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx
+++ b/content/docs/lt-LT/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx
@@ -294,7 +294,7 @@ Combines all the positions into a single Positioins field.
 
 ---
 
-### SimpleHoritontal
+### SimpleHorizontal
 
 Keeps only the positions that are within the provided range.
 
diff --git a/content/docs/lt-LT/official-documentation/worldgen/worldgen-tutorial/README.mdx b/content/docs/lt-LT/official-documentation/worldgen/worldgen-tutorial/README.mdx
new file mode 100644
index 00000000..5f66d245
--- /dev/null
+++ b/content/docs/lt-LT/official-documentation/worldgen/worldgen-tutorial/README.mdx
@@ -0,0 +1,166 @@
+---
+title: How to edit and create Biomes
+description: Explores where world generation assets can be found and how to edit them.
+---
+
+### Where are the Assets
+
+World generation assets are kept in the HytaleGenerator directory within the assets.
+
+```
+/Server/HytaleGenerator/
+```
+
+<div className="flex flex-row rounded-lg border p-4">
+  <div className="flex-1/2 border-r pr-4">
+    ```
+    /Biomes
+    ```
+
+    Biome assets, with content configurations.
+  </div>
+
+  <div className="flex-1/2 pl-4">
+    ```
+    /WorldStructure
+    ```
+
+    Generator files that define which biomes spawn together.
+  </div>
+</div>
+
+<div className="flex flex-row rounded-lg border p-4">
+  <div className="flex-1/2 border-r pr-4">
+    ```
+    /Density
+    ```
+
+    Density assets that can be referenced by any other assets.
+  </div>
+
+  <div className="flex-1/2 pl-4">
+    ```
+    /Assignments
+    ```
+
+    Prop assets that can be referenced by any Biome assets.
+  </div>
+</div>
+
+***
+
+An example of this structure can be found bellow, packed in an asset pack with the instance configuration.
+
+[https://drive.google.com/file/d/1sIz_CluANIIe3n8vNiOi-4PQdeqCO0qY/view?usp=drive_link](https://drive.google.com/file/d/1sIz_CluANIIe3n8vNiOi-4PQdeqCO0qY/view?usp=drive_link)
+
+<Callout>
+  Ensure you place your asset pack in the correct directory, under Mods.
+</Callout>
+
+### How to visit our worlds
+
+https://drive.google.com/file/d/1BJurxyj-taE-PXWm04bk7Dl6X7ZHTH92/view?usp=sharing
+
+#### Requirements
+
+- You must be an **Operator** in the world.
+  - To do this, run <mark style="color:$danger;">`/op self`</mark>
+- You must be in **Creative mode**.
+  - Press the <mark style="color:$danger;">`O`</mark> key, O for Orange.&#x20;
+
+The generation assets define a set of generators but on their own you cannot visit these. Currently you require an Instance with a generator that will allow you to visit your work.
+
+```
+/Server/Instances/
+```
+
+Instances are separate worlds that players can join using the `/instances` command. Each instance has an `Instance.bson` configuration asset that specifies which generator to use, among other worldly settings.
+
+```json
+{
+  "WorldGen": {
+    "Type": "HytaleGenerator",
+    "WorldStructure": "Basic",
+    "playerSpawn" : {
+      "X" : 123,
+      "Y" : 480,
+      "Z" : 10000,
+      "Pitch" : 0,
+      "Yaw" : 0,
+      "Roll" : 0
+    }
+  }
+}
+```
+
+<Callout>
+  You can create custom instances for different world structures and biomes as you need them.
+</Callout>
+
+### How to edit Biomes
+
+<video>
+  <source src="https://cdn.internal.hytalemodding.dev/guides/official/How-to-edit-Biomes.mp4" type="video/mp4" />
+</video>
+
+We currently use the Hytale Node Editor when editing world generation assets. This can be accessed while in-game from the Content Creation menu when pressing B. The node editor is then found under the asset editor dropdown on the upper left.&#x20;
+
+![Node Editor 1](/assets/official-documentation/worldgen/worldgen-tutorial/biomes/node-editor-1.png)
+
+Once you have the Hytale Node Editor open, through the file menu you can open Biomes by navigating to the Biomes directory and selecting one from your pack.&#x20;
+
+```
+/Server/HytaleGenerator/Biomes/
+```
+
+### Biome Asset Structure
+
+Every Biome has a root Biome node, this node splits into 5 structures. This is covered briefly but more information on each field can be found on the World Generation Concepts page.
+
+![Node Editor 2](/assets/official-documentation/worldgen/worldgen-tutorial/biomes/node-editor-2.png)
+
+<Callout>
+  Each biome is for the most part self contained, meaning it has control over what appears with the biome. The only exception to this are Base Heights.
+</Callout>
+
+<Tabs>
+  <Tab value="Terrain">
+    Mathematical function nodes that calculate the physical shape of the Biome's terrain.
+  </Tab>
+
+  <Tab value="Materials">
+    Logical nodes that determine what materials (blocks) make up a Biome's terrain.
+  </Tab>
+
+  <Tab value="Props">
+    Function nodes that add objects like prefabs and decorations to the terrain.
+  </Tab>
+
+  <Tab value="Environments">
+    Logical nodes that determine the environment asset at a given coordinate within the biome. This asset determines things like weather, NPC spawns, and sounds.
+  </Tab>
+
+  <Tab value="Tints">
+    Logical function nodes that determine a colour code that can be used by certain blocks in the world. Typically this will be grasses and soils.
+  </Tab>
+</Tabs>
+
+### How to preview your work
+
+[https://drive.google.com/file/d/1mNcHn9LhFnWDF0DzWFH6_YllmKAUvUry/view?t=6](https://drive.google.com/file/d/1mNcHn9LhFnWDF0DzWFH6_YllmKAUvUry/view?t=6)
+
+Once you are in an Instance world with the Hytale Generator active you will only be able to see your work by generating new chunks. There are a few ways to do this.
+
+The viewport command selects an area around the Player that will live reload as you make changes to the generator.&#x20;
+
+```
+/viewport --radius 5 
+```
+
+You can also create a new world to show your changes.&#x20;
+
+```
+/instances spawn <instance> 
+```
+
+The last option is to simply fly south, new chunks will generate with the changes made.
diff --git a/content/docs/lt-LT/quick-start.mdx b/content/docs/lt-LT/quick-start.mdx
index 653644f4..249d803a 100644
--- a/content/docs/lt-LT/quick-start.mdx
+++ b/content/docs/lt-LT/quick-start.mdx
@@ -9,3 +9,8 @@ Welcome to the Hytale modding documentation! Here you'll find everything you nee
 * [Setting up your dev environment](./guides/plugin/setting-up-env)
 * [Entity Component System (ECS)](./guides/ecs/entity-component-system)
 * [Publishing your mod](./publishing)
+
+### Useful Links
+
+* [Kaupenjoe's Modding Videos](https://www.youtube.com/@ModdingByKaupenjoe)
+* [TroubleDEV's Modding Videos](https://www.youtube.com/@TroubleDEV)
diff --git a/content/docs/lt-LT/server/argtypes.mdx b/content/docs/lt-LT/server/argtypes.mdx
new file mode 100644
index 00000000..e54a442e
--- /dev/null
+++ b/content/docs/lt-LT/server/argtypes.mdx
@@ -0,0 +1,61 @@
+---
+title: ArgTypes
+description: Available ArgTypes
+icon: List
+full: true
+authors:
+  - name: Valeena
+---
+
+| Name                        | Target Class                           | Description                                                                                                                               |   |
+| :-------------------------- | :------------------------------------- | :---------------------------------------------------------------------------------------------------------------------------------------- | - |
+| Boolean                     | java.lang.Boolean                      | A 'true' or 'false' input                                                                                                                 |   |
+| Integer                     | java.lang.Integer                      | A whole number                                                                                                                            |   |
+| String                      | java.lang.String                       | Words, text, numbers, letters. To input more than one word at a time, you may need to wrap it with double quotes (`"my fancy sentence"`). |   |
+| Float                       | java.lang.Float                        | A floating-pointer number                                                                                                                 |   |
+| Double                      | java.lang.Double                       | A decimal number                                                                                                                          |   |
+| UUID                        | java.util.UUID                         | A UUID (Universally Unique IDentifier)                                                                                                    |   |
+| Player_UUID                 | java.util.UUID                         | A UUID or an online player username                                                                                                       |   |
+| Game_Profile_Lookup_Async   | ProfileServiceClient.PublicGameProfile | A player UUID or username. If not found locally, performs a remote lookup via the Profile Service.                                        |   |
+| Relative_Double_Coord       | Coord                                  | An x, y, or z coordinate as a decimal, optionally relative by specifying a tilde (~) in front of the number                               |   |
+| Relative_Int_Coord          | IntCoord                               | An x, y, or z coordinate as a whole number, optionally relative by specifying a tilde (~) in front of the number                          |   |
+| Relative_Integer            | RelativeInteger                        | A tilde to mark an integer relative to a base                                                                                             |   |
+| Relative_Float              | RelativeFloat                          | A tilde to mark a float relative to a base                                                                                                |   |
+| Player_Ref                  | PlayerRef                              | A UUID or an online player's username                                                                                                     |   |
+| World                       | World                                  | A world folder name                                                                                                                       |   |
+| Model_Asset                 | ModelAsset                             | A reference to an Asset of type Model                                                                                                     |   |
+| Weather_Asset               | Weather                                | A reference to an Asset of type Weather                                                                                                   |   |
+| Interaction_Asset           | Interaction                            | A reference to an Asset of type Interaction                                                                                               |   |
+| Root_Interaction_Asset      | RootInteraction                        | A reference to an Asset of type Root Interaction                                                                                          |   |
+| Effect_Asset                | EntityEffect                           | A refernece to an Asset of type EntityEffect                                                                                              |   |
+| Environment_Asset           | Environment                            | A reference to an Asset of type Environment                                                                                               |   |
+| Item_Asset                  | Item                                   | A reference to an Asset of type Item                                                                                                      |   |
+| Block_Type_Asset            | BlockType                              | A reference to an Asset of type BlockType                                                                                                 |   |
+| Particle_System             | ParticleSystem                         | A reference to an Asset of type ParticleSystem                                                                                            |   |
+| Hitbox_Collision_Config     | HitboxCollisionConfig                  | A reference to an Asset of type HitboxCollisionConfig                                                                                     |   |
+| Repulsion_Config            | RepulsionConfig                        | A reference to an Asset of type RepulsionConfig                                                                                           |   |
+| Sound_Event_Asset           | SoundEvent                             | A reference to an Asset of type SoundEvent                                                                                                |   |
+| Ambiance_Fx_Asset           | AmbianceFX                             | A reference to an Asset of type AmbianceFX                                                                                                |   |
+| Sound_Category              | SoundCategory                          | A sound category (sfx, music, ambient, ui)                                                                                                |   |
+| Entity_ID                   | `ArgWrapper<EntityWrappedArg, UUID>`   | A UUID representing an entity id                                                                                                          |   |
+| Integer_Comparison_Operator | IntegerComparisonOperator              | A mathematical sign for integer comparison                                                                                                |   |
+| Integer_Operation           | IntegerOperation                       | A mathematical sign for performing an operation                                                                                           |   |
+| Int_Range                   | `Pair<Integer, Integer>`               | Two integers representing a minimum and maximum of a range                                                                                |   |
+| Relative_Int_Range          | RelativeIntRange                       | Two integers representing a minimum and maximum of a range                                                                                |   |
+| Vector2I                    | Vector2i                               | Two integers, generally corresponding to x/z axis                                                                                         |   |
+| Vector3I                    | Vector3i                               | Three integers, generally corresponding to x/y/z axis                                                                                     |   |
+| Relative_Vector3I           | RelativeVector3i                       | Three optionally relative integers, generally corresponding to x/y/z axis                                                                 |   |
+| Relative_Block_Position     | RelativeIntPosition                    | A position with three integer coordinates, representing a block's location in world space.                                                |   |
+| Relative_Position           | Relative                               | A position with three decimal coordinates, representing a location in world space.                                                        |   |
+| Relative_Chunk_Position     | RealtiveChunkPosition                  | A position with two integer coordinates (x, z), representing a chunk's location.                                                          |   |
+| Rotation                    | Vector3f                               | A rotation with three coordinates, representing the pitch, yaw, and roll respectively                                                     |   |
+| Block_Type_Key              | String                                 | A block type                                                                                                                              |   |
+| Block_ID                    | Integer                                | A block type, converted to an int id                                                                                                      |   |
+| Color                       | Integer                                | A color value in hex format, hex integer, or decimal integer                                                                              |   |
+| Weighted_Block_Type         | `Pair<Integer, String>`                | A weight corresponding to a blocktype                                                                                                     |   |
+| Weighted_Block_Entry        | String                                 | A block with optional weight prefix                                                                                                       |   |
+| Block_Pattern               | BlockPattern                           | A list of blocks with optional weights                                                                                                    |   |
+| Individual_Block_Mask       | BlockMask                              | Create a block mask using symbols and block names                                                                                         |   |
+| Block_Mask                  | BlockMask                              | A tick rate value (e.g., 30tps, 33ms, or 30)                                                                                              |   |
+| Tick_Rate                   | Integer                                | A list of block masks that combine together                                                                                               |   |
+| Game_Mode                   | GameMode                               | GameMode                                                                                                                                  |   |
diff --git a/content/docs/lt-LT/server/interaction-reference.mdx b/content/docs/lt-LT/server/interaction-reference.mdx
new file mode 100644
index 00000000..6c0d01b3
--- /dev/null
+++ b/content/docs/lt-LT/server/interaction-reference.mdx
@@ -0,0 +1,1586 @@
+---
+title: Interactions
+description: A list of most Interaction types provided by Hypixel, along with the meaning of their fields, and how they fit together.
+icon: List
+authors:
+  - name: Stephen Baynham
+    url: https://github.com/cannibalvox
+---
+
+### The Interaction Base Type
+
+All interactions of every type below are inherited from Interaction and have these fields.
+
+**Interaction Fields**
+
+| Field Name                | Type                                                                 | Required? | Notes                                                                                                                                                                                                                       |
+| ------------------------- | -------------------------------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| ViewDistance              | `Double`<br />(Default: 96.0)                                        | **No**    | Distance in blocks at which other players can see the effects from this interaction.                                                                                                                                        |
+| Effects                   | `InteractionEffects`                                                 | **No**    | Sound, animations, and particle effects that should trigger when this interaction begins executing.                                                                                                                         |
+| HorizontalSpeedMultiplier | `Float`<br />(Default: 1.0)                                          | **No**    | Multiplier applied to the User entity's movement speed while this interaction is executing                                                                                                                                  |
+| RunTime                   | `Float`                                                              | **No**    | If provided, this interaction will continue executing for at least this long before the interaction chain moves onto the next interaction.                                                                                  |
+| CancelOnItemChange        | `Boolean`<br />(Default: true)                                       | **No**    | If true, this interaction will be cancelled if the User entity's held item changes during execution. This can happen either due to the selected hotbar slot changing or the contents of the item's inventory slot changing. |
+| Rules                     | `InteractionRules`                                                   | **Yes**   | If provided, adds additional limitations and cancellation conditions to this interaction.                                                                                                                                   |
+| Settings                  | `Map`<br />(Key Type: `GameMode`, Value Type: `InteractionSettings`) | **No**    | If provided, adds additional per-GameMode settings to the interaction.                                                                                                                                                      |
+| Camera                    | `InteractionCameraSettings`                                          | **No**    | Arrays of camera motion keyframes for cutscenes and reveals.                                                                                                                                                                |
+
+**GameMode Values**
+
+- `Creative`: The game is currently in Creative Mode
+- `Adventure`: The game is currently in Adventure Mode
+
+**InteractionEffects Fields**
+
+| Field Name               | Type                                              | Required? | Notes                                                                                                                                                 |
+| ------------------------ | ------------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Particles                | `Array`<br />(Element Type: `ModelParticle`)      | **No**    | Particle systems to activate when this interaction begins if the player is in third-person mode.                                                      |
+| FirstPersonParticles     | `Array`<br />(Element Type: `ModelParticle`)      | **No**    | Particle systems to activate when this interaction begins if the player is in first-person mode.                                                      |
+| WorldSoundEventId        | `Asset`<br />(Asset Type: `SoundEvent`)           | **No**    | A sound to play in the world at the User entity's location when this interaction begins.<br />**The SoundEvent must be single-channel (mono) sound.** |
+| LocalSoundEventId        | `Asset`<br />(Asset Type: `SoundEvent`)           | **No**    | A 2D sound to play for the User entity when this interaction begins. Ignored if the User entity is not a player.                                      |
+| Trails                   | `Array`<br />(Element Type: `ModelTrail`)         | **No**    | Trail effects to activate on the User entity when this interaction begins.                                                                            |
+| WaitForAnimationToFinish | `Boolean`<br />(Default: false)                   | **No**    | If true, this interaction will continue executing for at least the length of any animations in this InteractionEffects object.                        |
+| ItemPlayerAnimationsId   | `Asset`<br />(Asset Type: `ItemPlayerAnimations`) | **No**    | If provided, the User entity will use this ItemPlayerAnimations set while this interaction is executing.                                              |
+| ItemAnimationId          | `String`                                          | **No**    | Id of an animation to trigger when this interaction begins executing.<br />**This animation id is not validated on server start.**                    |
+| ClearAnimationOnFinish   | `Boolean`<br />(Default: false)                   | **No**    | If true, animations triggered by this interaction will be halted when the interaction completes.                                                      |
+| ClearSoundEventOnFinish  | `Boolean`<br />(Default: false)                   | **No**    | If true, sounds triggered by this interaction will be halted when the interaction completes.                                                          |
+| CameraEffect             | `Asset`<br />(Asset Type: `CameraEffect` )        | **No**    | If provided, the CameraEffect will be applied while this interaction is executing.                                                                    |
+| MovementEffects          | `MovementEffects`                                 | **No**    | If provided, apply the movement effects to the User entity while this interaction is executing.                                                       |
+| StartDelay               | `Float`<br />(Default: 0.0f)                      | **No**    | The interaction will wait this many seconds before triggering the effects in this object.                                                             |
+
+**InteractionRules Fields**
+
+| Field Name          | Type                                                                                                | Required? | Notes                                                                                                                                                                                                                                     |
+| ------------------- | --------------------------------------------------------------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| BlockedBy           | `Array`<br />(Element Type: `InteractionType`)<br />(Default: Based on the chain's InteractionType) | **No**    | If provided, this RootInteraction cannot be executed while interaction chains of the provided types are executing.<br />**This field only functions for rules attached to a RootInteraction. It has no effect on an Interaction.**        |
+| Blocking            | `Array`<br />(Element Type: `InteractionType`)                                                      | **No**    | If provided, interaction chains with the specified InteractionTypes cannot be executed while this interaction is executing.                                                                                                               |
+| InterruptedBy       | `Array`<br />(Element Type: `InteractionType`)                                                      | **No**    | If provided, interaction chains with the specified InteractionTypes will cancel this interaction chain when they execute.<br />**This field only functions for rules attached to a RootInteraction. It has no effect on an Interaction.** |
+| Interrupting        | `Array`<br />(Element Type: `InteractionType`)                                                      | **No**    | If provided, interaction chains with the specified InteractionTypes will be canceled when this interaction begins.                                                                                                                        |
+| BlockedByBypass     | `String`                                                                                            | **No**    | If provided, this RootInteraction cannot be blocked by interaction chains whose RootInteraction has this value as an asset tag.                                                                                                           |
+| BlockingBypass      | `String`                                                                                            | **No**    | If provided, this interaction will not block RootInteractions that have the this value as an asset tag.                                                                                                                                   |
+| InterruptedByBypass | `String`                                                                                            | **No**    | If provided, this RootInteraction cannot be canceled by RootInteractions that have this value as an asset tag.                                                                                                                            |
+| InterruptingBypass  | `String`                                                                                            | **No**    | If provided, this interaction will not cancel interaction chains whose RootInteraction has this value as an asset tag.                                                                                                                    |
+
+**InteractionType Values**
+
+- `Primary`
+- `Secondary`
+- `Ability1`
+- `Ability2`
+- `Ability3`
+- `Use`
+- `Pick`
+- `Pickup`
+- `CollisionEnter`
+- `CollisionLeave`
+- `Collision`
+- `EntityStatEffect`
+- `SwapTo`
+- `SwapFrom`
+- `Death`
+- `Wielding`
+- `ProjectileSpawn`
+- `ProjectileHit`
+- `ProjectileMiss`
+- `ProjectileBounce`
+- `Held`
+- `HeldOffhand`
+- `Equipped`
+- `Dodge`
+- `GameModeSwap`
+
+**InteractionSettings Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                        |
+| ---------------- | ------------------------------- | --------- | -------------------------------------------------------------------------------------------- |
+| AllowSkipOnClick | `Boolean`<br />(Default: false) | **No**    | If true, the user will be able to skip this interaction by clicking shortly after it starts. |
+
+**InteractionCameraSettings Fields**
+
+| Field Name  | Type                                             | Required? | Notes                                                                                                                                                           |
+| ----------- | ------------------------------------------------ | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| FirstPerson | `Array`<br />(Element Type: `InteractionCamera`) | **No**    | A list of camera keyframes to be played if the player is in first-person.<br />**The time of each keyframe must be after the keyframe before it in the array.** |
+| ThirdPerson | `Array`<br />(Element Type: `InteractionCamera`) | **No**    | A list of camera keyframes to be played if the player is in third-person.<br />**The time of each keyframe must be after the keyframe before it in the array.** |
+
+**InteractionCamera Fields**
+
+| Field Name | Type                         | Required? | Notes                                                                                                                                       |
+| ---------- | ---------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------- |
+| Time       | `Float`<br />(Default: 0.1f) | **No**    | How long after the interaction begins executing that the camera should arrive at this keyframe.<br />**Cannot be less than or equal to 0.** |
+| Position   | `Vector3`                    | **Yes**   | Where the camera should be located when it arrives at this keyframe.                                                                        |
+| Rotation   | `Direction`                  | **Yes**   | Where the camera should be pointing when it arrives at this keyframe.                                                                       |
+
+### SimpleInteraction
+
+Most interaction types below are inherited from SimpleInteraction and have these
+fields.  If a type does not have these fields, the documentation will mention it.
+
+The purpose of SimpleInteraction is to facilitate Interaction chaining by taking different paths
+based on whether the Interaction succeeded or failed.  The circumstances under which
+a given Interaction fails are generally type-specific (and described in the documentation
+below), but all interactions will be marked failed if they are cancelled via one of the
+many, many mechanisms for doing so.
+
+It is valid to create an interaction asset of type "Simple", which can be valuable when you want to use the
+interaction fields with no additional functionality.
+
+**SimpleInteraction Fields**
+
+| Field Name | Type                                     | Required? | Notes                                                                                          |
+| ---------- | ---------------------------------------- | --------- | ---------------------------------------------------------------------------------------------- |
+| Next       | `Asset`<br />(Asset Type: `Interaction`) | **No**    | After this Interaction has finished, "Next" will be executed if this Interaction did not fail. |
+| Failed     | `Asset`<br />(Asset Type: `Interaction`) | **No**    | After this Interaction has finished, "Failed" will be executed if this Interaction failed.     |
+
+## Flow Control
+
+These are interaction types used to control the flow of an interaction chain and allow interactions
+to be composed into more complex behaviors.  These interaction types generally do not pertain to
+the game and instead pertain to the interaction system itself.
+
+### Condition
+
+This interaction will fail if one of the fields is provided but does not match the current state.
+
+**Condition Fields**
+
+| Field Name       | Type       | Required? | Notes                                                                                                                                                                                    |
+| ---------------- | ---------- | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| RequiredGameMode | `GameMode` | **No**    | If provided, the interaction will fail if the current GameMode does not match the provided value.                                                                                        |
+| Jumping          | `Boolean`  | **No**    | If provided, the interaction will fail if the player's Jumping state does not match the provided value. (i.e. if True, the player must be jumping, if False, the player must not be)     |
+| Swimming         | `Boolean`  | **No**    | If provided, the interaction will fail if the player's Swimming state does not match the provided value. (i.e. if True, the player must be swimming, if False, the player must not be)   |
+| Crouching        | `Boolean`  | **No**    | If provided, the interaction will fail if the player's Crouching state does not match the provided value. (i.e. if True, the player must be crouching, if False, the player must not be) |
+| Running          | `Boolean`  | **No**    | If provided, the interaction will fail if the player's Running state does not match the provided value. (i.e. if True, the player must be running, if False, the player must not be)     |
+| Flying           | `Boolean`  | **No**    | If provided, the interaction will fail if the player's Flying state does not match the provided value. (i.e. if True, the player must be flying, if False, the player must not be)       |
+
+**GameMode Values**
+
+- `Creative`: The game is currently in Creative Mode
+- `Adventure`: The game is currently in Adventure Mode
+
+### FirstClick
+
+This interaction does not inherit from SimpleInteraction and therefore has no Next or Failed fields.
+
+This interaction has two fields that each contain a reference to an Interaction: Click and Hold.  If the root interaction
+of the chain was initiated by a client button/key press (or simulated NPC input) and the input was a tap, then
+the Click interaction is run. if it was a longer press, then the Hold interaction is run.
+
+As a minor implementation detail, this interaction is internally marked as failed when the Hold path is followed.
+This generally shouldn't matter.  If the interaction was not initiated by a key press at all, the Click path will be followed,
+but it seems risky to rely on that behavior.
+
+**FirstClick Fields**
+
+| Field Name | Type                                     | Required? | Notes                                                                                                                                                    |
+| ---------- | ---------------------------------------- | --------- | -------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Click      | `Asset`<br />(Asset Type: `Interaction`) | **No**    | If provided and the root interaction of the chain was initiated by button/key press, this interaction is executed next if the press was a quick tap.     |
+| Hold       | `Asset`<br />(Asset Type: `Interaction`) | **No**    | If provided and the root interaction of the chain was initiated by a button/key press, this interaction is executed next if the press was a longer hold. |
+
+### Interrupt
+
+This interaction can be used to cancel one or more running interaction chains on an entity and **all forked interaction
+chains those chains have spawned that are still currently running**.  All interaction chains canceled in this manner will be marked as
+Failed, which may have additional implications if the canceled chains are themselves forked from
+other chains that are still running.
+
+**Interrupt Fields**
+
+| Field Name     | Type                                           | Required? | Notes                                                                                                                                                                                               |
+| -------------- | ---------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Entity         | `InteractionTarget`<br />(Default: User)       | **Yes**   | The entity that is the owner of the target interaction chains.  This field can indicate the Owner, User, or Target of this interaction chain.                                                       |
+| InterruptTypes | `Array`<br />(Element Type: `InteractionType`) | **No**    | A set of InteractionTypes that are to be interrupted. Only interactions of these types are affected. If null, all types will be interrupted.<br />**(Note: An empty set will interrupt NO TYPES.)** |
+| RequiredTag    | `String`                                       | **No**    | An asset tag that, if provided, the RootInteraction of the interaction chain must have in order to be canceled.                                                                                     |
+| ExcludedTag    | `String`                                       | **No**    | An asset tag that, if provided, the RootInteraction of the interaction chain must not have in order to be canceled.                                                                                 |
+
+**InteractionTarget Values**
+
+- `User` - The user of this interaction chain. The entity whose actions caused this interaction chain to be executed. This is usually the same as the Owner.
+- `Owner` - The owner of this interaction chain. The entity upon whom this interaction chain is executing.
+- `Target` - The entity target of this interaction chain, if any.  This value is mutable (and can therefore come from many places) but most commonly, it is an entity the User was targeting when this interaction chain began executing.
+
+**InteractionType Values**
+
+- `Primary`
+- `Secondary`
+- `Ability1`
+- `Ability2`
+- `Ability3`
+- `Use`
+- `Pick`
+- `Pickup`
+- `CollisionEnter`
+- `CollisionLeave`
+- `Collision`
+- `EntityStatEffect`
+- `SwapTo`
+- `SwapFrom`
+- `Death`
+- `Wielding`
+- `ProjectileSpawn`
+- `ProjectileHit`
+- `ProjectileMiss`
+- `ProjectileBounce`
+- `Held`
+- `HeldOffhand`
+- `Equipped`
+- `Dodge`
+- `GameModeSwap`
+
+### Parallel
+
+This interaction does not inherit from SimpleInteraction and therefore has no Next or Failed fields.
+
+This interaction has a field `Interactions` that is an array of RootInteraction assets. The list must contain at least
+two RootInteractions.  This interaction will fork all of its children except for the first into their
+own interaction chains and immediately complete. After this interaction completes, this interaction chain will
+execute the first RootInteraction in the `Interactions` list.
+
+This interaction does not have any failure conditions and is indifferent to the fate of the forked interaction chains.
+
+**Parallel Fields**
+
+| Field Name   | Type                                                | Required? | Notes                                                         |
+| ------------ | --------------------------------------------------- | --------- | ------------------------------------------------------------- |
+| Interactions | `AssetArray`<br />(Element Type: `RootInteraction`) | **Yes**   | An array of RootInteractions that will be forked or executed. |
+
+### Repeat
+
+This interaction has a field `ForkInteractions` that is an asset of type RootInteraction. This interaction will fork that
+RootInteraction into its own interaction chain and then wait for it to complete. If the RootInteraction fails, this
+interaction will complete immediately and be marked failed. Otherwise, the RootInteraction will be forked and run again,
+up to a specified total number of times.
+
+**Repeat Fields**
+
+| Field Name       | Type                                                                                   | Required? | Notes                                                                                                                                                                                                              |
+| ---------------- | -------------------------------------------------------------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| ForkInteractions | `Asset`<br />(Asset Type: `RootInteraction`)                                           | **Yes**   | A RootInteraction that will be forked.                                                                                                                                                                             |
+| Repeat           | `Integer`<br />(Default: 1)<br />**Must be -1 or a positive integer. 0 is not valid.** | **No**    | The total number of times to fork ForkInteractions. If -1 is provided, ForkInteractions will continue being forked and executed indefinitely, until this interaction is cancelled or until ForkInteractions fails. |
+
+### Replace
+
+This interaction does not inherit from SimpleInteraction and therefore has no Next or Failed fields.
+
+This interaction uses the InteractionVars system that is avaiable for items. InteractionVars are RootInteractions that
+can be attached to an Item asset with a name.
+
+This interaction specifies a var name, and if this interaction chain was executed through
+an item and that item has an InteractionVar of the same name, then this interaction will immediately execute
+the RootInteraction on the var.  Otherwise, it will execute the default RootInteraction specified in this interaction.
+If no default is specified, then this interaction will be marked as failed.
+
+**Replace Fields**
+
+| Field Name   | Type                                         | Required? | Notes                                                                                                                                                                                                           |
+| ------------ | -------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Var          | `String`                                     | **Yes**   | The name of the InteractionVar to execute.                                                                                                                                                                      |
+| DefaultValue | `Asset`<br />(Asset Type: `RootInteraction`) | **No**    | The RootInteraction to execute if the owning item does not have an InteractionVar by the specified name. If not provided, the interaction will be marked as failed instead.                                     |
+| DefaultOk    | `Boolean`<br />(Default: false)              | **No**    | If false, then an angry message will be printed to the server logs if the owning item does not have an InteractionVar by the specified name.  The functioning of this interaction will be otherwise unaffected. |
+
+### RunRootInteraction
+
+This interaction immediately executes the provided RootInteraction as part of this interaction chain. This interaction
+does not have any failure conditions.
+
+**RunRootInteraction Fields**
+
+| Field Name      | Type                                         | Required? | Notes                           |
+| --------------- | -------------------------------------------- | --------- | ------------------------------- |
+| RootInteraction | `Asset`<br />(Asset Type: `RootInteraction`) | **Yes**   | The RootInteraction to execute. |
+
+### Selector
+
+This interaction will execute a Selector to find entities and/or blocks (depending on the Selector) and fork off an
+interaction chain for each located entity or block. This interaction will not wait for those interaction chains
+to complete and is indifferent to their fate. The forked interaction chains will use the located entity/block as
+their target entity/target block. Each entity or block will only fork one interaction chain over the life of this
+interaction.  The Selector is guaranteed to run once for each execution of this interaction, but some Selectors
+are intended to be run over a period of time and sweep across an area to locate targets. In order to use those Selectors
+properly, you will need to extend the execution time of this interaction using `RunTime` or `WaitForAnimationToFinish`.
+The Selector will be executed repeatedly over the lifetime of the interaction.
+
+If the Selector is configured to locate entities, you can add additional sets of entity matching rules. If a located entity
+matches one of the rules, the matching RootInteraction will be forked instead of the standard `HitEntity` RootInteraction.
+
+Entities located by the Selector will be ignored if they do not have a NetworkId, if they are dead, or if they are invulnerable.
+The only exception to this rule is that players in Creative Mode that are marked to receive hits will not be ignored.
+
+This interaction's failure conditions are configurable via the `FailOn` field. You can configure this interaction to never
+fail, to fail if the Selector does not locate any blocks before this interaction finishes executing, to fail if the
+Selector does not locate any entities before this interaction finishes executing, or to fail in either case.
+
+**Selector Fields**
+
+| Field Name     | Type                                         | Required? | Notes                                                                                                                                                                                                                                     |
+| -------------- | -------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Selector       | `Selector`                                   | **Yes**   | The Selector is executed at least once and may be executed repeatedly to locate blocks and/or entities in an area.                                                                                                                        |
+| HitEntity      | `Asset`<br />(Asset Type: `RootInteraction`) | **No**    | If included and the `Selector` locates an entity that does not match any `HitEntityRules`, this RootInteraction will be forked into a new interaction chain with the located entity as the target entity.                                 |
+| HitEntityRules | `Array`<br />(Element Type: `HitEntity`)     | **No**    | If included, these rules will be matched against any entity located by the `Selector`. If an entity matches a set of rules, the RootInteraction associated with the rules will be forked instead of the standard `HitEntity` interaction. |
+| HitBlock       | `Asset`<br />(Asset Type: `RootInteraction`) | **No**    | If included and the `Selector` locates a block, this RootInteraction will be forked into a new interaction chain with the located block as the block target.                                                                              |
+| FailOn         | `FailOnType`<br />(Default: `Neither`)       | **No**    | Defines under what circumstances this interaction will fail.  It can be marked to fail when it completes without locating any blocks, it can be marked to fail when it completes without locating any entities, both, or neither.         |
+| IgnoreOwner    | `Boolean`<br />(Default: true)               | **No**    | If true, the Selector will not locate the User entity of this interaction.                                                                                                                                                                |
+
+**HitEntity Fields**
+
+| Field Name | Type                                         | Required? | Notes                                                                                                 |
+| ---------- | -------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------- |
+| Matchers   | `Array`<br />(Element Type: `EntityMatcher`) | **Yes**   | A set of rules that an entity must match. An entity must successful match all rules to be considered. |
+| Next       | `Asset`<br />(Asset Type: `RootInteraction`) | **Yes**   | The RootInteraction to fork if an entity matches all rules.                                           |
+
+**EntityMatcher Fields**
+
+| Field Name | Type                            | Required? | Notes                                                                                                     |
+| ---------- | ------------------------------- | --------- | --------------------------------------------------------------------------------------------------------- |
+| Type       | `String`                        | **Yes**   | If provided, specifies a type of EntityMatcher to use. Each matcher type may come with additional fields. |
+| Invert     | `Boolean`<br />(Default: false) | **No**    | If true, an entity must fail this rule for it to be marked as succeeded.                                  |
+
+**EntityMatcher Type: Player**
+
+This EntityMatcher will succesfully match the entity only if they are a player.
+
+**EntityMatcher Type: Vulnerable**
+
+This Entitymatcher will successfully match the entity only if they are not marked as invulnerable.
+
+**FailOnType Values**
+
+- `Neither`
+- `Entity`
+- `Block`
+- `Either`
+
+### Serial
+
+This interaction does not inherit from SimpleInteraction and therefore has no Next or Failed fields.
+
+This interaction has a field `Interactions` which is a list of Interaction assets. This interaction immediately
+completes and the interaction chain continues by executing the interactions in the list one at a time. This
+interaction does not have any failure conditions.
+
+**Serial Fields**
+
+| Field Name   | Type                                            | Required? | Notes                                      |
+| ------------ | ----------------------------------------------- | --------- | ------------------------------------------ |
+| Interactions | `AssetArray`<br />(Element Type: `Interaction`) | **Yes**   | An array of Interaction assets to execute. |
+
+## Cooldowns
+
+RootInteractions interface with a complex cooldown system that can be used for a variety of purposes. Aside from simply
+adding an important aspect of resource management to your game design, cooldowns can be used to ensure that click-activated
+interaction chains don't repeatedly spam if the player holds down the input.
+
+By default, every RootInteraction has a cooldown timer that is keyed to the RootInteraction name, and by default, it
+will launch a cooldown of 0.35 seconds when activated by client input.  Otherwise, no cooldown will be activated.  However,
+by configuring your RootInteraction, you can change the key for the cooldown (so that multiple RootInteractions can share
+a single cooldown), set the cooldown timer to whatever you like, and configure multiple charges that can build up over time
+to allow the entity to activate the RootInteraction multiple times before being forced to pause.
+
+One important concept to keep in mind is the difference between **cooldown** and **charge time**.  The cooldown, if any,
+is activated each time a RootInteraction triggers, even if the player has more available charges. If the RootInteraction
+is configured to use charges, then they will gradually build up over time. In order for a RootInteraction to be activated,
+the cooldown (if any) must be expired, and the RootInteraction must have at least one charge (if it has been
+configured to use charges).
+
+Bear in mind that the entire Cooldown configuration is shared between different RootInteractions with the same cooldown id.
+If you activate an ability with 5 charges and a short cooldown and then another ability with a much longer cooldown and no
+charges, the second ability will use the cooldown properties of the first ability until/unless the first ability finishes
+charging and is cleared from the system.  You should generally only have multiple RootInteractions share a cooldown id
+if they have the same configuration.
+
+The interactions below interact with the cooldown system to allow you to manipulate cooldowns via the interaction system. By
+using these interactions, you can have several interaction chains with different cooldown configurations share cooldowns
+that are checked and activated as part of the interaction chain itself, or have some components of an interaction change
+use a second cooldown separate from the main one.
+
+### CooldownCondition
+
+**CooldownCondition Fields**
+
+This interaction will fail if the specified cooldown id is on cooldown for the User entity.  This interaction will only
+function for players- the interaction will always succeed for NPCs.  In order for this interaction to succeed, the
+cooldown, if any, must have expired and at least one charge, if any, must have filled.
+
+| Field Name | Type     | Required? | Notes                     |
+| ---------- | -------- | --------- | ------------------------- |
+| Id         | `String` | **Yes**   | The cooldown id to check. |
+
+### IncrementCooldown
+
+**IncrementCooldown Fields**
+
+This interaction will modify a cooldown that is currently active on the User entity, allowing charges and remaining
+cooldown to be modified.
+Despite its name, this interaction can be used to reduce a cooldown as well as increase it. If the cooldown is not
+currently active, this interaction will have no effect. The interaction has no special failure conditions.
+
+| Field Name        | Type                        | Required? | Notes                                                                                                                                                                                                                                                                                     |
+| ----------------- | --------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Id                | `String`                    | **No**    | If provided, the cooldown id of the cooldown to be manipulated. If not provided, the cooldown id of the current chain's RootInteraction will be used.                                                                                                                                     |
+| Time              | `Float`<br />(Default: 0.0) | **No**    | The amount to increase the remaining cooldown by. Can be negative. The remaining cooldown time will not be reduced below zero or increased above the maximum cooldown time.                                                                                                               |
+| ChargeTime        | `Float`<br />(Default: 0.0) | **No**    | The amount to increase the remaining time until the next charge is filled by. Can be negative. The remaining charge time cannot be reduced below zero or increased above the maximum cooldown time. **This will not work on abilities that have a maximum of 1 charge, for some reason.** |
+| Charge            | `Integer`<br />(Default: 0) | **No**    | The amount to increase the number of charges by. Can be negative. The number of charges cannot be reduced below 0 or increased above the maximum.                                                                                                                                         |
+| InterruptRecharge | `Boolean`(Default: false)   | **No**    | If true and `Charge` is not 0, will reset the remaining time to the next charge to the maximum value after changing the charge count.                                                                                                                                                     |
+
+### ResetCooldown
+
+This interaction will trigger a cooldown on the User entity with a specified configuration. The charges will be refilled
+but the cooldown will be immediately triggered.  The mechanisms for deciding on the configuration are a little bit complicated.
+You may specify a cooldown configuration via the `Cooldown` field. If you do not include an `Id` field, then the
+interaction chain's RootInteraction will be used for any field not specified in the configuration. If there is an active
+cooldown under the specified `Id` (or under the RootInteraction's cooldown id if none is specified) then the fields
+from that active cooldown will overwrite data in the RootInteraction's cooldown, but not data in your `Cooldown` field.
+
+**ResetCooldown Fields**
+
+| Field Name | Type                  | Required? | Notes                                                        |
+| ---------- | --------------------- | --------- | ------------------------------------------------------------ |
+| Cooldown   | `InteractionCooldown` | **No**    | A cooldown configuration to use for the new, reset cooldown. |
+
+**InteractionCooldown Fields**
+
+| Field Name        | Type                                 | Required? | Notes                                                                                                                                                                                                 |
+| ----------------- | ------------------------------------ | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Id                | `String`                             | **No**    | The cooldown id to use for this cooldown. If not provided, the RootInteraction's cooldown id will be used, if any.                                                                                    |
+| Cooldown          | `Float`<br />(Default: 0.0)          | **No**    | The duration of the cooldown, in seconds.                                                                                                                                                             |
+| Charges           | `Array`<br />(Element Type: `Float`) | **No**    | If provided, a list of how many charges this cooldown can build, and how long each charge takes to build, in seconds.                                                                                 |
+| InterruptRecharge | `Boolean`<br />(Default: false)      | **No**    | If true, the charge time will be reset when the number of charges changes.                                                                                                                            |
+| ClickBypass       | `Boolean`<br />(Default: false)      | **No**    | If true, RootInteractions keyed to this cooldown can still be activated when it is on cooldown provided that the RootInteraction was triggered by a distinct key or mouse button press on the client. |
+
+### TriggerCooldown
+
+This interaction is similar to ResetCooldown, except instead of refilling the cooldown's charges, one charge will be deducted
+as normal.
+
+**TriggerCooldown Fields**
+
+| Field Name | Type                  | Required? | Notes                                                        |
+| ---------- | --------------------- | --------- | ------------------------------------------------------------ |
+| Cooldown   | `InteractionCooldown` | **No**    | A cooldown configuration to use for the new, reset cooldown. |
+
+**InteractionCooldown Fields**
+
+| Field Name        | Type                                 | Required? | Notes                                                                                                                                                                                                 |
+| ----------------- | ------------------------------------ | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Id                | `String`                             | **No**    | The cooldown id to use for this cooldown. If not provided, the RootInteraction's cooldown id will be used, if any.                                                                                    |
+| Cooldown          | `Float`<br />(Default: 0.0)          | **No**    | The duration of the cooldown, in seconds.                                                                                                                                                             |
+| Charges           | `Array`<br />(Element Type: `Float`) | **No**    | If provided, a list of how many charges this cooldown can build, and how long each charge takes to build, in seconds.                                                                                 |
+| InterruptRecharge | `Boolean`<br />(Default: false)      | **No**    | If true, the charge time will be reset when the number of charges changes.                                                                                                                            |
+| ClickBypass       | `Boolean`<br />(Default: false)      | **No**    | If true, RootInteractions keyed to this cooldown can still be activated when it is on cooldown provided that the RootInteraction was triggered by a distinct key or mouse button press on the client. |
+
+## Combo Chains
+
+Hytale additionally comes with a rich "combo chaining" system, which allows several inputs in a row to result in different
+attacks and special moves.  Rather than being attached to the RootInteraction like the cooldown system, these are
+primarily driven by the `Chaining` interaction.
+
+### Chaining
+
+This interaction does not inherit from SimpleInteraction and therefore has no Failed field. Its Next field works differently
+from most interaction types.
+
+Chaining is a type of flow control interaction- each time a Chaining interaction with the same `ChainId` is called, a single
+interaction in the `Next` list is chosen and the others are ignored. The first time the `ChainId` is used, the first
+interaction in the list is chosen, the next time the second, etc. Once the end of the list is reached, the first
+interaction will be chosen again.
+
+Bear in mind: the progress through the Next list is based on the **ChainId**, not the interaction!  That means that two
+different Chaining interactions can share a single combo chain. You could have a pair of daggers that attacks with
+the left when the left mouse button is clicked and with the right when the right mouse button is clicked.  You could give
+both interaction chains a Chaining interaction with the same `ChainId` and three `Next` entries that do a light-light-heavy
+combo.  Each specific hit would occur with either the left or the right knife based on which button you clicked, but
+the combo would be otherwise identical regardless of which you chose.
+
+The Chaining interaction also has a concept called "flags".  It is possible to attach named flags to a `ChainId` by using
+the ChainFlag interaction.  Then, you specify the flag name in Chaining's `Flags` field. If a Flag is active when the
+Chaining interaction is run, the Flag's interaction will be run instead of the appropriate interaction in `Next`.
+Bear in mind: the entity's progress through the `Next` list still advances, the resulting `Next` interaction is just not
+run.  Only one flag can be active at a time.
+
+Lastly, it is possible to cancel the entity's progress through the combo chain and reset them to the first interaction in
+the list. This can be done with the CancelChain interaction, but it will also happen automatically if the player does
+not trigger an interaction with the ChainId for the specified ChainingAllowance.  When either of these happen, all flags will be
+canceled as well.
+
+All of these effects are triggered on the User entity only. Non-players can use the chaining system, but Flags do not currently
+work for non-players.  This interaction has no special failure conditions.
+
+**Chaining Fields**
+
+| Field Name        | Type                                                       | Required? | Notes                                                                                                                                                                                                                       |
+| ----------------- | ---------------------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| ChainId           | `String`                                                   | **No**    | If provided, acts as a key that multiple Chaining interactions can use to share combo chain progress and flags. If not provided, a unique ChainId will be generated for this interaction.                                   |
+| ChainingAllowance | `Double`<br />(Default: 0.0)                               | **No**    | If, at the time this interaction is triggered, it has been this long in seconds since the last time a Chaining interaction with the same ChainId was executed, all state for this ChainId will be cleared before execution. |
+| Next              | `AssetArray`<br />(Element Type: `Interaction`)            | **Yes**   | A list of interactions to cycle between each time this interaction is run.                                                                                                                                                  |
+| Flags             | `Map`<br />(Key Type: `String`, Value Type: `Interaction`) | **No**    | A map of flag names to interactions to run if the flag is active when this interaction executes.                                                                                                                            |
+
+### CancelChain
+
+This interaction resets all progress and flag data on the User entity for the provided `ChainId`.  The next time a Chaining
+interaction is called for the provided `ChainId`, it will begin at the first interaction in the `Next` list. This
+interaction has no special failure conditions.
+
+**CancelChain Fields**
+
+| Field Name | Type     | Required? | Notes                                 |
+| ---------- | -------- | --------- | ------------------------------------- |
+| ChainId    | `String` | **Yes**   | A ChainId whose data should be reset. |
+
+### ChainFlag
+
+This interaction activates a flag on the User entity for the provided `ChainId`, which can be used to change behavior the
+next time a Chaining interaction with this `ChainId` is run. This will overwrite any flag that has
+already been raised. This interaction will have no effect for non-players. This interaction has no special failure
+conditions.
+
+| Field Name | Type     | Required? | Notes                                        |
+| ---------- | -------- | --------- | -------------------------------------------- |
+| ChainId    | `String` | **Yes**   | A ChainId on whom the flag should be raised. |
+| Flag       | `String` | **Yes**   | The name of the flag to raise.               |
+
+## Charging
+
+A unique flow-control interaction that is frequently used is the Charging interaction.  It is a flow-control interaction
+that delays while the input button used to trigger the interaction chain is held.  When it is released (or the interaction
+is forced to end), the interaction chain can continue with a different interaction based on how long the input was held
+for.
+
+These interactions are all related by either being the Charging interaction, or other interaction types that inherit the
+Charging interaction's behavior.
+
+### Charging
+
+This interaction does not inherit from SimpleInteraction and therefore its Next field works different from most interactions.
+This interaction adds its own Failed field which works the same way that SimpleInteraction's does.
+
+This interaction only works properly when its interaction chain was triggered by a client key or button press (or
+NPC-simulated equivalent). This interaction will continue executing for as long as the key or button press is held (with
+some exceptions, covered below) by the User entity.  Like other interactions, it has a `Next` field indicating which interaction to execute
+after this one, but the field is a map from `Float` values to `Interaction` assets. When this interaction ends, either
+due to the input being released or the charge duration completing, this interaction will determine the largest `Float` key that is less
+than the amount of time in seconds that the interaction was executing for.  The Interaction mapped to that key will be
+executed next.
+
+The interaction includes some cancellation conditions that are specific to this interaction. For instance, the interaction
+has a `CancelOnOtherClick` field that matches the field on RootInteraction. If it is active on this interaction but not
+the RootInteraction, then clicking while charging will cancel this interaction (and execute the `Failed` interaction rather
+than any of the `Next` interactions) but otherwise continue the interaction chain.
+
+Another valuable feature Charging has is the `Forks` field.  For input-triggered interactions that are triggered while the
+Charging interaction is executing, you can add an entry for the relevant InteractionType to this field and instead of
+triggering the usual interaction chain based on held item, targeted block, etc. the RootInteraction specified in the
+`Forks` field will be triggered.  This can unlock rich attack modes and behaviors. For instance, having a shield bash attack
+triggered off left click while blocking, or a special attack that triggers when both mouse buttons are pressed at the
+same time.
+
+There are two modes of operation for the Charging interaction. One is to have the ability charge for as long
+as the input is held and only end execution when the entity releases the input.  Bows in the main Hytale game work
+that way.  That is accomplished by setting `AllowIndefiniteHold` to true.  Another mode of operation is to have the
+interaction complete execution when the execution time has surpassed the largest key value in the `Next` field and
+immediately begin executing the Interaction mapped to that key.  Food in the main Hytale game work like this.  It
+is accomplished by setting `AllowIndefiniteHold` to false.
+
+One pitfall to be careful of when setting `AllowIndefiniteHold` to false is the way it interacts with cooldowns.\
+Normally, input-initiated interaction chains start a 0.35s cooldown on the triggered RootInteraction that prevents
+holding the mouse button from immediately spamming a new interaction when the first one completes.  However, if the
+duration of a Charging interaction is longer than 0.35s, then the cooldown will have already completed when the
+interaction chain finishes, which will often result in a new execution beginning immediately before the player can
+stop pressing the mouse button.  One solution for this problem is to add a `Simple` interaction to the end of your
+interaction chain with a `RunTime` of 0.35s to simulate the cooldown.  Alternatively, you can add a longer cooldown
+(the maximum duration of your Charging interaction plus 0.35s) to the RootInteraction. However, the longer cooldown is
+not always desirable, as the interaction may have ended prematurely, resulting in an unusually long lockout between
+executions.
+
+**Charging Fields**
+
+| Field Name                         | Type                                                                    | Required? | Notes                                                                                                                                                                                                                                                                                                                                                                                       |
+| ---------------------------------- | ----------------------------------------------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| FailOnDamage                       | `Boolean`<br />(Default: false)                                         | **No**    | If true, this interaction will fail and end immediately if the User entity takes any damage while it is executing.                                                                                                                                                                                                                                                                          |
+| CancelOnOtherClick                 | `Boolean`<br />(Default: true)                                          | **No**    | If true, this interaction will fail and end immediately if the User entity sends another button or key press while it is executing.                                                                                                                                                                                                                                                         |
+| Forks                              | `Map`<br />(Key Type: `InteractionType`, Value Type: `RootInteraction`) | **No**    | A map of InteractionType to RootInteraction. If entity input triggers the InteractionType while this interaction is executing, the mapped RootInteraction will be forked into its own interaction chain. This will happen instead of the usual handling for that InteractionType.  This fork will occur even if `CancelOnOtherClick` is set to true.                                        |
+| Failed                             | `Asset`<br />(Asset Type: `Interaction`)                                | **No**    | After this Interaction has finished, "Failed" will be executed if this Interaction failed.                                                                                                                                                                                                                                                                                                  |
+| AllowIndefiniteHold                | `Boolean`<br />(Default: false)                                         | **No**    | If true, this interaction will continue executing for as long as the User entity continues to hold the input. If false, execution will end as soon as the execution time in seconds reaches the largest key value in the `Next` map.                                                                                                                                                        |
+| DisplayProgress                    | `Boolean`<br />(Default: true)                                          | **No**    | If true, players executing this interaction will see a progress bar will be displayed below their cursor indicating how close to reaching the highest key value in `Next` they are.                                                                                                                                                                                                         |
+| Next                               | `Map`<br />(Key Type: `Float`, Value Type: `Interaction`)               | **No**    | A map from `Float` to `Interaction`.  When this interaction successfully finishes executing (either because the input was released or because the maximum duration was reached), this interaction will find the `Float` value with the largest duration in seconds that is less than the amount of time this interaction executed for. That key's mapped Interaction will then be executed. |
+| MouseSensitivityAdjustmentTarget   | `Float`<br />(Default: 1.0)                                             | **No**    | While charging, this mouse sensitivity multiplier will gradually be applied.                                                                                                                                                                                                                                                                                                                |
+| MouseSensitivityAdjustmentDuration | `Float`<br />(Default: 1.0)                                             | **No**    | Duration in seconds. After this many seconds, `MouseSensitivityAdjustmentTarget` will be fully applied to the mouse sensitivity.                                                                                                                                                                                                                                                            |
+| Delay                              | `ChargingDelay`                                                         | **No**    | Settings that allow charging progress to be pushed back when the User entity takes damage.                                                                                                                                                                                                                                                                                                  |
+
+**ChargingDelay Fields**
+
+| Field Name    | Type                        | Required? | Notes                                                                                                                                                                                                                                                                     |
+| ------------- | --------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| MinHealth     | `Float`<br />(Default: 0.0) | **No**    | Damage taken as a percentage of entity health (0.0-1.0). If a hit deals less than this much damage, no pushback will be applied.  If a hit deals exactly this much damage, `MinDelay` seconds worth of pushback will be applied.                                          |
+| MaxHealth     | `Float`<br />(Default: 0.0) | **No**    | Damage taken as a percentage of entity health (0.0-1.0). If a hit deals at least this much damage, `MaxDelay` seconds worth of pushback will be applied.                                                                                                                  |
+| MinDelay      | `Float`<br />(Default: 0)   | **No**    | The amount of pushback, in seconds, to apply if the entity takes a hit that deals `MinHealth` damage. The amount of pushback applied by a hit is a gradiant between `MinDelay` and `MaxDelay` based on the amount of damage between `MinHealth` and `MaxHealth`.          |
+| MaxDelay      | `Float`<br />(Default: 0)   | **No**    | The amount of pushback, in seconds, to apply if the entity takes a hit that deals at least `MaxHealth` damage. The amount of pushback applied by a hit is a gradiant between `MinDelay` and `MaxDelay` based on the amount of damage between `MinHealth` and `MaxHealth`. |
+| MaxTotalDelay | `Float`<br />(Deault: 0)    | **No**    | The maximum amount of pushback the entity can receive over the course of a single charge, regardless of how many times they are hit.                                                                                                                                      |
+
+**InteractionType Values**
+
+- `Primary`
+- `Secondary`
+- `Ability1`
+- `Ability2`
+- `Ability3`
+- `Use`
+- `Pick`
+- `Pickup`
+- `CollisionEnter`
+- `CollisionLeave`
+- `Collision`
+- `EntityStatEffect`
+- `SwapTo`
+- `SwapFrom`
+- `Death`
+- `Wielding`
+- `ProjectileSpawn`
+- `ProjectileHit`
+- `ProjectileMiss`
+- `ProjectileBounce`
+- `Held`
+- `HeldOffhand`
+- `Equipped`
+- `Dodge`
+- `GameModeSwap`
+
+### Wielding
+
+This interaction is inherited from Charging rather than SimpleInteraction.  However, its `Failed` and `Next` fields function
+identically to SimpleInteraction.  It does not inherit all fields from Charging, so be sure to pay close attention to
+the field list below.
+
+This interaction drives most blocking behavior in the game. While this interaction is executing, attacks made against
+the Owner entity will (conditionally) trigger effects defined in this interaction.  Unlike the Charging interaction,
+this interaction can always execute indefinitely and will only end when it fails or when the input is released.
+
+One option available in Wielding is `AngledWielding`, which allows damage and knockback modifiers to only be applied
+depending on the direction the attack against the Owner entity is coming from.  The AngledWielding type has a
+field `Angle` which determines which direction the protection points relative to the player (0 is the player's
+front), and `AngleDistance` which determines how wide the cone of protection extends around the player.  Block effects
+from this interaction (such as `BlockedEffects`, `BlockedInteractions`, and `StaminaCost`) will only apply if
+the DamageCause matches `DamageModifiers` OR if the DamageCause matches `AngledWielding.DamageModifiers` and
+the source of the damage matches `Angle` and `AngleDistance`.  It is possible for damage and knockback multipliers
+specified on both this interaction's modifier fields and `AngledWielding`'s modifier fields to stack, if both
+have entries for the same DamageCause.
+
+This interaction will only have an effect on damage taken by one of the DamageCause entries in `DamageModifiers` or
+`AngledWielding.DamageModifiers`.  If a DamageCause is in `DamageModifiers`, then the block effect will be triggered
+and the damage modifier applied regardless of what direction the Owner entity is attacked from.  If a DamageCause is in
+`AngledWielding.DamageModifiers`, then the damage modifier is only applied if the
+
+\*\* Wielding Fields\*\*
+
+| Field Name          | Type                                                                    | Required? | Notes                                                                                                                                                                                                                                                                                                                                                                                                      |
+| ------------------- | ----------------------------------------------------------------------- | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| FailOnDamage        | `Boolean`<br />(Default: false)                                         | **No**    | If true, this interaction will fail and end immediately if the User entity takes any damage while it is executing.                                                                                                                                                                                                                                                                                         |
+| CancelOnOtherClick  | `Boolean`<br />(Default: true)                                          | **No**    | If true, this interaction will fail and end immediately if the User entity sends another button or key press while it is executing.                                                                                                                                                                                                                                                                        |
+| Forks               | `Map`<br />(Key Type: `InteractionType`, Value Type: `RootInteraction`) | **No**    | A map of InteractionType to RootInteraction. If entity input triggers the InteractionType while this interaction is executing, the mapped RootInteraction will be forked into its own interaction chain. This will happen instead of the usual handling for that InteractionType.  This fork will occur even if `CancelOnOtherClick` is set to true (after which this interaction chain will be canceled). |
+| Next                | `Asset`<br />(Asset Type: `Interaction`)                                | **No**    | After this interaction has finished, "Next" will be executed if this interaction did not fail.                                                                                                                                                                                                                                                                                                             |
+| Failed              | `Asset`<br />(Asset Type: `Interaction`)                                | **No**    | After this interaction has finished, "Failed" will be executed if this interaction failed.                                                                                                                                                                                                                                                                                                                 |
+| DamageModifiers     | `Map`<br />(Key Type: `DamageCause`, Value Type: `Float`)               | **No**    | A map from DamageCause to Float, where the Float is multiplied against any damage received from the mapped DamageCause while this interaction is executing.                                                                                                                                                                                                                                                |
+| KnockbackModifiers  | `Map`<br />(Key Type: `DamageCause`, Value Type: `Float`)               | **No**    | A map from DamageCause to Float, where the Float is multiplied against any knockback force received from the mapped DamageCause while this interaction is executing.                                                                                                                                                                                                                                       |
+| AngledWielding      | `AngledWielding`                                                        | **No**    | Configuration to only trigger block effects from certain angles.                                                                                                                                                                                                                                                                                                                                           |
+| StaminaCost         | `StaminaCost`                                                           | **No**    | If the Owner entity receives damage that matches `DamageModifiers` or `AngledWielding` while this interaction is executing, then the entity's stamina will be deducted according to this configuration.                                                                                                                                                                                                    |
+| BlockedEffects      | `DamageEffects`                                                         | **No**    | If the Owner entity receives damage that matches `DamageModifiers` or `AngledWielding` while this interaction is executing, then these effects will be applied to the instance of damage.                                                                                                                                                                                                                  |
+| BlockedInteractions | `Asset`<br />(Asset Type: `RootInteraction`)                            | **No**    | If the Owner entity receives damage that matches `DamageModifiers` or `AngledWielding` while this interaction is executing, then this RootInteraction will be launched as a brand new interaction chain with the Owner entity as both Owner and User, and the attacker as the Target entity.  This new interaction chain is, notably, brand new, **not** forked from the current one.                      |
+
+**AngledWielding Fields**
+
+| Field Name         | Type                                                      | Required? | Notes                                                                                                                                                                                                            |
+| ------------------ | --------------------------------------------------------- | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Angle              | `Float`<br />(Default: 0.0)                               | **No**    | Angle in degrees relative to the Owner entity where the angled protection is centered. 0.0 means pointed towards the front of the Owner entity.                                                                  |
+| AngleDistance      | `Float`<br />(Default: 0.0)                               | **No**    | Angle in degrees indicating how wide the cone of protection is.                                                                                                                                                  |
+| DamageModifiers    | `Map`<br />(Key Type: `DamageCause`, Value Type: `Float`) | **No**    | A map from DamageCause to Float, where the Float is multiplied against any damage received from the mapped DamageCause received from within the cone of protection while this interaction is executing.          |
+| KnockbackModifiers | `Map`<br />(Key Type: `DamageCause`, Value Type: `Float`) | **No**    | A map from DamageCause to Float, where the Float is multiplied against any knockback force received from the mapped DamageCause received from within the cone of protection while this interaction is executing. |
+
+**StaminaCost Fields**
+
+| Field Name | Type                                             | Required? | Notes                                                                                                                                                                                                                                                |
+| ---------- | ------------------------------------------------ | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| CostType   | `CostType`<br />(Default: `MaxHealthPercentage`) | **No**    | How to calculate stamina consumed by blocking from the raw pre-block damage. If `Damage`, then the stamina consumed will be `rawDamage / Value`. If `MaxHealthPercentage`, then the stamina consumed will be `rawDamage / (EntityMaxHealth * Value)` |
+| Value      | `Float`<br />(Default: 0.04)                     | **No**    | The value to use in the `CostType` formula.                                                                                                                                                                                                          |
+
+**DamageEffects Fields**
+
+| Field Name             | Type                                         | Required? | Notes                                                                           |
+| ---------------------- | -------------------------------------------- | --------- | ------------------------------------------------------------------------------- |
+| ModelParticles         | `Array`<br />(Element Type: `ModelParticle`) | **No**    | Particle systems to trigger in the first-person view.                           |
+| WorldParticles         | `Array`<br />(Element Type: `WorldParticle`) | **No**    | Particle systems to trigger in the third-person view.                           |
+| LocalSoundEventId      | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | 2D sound to play locally to the attacking entity if they are a player.          |
+| WorldSoundEventId      | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | Sound to play in the world at the Owner entity's location.                      |
+| PlayerSoundEventId     | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | 2D sound to play locally to the Owner entity if they are a player.              |
+| ViewDistance           | `Double`<br />(Default: 75.0)                | **No**    | Distance at which these effects should play for other players.                  |
+| Knockback              | `Knockback`                                  | **No**    | The properties of the knockback that will be applied.                           |
+| CameraEffect           | `Asset`<br />(Asset Type: `CameraEffect`)    | **No**    | CameraEffect to briefly apply locally to the Owner entity if they are a player. |
+| StaminaDrainMultiplier | `Float`<br />(Default: 1.0)                  | **No**    | This multiplier is applied to the `StaminaCost`, if any.                        |
+
+**Knockback Fields**
+
+| Field Name     | Type                                       | Required? | Notes                                                                                                                      |
+| -------------- | ------------------------------------------ | --------- | -------------------------------------------------------------------------------------------------------------------------- |
+| Type           | `String`                                   | **No**    | If provided, specifies a type of knockback to use. Each knockback type may come with additional fields.                    |
+| Force          | `Double`<br />(Default: 0.0)               | **No**    | The amount of force to apply to the Owner entity.                                                                          |
+| Duration       | `Double`<br />(Default: 0.0)               | **No**    | If 0.0, apply the force as a single impulse.  If more, continuously apply the force over a period of time.                 |
+| VelocityType   | `ChangeVelocityType`<br />(Default: `Add`) | **No**    | How to apply the force, either adding it to the entity's current velocity, or setting the velocity to the knockback force. |
+| VelocityConfig | `VelocityConfig`                           | **No**    | Characteristics of friction as the Owner entity is thrown by this knockback.                                               |
+
+**Knockback Type: Force**
+
+Apply the calculated knockback force along the provided direction.
+
+| Field Name | Type                         | Required? | Notes                                                                                |
+| ---------- | ---------------------------- | --------- | ------------------------------------------------------------------------------------ |
+| Direction  | `Vector3`<br />(Default: Up) | **No**    | Which direction the player should be flung, relative to the direction of the attack. |
+
+**Knockback Type: Point**
+
+Apply the calculated knockback force laterally along the XZ plane, plus provided Y velocity.
+
+| Field Name | Type                        | Required? | Notes                                                                                                   |
+| ---------- | --------------------------- | --------- | ------------------------------------------------------------------------------------------------------- |
+| OffsetX    | `Integer`<br />(Default: 0) | **No**    | Offset the source position of the knockback left or right perpendicular to the direction of the attack. |
+| OffsetZ    | `Integer`<br />(Default: 0) | **No**    | Offset the source position of the knockback, forward or backward along the directon of the attack.      |
+| RotateY    | `Integer`<br />(Default: 0) | **No**    | Rotate the knockback direction around the Y axis, where 0 is the default attack direction.              |
+| VelocityY  | `Float`<br />(Default: 0.0) | **No**    | Add vertical velocity to the knockback force after the direction and force has been calculated.         |
+
+**Knockback Type: Directional**
+
+Apply the calculated knockback force along the attack direction, removing any vertical component and replacing it with a provided Y velocity.
+
+| Field Name | Type                      | Required? | Notes                                                                                                                                            |
+| ---------- | ------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------ |
+| RelativeX  | `Float`<br />(Default: 0) | **No**    | Apply additional force left or right perpendicular to the direction of the attack. The additional force is multiplied by the knockback strength. |
+| RelativeZ  | `Float`<br />(Default: 0) | **No**    | Apply additional force forward or backward along the attack direction. The additional force is multiplied by the knockback strength.             |
+| VelocityY  | `Float`<br />(Default: 0) | **No**    | Replace the vertical velocity of the knockback with this value.  This value is not multiplied by knockback strength.                             |
+
+**VelocityConfig Fields**
+
+| Field Name          | Type                                              | Required? | Notes                                                                                                                                                                                           |
+| ------------------- | ------------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| GroundResistance    | `Float`<br />(Default: 0.82)                      | **No**    | The minimum amount of friction applied when the entity is in contact with the ground.  1.0 = no friction, 0.0 = total friction                                                                  |
+| GroundResistanceMax | `Float`<br />(Default: 0.0)                       | **No**    | The maximum amount of friction applied when the entity is in contact with the ground.  1.0 = no friction, 0.0 = total friction                                                                  |
+| AirResistance       | `Float`<br />(Default: 0.96)                      | **No**    | The minimum amount of friction applied when the entity is in the air. 1.0 = no friction, 0.0 = total friction                                                                                   |
+| AirResistanceMax    | `Float`<br />(Default: 0.0)                       | **No**    | The maximum amount of friction applied when the entity is in the air. 1.0 = no friction, 0.0 = total friction                                                                                   |
+| Threshold           | `Float`<br />(Default: 1.0)                       | **No**    | The speed at which the maximum amount of friction will be applied to the entity. The amount of friction applied will increase from minimum to maximum as the entity moves from 0 to this speed. |
+| Style               | `VelocityThresholdStyle`<br />(Default: `Linear`) | **No**    | The curve that friction follows as the entity's speed increases toward the `Threshold`.                                                                                                         |
+
+**CostType Values**
+
+- `MaxHealthPercentage`
+- `Damage`
+
+**ChangeVelocityType Values**
+
+- `Add`
+- `Set`
+
+**VelocityThresholdStyle Values**
+
+- `Linear`
+- `Exp`
+
+## Blocks
+
+These are interaction types meant to reason about and modify blocks in the world.  The most important concept unique
+to these interactions is the Block Target.  Like the Entity Target, it is mutable and can come from many places.
+However, for interaction chains initiated by the client, the block target will initially be the block that the player's cursor was
+over, if any.
+
+Additionally, for interaction chains initiated by the client, the client will send along which face of the block is targeted,
+which is used by a few block-related interactions.
+It is left up to each interaction type that cares about block faces as to how to handle this behavior for simulated input
+(i.e. NPCs initiating chains that are normally initated by the client).  At the time of this writing, all block-related
+interactions choose the top face where relevant in simulated input.
+
+### BlockCondition
+
+This interaction has a field `Matchers` which specifies certain conditions, such as block type, state, etc.  This
+interaction fails if the current target block does not match all of them.
+
+**BlockCondition Fields**
+
+| Field Name       | Type                                        | Required? | Notes                                                                                                                                                                                                                                                                                                                                   |
+| ---------------- | ------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false)             | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction.                                                                                                                                                                                                       |
+| Matchers         | `Array`<br />(Element Type: `BlockMatcher`) | **Yes**   | A list of conditions that the target block must match or this condition will fail.<br />**Note: This field is technically not required but there is a bug that makes it dangerous to not provide at the time of this writing.**<br />**Note: If no conditions are added to this array, the interaction will fail, counterintuitively.** |
+
+**BlockMatcher Fields**
+
+| Field Name | Type                       | Required? | Notes                                                                          |
+| ---------- | -------------------------- | --------- | ------------------------------------------------------------------------------ |
+| Block      | `BlockIdMatcher`           | **No**    | If provided, requires the block itself match some set of conditions.           |
+| Face       | `BlockFace`                | **No**    | If provided and not 'None', requires a specific block face be targeted.        |
+| StaticFace | `Boolean` (Default: false) | **No**    | If false, the face condition will be adjusted by the block's current rotation. |
+
+**BlockFace Values**
+
+- `Up`
+- `Down`
+- `North`
+- `South`
+- `East`
+- `West`
+- `None`
+
+**BlockIdMatcher Fields**
+
+| Field Name | Type                                   | Required? | Notes                                                                      |
+| ---------- | -------------------------------------- | --------- | -------------------------------------------------------------------------- |
+| Id         | `Asset`<br />(Asset Type: `BlockType`) | **No**    | If provided, the block must match the specified `BlockType`.               |
+| State      | `String`                               | **No**    | If provided, the block's current state must match the provided state name. |
+| Tag        | `String`                               | **No**    | If provided, the block type's asset tags must contain the provided tag.    |
+
+### DestroyCondition
+
+This interaction fails if the current User entity cannot destroy the current target blcok.
+
+**DestroyCondition Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+
+### PlacementCountCondition
+
+This interaction accepts the name of a BlockType that has the TrackedPlacement BlockEntity. The interaction will fail if the number of
+blocks of the provided BlockType in the world do not match the provided condition.
+
+**PlacementCountCondition Fields**
+
+| Field Name | Type                           | Required? | Notes                                                                                                                                                                                                                                                           |
+| ---------- | ------------------------------ | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Block      | `String`                       | **Yes**   | The BlockType to examine. The number of instances of the BlockType in the world will be compared to Value.<br />**Note: The specified BlockType must have the TrackedPlacement BlockEntity. Otherwise, the number of blocks in the world will always be zero.** |
+| Value      | `Integer`<br />(Default: 0)    | **No**    | The value to compare the number of blocks in the world with.                                                                                                                                                                                                    |
+| LessThan   | \`Boolean<br />(Default: true) | **No**    | If true, the interaction will fail if the number of blocks in the world is greater than or equal to Value. If false, the interaction will fail if the number of blocks in the world is less than or equal to Value.                                             |
+
+### BreakBlock
+
+This interaction attempts to break the target block while acting as the User entity. The User entity must be a player. It
+is not guaranteed to work, depending on world settings and the User entity's current state, it may not work.  If it
+fails, it will fail the interaction under some circumstances, but not others.
+
+**Note: In particular, if `Harvest`=false and the player is in Survival mode, the player will simply execute a damage operation
+against the block. Even when the Tool field is specified, the player's currently-held item can impact the results in unintuitive
+ways.**
+
+This interaction will fail if there is no block target, if `Harvest`=true and the
+block is not harvestable, or if the world settings prevent the Harvest/Break operation.
+It will generally not fail otherwise, even if the block was not broken or damaged.
+The block will generally break every time if `Harvest`=true or the player is in
+Creative mode.
+
+**BreakBlock Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                                                                                                                                                                                                  |
+| ---------------- | ------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction.                                                                                                                                                                      |
+| Harvest          | `Boolean` (Default: false)      | **No**    | If true, harvest the block and deposit the drops in the player's inventory. This operation will generally always succeed.  If false, this interaction will effectively perform whatever action would have occurred if the player had left-clicked the block.                                           |
+| Tool             | `String`                        | **No**    | If `Harvest`=true, the player is in Survival mode, and this field is provided, then the break operation will be performed as though with this tool type.<br />**This field mostly doesn't work.  Your held item will be used for most block damage calculations regardless of this field's contents.** |
+| MatchTool        | `Boolean` (Default: false)      | **No**    | If true, `Harvest`=true, the player is in Survival mode, and `Tool` is provided, block breaking will be prevented unless `Tool` is a valid gathering tool for the target block. The interaction will not be failed, even if block breaking is prevented in this manner.                                |
+
+### ChangeBlock
+
+This interaction requires a mapping from one or more current BlockTypes to one or more target BlockTypes.  If the
+target block is one of the key BlockTypes, then it will be changed to the mapped target BlockType.  If the current
+BlockType of the target block does not appear as a key in the Changes field, then this interaction fails.
+
+**ChangeBlock Fields**
+
+| Field Name        | Type                                                        | Required? | Notes                                                                                                                             |
+| ----------------- | ----------------------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget  | `Boolean`<br />(Default: false)                             | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+| Changes           | `Map`<br />(Key Type: `BlockType`, Value Type: `BlockType`) | **No**    | A list of potential block type changes, with each entry having a current and new BlockType id.                                    |
+| WorldSoundEventId | `Asset`<br />(Asset Type: `SoundEvent`)                     | **No**    | If provided, this SoundEvent is played in the world at the position of the block if the block successfully changes.               |
+| RequireNotBroken  | `Boolean`<br />(Default: false)                             | **No**    | If true, this interaction will fail if the player's held item is broken (durability 0), and the block change will not take place. |
+
+### ChangeState
+
+This interaction requires a mapping from one or more current block state names to one or more state names. If the
+target block is in one of the key block states, then it will be changed to the mapped target blocks tate. If the
+current block state of the target block does nto appear as a key in the Changes field, then this interaction fails.
+
+All blocks start out with a null state by default.  This null state can be referenced by the key "default" and the block
+can be returned to that state with the value "default".
+
+**ChangeState Fields**
+
+| Field Name       | Type                                                  | Required? | Notes                                                                                                                                          |
+| ---------------- | ----------------------------------------------------- | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false)                       | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction.              |
+| Changes          | `Map`<br />(Key Type: `String`, Value Type: `String`) | **No**    | A list of potential block state changes, with each entry having a current and new state name.                                                  |
+| UpdateBlockState | `Boolean`<br />(Default: false)                       | **No**    | If true, performs a full refresh of the block's BlockEntity component and notifies nearby players as though a full block type change occurred. |
+
+### CycleBlockGroup
+
+This interaction will attempt to change the target block to the next block type in one of the BlockGroups it belongs to.
+If the block type belongs to multiple BlockGroups, which one is used is effectively arbitrary. The User entity must be
+a player. If the block cannot be changed for any reason (entity not a player, no block target, block does not belong
+to a BlockGroup, etc.). If the block is the only entry in the BlockGroup, this interaction will succeed and the block
+will be considered changed despite nothing happening.  Unlike most other block-changing interactions, this one will
+fail if the world settings prevent players from breaking blocks.
+
+**This interaction always reduces the player's held item's durability by a single 'hit' worth of damage if the block
+changes. There is no way to prevent it. The block type will change and the interaction will succeed even if the player's
+held item is broken, however.**
+
+**CycleBlockGroup Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+
+### DestroyBlock
+
+This interaction destroys the target block without dropping anything.  It will successfully destroy the block if the
+target block exists and this interaction has no failure conditions.
+
+**This interaction has no additional fields.**
+
+### PickBlock
+
+This interaction is effectively equivalent to using the middle mouse button in creative mode. In survival mode, the
+block's item will be moved to the user's current active hotbar slot if it is in the player's inventory.  This
+interaction is performed entirely on the client and cannot be performed by non-players.  It is unclear if this
+interaction has failure conditions.
+
+**PickBlock Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+
+### PlaceBlock
+
+This interaction is effectively identical to a right clicking while holding a block in their hand, with some
+additional options. For one, it can be executed with any LivingEntity as the User entity. For another, it has some
+useful fields.  For the most part, though, it follows the same behaviors and rules as any ordinary block placement
+by a player.
+
+It's not clear under what circumstances this interaction can fail. The server will not fail the interaction under any
+special circumstances (including when there is no target block, or when `BlockTypeToPlace` is not provided and the
+LivingEntity is not holding a block). However, the client is very involved with the function of this interaction and
+its behavior is unknown.
+
+**PlaceBlock Fields**
+
+| Field Name         | Type                                   | Required? | Notes                                                                                                                                                                                                                                                                                                                                                           |
+| ------------------ | -------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| BlockTypeToPlace   | `Asset`<br />(Asset Type: `BlockType`) | **No**    | If provided, the block placed by this interaction will be the specified BlockType. If not provided, the User entity's held item will be used, instead, if it is a block.                                                                                                                                                                                        |
+| RemoveItemInHand   | `Boolean`<br />(Default: True)         | **No**    | If true and the User entity is not a player in Creative mode, the item in the player's hand must match the block being placed and one quantity will be removed for each block placed. If the item does not match, the block cannot be placed.  If false, the player's hand item is ignored entirely.\*\*                                                        |
+| AllowDragPlacement | `Boolean`<br />(Default: True)         | **No**    | If true and the interaction was triggered on the client by a player, then the player can hold the input that was used to activate this interaction chain and move the mouse around in order to execute this interaction repeatedly and place several blocks. The interaction chain will not move onto the next interaction until the player releases the input. |
+
+### RunOnBlockTypes
+
+This interaction retrieves all blocks within a provided radius of the User entity. For each block that matches any of
+the provided BlockSets, a new interaction chain will be forked that uses the matching block as the target block.
+This interaction will continue executing until all forked interaction chains have completed.  The interaction will fail if no
+blocks within the radius match the provided BlockSets or if all of the forked interaction chains fail.
+
+**RunOnBlockTypes Fields**
+
+| Field Name   | Type                                         | Required?        | Notes                                                                                                                                                                                                                                                                                      |
+| ------------ | -------------------------------------------- | ---------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| Range        | `Integer`                                    | **Yes**          | The spherical radius around the User entity to search for blocks. Must be at least 1.                                                                                                                                                                                                      |
+| BlockSets    | `AssetArray`<br />(Element Type: `BlockSet`) | **No**           | A list of BlockSets to match nearby blocks again. Only blocks that match any of the BlockSets will have interaction chains forked for them.                                                                                                                                                |
+| MaxCount     | `Integer`                                    | **Yes**          | The maximum number of blocks that will be located with the search. Further blocks will be ignored. If there are more matching blocks within the radius than this number, the specific set of blocks that will be found is completely arbitrary and may change from execution to execution. |
+| Interactions | `Asset`<br />(Asset Type: `RootInteraction`) | **No, but yes.** | The RootInteraction that will be forked for each matching block.  This interaction will not fail to validate if it is missing, but every execution of this interaction will fail.                                                                                                          |
+
+### UseBlock
+
+If the target block has an interaction for this interaction chain's interaction type, execute it immediately as part of
+this interaction chain. The execution will be wrapped in UseBlockEvent.Pre and UseBlockEvent.Post events, and cancellations
+of the UserBlockEvent.Pre event are respected. The User entity is considered the triggering entity for both events.
+
+If the target block does not have an interaction for this interaction chain's interaction type, this interaction fails.
+
+**This interaction has no additional fields.**
+
+## Items
+
+These are interactions intended to interface with an entity's inventory. There is no concept of an "item target",
+unfortunately, so these generally either interact with the entity's held item or the entity's inventory at a high level.
+
+### AddItem
+
+Adds a specified quantity of a specified item to the User entity's inventory, preferring to add it to the
+entity's hotbar where possible. This interaction will have no effect on User entities that are not LivingEntities.
+This interaction has no failure states.
+
+**Note: This interaction has a bug in its field validators that will cause interactions that reference items declared
+in the same mod to fail validation on startup.  Additionally, this interaction has a bug that will cause it to
+fail and have no effect if the User entity has no block target. Use ModifyInventory instead.**
+
+**AddItem Fields**
+
+| Field Name       | Type                              | Required? | Notes                                                                                                                             |
+| ---------------- | --------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false)   | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+| ItemId           | `Asset`<br />(Asset Type: `Item`) | **Yes**   | The item id of the item to add to the player's inventory.                                                                         |
+| Quantity         | `Integer`<br />(Default: 0)       | **No**    | The quantity of the item to add to the player's inventory.                                                                        |
+
+### CheckUniqueItemUsage
+
+This interaction will check whether it has run once for the User entity with their currently-held item before. If it hasn't,
+it will succeed. If it has, it will fail. It will also fail if the User entity is not a player. The interaction will record
+the item id of the User entity's currently-held item on success, ensuring it cannot be successfully run with that player
+and item id combination again.
+
+**This interaction has no additional fields.**
+
+### ChangeActiveSlot
+
+This interaction does not inherit from SimpleInteraction and therefore has no Next or Failed fields.  The `CancelOnItemChange`
+field is ignored for this interaction and is always treated as false. This interaction will set the User entity's currently-
+active hotbar slot to the specified slot index. If none is specified, the interaction chain's target slot will be used,
+if any. Otherwise, slot 0 will be used.  If a slot is specified and it is already active, then this interaction will
+have no effect, but if no slot is specified and the interaction chain's target slot is already active, the logic in
+the next paragraph will still be executed. This interaction will also have no effect if the User entity is not a
+LivingEntity.
+
+Once the slot has changed, a new SwapTo interaction chain will be forked off for the selected slot.
+If a target slot was specified, then the interaction chain's current target slot will be set to the specified slot, as will
+the forked SwapTo interaction chain. If this interaction chain was initiated by a player swapping an item into or out of
+an occupied active hotbar slot, then the swap will be executed after the slot is changed and before the SwapTo
+interaction is forked. Not running this interaction in the resulting SwapFrom interaction chain is a way for the server
+to cancel players performing these sorts of swap interactions. The default behavior for these swap interactions is that
+the SwapFrom interaction chain will be initiated with the currently-active-slot as the target slot. As a result, the
+target slot will usually not change when this interaction runs, it merely exists as a signal for the server to continue the
+item swap.
+
+**ChangeActiveSlot Fields**
+
+| Field Name | Type      | Required? | Notes                                                                                                                                                                                                     |
+| ---------- | --------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| TargetSlot | `Integer` | **No**    | If not provided, indicates the slot the player's active hotbar slot should be changed to.  Otherwise, the interaction chain's target slot will be used (which is usually the already-active hotbar slot). |
+
+### EquipItem
+
+This interaction will equip the User entity's currently-held item into the appropriate armor slot, if it is armor. The
+interaction will fail if the item is armor but it cannot be equipped for some reason. The interaction will succeed but
+take no action if the User entity cannot equip armor or if the item is not armor.
+
+**This interaction has no additional fields.**
+
+### IncreaseBackpackCapacity
+
+This interaction will increase the User entity's backpack size by the provided amount.  **It will additionally remove one
+quantity from the player's currently-held item. There is no way to prevent this.**  This interaction will have no effect
+if the User entity is not a player.  This interaction has no special failure conditions, even if the User entity
+is not a player, or the player is not currently holding an item.
+
+| Field Name | Type                        | Required? | Notes                                                                                   |
+| ---------- | --------------------------- | --------- | --------------------------------------------------------------------------------------- |
+| Capacity   | `Integer`<br />(Default: 1) | **No**    | The additional backpack capacity to add to the player. **Must be between 1 and 32767.** |
+
+### ModifyInventory
+
+This interaction attempts to perform one or more inventory-modifying actions against the User entity. The User entity must
+be a player. If they are not, no actions will be performed, but the interaction will not fail. Any item removals performed
+by this interaction, either as a result of `ItemToRemove` or `AdjustHeldItemQuantity`, are both atomic (meaning the entire
+quantity must be removed, or none) and required (meaning that the interaction will fail and no further actions taken if
+the removal fails for any reason).  Item additions performed by this interaction, either as a result of `ItemToAdd` or
+`AdjustHeldItemQuantity` will drop excess items on the ground near the player if necesary and continue on.
+
+This interaction first executes the item removal in `ItemToRemove`, if any, then adjusts the held item as specified by
+`AdjustHeldItemQuantity`, if provided, then executes the item addition in `ItemToAdd`, if any, and then finally executes
+the damage/healing of the held item in `AdjustHeldItemDurability`, if provided.
+
+**ModifyDurability Fields**
+
+| Field Name               | Type                            | Required? | Notes                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
+| ------------------------ | ------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| RequiredGameMode         | `GameMode`                      | **No**    | If provided, only execute the inventory-modifying actions if the player is in the provided GameMode. The interaction will not fail if the GameMode doesn't match.                                                                                                                                                                                                                                                                                                                                                                               |
+| ItemToRemove             | `ItemStack`                     | **No**    | If provided, a matching item will be removed in the provided quantity. If there is no matching item in the player inventory in the required quantity, then the interaction will fail and further actions will not be executed.                                                                                                                                                                                                                                                                                                                  |
+| AdjustHeldItemQuantity   | `Integer`<br />(Default: 0)     | **No**    | The player's held item, if any, will have its quantity will be modified by the provided amount- subtracted from if this number is negative or added to if this item is positive.  If the player has no held item, then this field will have no effect regardless of its value and the interaction will NOT fail.  If the player's inventory does not have sufficient quantity of items to support the removal, this interaction will fail and further actions will not be executed. Excess items will be dropped on the ground near the player. |
+| ItemToAdd                | `ItemStack`                     | **No**    | If provided, the ItemStack will be added to the player's inventory. Excess items will be dropped on the ground near the player.                                                                                                                                                                                                                                                                                                                                                                                                                 |
+| AdjustHeldItemDurability | `Double`<br />(Default: 0.0)    | **No**    | The player's held item, if any, will have its durability adjusted by the specified amount.  The durability cannot go below 0 or raise above the item's maximum durability. Invalid durability values in this field will not cause the interaction to fail. Neither will it fail if the player has no held item.                                                                                                                                                                                                                                 |
+| BrokenItem               | `String`                        | **No**    | This field should contain an ItemId, but it is not validated by the server on startup, so be careful.  This field can have the value of "Empty" to specify no item, or an empty hand. If specified and the `AdjustHeldItemDurability` operation reduces the player's held item to 0 durability, the player's held item is changed to this ItemId. If the inventory replacement fails, this interaction will fail.                                                                                                                               |
+| NotifyOnBreak            | `Boolean`<br />(Default: false) | **No**    | If true and the `AdjustHeldItemDurability` operation reduces the player's held item to 0 durability, this interaction will perform the usual audiovisual feedback of a broken tool. It will play the usual tool breaking sound and send the player a text message in chat that their item has broken.                                                                                                                                                                                                                                           |
+| NotifyOnBreakMessage     | `String`                        | **No**    | If provided, and `NotifyOnBreak` is true, when the player is notified of a broken tool by this interaction, the message sent to their chat will instead be the translation key specified by this field. The translation key supports the templating parameter `{itemName}`. See the translation key `server.general.repair.itemBroken_Hoe` for an example.                                                                                                                                                                                      |
+
+**GameMode Values**
+
+- `Creative`: The game is currently in Creative Mode
+- `Adventure`: The game is currently in Adventure Mode
+
+**ItemStack Fields**
+
+| Field Name                   | Type                              | Required? | Notes                                                                                |
+| ---------------------------- | --------------------------------- | --------- | ------------------------------------------------------------------------------------ |
+| Id                           | `Asset`<br />(Asset Type: `Item`) | **Yes**   | The id of the Item asset this stack contains.                                        |
+| Quantity                     | `Integer`<br />(Default: 1)       | **No**    | The number of items in this stack.<br />**Must be greater than 0.**                  |
+| Durability                   | `Double`<br />(Default: 0.0)      | **No**    | The durability of the item stack.<br />**Cannot be negative.**                       |
+| MaxDurability                | `Double`<br />(Default: 0.0)      | **No**    | The maximum durability of the item this stack contains.<br />**Cannot be negative.** |
+| Metadata                     | `Bson Document`                   | **No**    | If provided, applies the bson to the item stack metadata.                            |
+| OverrideDroppedItemAnimation | `Boolean`\*(Default: false)       | **No**    | ???                                                                                  |
+
+### PickupItem
+
+This interaction will attempt to pick up the User entity's current target entity and add it to their inventory. It will
+fail if the User entity is not a player, if they do not have a target entity, or if the target entity is not an item
+located in the world.  It will not fail if the player simply cannot pick up the item.
+
+**This interaction has no additional fields.**
+
+### RefillContainer
+
+This interaction will fail if the User entity is not a player. The interaction will draw a ray from the player's head
+down their look direction until the edge of the player's held item's interaction range or until the first solid block.
+The nearest fluid block of a type listed in this interaction's `States` map will result in the one of the player's
+currently-held items being converted to the fluid's related item state.  If the `States` map indicates a durability
+for the new item state, then the converted item will use that durability. If the item is already in the fluid's related
+item state, then this interaction will fail if the player's held item is already at maximum durability (unless the
+`States` map indicates a durability value greater than the item's maximum, in which case the interaction will succeed
+but the item will not change).  Otherwise, the durability listed for the fluid in the `States` map will be added to the
+item's current durability.
+
+If the interaction has not failed by this point, the fluid block in the world may be transformed to a different type if one is listed
+in the `States` map.
+
+If any part of this process does not proceed for any reason (for instance, if the player is not holding an item),
+then this interaction will fail.
+
+**RefillContainer Fields**
+
+| Field Name | Type                                                       | Required? | Notes                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| ---------- | ---------------------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| States     | `Map`<br />(Key Type: `String`, Value Type: `RefillState`) | **Yes**   | A map from item state names to `RefillState` objects, which contain information such as acceptable fluid block types, durability increases, and what fluid type to convert the targeted fluid block to after refill, if any. If the player targets a fluid block that matches one of the fluid types in the `RefillState`, the item will be converted to the keyed item state and the `RefillState` will be used to decide what happens next. |
+
+**RefillState Fields**
+
+| Field Name     | Type                                  | Required? | Notes                                                                                                                                                                                                                                                                                                                           |
+| -------------- | ------------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| AllowedFluids  | `Array`<br />(Element Type: `String`) | **Yes**   | If any of these fluids are targeted by the player, the player's held item will be converted to the keyed item state and `Durability` and `TransformFluid` will be used.                                                                                                                                                         |
+| Durability     | `Double`<br />(Default: -1.0)         | **No**    | If the player's held item changes item states, this value is the new item's durability, unless it is negative, in which case the item will begin at full durability. If the player's held item is already in the item state, and the item is not already at full durability, this value will be added to the item's durability. |
+| TransformFluid | `String`                              | **No**    | If provided, this field is a fluid id that the targeted fluid block should be transformed to if the player's held item is successfully updated.                                                                                                                                                                                 |
+
+## Entities
+
+### DamageEntity
+
+This interaction does not inherit from SimpleInteraction, but adds its own Next and Failed fields that
+work similarly.
+
+This interaction will cause the User entity to damage the Target entity.  It has the capability to apply different
+damage based on the direction of the attack or what body part was targeted by the User entity, with each possibility
+providing different damage calculations, effects, and Next interaction. If multiple entires match the attack, `TargetedDamage`
+(body part damage) takes highest priority, then the first matching `AngledDamage` in the list, then the default
+damage in the base interaction fields.  It is possible for elements of these different damage priorities to be taken peacemeal if higher-priority
+damage fields do not overwrite lower-priority damage fields. For instance,
+damage calculation could be taken from `TargetedDamage`, the damage effects could be taken from the first matching
+`AngledDamage`, and the Next interaction coming from the default damage field.
+
+If all damage dealt by this interaction is cancelled, then this interaction will fail, and the `Failed` interaction
+will be executed next in the chain. If any damage dealt by this interaction is blocked, then this interaction will
+succeed, but the `Blocked` interaction wil lbe executed next in the chain. Otherwise, the highest-precedent matching
+`Next` interaction that you provide will be executed.  For instance, if you provide `Next` interactions for all
+`TargetedDamage` and `AngledDamage` entries, and one in the interaction's `Next` field, then a headshot could result
+in a unique `Next` interaction being executed, even if there is a matching `AngledDamage` entry. However, if you leave
+the `Next` interaction out of your `TargetedDamage` entries, a special `Next` interaction for backstabs could be
+executed.  Otherwise, the `Next` field in the root of the interaction will be executed instead.
+
+DamageEntity has an unusual relationship with `RunTime`. This interaction always ends immediately after its first tick,
+regardless of the status of `RunTime` or `WaitForAnimationToFinish`.  However, if damage dealt by this interaction is
+calculated as `DamageCalculatorType` `Dps`, then the `RunTime` will be used to determine the precise amount of damage to
+deal. If `RunTime` is 0, then no damage will be dealt.
+
+**DamageEntity Fields**
+
+| Field Name       | Type                                                          | Required?                                                                                                                    | Notes                                                                                                                                                                                                                                                                                                                                                                         |
+| ---------------- | ------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| DamageCalculator | `DamageCalculator`                                            | **No**                                                                                                                       | If provided, describes the damage amounts and types to apply to the Target entity.                                                                                                                                                                                                                                                                                            |
+| DamageEffects    | `DamageEffects`                                               | **No**                                                                                                                       | If provided, describes particles, sounds, knockback, etc. to apply to the target entity on damage.                                                                                                                                                                                                                                                                            |
+| Next             | `Asset`<br />(Asset Type: `Interaction`)                      | **No**  After this interaction has finished, "Next" will be executed if damage was dealt to the target and none was blocked. |                                                                                                                                                                                                                                                                                                                                                                               |
+| AngledDamage     | `Array`<br />(Element Type: `AngledDamage`)                   | **No**                                                                                                                       | If provided, allows alternative `DamageCalculator`, `DamageEffects`, and `Next` entries for attacks that approach the target from certain angles.                                                                                                                                                                                                                             |
+| TargetedDamage   | `Map`<br />(Key Type: `String`, Value Type: `TargetedDamage`) | **Yes**                                                                                                                      | This field must be provided, but is not required to have any entries.  This is a map from body part names to `TargetedDamage` values. Hypixel only uses one body part name: `Head`, and it is not clear whether there are others.  If provided, allows alternative `DamageCalculator`, `DamageEffects`, and `Next` entries for attacks that damage specific enemy body parts. |
+| EntityStatsOnHit | `Array`<br />(Element Type: `EntityStatOnHit`)                | **No**                                                                                                                       | If provided, allows this attack to reduce enemy stats other than health.  Each individual damage application dealt by the same ability will apply stat reductions, at diminishing returns. All damage dealt in interaction chains forked by a Selector interaction will share the number of hits across all targets.                                                          |
+| Failed           | `Asset`<br />(Asset Type: `Interaction`)                      | **No**                                                                                                                       | After this interaction has finished, "Failed" will be executed if no damage hits were applied to the player, or if all damage hits were cancelled.                                                                                                                                                                                                                            |
+| Blocked          | `Asset`<br />(Asset Type: `Interaction`)                      | **No**                                                                                                                       | After this interaction has finished, "Blocked" will be executed if any damage hits were blocked by the target.                                                                                                                                                                                                                                                                |
+
+**DamageCalculator Fields**
+
+| Field Name                | Type                                                      | Required? | Notes                                                                                                                                                                                                                                                 |
+| ------------------------- | --------------------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Type                      | `DamageCalculatorType`<br />(Default: Absolute)           | **No**    | Whether the damage being applied is `Absolute` or \`Dps'.                                                                                                                                                                                             |
+| Class                     | `DamageClass`<br />(Default: Unknown)                     | **No**    | The type of attack producing the damage. Some weapon systems apply equipment modifiers based on this value.                                                                                                                                           |
+| BaseDamage                | `Map`<br />(Key Type: `DamageCause`, Value Type: `Float`) | **No**    | A set of DamageCauses and how much base damage is dealt for each.                                                                                                                                                                                     |
+| SequentialModifierStep    | `Float`<br />(Default: 0.0)                               | **No**    | Value between 0.0-1.0. Each additional hit from a single ability will have its damage reduced by this much as a percentage. All damage dealt in interaction chains forked by a Selector interaction will share the number of hits across all targets. |
+| SequentialModifierMinimum | `Float`<br />(Default: 0.0)                               | **No**    | Value between 0.0-1.0. `SequentialModifierStep` cannot reduce damage below this percentage regardless of the number of hits.                                                                                                                          |
+| RandomPercentageModifier  | `Float`<br />(Default: 0.0)                               | **No**    | A random value between +/- this amount multiplied by the base damage will be added to the base damage.                                                                                                                                                |
+
+**DamageEffects Fields**
+
+| Field Name             | Type                                         | Required? | Notes                                                                                   |
+| ---------------------- | -------------------------------------------- | --------- | --------------------------------------------------------------------------------------- |
+| ModelParticles         | `Array`<br />(Element Type: `ModelParticle`) | **No**    | Particle systems to trigger in the first-person view.                                   |
+| WorldParticles         | `Array`<br />(Element Type: `WorldParticle`) | **No**    | Particle systems to trigger in the third-person view.                                   |
+| LocalSoundEventId      | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | 2D sound to play locally to the attacking entity if they are a player.                  |
+| WorldSoundEventId      | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | Sound to play in the world at the Target entity's location.                             |
+| PlayerSoundEventId     | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | 2D sound to play locally to the Target entity if they are a player.                     |
+| ViewDistance           | `Double`<br />(Default: 75.0)                | **No**    | Distance at which these effects should play for other players.                          |
+| Knockback              | `Knockback`                                  | **No**    | The properties of the knockback that will be applied.                                   |
+| CameraEffect           | `Asset`<br />(Asset Type: `CameraEffect`)    | **No**    | CameraEffect to briefly apply locally to the Target entity if they are a player.        |
+| StaminaDrainMultiplier | `Float`<br />(Default: 1.0)                  | **No**    | This multiplier is applied to the stamina cost incurred by the target blocking, if any. |
+
+**AngledDamage Fields**
+
+| Field Name       | Type                                     | Required? | Notes                                                                                                                                                                                                     |
+| ---------------- | ---------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| AngleDistance    | `Float`<br />(Default: 0)                | **No**    | The width in degrees of the matching arc around the Target entity. If the attack against the Target originates from within the arc, then the properties below will be applied to the attack, if provided. |
+| Angle            | `Float`<br />(Default: 0.0)              | **No**    | The angle in degrees around the Target entity at which the matching arc is centered.                                                                                                                      |
+| DamageCalculator | `DamageCalculator`                       | **No**    | If provided and the attack against the Target entity originates from within the provided arc, this DamageCalculator will override the interaction's `DamageCalculator` field.                             |
+| DamageEffects    | `DamageEffects`                          | **No**    | If provided and the attack against the Target entity originates from within the provided arc, this DamageEffects will override the interaction's `DamageEffects` field.                                   |
+| Next             | `Asset`<br />(Asset Type: `Interaction`) | **No**    | If provided and the attack against the Target entity originates from within the provided arc, this Interaction will override the interaction's `Next` field.                                              |
+
+**TargetedDamage Fields**
+
+| Field Name       | Type                                     | Required? | Notes                                                                                                                                                                                            |
+| ---------------- | ---------------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| DamageCalculator | `DamageCalculator`                       | **No**    | If provided and this TargetedDamage was matched, this DamageCalculator will override the interaction's `DamageCalculator` field and the `DamageCalculator` field of any matching `AngledDamage`. |
+| DamageEffects    | `DamageEffects`                          | **No**    | If provided and this TargetedDamage was matched, this DamageEffects will override the interaction's `DamageEffects` field and the `DamageEffects` field of any matching `AngledDamage`.          |
+| Next             | `Asset`<br />(Asset Type: `Interaction`) | **No**    | If provided and this TargetedDamage was matched, this Interaction will override the interaction's `Next` field and the `Next` field of any matching `AngledDamage`.                              |
+
+**EntityStatOnHit Fields**
+
+| Field Name                  | Type                                                                       | Required? | Notes                                                                                                                                                                                                                                                                                        |
+| --------------------------- | -------------------------------------------------------------------------- | --------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| EntityStatId                | `Asset`<br />(AssetType: `EntityStatType`)                                 | **Yes**   | Which entity stat to affect.                                                                                                                                                                                                                                                                 |
+| Amount                      | `Float`<br />(Default: 0.0)                                                | **No**    | How much of the stat to apply for each damage application. Use negative numbers to reduce stats.                                                                                                                                                                                             |
+| MultipliersPerEntitiesHit   | `Array`<br />(Element Type: `Float`, Default: `[1.0, 0.6, 0.4, 0.2, 0.1]`) | **No**    | The diminishing returns curve to be applied for multiple damage applications by the same ability. Each hit's stat impact will be multiplied by the next value in the list.  If there are more hits than array elements, subsequent hits will be multiplied by `MultiplierPerExtraEntityHit`. |
+| MultiplierPerExtraEntityHit | `Float`<br />(Default: 0.05)                                               | **No**    | If an ability carries out more damage applications than there are elements in the `MultipliersPerEntitiesHit` array, then subsequent stat values will be multiplied by this number.                                                                                                          |
+
+**Knockback Fields**
+
+| Field Name     | Type                                       | Required? | Notes                                                                                                                      |
+| -------------- | ------------------------------------------ | --------- | -------------------------------------------------------------------------------------------------------------------------- |
+| Type           | `String`                                   | **No**    | If provided, specifies a type of knockback to use. Each Target type may come with additional fields.                       |
+| Force          | `Double`<br />(Default: 0.0)               | **No**    | The amount of force to apply to the Owner entity.                                                                          |
+| Duration       | `Double`<br />(Default: 0.0)               | **No**    | If 0.0, apply the force as a single impulse.  If more, continuously apply the force over a period of time.                 |
+| VelocityType   | `ChangeVelocityType`<br />(Default: `Add`) | **No**    | How to apply the force, either adding it to the entity's current velocity, or setting the velocity to the knockback force. |
+| VelocityConfig | `VelocityConfig`                           | **No**    | Characteristics of friction as the Owner entity is thrown by this knockback.                                               |
+
+**Knockback Type: Force**
+
+Apply the calculated knockback force along the provided direction.
+
+| Field Name | Type                         | Required? | Notes                                                                                |
+| ---------- | ---------------------------- | --------- | ------------------------------------------------------------------------------------ |
+| Direction  | `Vector3`<br />(Default: Up) | **No**    | Which direction the entity should be flung, relative to the direction of the attack. |
+
+**Knockback Type: Point**
+
+Apply the calculated knockback force laterally along the XZ plane, plus provided Y velocity.
+
+| Field Name | Type                        | Required? | Notes                                                                                                   |
+| ---------- | --------------------------- | --------- | ------------------------------------------------------------------------------------------------------- |
+| OffsetX    | `Integer`<br />(Default: 0) | **No**    | Offset the source position of the knockback left or right perpendicular to the direction of the attack. |
+| OffsetZ    | `Integer`<br />(Default: 0) | **No**    | Offset the source position of the knockback, forward or backward along the directon of the attack.      |
+| RotateY    | `Integer`<br />(Default: 0) | **No**    | Rotate the knockback direction around the Y axis, where 0 is the default attack direction.              |
+| VelocityY  | `Float`<br />(Default: 0.0) | **No**    | Add vertical velocity to the knockback force after the direction and force has been calculated.         |
+
+**Knockback Type: Directional**
+
+Apply the calculated knockback force along the attack direction, removing any vertical component and replacing it with a provided Y velocity.
+
+| Field Name | Type                      | Required? | Notes                                                                                                                                            |
+| ---------- | ------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------ |
+| RelativeX  | `Float`<br />(Default: 0) | **No**    | Apply additional force left or right perpendicular to the direction of the attack. The additional force is multiplied by the knockback strength. |
+| RelativeZ  | `Float`<br />(Default: 0) | **No**    | Apply additional force forward or backward along the attack direction. The additional force is multiplied by the knockback strength.             |
+| VelocityY  | `Float`<br />(Default: 0) | **No**    | Replace the vertical velocity of the knockback with this value.  This value is not multiplied by knockback strength.                             |
+
+**VelocityConfig Fields**
+
+| Field Name          | Type                                              | Required? | Notes                                                                                                                                                                                           |
+| ------------------- | ------------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| GroundResistance    | `Float`<br />(Default: 0.82)                      | **No**    | The minimum amount of friction applied when the entity is in contact with the ground.  1.0 = no friction, 0.0 = total friction                                                                  |
+| GroundResistanceMax | `Float`<br />(Default: 0.0)                       | **No**    | The maximum amount of friction applied when the entity is in contact with the ground.  1.0 = no friction, 0.0 = total friction                                                                  |
+| AirResistance       | `Float`<br />(Default: 0.96)                      | **No**    | The minimum amount of friction applied when the entity is in the air. 1.0 = no friction, 0.0 = total friction                                                                                   |
+| AirResistanceMax    | `Float`<br />(Default: 0.0)                       | **No**    | The maximum amount of friction applied when the entity is in the air. 1.0 = no friction, 0.0 = total friction                                                                                   |
+| Threshold           | `Float`<br />(Default: 1.0)                       | **No**    | The speed at which the maximum amount of friction will be applied to the entity. The amount of friction applied will increase from minimum to maximum as the entity moves from 0 to this speed. |
+| Style               | `VelocityThresholdStyle`<br />(Default: `Linear`) | **No**    | The curve that friction follows as the entity's speed increases toward the `Threshold`.                                                                                                         |
+
+**DamageCalculatorType Values**
+
+- `Absolute`
+- `Dps`
+
+**DamageClass Values**
+
+- `Unknown`
+- `Light`
+- `Charged`
+- `Signature`
+
+**ChangeVelocityType Values**
+
+- `Add`
+- `Set`
+
+**VelocityThresholdStyle Values**
+
+- `Linear`
+- `Exp`
+
+### LaunchProjectile
+
+This is just a worse version of Projectile and is slated to be removed.  Use Projectile.
+
+### Projectile
+
+This interaction will spawn a new projectile at the User entity's eye position that will travel in its look direction.
+
+| Field Name | Type                                          | Required? | Notes                                                  |
+| ---------- | --------------------------------------------- | --------- | ------------------------------------------------------ |
+| Config     | `Asset`<br />(Asset Type: `ProjectileConfig`) | **No**    | Configuration describing the projectile to be spawned. |
+
+### RemoveEntity
+
+Despawns the specified entity from the world. This interaction will have no effect if the specified entity is a player. This
+interaction has no special failure conditions.
+
+| Field Name | Type                                     | Required? | Notes                  |
+| ---------- | ---------------------------------------- | --------- | ---------------------- |
+| Entity     | `InteractionTarget`<br />(Default: User) | **No**    | The entity to despawn. |
+
+**InteractionTarget Values**
+
+- `User` - The user of this interaction chain. The entity whose actions caused this interaction chain to be executed. This is usually the same as the Owner.
+- `Owner` - The owner of this interaction chain. The entity upon whom this interaction chain is executing.
+- `Target` - The entity target of this interaction chain, if any.  This value is mutable (and can therefore come from many places) but most commonly, it is an entity the User was targeting when this interaction chain began executing.
+
+### SendMessage
+
+This interaction sends a message to the Owner entity if that entity can receive messages.  Otherwise, the message
+is written to the server logs.  If the entity is a player, the message will appear in the player's chat window.
+
+\*\*SendMessage
+
+| Field Name | Type     | Required? | Notes                                                                                                                 |
+| ---------- | -------- | --------- | --------------------------------------------------------------------------------------------------------------------- |
+| Message    | `String` | **No**    | A text message to be sent to the Owner entity.  If this field is not provided, `Key` is used instead.                 |
+| Key        | `String` | **No**    | A translation key for a message to be sent to the Owner entity. If `Message` is provided, then this field is ignored. |
+
+### UseEntity
+
+This interaction is not in use by Hypixel and has some unusual qualities that mean it probably won't do what you want it
+to.  Do not use it.
+
+This interaction will retrieve the entity currently targeted by the client (NOT the interaction chain's current Target
+entity) and execute that entity's RootInteraction for this interaction chain's current interaction type. The
+RootInteraction will be executed as part of this current interaction chain. None of the properties of this interaction
+chain will be modified.
+
+This interaction will fail if the client is not currently targeting an entity, or if no interaction for the current
+interaction type exists on the entity.
+
+## Stats
+
+Hytale's resource system has been written about fairly extensively.  You can use these interactions to modify stats in
+response to actions or use stats as a cost for abilities.
+
+### ChangeStat
+
+This interaction applies a set of raw stat changes to the User entity. It has no special failure conditions.
+
+| Field Name    | Type                                                         | Required? | Notes                                                                                                                                                                                                                      |
+| ------------- | ------------------------------------------------------------ | --------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| StatModifiers | `Map`<br />(Key Type: `EntityStatType`, Value Type: `Float`) | **Yes**   | A set of stats to modify and what value to apply to them.                                                                                                                                                                  |
+| ValueType     | `ValueType`<br />(Default: Absolute)                         | **No**    | Whether the values in the `StatModifiers` map represent flat values to apply to the stat total, or percentages (0.0-100.0). Percentage values are percentage of the difference between the maximum and minimum stat value. |
+| Behaviour     | `ChangeStatBehavior`<br />(Default: Add)                     | **No**    | Whether the values in the `StatModifiers` map represent deltas to add into the User entity's current stat values, or fixed values to set the entity's stats to.                                                            |
+
+**ValueType Values**
+
+- `Absolute`
+- `Percent`
+
+**ChangeStatBehaviour Values**
+
+- `Add`
+- `Set`
+
+### ChangeStatWithModifier
+
+This interaction is like ChangeStat, except an armor stat modifier can be chosen which will apply bonuses and penalties
+to a stat from the User entity's equipped armor before it is applied.
+
+| Field Name            | Type                                                         | Required? | Notes                                                                                                                                                                                                                      |
+| --------------------- | ------------------------------------------------------------ | --------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| StatModifiers         | `Map`<br />(Key Type: `EntityStatType`, Value Type: `Float`) | **Yes**   | A set of stats to modify and what value to apply to them.                                                                                                                                                                  |
+| ValueType             | `ValueType`<br />(Default: Absolute)                         | **No**    | Whether the values in the `StatModifiers` map represent flat values to apply to the stat total, or percentages (0.0-100.0). Percentage values are percentage of the difference between the maximum and minimum stat value. |
+| Behaviour             | `ChangeStatBehavior`<br />(Default: Add)                     | **No**    | Whether the values in the `StatModifiers` map represent deltas to add into the User entity's current stat values, or fixed values to set the entity's stats to.                                                            |
+| InteractionModifierId | `InteractionModifierId`                                      | **Yes**   | The armor interaction modifier to apply bonuses and penalties for.                                                                                                                                                         |
+
+**ValueType Values**
+
+- `Absolute`
+- `Percent`
+
+**ChangeStatBehaviour Values**
+
+- `Add`
+- `Set`
+
+**InteractionModifierId Values**
+
+- `Dodge`
+
+### StatsCondition
+
+This interaction will fail if the User entity cannot afford the specified stats costs, or if it does not have the
+requested stats.
+
+| Field Name | Type                                                         | Required? | Notes                                                                                                                                                                                    |
+| ---------- | ------------------------------------------------------------ | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Costs      | `Map`<br />(Key Type:` EntityStatType`, Value Type: `Float`) | **Yes**   | A set of costs that the User entity needs to be able to afford for this interaction to succeed.                                                                                          |
+| ValueType  | `ValueType`<br />(Default: Absolute)                         | **No**    | Whether the values in the `Costs` map represetn flat values or percentages (0.0-100.0).  Percentage values are percentage of the difference between the maximum and minimum value.       |
+| LessThan   | `Boolean`<br />(Default: false)                              | **No**    | If true, this interaction will fail unless the User entity's current stat values are at or **below** the specified levels.  If false, they must be at or **above** the specified levels. |
+| Lenient    | `Boolean`<br />(Default: false)                              | **No**    | If true and `LessThan` is true, and a player's minimum stat value is below zero, then the player can afford a stat cost if the current value of a stat if above 0.                       |
+
+**ValueType Values**
+
+- `Absolute`
+- `Percent`
+
+### StatsConditionWithModifier
+
+This interaction is like StatsCondition, except an armor stat modifier can be chosen which will apply bonuses and penalties
+to a stat's cost from the User entity's equipped armor before it is compared.
+
+| Field Name            | Type                                                         | Required? | Notes                                                                                                                                                                                    |
+| --------------------- | ------------------------------------------------------------ | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Costs                 | `Map`<br />(Key Type:` EntityStatType`, Value Type: `Float`) | **Yes**   | A set of costs that the User entity needs to be able to afford for this interaction to succeed.                                                                                          |
+| ValueType             | `ValueType`<br />(Default: Absolute)                         | **No**    | Whether the values in the `Costs` map represetn flat values or percentages (0.0-100.0).  Percentage values are percentage of the difference between the maximum and minimum value.       |
+| LessThan              | `Boolean`<br />(Default: false)                              | **No**    | If true, this interaction will fail unless the User entity's current stat values are at or **below** the specified levels.  If false, they must be at or **above** the specified levels. |
+| Lenient               | `Boolean`<br />(Default: false)                              | **No**    | If true and `LessThan` is true, and a player's minimum stat value is below zero, then the player can afford a stat cost if the current value of a stat if above 0.                       |
+| InteractionModifierId | `InteractionModifierId`                                      | **Yes**   | The armor interaction modifier to apply bonuses and penalties for.                                                                                                                       |
+
+**ValueType Values**
+
+- `Absolute`
+- `Percent`
+
+**InteractionModifierId Values**
+
+- `Dodge`
+
+## EntityEffects
+
+EntityEffects are buff or debuff effects that can be applied to a LivingEntity.  These can have a variety of effects from
+movement speed changes to periodic damage.
+
+### EffectCondition
+
+This interaction will fail if the specified entity's EntityEffects do not match the provided conditions.
+
+**EffectCondition Fields**
+
+| Field Name      | Type                                             | Required? | Notes                                                                                                                                                                                                             |
+| --------------- | ------------------------------------------------ | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Entity          | `InteractionTarget`<br />(Default: User)         | **Yes**   | The entity to examine for EntityEffects. This field can indicate the Owner, User, or Target of this interaction chain.                                                                                            |
+| Match           | `Match`<br />(Default: All)                      | **No**    | If `All`, then this interaction will fail if any EntityEffect in the `EntityEffectIds` is not on the specified entity. If `None`, then this interaction will fail if any EntityEffect IS on the specified entity. |
+| EntityEffectIds | `AssetArray`<br />(Element Type: `EntityEffect`) | **Yes**   | The set of EntityEffects to check against the specified entity and `Match`.                                                                                                                                       |
+
+**InteractionTarget Values**
+
+- `User` - The user of this interaction chain. The entity whose actions caused this interaction chain to be executed. This is usually the same as the Owner.
+- `Owner` - The owner of this interaction chain. The entity upon whom this interaction chain is executing.
+- `Target` - The entity target of this interaction chain, if any.  This value is mutable (and can therefore come from many places) but most commonly, it is an entity the User was targeting when this interaction chain began executing.
+
+**Match Values**
+
+- `All` - All EntityEffects must be on the specified entity for this interaction to succeed.
+- `None` - None of the EntityEffects must be on the specified entity for this interaction to succeed.
+
+### ApplyEffect
+
+This interaction will apply the specified EntityEffect to the specified Entity.  It has no special failure conditions.
+
+**ApplyEffect Fields**
+
+| Field Name | Type                                      | Required? | Notes                                                                                                                  |
+| ---------- | ----------------------------------------- | --------- | ---------------------------------------------------------------------------------------------------------------------- |
+| Entity     | `InteractionTarget`<br />(Default: User)  | **Yes**   | The entity to apply the EntityEffect to. This field can indicate the Owner, User, or Target of this interaction chain. |
+| EffectId   | `Asset`<br />(Asset Type: `EntityEffect`) | **Yes**   | The effect to apply.                                                                                                   |
+
+**InteractionTarget Values**
+
+- `User` - The user of this interaction chain. The entity whose actions caused this interaction chain to be executed. This is usually the same as the Owner.
+- `Owner` - The owner of this interaction chain. The entity upon whom this interaction chain is executing.
+- `Target` - The entity target of this interaction chain, if any.  This value is mutable (and can therefore come from many places) but most commonly, it is an entity the User was targeting when this interaction chain began executing.
+
+### ClearEntityEffect
+
+This interaction will remove the specified EntityEffect from the specified Entity. It has no special failure conditions.
+It will not fail if the Entity does not have the EntityEffect.
+
+**ClearEntityEffect Fields**
+
+| Field Name | Type                                      | Required? | Notes                                                                                                                     |
+| ---------- | ----------------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------- |
+| Entity     | `InteractionTarget`<br />(Default: User)  | **Yes**   | The entity to remove the EntityEffect from. This field can indicate the Owner, User, or Target of this interaction chain. |
+| EffectId   | `Asset`<br />(Asset Type: `EntityEffect`) | **Yes**   | The effect to remove.                                                                                                     |
+
+**InteractionTarget Values**
+
+- `User` - The user of this interaction chain. The entity whose actions caused this interaction chain to be executed. This is usually the same as the Owner.
+- `Owner` - The owner of this interaction chain. The entity upon whom this interaction chain is executing.
+- `Target` - The entity target of this interaction chain, if any.  This value is mutable (and can therefore come from many places) but most commonly, it is an entity the User was targeting when this interaction chain began executing.
+
+## Farming
+
+These are interaction types built to support the in-game farming system in Hytale. They are mostly block-related interactions
+with a few exceptions.
+
+### ChangeFarmingStage
+
+If the target block is a farming block, this interaction will attempt to modify the current farming stage in one of
+three ways.  The interaction can optionally specify which StageSet to use for the new stage. If it is not specified,
+the current StageSet will be used. If any part of the the process of changing the growth stage fails, this interaction
+will fail, with the one exception that attempting to set the stage to the crop's existing stage will have no effect but
+still succeed.
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                                                                                                                                                                          |
+| ---------------- | ------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction.                                                                                                                                              |
+| StageSet         | `String`                        | **No**    | If provided, set the block's current stage to one in the provided StageSet. Otherwise, use the crop's current StageSet.                                                                                                                                                        |
+| Increase         | `Integer`                       | **No**    | If provided, increase the current stage by the specified amount. If the specified stage does not exist, the block will be set to the closest extant stage.                                                                                                                     |
+| Decrease         | `Integer`                       | **No**    | If provided and `Increase` is not provided, decrease the current stage by the specified amount. If the specified stage does not exist, the block will be set to the closest extant stage.                                                                                      |
+| Stage            | `Integer`<br />(Default: -1)    | **No**    | If provided and `Increase`/`Decrease` are not provided, set the current stage to the specified stage. If this value is less than 0, set the current stage to the final growth stage. If the specified stage does not exist, the block will be set to the closest extant stage. |
+
+### FertilizeSoil
+
+If the target block is unfertilized tilled soil or a farming block on top of unfertilized tilled soil, fertilizes the soil.
+The interaction will fail otherwise.
+
+**FertilizeSoil Fields**
+
+| Field Name       | Type                                  | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false)       | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+| RefreshModifiers | `Array`<br />(Element Type: `String`) | **No**    | Does nothing.                                                                                                                     |
+
+### HarvestCrop
+
+This interaction will attempt to execute the harvest action on the current block target and add the crop's drops to the User entity's
+inventory.  The block will either be destroyed or set to its post-harvest growth stage, depending on the farming
+configuration of the block.  This will happen (and the player will receive the full harvest drops) regardless of the
+block's current growth stage. This interaction has no special failure conditions, even if the block target isn't a
+farming block or gathering isn't permitted in the current world, but nothing will occur in those cases.
+
+**HarvestCrop Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+
+### UseWateringCan
+
+If the target block is tilled soil or a farming block on top of tilled soil, waters the soil for the specified duration.
+The interaction will fail otherwise.
+
+**UseWateringCan Fields**
+
+| Field Name       | Type                                  | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false)       | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+| Duration         | `Integer`<br />(Default: 0)           | **No**    | The duration in seconds to water the soil for.                                                                                    |
+| RefreshModifiers | `Array`<br />(Element Type: `String`) | **No**    | Does nothing.                                                                                                                     |
diff --git a/content/docs/lv-LV/contributing/pr-guidelines.mdx b/content/docs/lv-LV/contributing/pr-guidelines.mdx
index 98228ff9..08e67ce9 100644
--- a/content/docs/lv-LV/contributing/pr-guidelines.mdx
+++ b/content/docs/lv-LV/contributing/pr-guidelines.mdx
@@ -19,6 +19,8 @@ Lai nodrošinātu vienmērīgu un efektīvu pārskatīšanas procesu, gan līdzd
 4. **Koda Kvalitāte**
    - Pārliecinieties, ka tavs kods atbilst projekta kodēšanas standartiem un labākajai praksei.
    - Iekļauj komentārus tur, kur nepieciešams izskaidrot sarežģītu loģiku.
+   - Always test your changes locally before submitting the PR to catch any issues early.
+   - Format your code using `bun format` to maintain consistency across the codebase.
 5. **Testēšana**
    - Pirms PR iesniegšanas rūpīgi pārbaudiet izmaiņas.
    - Ja piemērojams, iekļaujiet vienību testus vai integrācijas testus, lai pārbaudītu izmaiņas.
diff --git a/content/docs/lv-LV/contributing/translate.mdx b/content/docs/lv-LV/contributing/translate.mdx
new file mode 100644
index 00000000..c62ffdde
--- /dev/null
+++ b/content/docs/lv-LV/contributing/translate.mdx
@@ -0,0 +1,74 @@
+---
+title: Translate
+description: How to translate HytaleModding to your language
+---
+
+# Translating HytaleModding
+
+HytaleModding is translated with the help of the community using **Crowdin**. If you want to help translate or improve existing translations, this is the right place.
+
+## Steps to Translate
+
+All translations are managed **via Crowdin**.
+
+1. Visit [our Crowdin project](https://crowdin.com/project/hytalemodding) and log in if required.
+2. Click on your language.
+3. Click on the file/article you wish to translate. We recommend starting with Official Documentation, and then Server Plugin Documentation.
+4. Start translating!
+5. Approved translations will appear on the website.
+
+### Video Guide
+
+<iframe src="https://www.youtube.com/embed/NHiG1rDRgks" allowFullScreen />
+
+## How to discuss
+
+You can always report issues or discuss specific topics directly on Crowdin, but we recommend using Discord instead of the Crowdin comment system to keep everything organized in one place.
+
+1. Join [our Discord](https://discord.gg/hytalemodding)
+2. Open `#translations` channel. Here you can discuss or ask questions that are not related to a specific language.
+3. If you want to join a thread, you are required to run `/translator <your-language>` command here. The bot will add you to the thread for your language.
+
+## Translation Guidelines
+
+- You need to be confident in what you are translating. You should be able to read the text you just translated and understand the meaning of it very easily.
+- It should use the simplest form of language possible. Use English words if the translation is unknown to the majority in your country.
+- Use your imagination, trust yourself. Feel free to change any context as you wish as long as it can still get the same point across and is understandable.
+- These guidelines are more important than language-specific guidelines, but less important than Hytale terminology and rules.
+
+## What not to translate
+
+We request you all to not translate these specific sections of the website:
+
+### Callout types
+
+Callouts are the boxes that contain important information. We request you to not translate the types as they only work in English.
+
+**Example:**
+
+```mdx
+<Callout type="warning" title="Translate this title!">
+Translate the text inside the callout!
+</Callout>
+```
+
+In this example, please don't translate the word warning, the rest you can translate.
+
+### Icons
+
+Icon names must not be translated.
+They are technical identifiers mapped directly to existing icons. Translating them will break the icon rendering.
+
+```mdx
+icon: Globe
+```
+
+---
+
+{/* 
+For translators who will edit this page:
+
+- You are required to translate the Guidelines as they change.
+- General guidelines should be translated but not edited.
+- Learn how to use Markdown from writing_guides.mdx
+*/}
diff --git a/content/docs/lv-LV/established-information/server/content-categories/art-assets.mdx b/content/docs/lv-LV/established-information/server/content-categories/art-assets.mdx
index 4a2b6369..d73b4364 100644
--- a/content/docs/lv-LV/established-information/server/content-categories/art-assets.mdx
+++ b/content/docs/lv-LV/established-information/server/content-categories/art-assets.mdx
@@ -14,7 +14,7 @@ Hytale sniedz visaptverošu atbalstu 3D modelēšanai un tekstūru izstrādāša
 Hytale izmanto **blockbench** kā primāro rīku priekš 3D modelēšanas un animācijām:
 
 * **Oficiāls atbalsts**: Izmanto priekš "Hytale modeļu, tekstūru un animāciju izveides"
-* **Speciāls spraudnis** Priekš Hytale tiks sagatavots piemērotrs Blockbench spraudnis tuvākajā laikā
+* **Special plugin**: Hytale has a dedicated [Blockbench Plugin](https://www.blockbench.net/plugins/hytale_plugin).
 * **Tieša saderība**: Spraudnis ļauj māksliniekiem "radīt Hytale-saderošus modeļus, tekstūras un animācijas tieši iekš Blockbench"
 * **Aizvieto vecos rīkus**: Pilnībā aizvieto veco Hytale Model Maker, lai labāk atbalstītu izstrādātas radošās darba plūsmas kopienā
 * **Drošības funkcijas**: Atļauj pievienot tikai to, kas spēles dzinējam pieņemams, tāpēc neuztraucies par kaut kā sabojāšanu
diff --git a/content/docs/lv-LV/guides/ecs/block-components.mdx b/content/docs/lv-LV/guides/ecs/block-components.mdx
new file mode 100644
index 00000000..ca68b38a
--- /dev/null
+++ b/content/docs/lv-LV/guides/ecs/block-components.mdx
@@ -0,0 +1,247 @@
+---
+title: Block Components
+description: Learn how to use the block components.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+  - name: oskarscot
+    link: https://oskar.scot
+---
+
+# Overview
+
+In this guide, you'll learn how to use block components to create a ticking block.
+
+<Callout>
+  For a more complete reference, you may also want to review FarmingSystems.Ticking, as much of the underlying logic is based on its implementation.
+</Callout>
+
+## Steps
+
+### 1. ExampleBlock - holds block behavior
+
+```java
+public class ExampleBlock implements Component<ChunkStore> {
+
+    public static final BuilderCodec CODEC = BuilderCodec.builder(ExampleBlock.class, ExampleBlock::new).build();
+
+    // Components usually require a copy constructor as well but since we don't actually hold any data in this component this is not neccessary
+    public ExampleBlock() { }
+
+    public static ComponentType getComponentType() {
+        return ExamplePlugin.get().getExampleBlockComponentType();
+    }
+
+    @Nullable
+    public Component<ChunkStore> clone() {
+        return new ExampleBlock();
+    }
+}
+```
+
+ExampleBlock is a custom component that stores the behavior and data for your ticking block. Here, it simply places an Ice Block at x + 1 relative to its current position when it ticks.
+
+---
+
+### 2. ExampleInitializer - marks blocks as ticking when placed
+
+```java
+public class ExampleInitializer extends RefSystem {
+
+    @Override
+    public void onEntityAdded(@Nonnull Ref ref, @Nonnull AddReason reason, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+        BlockModule.BlockStateInfo info = (BlockModule.BlockStateInfo) commandBuffer.getComponent(ref, BlockModule.BlockStateInfo.getComponentType());
+        if (info == null) return;
+
+        ExampleBlock generator = (ExampleBlock) commandBuffer.getComponent(ref, ExamplePlugin.get().getExampleBlockComponentType());
+        if (generator != null) {
+            int x = ChunkUtil.xFromBlockInColumn(info.getIndex());
+            int y = ChunkUtil.yFromBlockInColumn(info.getIndex());
+            int z = ChunkUtil.zFromBlockInColumn(info.getIndex());
+
+            WorldChunk worldChunk = (WorldChunk) commandBuffer.getComponent(info.getChunkRef(), WorldChunk.getComponentType());
+            if (worldChunk != null) {
+				worldChunk.setTicking(x, y, z, true);
+            }
+        }
+    }
+
+    @Override
+    public void onEntityRemove(@Nonnull Ref ref, @Nonnull RemoveReason reason, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+    }
+
+    @Override
+    public Query getQuery() {
+        return Query.and(BlockModule.BlockStateInfo.getComponentType(), ExamplePlugin.get().getExampleBlockComponentType());
+    }
+}
+```
+
+ExampleInitializer is a RefSystem that reacts when block entities with the ExampleBlock component are added or removed. This is crucial for marking blocks as ticking when they're first placed.
+
+**Key Points:**
+
+- Tells the game that this block should tick, allowing `ExampleSystem` to process it.
+
+```java
+worldChunk.setTicking(x, y, z, true);
+```
+
+---
+
+### 3. ExampleSystem - handles ticking
+
+```java
+public class ExampleSystem extends EntityTickingSystem {
+
+    public void tick(float dt, int index, @Nonnull ArchetypeChunk archetypeChunk, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+        BlockSection blocks = (BlockSection) archetypeChunk.getComponent(index, BlockSection.getComponentType());
+
+        assert blocks != null;
+
+        if (blocks.getTickingBlocksCountCopy() != 0) {
+            ChunkSection section = (ChunkSection) archetypeChunk.getComponent(index, ChunkSection.getComponentType());
+
+            assert section != null;
+
+            BlockComponentChunk blockComponentChunk = (BlockComponentChunk) commandBuffer.getComponent(section.getChunkColumnReference(), BlockComponentChunk.getComponentType());
+
+            assert blockComponentChunk != null;
+
+            blocks.forEachTicking(blockComponentChunk, commandBuffer, section.getY(), (blockComponentChunk1, commandBuffer1, localX, localY, localZ, blockId) -> {
+                Ref<ChunkStore> blockRef = blockComponentChunk.getEntityReference(ChunkUtil.indexBlockInColumn(localX, localY, localZ));
+                if (blockRef == null) {
+                    return BlockTickStrategy.IGNORED;
+                } else {
+                    ExampleBlock exampleBlock = (ExampleBlock) commandBuffer1.getComponent(blockRef, ExampleBlock.getComponentType());
+                    if (exampleBlock != null) {
+                        WorldChunk worldChunk = (WorldChunk) commandBuffer.getComponent(section.getChunkColumnReference(), WorldChunk.getComponentType());
+                        World world = worldChunk.getWorld();
+
+                        int globalX = localX + (worldChunk.getX() * 32);
+                        int globalZ = localZ + (worldChunk.getZ() * 32);
+
+                        // We need to execute setBlock on the world thread as you cannot call store functions from a system
+                        // This is because of the architecture of the server, depending on your needs you can also use the CommandBuffer
+                        world.execute(() -> {
+                            world.setBlock(globalX + 1, localY, globalZ, "Rock_Ice");
+                        });
+
+                        return BlockTickStrategy.CONTINUE;
+
+                    } else {
+                        return BlockTickStrategy.IGNORED;
+                    }
+                }
+            });
+        }
+    }
+
+    @Nullable
+    public Query getQuery() {
+        return Query.and(BlockSection.getComponentType(), ChunkSection.getComponentType());;
+    }
+}
+```
+
+ExampleSystem is an EntityTickingSystem that runs every tick to execute the logic for all ticking blocks with the ExampleBlock component.
+
+**Key Points:**
+
+- **Get the block component**
+
+```java
+ExampleBlock exampleBlock = (ExampleBlock) commandBuffer.getComponent(blockRef, ExampleBlock.getComponentType());
+```
+
+- **Convert local chunk coordinates to world coordinates**
+
+```java
+int globalX = localX + (worldChunk.getX() * 32);
+int globalZ = localZ + (worldChunk.getZ() * 32);
+```
+
+- **Run the block logic**
+
+```java
+exampleBlock.runBlockAction(globalX, localY, globalZ, worldChunk.getWorld());
+```
+
+- **Keep the block ticking in the next tick**
+
+```java
+return BlockTickStrategy.CONTINUE;
+```
+
+---
+
+### 4. ExamplePlugin - registers components and systems
+
+```java
+public class ExamplePlugin extends JavaPlugin {
+    protected static ExamplePlugin instance;
+    private static final HytaleLogger LOGGER = HytaleLogger.forEnclosingClass();
+    private ComponentType exampleBlockComponentType;
+
+    public static ExamplePlugin get() {
+        return instance;
+    }
+
+    public ExamplePlugin(@Nonnull JavaPluginInit init) {
+        super(init);
+        LOGGER.atInfo().log("Hello from " + this.getName() + " version " + this.getManifest().getVersion().toString());
+    }
+
+    @Override
+    protected void setup() {
+        instance = this;
+        LOGGER.atInfo().log("Setting up plugin " + this.getName());
+        this.exampleBlockComponentType = this.getChunkStoreRegistry().registerComponent(ExampleBlock.class, "ExampleBlock", ExampleBlock.CODEC);
+    }
+	
+	@Override
+	protected void start() {
+		this.getChunkStoreRegistry().registerSystem(new ExampleSystem());
+		this.getChunkStoreRegistry().registerSystem(new ExampleInitializer());
+	}
+
+    public ComponentType getExampleBlockComponentType() {
+        return this.exampleBlockComponentType;
+    }
+}
+```
+
+---
+
+### 5. Configure In-Game
+
+![block-component-1](/assets/guides/block-component-1.png)
+
+![block-component-2](/assets/guides/block-component-2.png)
+
+With this logic, the block will now continuously place an Ice Block at the coordinates x + 1 relative to its current position every time it ticks.
+
+---
+
+## Common Issues
+
+### NullPointerException on Startup
+
+**Error message:**
+
+```java
+java.lang.NullPointerException: Cannot invoke "com.hypixel.hytale.component.query.Query.validateRegistry(com.hypixel.hytale.component.ComponentRegistry)" because "query" is null
+```
+
+**Cause:**
+This error occurs when your module is loaded **before** the required Hytale modules.
+
+**Fix:**
+Add `EntityModule` and `BlockModule` as dependencies in your `manifest.json` to ensure proper load order.
+
+```json
+"Dependencies": {
+  "Hytale:EntityModule": "*",
+  "Hytale:BlockModule": "*"
+}
+```
diff --git a/content/docs/lv-LV/guides/ecs/hytale-ecs-theory.mdx b/content/docs/lv-LV/guides/ecs/hytale-ecs-theory.mdx
index db3e9d50..f04c8186 100644
--- a/content/docs/lv-LV/guides/ecs/hytale-ecs-theory.mdx
+++ b/content/docs/lv-LV/guides/ecs/hytale-ecs-theory.mdx
@@ -28,7 +28,7 @@ Vēl viens `Store` tips ar ko varētu sastapties ir `ChunkStore`. Tas atbild par
 
 ## Holder
 
-Holder/Turētājs pamatā ir vienības plāns. Pirms vienība eksistē Glabātuvē (un pasaulē), tā eksistē kā `Holder`. Tā ievāc un tur nepieciešamos komponentus (datus). Tu vari salīdzināt to ar analogu, kā iepirkšanās grozu. Tu vispirms paņem visus vajadzīgos komponentus veikalā un tikai tad dodies uz kasi, kas paņems groza saturu, izveidos derīgus vienības ID un atdos tos atpakaļ ar čeku (Ref).
+Holder/Turētājs pamatā ir vienības plāns. Before an entity exists in the Store (and thus in the world), it exists as a `Holder`. Tā ievāc un tur nepieciešamos komponentus (datus). Tu vari salīdzināt to ar analogu, kā iepirkšanās grozu. Tu vispirms paņem visus vajadzīgos komponentus veikalā un tikai tad dodies uz kasi, kas paņems groza saturu, izveidos derīgus vienības ID un atdos tos atpakaļ ar čeku (Ref).
 
 Apskatīsim kādu piemēru: Spēlētāja inicializācija. Iekš `Universe`, `addPlayer` metode demonstrē to perfekti.
 Kad spēlētājs savienojas, mēs uzreiz neiemetam viņu ECS. Mēs vispirms izveidojam spēlētāja datus iekš Holder.
@@ -166,7 +166,7 @@ MyComponent comp = commandBuffer.getComponent(ref, componentType);
 
 Codecs handle serialization and deserialization of components. Hytale uses them to save and load entity data to and from disk as well as sending component data over the network. When creating a custom component, you must also create a corresponding Codec.
 
-There are mutliple Codec types already implemented in the default Codec Interface:
+There are multiple Codec types already implemented in the default Codec Interface:
 
 - Codec.STRING
 - Codec.BOOLEAN
@@ -214,7 +214,7 @@ This might seem tedious at first but it ensures that your component can be corre
   KeyedCodec<Integer> exampleInt = new KeyedCodec<Integer>("ExampleIntIdForCodec", Codec.INTEGER);
   ```
 
-- **Setter Function**: This is a lambda function that takes an instance of your component and returns the value of the field you want to serialize. For example, if you have a field called `myCustomField` in your custom component, your getter function would look like this:
+- **Setter Function**: This is a lambda function that takes an instance of your component + the value to set and sets the field value on the component. For example, if you have a field called `myCustomField` in your custom component, your setter function would look like this:
   ```java
   (data, value) -> data.myCustomField = value
   ```
@@ -275,7 +275,7 @@ public class PoisonComponent implements Component<EntityStore> {
 
 You can also add validators to your Codec fields to ensure that the data being serialized/deserialized meets certain criteria. For example, if you want to ensure that the `damagePerTick` field is always non-negative or the poison name is never null, you can add a validator like this:
 
-````java
+```java
 .append(
     new KeyedCodec<Float>("DamagePerTick", Codec.FLOAT),
     (data, value) -> data.damagePerTick = value,
@@ -291,14 +291,15 @@ You can also add validators to your Codec fields to ensure that the data being s
 )
 .addValidator(Validators.nonNull())
 .add()
+```
 
 ### Complex Codec Examples
 
-If you want to have a map inside your component, you can use the MapCodec class to build a KeyedCoded for it. Here's an example of how to create a Codec for a Map field:
+If you want to have a map inside your component, you can use the MapCodec class to build a KeyedCodec for it. Here's an example of how to create a Codec for a Map field:
 
 ```java
 var damagePerTick = new KeyedCodec<>("DamagePerTick", new MapCodec<>(Codec.FLOAT, HashMap<String, Float>::new));
-````
+```
 
 <Callout type="info">
   This also works with custom Objects as long as you have a Codec defined for the Object type.
diff --git a/content/docs/lv-LV/guides/java-basics/00-introduction.mdx b/content/docs/lv-LV/guides/java-basics/00-introduction.mdx
index 0256b529..bd0eace7 100644
--- a/content/docs/lv-LV/guides/java-basics/00-introduction.mdx
+++ b/content/docs/lv-LV/guides/java-basics/00-introduction.mdx
@@ -7,7 +7,7 @@ Sveicināts ceļojumā uz Java programmēšanu! Šī rokasgrāmata ir izstrādā
 
 ## Kas ir Java?
 
-Java ir spēcīga, objektorientēta programmēšanas valoda, kas izveidota 1995. gadā. Tā ir viena no populārākajām programmēšanas valodām pasaulē, un to izmanto visam, sākot no mobilajām lietotnēm līdz uzņēmuma programmatūrai. Mums vissvarīgākais ir tas, ka tā ir valoda, ko Hytale izmanto saviem serveriem un modifikācijas API.
+Java ir spēcīga, objektorientēta programmēšanas valoda, kas izveidota 1995. gadā. Tā ir viena no populārākajām programmēšanas valodām pasaulē, un to izmanto visam, sākot no mobilajām lietotnēm līdz uzņēmuma programmatūrai. Most importantly for us, it's the language Hytale uses for its servers & modding API.
 
 ## Kas Tiks Apgūts
 
diff --git a/content/docs/lv-LV/guides/java-basics/02-operators.mdx b/content/docs/lv-LV/guides/java-basics/02-operators.mdx
index 44b7fee5..cb491631 100644
--- a/content/docs/lv-LV/guides/java-basics/02-operators.mdx
+++ b/content/docs/lv-LV/guides/java-basics/02-operators.mdx
@@ -119,7 +119,7 @@ String svieciensArVardu = "Hello, " + name + "!"; // "Hello, Alice!"
 
 ## Operātora Prioritāte
 
-Operātora prioritāte nozīmē, kurš operātors tiek novērtēts pirmais koda rindā. Domā par to kā darbības secību BODMAS/PEMDAS matemātikā!
+Operator Precedence means which operator gets evaluated first in an line of code. Domā par to kā darbības secību BODMAS/PEMDAS matemātikā!
 
 ```java
 int rezultats = 10 + 5 * 2; // rezultātā ir 20, nevis 30
diff --git a/content/docs/lv-LV/guides/java-basics/03-control-flow-if.mdx b/content/docs/lv-LV/guides/java-basics/03-control-flow-if.mdx
index 7c6b643b..748016f9 100644
--- a/content/docs/lv-LV/guides/java-basics/03-control-flow-if.mdx
+++ b/content/docs/lv-LV/guides/java-basics/03-control-flow-if.mdx
@@ -7,7 +7,7 @@ Programmām jāpieņem lēmumi. If nosacījumi ļauj kodam izvēlēties dažādu
 
 ## Pamata If Nosacījums
 
-Vienkāršāka forma pārbauda vienu stāvokli;
+The simplest form checks one condition:
 
 ```java
 int veseliba = 20;
diff --git a/content/docs/lv-LV/guides/java-basics/08-access-modifiers.mdx b/content/docs/lv-LV/guides/java-basics/08-access-modifiers.mdx
index f3ab18de..5e55d708 100644
--- a/content/docs/lv-LV/guides/java-basics/08-access-modifiers.mdx
+++ b/content/docs/lv-LV/guides/java-basics/08-access-modifiers.mdx
@@ -471,20 +471,20 @@ Vienkāršāk sakot: instances dalībnieki pieder objektiem; statiski dalībniek
 
 ```java
 class Data {
-    public int x; // Instances dalībnieks
-    public static int y = 1000; // Static dalībnieks
+    public int x; // Instanced member
+    public static int y = 1000; // Static member
 
     // Instanced member:
-    // var piekļut abiem - statiskiem un ne statiskiem dalībniekiem
+    // can access to both static and non-static members
     public void foo() {
-        x = 100; // OK - tas pats, kas this.x = 100;
-        y = 100; // OK - tas pats, kas Data.y = 200;
+        x = 100; // OK - same as this.x = 100;
+        y = 100; // OK - same as Data.y = 200;
     }
 
     // Static member:
-    // nevar piekļūt ne-static mainīgajiem
+    // cannot access to non-static variables
     public static void bar() {
-        x = 100; // Kļūda: ne-static mainīgais x nevar būt piesaukts no static konteksta
+        x = 100; // Error: non-static variable x cannot be referenced from a static context
         y = 100; // OK
     }
 }
@@ -504,7 +504,7 @@ Data.x = 1000; // Kļūda: nevar piekļūt instances mainīgajam iekš static ko
 
 ### Static Laukumi
 
-Static laukums pārstāv datu dalībniekus, kas pieder klases tipam, nevis objektam. Static laukumi arī tiek glabāti specifiskā atmiņas lokācijā ar kuru dalās starp visām objektu instancēm, kas tiek izveidotas.
+A static field represents a data member owned by the class type rather than the object. Static laukumi arī tiek glabāti specifiskā atmiņas lokācijā ar kuru dalās starp visām objektu instancēm, kas tiek izveidotas.
 
 Tas tiek deklarēts sekojoši:
 
diff --git a/content/docs/lv-LV/guides/plugin/animated-block-textures.mdx b/content/docs/lv-LV/guides/plugin/animated-block-textures.mdx
new file mode 100644
index 00000000..42bfa51f
--- /dev/null
+++ b/content/docs/lv-LV/guides/plugin/animated-block-textures.mdx
@@ -0,0 +1,101 @@
+---
+title: Animated Block Textures
+description: Learn how to attach a .blockyanim to a block
+authors:
+  - name: Burkino
+---
+
+import { File, Folder, Files } from 'fumadocs-ui/components/files';
+
+So, you want to make your blocks feel more alive through animations, do you?\
+Now for the most part this is the exact same as [Creating custom blocks](./creating-block).
+![blue fire gif](/assets/guides/blue_fire.gif)
+
+## Prerequisites
+
+This is NOT a guide on animating or texturing or even using BlockBench, why? Because I don't know how to do that.\
+The only thing we will be doing is taking the fire texture, changing the color, and applying it to our new fire block.
+
+## Setup
+
+To start, you're obviously going to want to grab the `Common/VFX/Fire/Fire.png` file. How you do it is up to you, in the Asset Editor you'll need to switch to the Common tab.\
+I'll assume you know how colorize or change the hue of an image, so go ahead and do that now and save it as `Blue_Fire.png`.
+
+The other assets used in this guide are `Common/VFX/Fire/Fire.blockymodel` and `Common/Blocks/Animations/Fire/Fire_Burn.blockyanim` (both renamed to `Blue_Fire`) but since we won't be changing them it's probably fine to leave them. I will reference the `Blue_Fire` versions as a way to point out what should be custom assets.\
+I will also duplicate `Server/Item/Item/Deco/Deco_Fire.json` and call it `Deco_Blue_Fire.json`.
+
+## Applying the changes
+
+The `Deco_Blue_Fire` block is actually just a particle emitter, however we will not be using particles, so lets start by removing them in `Block > Particles`.\
+Next we want to set the Block Model (called `CustomModel` in JSON) to `VFX/Blue_Fire/Blue_Fire.blockymodel` and Block Model Textures (`CustomModelTexture` in JSON) to
+
+```json
+[
+    {
+        "Texture": "VFX/Blue_Fire/Blue_Fire.png",
+        "Weight": 1
+    }
+]
+```
+
+Finally, we will apply the .blockyanim to our model, this is done through the Block Model Animation property (`CustomModelAnimation` in JSON) and the value should be `Blocks/Animations/Blue_Fire/Blue_Fire_Burn.blockyanim`.
+
+## Final Code
+
+With that your new blue fire should be done. Here is the minimal JSON for our blue fire.\
+There is an additional `Looping` and `RequiresAlphaBlending` property that I have not gone over, however I hope it is self-explanatory.
+
+```json
+{
+  "BlockType": {
+    "DrawType": "Model",
+    "CustomModel": "VFX/Blue_Fire/Blue_Fire.blockymodel",
+    "CustomModelAnimation": "Blocks/Animations/Blue_Fire/Blue_Fire_Burn.blockyanim",
+    "CustomModelTexture": [
+      {
+        "Texture": "VFX/Blue_Fire/Blue_Fire.png",
+        "Weight": 1
+      }
+    ],
+    "Looping": true,
+    "RequiresAlphaBlending": false
+  },
+  "PlayerAnimationsId": "Block"
+}
+```
+
+<Files>
+  <Folder name="resources" defaultOpen>
+    <Folder name="Server" defaultOpen>
+      <Folder name="Item" defaultOpen>
+        <Folder name="Items" defaultOpen>
+          <Folder name="Deco" defaultOpen>
+            <File name="Deco_Blue_Fire.json" />
+          </Folder>
+        </Folder>
+      </Folder>
+    </Folder>
+
+    <Folder name="Common" defaultOpen>
+      <Folder name="Blocks" defaultOpen>
+        <Folder name="Animations" defaultOpen>
+          <Folder name="Blue_Fire" defaultOpen>
+            <File name="Blue_Fire_Burn.blockyanim" />
+          </Folder>
+        </Folder>
+      </Folder>
+
+      <Folder name="VFX" defaultOpen>
+        <Folder name="Blue_Fire" defaultOpen>
+          <File name="Blue_Fire.blockymodel" />
+
+          <File name="Blue_Fire.png" />
+        </Folder>
+      </Folder>
+    </Folder>
+  </Folder>
+</Files>
+
+## Next steps
+
+Now that you know how to attach an animation to a block, try adding it to a block state.
diff --git a/content/docs/lv-LV/guides/plugin/build-and-test.mdx b/content/docs/lv-LV/guides/plugin/build-and-test.mdx
index 0e7fe7eb..f37534c3 100644
--- a/content/docs/lv-LV/guides/plugin/build-and-test.mdx
+++ b/content/docs/lv-LV/guides/plugin/build-and-test.mdx
@@ -9,18 +9,18 @@ If you followed along with the [Setting Up Your Development Environment](./setti
 
 ## Building Your Mod
 
-In our case, we've **Maven** as the build system. Maven is a powerful build automation tool that manages dependencies, compiles your code, and packages everything into a distributable JAR file.
+In our case, we've **Gradle** as the build system. Gradle is a powerful build automation tool that manages dependencies, compiles your code, and packages everything into a distributable JAR file.
 
-### Understanding Maven
+### Understanding Gradle
 
-Maven uses a `pom.xml` file (Project Object Model) to define your project's configuration, dependencies, and build settings. You can learn more about Maven at the [official Apache Maven website](https://maven.apache.org/).
+Gradle can use a `build.gradle.kts` file (Kotlin DSL) to define your project's configuration, dependencies, and build settings. You can learn more about Gradle at the [official Gradle website](https://gradle.org/).
 
-### Building with Maven
+### Building with Gradle
 
 To build your mod, open a terminal in your project directory and run:
 
 ```bash
-mvn package
+./gradlew build
 ```
 
 This command will:
@@ -29,16 +29,35 @@ This command will:
 2. Run any tests (if present)
 3. Package everything into a JAR file
 
+<Callout type="info">
+  If you are using the plugin template from the [Setting Up Your Development Environment](./setting-up-env) guide, then the build script is already set up for you. It includes paths to your Hytale game library and handles the packaging of your mod, managing hytale dependencies and manifest changes.
+
+  If you have a different path to your Hytale installation, you may receive the following error:
+
+  ```bash
+  FAILURE: Build failed with an exception.
+
+  * What went wrong:
+  Failed to find Hytale at the expected location. Please make sure you have installed the game. The expected location can be changed using the hytale.home_path property. Currently looking in 'C:\Path\To\Hytale'
+  ```
+
+  You can change the path by adding a property to your `gradle.properties` file (if it doesn't exist, create it in the root of your project):
+
+  ```properties
+  hytale.home_path=C:\Correct\Path\To\Hytale
+  ```
+</Callout>
+
 ### Build Output
 
-Once the build completes successfully, your mod will be located in the `target` directory and named:
+Once the build completes successfully, your mod will be located in the `build/libs` directory and named:
 
 ```
-ExamplePlugin-1.0-SNAPSHOT.jar
+ExamplePlugin-1.0.jar
 ```
 
 <Callout type="info">
-  The exact name may vary depending on what you configured in your `pom.xml` file. Check the `artifactId` and `version` fields to see what your JAR will be named.
+  The exact name may vary depending on what you configured in your `build.gradle.kts` and `settings.gradle.kts` file. Check the `rootProject.name` and `version` fields to see what your JAR will be named.
 </Callout>
 
 ## Testing Your Mod
@@ -49,11 +68,11 @@ Now that you've built your mod, it's time to test it in Hytale!
 
 First, you need to find Hytale's mods directory:
 
-1. Press **Win + R** on your keyboard
-2. Type `%appdata%` and press Enter
-3. Navigate to: `Hytale\UserData\Mods`
+1. Go to your Hytale installation directory (The default location is usually in your AppData folder)
+   > On Windows, you can access it by clicking `windows + R` and typing `%appdata%`.
+2. Navigate to: `/UserData/Mods`
 
-The full path should look like:
+The default path would look like:
 
 ```
 C:\Users\YourUsername\AppData\Roaming\Hytale\UserData\Mods
@@ -65,7 +84,7 @@ C:\Users\YourUsername\AppData\Roaming\Hytale\UserData\Mods
 
 ### 2. Copy Your Mod
 
-Copy the `ExamplePlugin-1.0-SNAPSHOT.jar` file from your project's `target` directory into the `Mods` folder you just located.
+Copy the `ExamplePlugin-1.0.jar` file from your project's `build/libs` directory into the `Mods` folder you just located.
 
 ### 3. Launch Hytale and Verify
 
@@ -84,7 +103,7 @@ If your mod doesn't appear in the mods list:
 - Make sure the JAR file is in the correct `Mods` folder
 - Check that your `manifest.json` file is properly configured
 - Look for any error messages in the Hytale logs
-- Verify that you're using the correct version of Java and Maven
+- Verify that you're using the correct version of Java and Gradle
 
 ## Next Steps
 
diff --git a/content/docs/lv-LV/guides/plugin/creating-commands.mdx b/content/docs/lv-LV/guides/plugin/creating-commands.mdx
index d33597f3..08572f16 100644
--- a/content/docs/lv-LV/guides/plugin/creating-commands.mdx
+++ b/content/docs/lv-LV/guides/plugin/creating-commands.mdx
@@ -8,6 +8,8 @@ authors:
     url: https://oskar.scot
   - name: jacobwojoski
     url: https://github.com/jacobwojoski
+  - name: Marcel-TO
+    url: https://marcel-to.net
 ---
 
 In this guide, you will learn how to create custom commands for your Hytale mod.
@@ -36,7 +38,7 @@ The most basic command is an `AbstractAsyncCommand`. It has very minimal data av
   `AbstractAsyncCommand` runs on its own background thread. This means its execute is not tied to any world instance and because of this it can not edit any **Stores** or **Refs** without getting the desired world first. To access this data any of the other command types would be preferred and are likely what you will want to use instead.
 </Callout>
 
-The main purpose for a command like this would be for something that can happen everywhere and is not tied to a specific world. For example a `serverRules` command to tell the user thats running the command in chat what the servers rules are nomatter what world they are in.
+The main purpose for a command like this would be for something that can happen everywhere and is not tied to a specific world. For example a `serverRules` command to tell the user that's running the command in chat what the server's rules are no matter what world they are in.
 
 ```java
 // Command that can be run that lists the server rules in chat to the player
@@ -49,7 +51,7 @@ public class ServerRulesCommand extends AbstractAsyncCommand {
     }
 
     // Run the command
-    // conetext - info about who ran the command. Server console?, Some player?
+    // context - info about who ran the command. Server console?, Some player?
     @Override
     protected CompletableFuture<Void> executeAsync(@Nonnull CommandContext context) {
         context.sendMessage(Message.raw("The only rule is there are no rules."));
@@ -134,7 +136,7 @@ Uses a Ray to see what the player is looking at and tries to run the command on
 
 ## Adding Arguments
 
-Arguments are additional fields that the user can input when running a command. The different types of arguments along with small snipits and a large example can be seen below.
+Arguments are additional fields that the user can input when running a command. The different types of arguments along with small snippets and a large example can be seen below.
 
 ### Command Argument Types
 
@@ -163,14 +165,14 @@ this.messageArg = this.withOptionalArg("message", "Message to print while healin
 
 ### Default Arguments
 
-Adding a default argument has two additional arguemnt for the default value and default value description. You need to use `withDefaultArg` method.
+Adding a default argument has two additional argument for the default value and default value description. You need to use `withDefaultArg` method.
 
 ```java
 // args <Command String> <Description> <Default Value> <Desc of default value>
 this.healthArg = this.withDefaultArg("health", "Amount to heal player", ArgTypes.FLOAT, (float)100, "Desc of Default: 100");
 ```
 
-### Flag Arguemnts
+### Flag Arguments
 
 Similar as above but the flags return is either true if it exists or false if it does not. You need to use `withFlagArg` method.
 
@@ -181,20 +183,13 @@ this.debugArg = this.withFlagArg("debug", "Add debug logs");
 
 ### ArgTypes
 
-The following ArgTypes are available (only lists common types):
-
-- `ArgTypes.STRING`
-- `ArgTypes.INTEGER`
-- `ArgTypes.BOOLEAN`
-- `ArgTypes.FLOAT`
-- `ArgTypes.DOUBLE`
-- `ArgTypes.UUID`
+You can find all the available argument types on the [ArgTypes](../../argtypes) page.
 
 ### Example Command Arg Types
 
-Shows all Command arguemnt types with different various input types.
+Shows all Command argument types with different various input types.
 
-**NOTE:** When getting the value of an argument during execute you need to pass the context with `someArg.get(commandContext)`. Where `commandContext` is the first variable in the execute funtion.
+**NOTE:** When getting the value of an argument during execute you need to pass the context with `someArg.get(commandContext)`. Where `commandContext` is the first variable in the execute function.
 
 ```java
 // Example usage: /healplayer --health 50 --message "Feels Good" --debug
@@ -204,7 +199,7 @@ public class HealPlayerCommand extends AbstractTargetPlayerCommand {
     private final FlagArg debugArg;
 
     public HealPlayerCommand() {
-        super("healplayer", "Healing a player for an <input> ammount of HP (default: 100)");
+        super("healplayer", "Healing a player for an <input> amount of HP (default: 100)");
 
         // Abstract TargetPlayerCommand passes the player that ran the command by default and implements
         // the use of `--player <value>` to specify someone else
@@ -213,10 +208,10 @@ public class HealPlayerCommand extends AbstractTargetPlayerCommand {
         this.healthArg = this.withDefaultArg("health", "Amount to heal player", ArgTypes.FLOAT, (float)100, "Desc of Default: 100");
 
         // Or you could do the following making the health value required instead of with a default.
-        //    You would need to change the decleration to RequiredArg<Float>
+        //    You would need to change the declaration to RequiredArg<Float>
         // this.healthArg = this.withRequiredArg("health", "Amount to heal player", ArgTypes.FLOAT);
 
-        // Optional args reguare the user the input `--<key> <value>` so the following would require `--message "Good Luck"`
+// Optional args require the user the input `--<key> <value>` so the following would require `--message "Good Luck"`
         this.messageArg = this.withOptionalArg("message", "Message to print while healing", ArgTypes.STRING);
 
         // No type needed due to being a bool
@@ -230,7 +225,7 @@ public class HealPlayerCommand extends AbstractTargetPlayerCommand {
             commandContext.sendMessage(Message.raw("We are debugging"));
         }
 
-        // Health is stored in a generic stat map to allowing mods/future contect to easily add more stats if desired.
+        // Health is stored in a generic stat map to allowing mods/future content to easily add more stats if desired.
         EntityStatMap stats = store.getComponent(ref, EntityStatMap.getComponentType());
         int healthIdx = DefaultEntityStatTypes.getHealth();
         EntityStatValue health = stats.get(healthIdx);
@@ -252,7 +247,7 @@ public class HealPlayerCommand extends AbstractTargetPlayerCommand {
 
 ## Argument Validators
 
-Argument validators are a way to check the command before the command gets executed. They are added with the `addValidator` method on an argument when calling `withXxxArg`. They provide a nice output to the user when an input value is invalid.
+Argument validators are a way to check the command before the command gets executed. They are added with the `addValidator` method on an argument when calling `withXxxArg`. They provide a nice output to the user when an input value is invalid. There are some common validators provided in the `Validators` class such as `greaterThan`, `lessThan`, and `or`, `max`, `range`, etc.
 
 ```java
 ...
@@ -260,18 +255,59 @@ Argument validators are a way to check the command before the command gets execu
     OptionalArg<Integer> healAmount = withOptionalArg("amount", "Heal Amount", ArgTypes.INTEGER)
         .addValidator(Validators.greaterThan(0))
         .addValidator(Validators.lessThan(1000));
-
-    // Custom check example
-    OptionalArg<Integer> healAmount = withOptionalArg("amount", "Heal Amount", ArgTypes.INTEGER)
-            .addValidator( value -> {
-                if (value != null && value <= 0) {
-                    return ValidationResult.error("ammount argument must be a positive number");
-                }
-                return ValidationResult.success();
-            });
 ...
 ```
 
+### Custom Validators
+
+You can also create custom validators by implementing the `com.hypixel.hytale.codec.validation.Validator` interface. The interfaces forces you to implement the `accept` and `updateSchema` method. The `accept` method takes in the argument value and validates it. If the validation fails, you can use the `fail` method of the `com.hypixel.hytale.codec.validation.ValidationResults` class to return an error message.
+The `updateSchema` method is used to update the schema of the command argument. This is used for commands that have dynamic schemas based on the input value. For example, if you have a command that takes in a player name as an argument, you can use the `updateSchema` method to update the schema to include a list of online players for validation.
+
+Here is an example of a custom validator that checks if a string value is equal to a banned word. In this example, the banned word is "badword". If the input value is "badword", the validator will fail and return an error message.
+
+```java
+import com.hypixel.hytale.codec.schema.SchemaContext;
+import com.hypixel.hytale.codec.schema.config.Schema;
+import com.hypixel.hytale.codec.validation.ValidationResults;
+import com.hypixel.hytale.codec.validation.Validator;
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+
+public class MyCustomValidator implements Validator<String> {
+    @Nonnull
+    private final String value;
+
+    public MyCustomValidator(@Nonnull String value) {
+        this.value = value;
+    }
+
+    @Override
+    public void accept(@Nullable String input, @Nonnull ValidationResults results) {
+        if (this.value.equalsIgnoreCase(input)) {
+            results.fail("The given role has been banned.");
+        }
+    }
+
+    @Override
+    public void updateSchema(SchemaContext context, @Nonnull Schema target) {
+        // This method can be used to update the schema of the command argument. This is useful for commands that have dynamic schemas based on the input value. For example, if you have a command that takes in a player name as an argument, you can use the `updateSchema` method to update the schema to include a list of online players for validation.
+        throw new UnsupportedOperationException("Not implemented yet.");
+    }
+}
+```
+
+After the custom validator is created, you can add it to an argument like the following example. In this example, we add the `MyCustomValidator` to a string argument called "role". If the user inputs "badword" as the role, the command will fail and return the error message defined in the `MyCustomValidator`.
+
+```java
+    ...
+    // Custom validator example
+    String bannedRole = "badword";
+
+    OptionalArg<String> roleArg = withOptionalArg("role", "Role to assign", ArgTypes.STRING)
+        .addValidator(new MyCustomValidator(bannedRole));
+    ...
+```
+
 ---
 
 ## Permissions
@@ -312,7 +348,7 @@ This allows the server to control who has access to specific commands. You add t
 
 If you want variants of the same command without doing argument parsing you can instead use `addUsageVariant(new OtherCommandClass())` in the original commands constructor.
 
-The only difference is in the `OtherCommandClass()` constrcutor you don't pass the command name to the super class.
+The only difference is in the `OtherCommandClass()` constructor you don't pass the command name to the super class.
 
 <Callout type="info">
   You can also use `addAliases("some_alias", "some_other_alias")` as a way to add shorthand or other ways to write the same command.
@@ -387,7 +423,7 @@ public class AdminCommand extends AbstractCommandCollection {
     public AdminCommand () {
         super("admin", "Admin commands");
         addSubCommand(new UserCommandCollection());
-        addSybCommand(new ServerCommandCollection);
+        addSubCommand(new ServerCommandCollection);
     }
 }
 ```
@@ -417,5 +453,5 @@ public class MyPlugin extends JavaPlugin {
 
 ## Video Link
 
-_Special Thanks to [TroubleDev](https://www.youtube.com/@TroubleDEV) for his excelent video guide on all of these features._
+_Special Thanks to [TroubleDev](https://www.youtube.com/@TroubleDEV) for his excellent video guide on all of these features._
 _Video Link: [TroubleDev - Hytale's Command API Explained](https://www.youtube.com/watch?v=KnmhG9MDMgo)_
diff --git a/content/docs/lv-LV/guides/plugin/creating-events.mdx b/content/docs/lv-LV/guides/plugin/creating-events.mdx
index 95863990..d3f0925d 100644
--- a/content/docs/lv-LV/guides/plugin/creating-events.mdx
+++ b/content/docs/lv-LV/guides/plugin/creating-events.mdx
@@ -1,6 +1,6 @@
 ---
-title: Creating Events
-description: Learn how to create custom events for your Hytale mod.
+title: Creating Events Listeners
+description: Learn how to create event listeners for your Hytale mod.
 authors:
   - name: Neil Revin
     url: https://itsneil.dev
@@ -10,7 +10,7 @@ authors:
 
 ## Event Class
 
-You can import a Event class and create a function with the Event as a argument. [Click here](../../server/events) to look at all available events.
+You can import an Event class and create a function with the Event as an argument. [Click here](../../server/events) to look at all available events.
 
 Example plugin when a player is ready (joins a server):
 
diff --git a/content/docs/lv-LV/guides/plugin/item-registry.mdx b/content/docs/lv-LV/guides/plugin/item-registry.mdx
new file mode 100644
index 00000000..9a0fd53a
--- /dev/null
+++ b/content/docs/lv-LV/guides/plugin/item-registry.mdx
@@ -0,0 +1,95 @@
+---
+title: Working with the Item Registry
+description: Learn how to access and query the game's item registry to list all items, check if items exist, and retrieve item properties.
+authors:
+  - name: Denis
+---
+
+In this guide, you'll learn how to work with Hytale's Item Registry system. This is useful when you need to programmatically list all available items, validate item IDs, or retrieve item properties at runtime.
+
+## Prerequisites
+
+Before diving in, you should be familiar with:
+
+- [Setting up your development environment](./setting-up-env)
+- [Creating commands](./creating-commands) (optional, for testing)
+
+## Required Imports
+
+To work with the Item Registry, you'll need the following imports:
+
+```java
+import com.hypixel.hytale.assetstore.map.DefaultAssetMap;
+import com.hypixel.hytale.server.core.asset.type.item.config.Item;
+```
+
+## Getting the Item Registry
+
+The Item Registry is accessed through the `Item.getAssetMap()` method, which returns a `DefaultAssetMap<String, Item>` containing all registered items in the game:
+
+```java
+DefaultAssetMap<String, Item> itemMap = Item.getAssetMap();
+```
+
+## Listing All Items
+
+To iterate through all items in the registry, you can get the underlying map and loop through its entries:
+
+```java
+DefaultAssetMap<String, Item> itemMap = Item.getAssetMap();
+var map = itemMap.getAssetMap();
+
+for (var entry : map.entrySet()) {
+    String itemId = String.valueOf(entry.getKey());
+    Item item = entry.getValue();
+    
+    // Do something with the item
+    LOGGER.atInfo().log("Item ID: " + itemId);
+}
+```
+
+You can also get the total count of registered items:
+
+```java
+int totalItems = map.size();
+```
+
+## Checking if an Item Exists
+
+To check if a specific item exists in the registry, use `getAsset()` and verify the result:
+
+```java
+public boolean itemExists(String itemId) {
+    var assetMap = Item.getAssetMap();
+    if (assetMap != null) {
+        Item item = assetMap.getAsset(itemId);
+        return item != null && item != Item.UNKNOWN;
+    }
+    return false;
+}
+```
+
+<Callout type="info">
+  The `Item.UNKNOWN` constant represents an invalid or unrecognized item. Always check for both `null` and `Item.UNKNOWN` when validating items.
+</Callout>
+
+## Accessing Item Properties
+
+Once you have an `Item` instance, you can access various properties:
+
+```java
+var assetMap = Item.getAssetMap();
+Item item = assetMap.getAsset("Soil_Grass");
+
+if (item != null && item != Item.UNKNOWN) {
+    String id = item.getId(); // Soil_Grass
+    int maxStack = item.getMaxStack(); // 100
+    boolean isBlock = item.hasBlockType(); // true
+    boolean isConsumable = item.isConsumable(); // false
+}
+```
+
+## Related Guides
+
+- [Inventory Management](./inventory-management) - Learn how to add and remove items from player inventories
+- [Create Custom Item and Interaction](./item-interaction) - Learn how to create your own custom items
diff --git a/content/docs/lv-LV/guides/plugin/permission-management.mdx b/content/docs/lv-LV/guides/plugin/permission-management.mdx
index 6b7cfd46..55f06101 100644
--- a/content/docs/lv-LV/guides/plugin/permission-management.mdx
+++ b/content/docs/lv-LV/guides/plugin/permission-management.mdx
@@ -10,132 +10,569 @@ authors:
     link: https://discord.com/users/292656109939064833
   - name: Ivan
     link: https://discord.com/users/505770451218333717
+  - name: ZenithDevHQ
+    link: https://github.com/ZenithDevHQ
 ---
 
-In this guide, you'll learn how to manage permission nodes and groups in your Hytale plugin.
+In this guide, you'll learn how to manage permission nodes and groups in your Hytale plugin. Permissions control what actions players can perform on your server, from basic commands to advanced administrative functions.
 
-## The `PermissionsModule` class
+## What Are Permissions?
 
-The `PermissionsModule` class is responsible for managing permission nodes and groups in your plugin. It provides methods to check, grant and revoke permissions and groups for players. It allows the following operations
+Permissions are string identifiers that control access to features and commands. When a player tries to perform an action (like using a command), the server checks if they have the required permission.
 
-- Add permissions to user
-- Remove permissions from user
-- Add permissions to group (this also creates the group if it doesn't exist)
-- Remove permissions from group
-- Add user to group
-- Remove user from group
-- List all groups for a user
-- Check if a user has a permission (it checks both user and group permissions for the given player UUID)
+**Example permission nodes:**
 
-With this class you cannot:
+- `hytale.command.gamemode` - Permission to use the gamemode command
+- `hytale.editor.brush.use` - Permission to use brush tools
+- `myplugin.teleport.home` - A custom permission for your plugin
 
-- List all defined groups
-- Remove a group
+Permissions follow a hierarchical naming pattern: `namespace.category.action`
 
-### Adding Permission Nodes
+## Key Concepts
 
-You need a `Set<String>` containing all the permission nodes you want to add, these are added on top of the already existing permission nodes the user may have, it is not a replacement.
+Before diving into code, let's understand the core concepts:
+
+| Concept             | Description                                                                |
+| ------------------- | -------------------------------------------------------------------------- |
+| **Permission Node** | A string like `myplugin.feature.use` that represents a specific permission |
+| **Group**           | A named collection of permissions (e.g., "Admin", "VIP", "Default")        |
+| **Provider**        | The backend that stores and retrieves permissions                          |
+| **Wildcard**        | A pattern like `*` or `myplugin.*` that matches multiple permissions       |
+
+### How Permissions Are Checked
+
+When checking if a player has a permission, Hytale follows this order:
+
+1. **User's direct permissions** - Permissions granted directly to the player
+2. **Group permissions** - Permissions from groups the player belongs to
+3. **Virtual groups** - Game-mode-based permissions (e.g., Creative mode grants builder tools)
+4. **Default value** - Falls back to `false` if no match found
+
+<Callout type="info">
+  The first definitive match wins. If a player has a permission granted at the user level, group permissions won't override it.
+</Callout>
+
+---
+
+## The `PermissionsModule` Class
+
+The `PermissionsModule` class is the central hub for managing permissions. Access it using the singleton pattern:
 
 ```java
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.addUserPermission(playerUUID, permissions);
 ```
 
-### Removing Permission Nodes
+### Available Operations
+
+The module supports these operations:
+
+| Operation                     | Method                                          |
+| ----------------------------- | ----------------------------------------------- |
+| Add permissions to user       | `addUserPermission(uuid, permissions)`          |
+| Remove permissions from user  | `removeUserPermission(uuid, permissions)`       |
+| Add permissions to group      | `addGroupPermission(groupName, permissions)`    |
+| Remove permissions from group | `removeGroupPermission(groupName, permissions)` |
+| Add user to group             | `addUserToGroup(uuid, groupName)`               |
+| Remove user from group        | `removeUserFromGroup(uuid, groupName)`          |
+| Get user's groups             | `getGroupsForUser(uuid)`                        |
+| Check permission              | `hasPermission(uuid, permissionNode)`           |
+
+<Callout type="warning">
+  The module does **not** support:
+
+  - Listing all defined groups
+  - Deleting a group entirely
+
+  Groups are implicitly created when you first add permissions to them.
+</Callout>
+
+---
 
-Same as above, we just use the `removeUserPermission` method instead to remove permission nodes.
+## Checking Permissions
+
+The most common operation is checking if a player has a permission.
+
+### Basic Permission Check
+
+```java
+// Returns true if player has the permission, false otherwise
+boolean canUse = PermissionsModule.get().hasPermission(playerUUID, "myplugin.feature.use");
+
+if (canUse) {
+    // Player has permission, allow the action
+} else {
+    // Player lacks permission, deny or show error
+}
+```
+
+### Permission Check with Default Value
+
+You can specify what to return when no permission is explicitly set:
+
+```java
+// Returns true by default if no explicit permission is found
+boolean canUse = PermissionsModule.get().hasPermission(playerUUID, "myplugin.feature.use", true);
+```
+
+This is useful for features that should be enabled by default but can be revoked.
+
+### Using PermissionHolder Interface
+
+Players and command senders implement `PermissionHolder`, allowing direct checks:
+
+```java
+// In a command or event handler where you have access to the player
+if (player.hasPermission("myplugin.admin.manage")) {
+    // Player has admin permission
+}
+```
+
+---
+
+## Managing User Permissions
+
+### Adding Permissions to a User
+
+Permissions are additive - new permissions are added on top of existing ones, not replaced.
+
+```java
+PermissionsModule perms = PermissionsModule.get();
+
+// Add a single permission
+perms.addUserPermission(playerUUID, Set.of("myplugin.vip.chat"));
+
+// Add multiple permissions at once
+Set<String> newPerms = Set.of(
+    "myplugin.vip.chat",
+    "myplugin.vip.fly",
+    "myplugin.vip.kit"
+);
+perms.addUserPermission(playerUUID, newPerms);
+```
+
+### Removing Permissions from a User
 
 ```java
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.removeUserPermission(playerUUID, permissions);
+
+// Remove specific permissions
+Set<String> toRemove = Set.of("myplugin.vip.fly");
+perms.removeUserPermission(playerUUID, toRemove);
 ```
 
-### Add permissions to group
+---
+
+## Managing Groups
+
+Groups let you assign a collection of permissions to multiple players. This is more manageable than assigning permissions individually.
+
+### Adding Permissions to a Group
+
+If the group doesn't exist, it will be created automatically.
 
 ```java
-String groupName = "testGroup";
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.addGroupPermission(groupName, permissions);
+
+// Create/update the "VIP" group with permissions
+Set<String> vipPerms = Set.of(
+    "myplugin.vip.chat",
+    "myplugin.vip.fly",
+    "myplugin.vip.kit"
+);
+perms.addGroupPermission("VIP", vipPerms);
 ```
 
-### Remove permissions from group
+### Removing Permissions from a Group
 
 ```java
-String groupName = "testGroup";
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.removeGroupPermission(groupName, permissions);
+
+// Remove specific permissions from the group
+Set<String> toRemove = Set.of("myplugin.vip.fly");
+perms.removeGroupPermission("VIP", toRemove);
 ```
 
-### Add user to group
+### Adding a User to a Group
 
 ```java
-String groupName = "testGroup";
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.addUserToGroup(playerUUID, groupName);
+
+// Add player to the VIP group - they now have all VIP permissions
+perms.addUserToGroup(playerUUID, "VIP");
 ```
 
-### Remove user from group
+### Removing a User from a Group
 
 ```java
-String groupName = "testGroup";
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.removeUserFromGroup(playerUUID, groupName);
+
+// Remove player from VIP group
+perms.removeUserFromGroup(playerUUID, "VIP");
 ```
 
-### List all groups for a user
+### Getting a User's Groups
 
 ```java
 PermissionsModule perms = PermissionsModule.get();
-perms.getGroupsForUser(playerUUID);
+
+// Get all groups the player belongs to
+Set<String> groups = perms.getGroupsForUser(playerUUID);
+
+for (String group : groups) {
+    System.out.println("Player is in group: " + group);
+}
 ```
 
-### Check Permission Nodes
+---
+
+## Built-in Groups
+
+Hytale includes two default groups:
+
+| Group     | Default Permissions   | Purpose                           |
+| --------- | --------------------- | --------------------------------- |
+| `OP`      | `*` (all permissions) | Server operators with full access |
+| `Default` | None                  | Base group for all players        |
+
+Players without any explicit group assignment are automatically part of the `Default` group.
 
-To check if a player has a specific permission node, you can use the `hasPermission` method.
+---
+
+## Wildcards
+
+Wildcards let you grant or deny multiple permissions with a single pattern.
+
+### Wildcard Patterns
+
+| Pattern             | Meaning                                          |
+| ------------------- | ------------------------------------------------ |
+| `*`                 | Grants **all** permissions                       |
+| `myplugin.*`        | Grants all permissions starting with `myplugin.` |
+| `-*`                | Denies **all** permissions                       |
+| `-myplugin.admin.*` | Denies all admin permissions in your plugin      |
+
+### Example: Admin Group with Wildcards
 
 ```java
-boolean hasPermission = PermissionsModule.hasPermission(playerUUID, "permission.node");
+// Grant all permissions to admins
+perms.addGroupPermission("Admin", Set.of("*"));
+
+// Grant all plugin permissions to moderators
+perms.addGroupPermission("Moderator", Set.of("myplugin.*"));
+
+// Grant all permissions except admin commands
+perms.addGroupPermission("Helper", Set.of(
+    "*",
+    "-myplugin.admin.*"  // Deny admin permissions
+));
 ```
 
-## Additional: Defining your own provider for permissions and groups
+<Callout type="warning">
+  Negation permissions (starting with `-`) take precedence at each level. Use them carefully to avoid accidentally blocking permissions.
+</Callout>
+
+---
+
+## Built-in Permission Nodes
+
+Hytale provides constants for common permissions in the `HytalePermissions` class:
+
+### Command Permissions
+
+```java
+// Generate permission for a command
+String perm = HytalePermissions.fromCommand("gamemode");
+// Result: "hytale.command.gamemode"
+
+// Generate permission for a subcommand
+String perm = HytalePermissions.fromCommand("gamemode", "creative");
+// Result: "hytale.command.gamemode.creative"
+```
+
+### Common Permission Nodes
+
+| Permission                    | Description                  |
+| ----------------------------- | ---------------------------- |
+| `hytale.command.op.add`       | Add players to OP group      |
+| `hytale.command.op.remove`    | Remove players from OP group |
+| `hytale.editor.brush.use`     | Use brush tools              |
+| `hytale.editor.prefab.use`    | Use prefabs                  |
+| `hytale.editor.selection.use` | Use selection tools          |
+| `hytale.editor.history`       | Undo/redo operations         |
+| `hytale.camera.flycam`        | Use fly camera mode          |
+
+---
+
+## Listening to Permission Events
+
+You can react to permission changes using Hytale's event system.
+
+### Available Events
+
+| Event                                            | Triggered When                   |
+| ------------------------------------------------ | -------------------------------- |
+| `PlayerPermissionChangeEvent.PermissionsAdded`   | Permissions added to a user      |
+| `PlayerPermissionChangeEvent.PermissionsRemoved` | Permissions removed from a user  |
+| `PlayerGroupEvent.Added`                         | User added to a group            |
+| `PlayerGroupEvent.Removed`                       | User removed from a group        |
+| `GroupPermissionChangeEvent.Added`               | Permissions added to a group     |
+| `GroupPermissionChangeEvent.Removed`             | Permissions removed from a group |
 
-The PermissionsModule also enables us to define our own PermissionProvider's, this can be useful for:
+### Example: Reacting to Permission Changes
 
-- Cross server permission systems
-- Implementing features missing in the `HytalePermissionsProvider` like permission expiry
+```java
+public class PermissionListener {
+
+    public static void onPermissionsAdded(PlayerPermissionChangeEvent.PermissionsAdded event) {
+        UUID playerUUID = event.getPlayerUuid();
+        Set<String> added = event.getAddedPermissions();
+
+        System.out.println("Permissions added to " + playerUUID + ": " + added);
 
-To implement our PermissionProvider, first we need to define a provider class that implements PermissionProvider:
+        // Maybe notify the player or update cached data
+    }
+
+    public static void onGroupAdded(PlayerGroupEvent.Added event) {
+        UUID playerUUID = event.getPlayerUuid();
+        String groupName = event.getGroupName();
+
+        System.out.println("Player " + playerUUID + " joined group: " + groupName);
+    }
+}
+```
+
+### Registering the Events
 
 ```java
-public class DatabasePermissionProvider implements PermissionProvider
+public class MyPlugin extends JavaPlugin {
+
+    @Override
+    public void setup() {
+        EventRegistry events = this.getEventRegistry();
+
+        events.registerGlobal(
+            PlayerPermissionChangeEvent.PermissionsAdded.class,
+            PermissionListener::onPermissionsAdded
+        );
+
+        events.registerGlobal(
+            PlayerGroupEvent.Added.class,
+            PermissionListener::onGroupAdded
+        );
+    }
+}
 ```
 
-Then we just implement the required methods using a database implementation.
+---
+
+## Creating a Custom Permission Provider
+
+For advanced use cases, you can create your own permission provider. This is useful for:
+
+- Database-backed permissions (MySQL, MongoDB, etc.)
+- Cross-server permission synchronization
+- Custom features like permission expiry or contexts
+
+### Implementing PermissionProvider
+
+```java
+public class DatabasePermissionProvider implements PermissionProvider {
+
+    @Nonnull
+    @Override
+    public String getName() {
+        return "DatabasePermissionProvider";
+    }
+
+    // User permission methods
+    @Override
+    public void addUserPermissions(@Nonnull UUID uuid, @Nonnull Set<String> permissions) {
+        // Save to your database
+    }
+
+    @Override
+    public void removeUserPermissions(@Nonnull UUID uuid, @Nonnull Set<String> permissions) {
+        // Remove from your database
+    }
+
+    @Override
+    public Set<String> getUserPermissions(@Nonnull UUID uuid) {
+        // Query your database
+        return Set.of();
+    }
+
+    // Group permission methods
+    @Override
+    public void addGroupPermissions(@Nonnull String group, @Nonnull Set<String> permissions) {
+        // Save to your database
+    }
+
+    @Override
+    public void removeGroupPermissions(@Nonnull String group, @Nonnull Set<String> permissions) {
+        // Remove from your database
+    }
+
+    @Override
+    public Set<String> getGroupPermissions(@Nonnull String group) {
+        // Query your database
+        return Set.of();
+    }
+
+    // User-group membership methods
+    @Override
+    public void addUserToGroup(@Nonnull UUID uuid, @Nonnull String group) {
+        // Save to your database
+    }
+
+    @Override
+    public void removeUserFromGroup(@Nonnull UUID uuid, @Nonnull String group) {
+        // Remove from your database
+    }
+
+    @Override
+    public Set<String> getGroupsForUser(@Nonnull UUID uuid) {
+        // Query your database
+        return Set.of("Default");
+    }
+}
+```
 
 <Callout type="warning">
-  Hytale will try to use the first available permissions provider to add/remove gamemode groups (i.e. `Creative`, `Adventure`).
+  Hytale automatically assigns players to game-mode groups (like `Creative` or `Adventure`) using the first available provider.
+
+  If your provider throws an error when the group doesn't exist, the player will be disconnected! Always handle missing groups gracefully.
+</Callout>
+
+### Registering Your Provider
 
-  If your provider throws an error (for instance, if the group does not exist) when the server is preparing the player, the player will be disconnected.
+```java
+public class MyPlugin extends JavaPlugin {
+
+    @Override
+    public void setup() {
+        // Add your provider alongside the default one
+        PermissionsModule.get().addProvider(new DatabasePermissionProvider());
+    }
+}
+```
+
+The `PermissionsModule` aggregates permissions from all registered providers. This means:
+
+- Permission checks query all providers
+- Write operations (add/remove) use the **first** provider
+
+### Replacing the Default Provider
+
+If you want full control, you can remove the default provider:
+
+```java
+public class MyPlugin extends JavaPlugin {
+
+    @Override
+    public void setup() {
+        PermissionsModule perms = PermissionsModule.get();
+
+        // Remove the default provider FIRST
+        perms.removeProvider(perms.getFirstPermissionProvider());
+
+        // Then add your provider
+        perms.addProvider(new DatabasePermissionProvider());
+    }
+}
+```
+
+<Callout type="info">
+  When you remove the default provider, the `/op self` command will stop working since it checks for provider tampering.
 </Callout>
 
-We can then register the provider using the built-in permission module:
+---
+
+## Best Practices
+
+### Permission Naming Conventions
+
+Follow the pattern: `namespace.category.action`
 
 ```java
-PermissionsModule.get().addProvider(new DatabasePermissionProvider());
+// Good - clear hierarchy
+"myplugin.admin.ban"
+"myplugin.user.teleport.home"
+"myplugin.vip.chat.color"
+
+// Bad - unclear structure
+"myplugin_ban"
+"teleport"
+"vipChatColor"
 ```
 
-Please note that the `HytalePermissionsProvider` will still be enabled alongside your provider.
-The `PermissionsModule` will aggregate groups and permissions from all available providers.
+### Use Constants for Permissions
 
-If you want to disable the default `HytalePermissionsProvider`, you can use:
+Define your permissions as constants to avoid typos:
 
 ```java
-// put this **before** you add your provider
-PermissionsModule.get().removeProvider(PermissionsModule.get().getFirstPermissionProvider());
+public final class MyPermissions {
+    public static final String ADMIN_BAN = "myplugin.admin.ban";
+    public static final String ADMIN_KICK = "myplugin.admin.kick";
+    public static final String USER_HOME = "myplugin.user.home";
+    public static final String VIP_FLY = "myplugin.vip.fly";
+}
+
+// Usage
+if (player.hasPermission(MyPermissions.ADMIN_BAN)) {
+    // ...
+}
 ```
+
+### Don't Over-Permission
+
+Only create permissions for actions that genuinely need access control. Not everything needs a permission check.
+
+### Thread Safety
+
+If you create a custom provider, ensure it's thread-safe. Permission checks can occur from multiple threads simultaneously. Use `ReadWriteLock` or `ConcurrentHashMap` for your data structures.
+
+---
+
+## In-Game Commands
+
+Hytale provides built-in commands for managing permissions:
+
+### `/op` Command
+
+| Command               | Description                                                        |
+| --------------------- | ------------------------------------------------------------------ |
+| `/op self`            | Toggle your own OP status (singleplayer or with `--allow-op` flag) |
+| `/op add <player>`    | Add a player to the OP group                                       |
+| `/op remove <player>` | Remove a player from the OP group                                  |
+
+### `/perm` Command
+
+Use `/perm --help` in-game for full usage. Common operations:
+
+| Command                                  | Description                   |
+| ---------------------------------------- | ----------------------------- |
+| `/perm user list <uuid>`                 | List user's permissions       |
+| `/perm user add <uuid> <perm>`           | Add permission to user        |
+| `/perm user remove <uuid> <perm>`        | Remove permission from user   |
+| `/perm user group list <uuid>`           | List user's groups            |
+| `/perm user group add <uuid> <group>`    | Add user to group             |
+| `/perm user group remove <uuid> <group>` | Remove user from group        |
+| `/perm group list <group>`               | List group's permissions      |
+| `/perm group add <group> <perm>`         | Add permission to group       |
+| `/perm group remove <group> <perm>`      | Remove permission from group  |
+| `/perm test <perm>`                      | Test if you have a permission |
+
+---
+
+## Summary
+
+You've learned how to:
+
+- **Check permissions** using `PermissionsModule.hasPermission()`
+- **Manage user permissions** with `addUserPermission()` and `removeUserPermission()`
+- **Work with groups** using `addGroupPermission()`, `addUserToGroup()`, etc.
+- **Use wildcards** like `*` and `myplugin.*` for bulk permissions
+- **Listen to events** for permission changes
+- **Create custom providers** for database-backed permissions
+
+For more advanced permission systems with features like inheritance, expiry, and contexts, we're looking into expanding this guide with advanced permission management techniques in the future.
diff --git a/content/docs/lv-LV/guides/plugin/setting-up-env.mdx b/content/docs/lv-LV/guides/plugin/setting-up-env.mdx
index d2718098..5be5e9e0 100644
--- a/content/docs/lv-LV/guides/plugin/setting-up-env.mdx
+++ b/content/docs/lv-LV/guides/plugin/setting-up-env.mdx
@@ -4,6 +4,10 @@ description: Learn how to set up your development environment for modding Hytale
 authors:
   - name: Neil Revin
     link: https://itsneil.dev
+  - name: Marcel-TO
+    url: https://marcel-to.net
+  - name: Ádám Liszkai
+    link: https://adaliszk.dev
 ---
 
 This guide will walk you through setting up a complete development environment for Hytale modding, including all necessary tools and dependencies.
@@ -19,24 +23,73 @@ Before we begin, make sure you have:
 
 ## Required Software
 
-### 1. Java Development Kit (JDK)
+### Integrated Development Environment (IDE)
 
+We recommend IntelliJ IDEA Community Edition for Hytale modding. If you use IntelliJ IDEA, **almost everything is built-in**. You can clone a template, open a new project, and start working right away!
+
+1. Download from [JetBrains website](https://www.jetbrains.com/idea/download/)
+2. Install with default settings
+3. Launch and complete the initial setup wizard
+
+When opening a project, wait for indexing to finish, then start coding.
+Now, IDEA may say "No JDK configured" at the top of the source file you have.
+In that case, you can click Download JDK and choose JetBrains JDK 25.
+
+<Callout type="success">
+  If IDEA opened the project without errors, your environment is ready.
+</Callout>
+
+More details by [JetBrains](https://www.jetbrains.com/help/idea/2026.1/run-for-the-first-time.html)
+help page, where we recommend that you also check the
+[SDK configuration](https://www.jetbrains.com/help/idea/2026.1/sdk.html) guide.
+
+<Callout type="info">
+  We recommened following
+  [TheNullicorn's](https://gist.github.com/TheNullicorn/90a619796c40f20ae1fcf13094c1a57d) guide to ensure
+  you are using the correct `Nonnull` in your projects.
+</Callout>
+
+#### What the IDE Does for You
+
+When opened in IntelliJ IDEA, the project automatically:
+
+- Detects and configures Gradle or Maven
+- Downloads all dependencies
+- Sets up project structure and classpaths
+- Configures run/build tasks
+
+You do **not** need to manually install or configure Maven or Gradle if you stay inside the IDE.
+
+Skip to the [Setting Up Your Workspace](#setting-up-your-workspace).
+
+### Manual Setup: Java Development Kit (JDK)
+
+For any other setup, you will need to install and configure your system to have and load Java.
 Hytale modding requires Java 25 or later. We recommend using OpenJDK.
 
-#### Windows
+#### Windows via Installer
 
 1. Download OpenJDK 25 from [Adoptium](https://adoptium.net/)
 2. Run the installer with default settings
+   - Optionally enable feature `Set or Override JAVA_HOME variable` to resolve version related build issues with your project.
 3. Verify installation by opening Command Prompt and running:
 
+#### Windows via Scoop
+
+1. Install Scoop via PowerShell using [scoop.sh](https://scoop.sh/)
+2. Install OpenJDK 25:
+
 ```bash
-java -version
+scoop bucket add java
+scoop install java/openjdk25
 ```
 
 #### macOS
 
+1. Install Brew via Terminal using [brew.sh](https://brew.sh)
+2. Install JDK via Homebrew:
+
 ```bash
-# Using Homebrew
 brew install openjdk@25
 ```
 
@@ -51,22 +104,41 @@ brew install openjdk@25
 
 #### Linux (Ubuntu/Debian)
 
+1. Install JDK via the built-in package repository:
+
 ```bash
 sudo apt update
 sudo apt install openjdk-25-jdk
 ```
 
-### 2. Integrated Development Environment (IDE)
+### Verify installation:
 
-We recommend IntelliJ IDEA Community Edition for Hytale modding.
+Run the following command to see what version of Java you have:
 
-1. Download from [JetBrains website](https://www.jetbrains.com/idea/download/)
-2. Install with default settings
-3. Launch and complete the initial setup wizard
+```bash
+java -version
+```
+
+### Java Build Tool (Optional)
+
+We recommend using a Gradle Wrapper for managing dependencies and building your Hytale plugins. It provides benefits by eliminating the need for a system-wide Gradle installation and ensuring consistent Gradle versions across different environments. (Alternatively you can use Maven, but this guide focuses on Gradle since it is the default for our plugin template.)
+
+The plugin template in the following sections includes a Gradle Wrapper, so you can skip this step if you plan to use the template.
+
+#### Choosing Gradle (if not using the template)
+
+If you prefer to install Gradle manually, follow these steps:
 
-### 3) Java Build Tool
+1. Visit the official website: https://gradle.org/releases/
+2. Download the newest gradle binary: `gradle-9.3.1-bin.zip` (Binary zip archive)
+3. Unzip it
+4. Add the `gradle-9.3.1/bin/` folder to your PATH
+
+You can now try the command `gradle -version` to verify Gradle is installed correctly. Make sure to do this in a fresh new terminal instead of one you had opened from before!
+
+#### Choosing Maven (if not using the template)
 
-We recommend using Apache Maven for managing dependencies and building your Hytale plugins. (Alternatively you can use Gradle, but this guide focuses on Maven.)
+If you prefer to use Maven instead of Gradle, follow these steps to install Maven:
 
 1. Visit the official website: https://maven.apache.org/download.cgi
 2. Download this file: `apache-maven-3.9.12-bin.zip` (Binary zip archive)
@@ -89,22 +161,61 @@ cd MyFirstMod
 
 If you don't have Git installed, you can download the ZIP file from the repository page and extract it to a folder named `MyFirstMod`.
 
-### 2. Open Plugin in your IDEA
+### 2. Open Plugin in your IDE
 
-1. Open IntelliJ IDEA
+1. Open Your IDE (e.g., IntelliJ IDEA)
 2. Click "Open" and navigate to your `MyFirstMod` directory
-3. IntelliJ will automatically detect it as a Maven project
+3. Most IDEs like IntelliJ will automatically detect it as a Gradle project
 4. Wait for the project to index and dependencies to download
 
-<Callout type="info">
-  We recommened following [this](https://gist.github.com/TheNullicorn/90a619796c40f20ae1fcf13094c1a57d) guide to ensure you are using the correct `Nonnull` in your projects.
-</Callout>
+## Alternate Approach: Hytale Dependency
+
+If you prefer to set up your project from scratch without using the template and importing the hytale dependencies manually, ensure your build configuration includes the Hytale repositories and dependencies:
+
+For Gradle, add the following to your `build.gradle.kts`:
+
+```kotlin
+repositories {
+    mavenCentral()
+    maven {
+        name = "hytale"
+        url = uri("https://maven.hytale.com/release") // Or "hytale-pre-release" for pre-release versions
+    }
+}
+dependencies {
+    // + here means the latest version, but you can hard-wire any known version!
+    implementation("com.hypixel.hytale:Server:+")
+}
+```
+
+For Maven, add the following to your `pom.xml`:
+
+```xml
+<project>
+    <repositories>
+        <repository>
+            <id>hytale-release</id> <!-- Or "hytale-pre-release" for pre-release versions -->
+            <url>https://maven.hytale.com/release</url> <!-- Or "https://maven.hytale.com/pre-release" -->
+        </repository>
+    </repositories>
+
+    <dependencies>
+        <dependency>
+            <groupId>com.hypixel.hytale</groupId>
+            <artifactId>Server</artifactId>
+            <!-- Replace with latest version, Hytale provides jars for the last five releases -->
+            <version>LATEST_VERSION_HERE</version>
+            <scope>provided</scope>
+        </dependency>
+    </dependencies>
+</project>
+```
 
 ## Next Steps
 
 Now that you have your development environment set up with the plugin template:
 
-1. **Customize the template** - Edit the `pom.xml` and `manifest.json` file to change your mod's name and details
+1. **Customize the template** - Edit the `settings.gradle.kts`, `build.gradle.kts` and `manifest.json` file to change your mod's name and details
 2. **Explore the code structure** - Familiarize yourself with the template's organization
 3. **Start modding** - Begin writing your first Hytale plugin!
 
diff --git a/content/docs/lv-LV/guides/plugin/spawning-entities.mdx b/content/docs/lv-LV/guides/plugin/spawning-entities.mdx
index e12c0aea..15be2fb3 100644
--- a/content/docs/lv-LV/guides/plugin/spawning-entities.mdx
+++ b/content/docs/lv-LV/guides/plugin/spawning-entities.mdx
@@ -36,7 +36,7 @@ Store<EntityStore> store = world.getEntityStore().getStore();
 
 ## Creating Entities
 
-Once you have the `EntityStore` instance, you can start to create a entity and give it components. Entities are just instances of `Holder<EntityStore>` with several components attached to them.
+Once you have the `EntityStore` instance, you can start to create an entity and give it components. Entities are just instances of `Holder<EntityStore>` with several components attached to them.
 
 <Callout type="warning">
   To interact with the `World` instance, some methods require you to run the code inside the world's execution context.
@@ -118,3 +118,48 @@ Finally, we can add the entity to the world by calling the `addEntity` method on
 ```java
 store.addEntity(holder, AddReason.SPAWN);
 ```
+
+## Making the entity persist
+
+Hytale automatically saves all entities, but the `NetworkId` component (required for players to be able to see the entity) needs to be manually added every time the entity is loaded.
+
+### Using a system
+
+If you have a component that is unique to your entities, this can be done by creating and registering a custom system as follows:
+
+```java
+public class AddNetworkIdToMyEntitySystem extends HolderSystem<EntityStore> {
+    private final ComponentType<EntityStore, MyEntityComponent> myEntityComponentType = MyEntityComponent.getComponentType();
+    private final ComponentType<EntityStore, NetworkId> networkIdComponentType = NetworkId.getComponentType();
+    private final Query<EntityStore> query = Query.and(this.myEntityComponentType, Query.not(this.networkIdComponentType));
+
+    @Override
+    public void onEntityAdd(@NotNull Holder<EntityStore> holder, @NotNull AddReason reason, @NotNull Store<EntityStore> store) {
+        if (!holder.getArchetype().contains(NetworkId.getComponentType())) {
+            holder.addComponent(NetworkId.getComponentType(), new NetworkId(store.getExternalData().takeNextNetworkId()));
+        }
+    }
+
+    @Override
+    public void onEntityRemoved(@NotNull Holder<EntityStore> holder, @NotNull RemoveReason reason, @NotNull Store<EntityStore> store) {}
+
+    @Override
+    public @Nullable Query<EntityStore> getQuery() {
+        return query;
+    }
+}
+```
+
+In your plugin's `setup()` function
+
+```java
+this.getEntityStoreRegistry().registerSystem(new AddNetworkIdToMyEntitySystem())
+```
+
+### Using PropComponent
+
+Alternatively you can add `PropComponent` to your entity. Hytale adds `PropComponent` to entities spawned with the Entity Tool, and such entities automatically get `NetworkId` and `PrefabCopyableComponent` (which makes the entity work with prefabs).
+
+<Callout type="warning">
+  There is no guarantee, that Hytale will not add some other behavior to this component in the future, which may break your entity, so be careful if you decide to rely on it.
+</Callout>
diff --git a/content/docs/lv-LV/guides/plugin/store-persistent-data.mdx b/content/docs/lv-LV/guides/plugin/store-persistent-data.mdx
new file mode 100644
index 00000000..1071dff3
--- /dev/null
+++ b/content/docs/lv-LV/guides/plugin/store-persistent-data.mdx
@@ -0,0 +1,171 @@
+---
+title: Storing Persistent Data on the Player
+description: Learn how to save and load persistent data using Components
+authors:
+  - name: Neil Revin
+    url: https://itsneil.dev/
+  - name: ArcticDev
+    url: https://github.com/ArcticRaven
+  - name: oskarscot
+    url: https://oskar.scot
+  - name: JammingEng
+    url: https://github.com/JammingEnd
+---
+
+Here is how to store persistent data using a custom component on a Player.
+
+## Build your Component Class
+
+Creating a custom component class leverages the Component system made with the ECS architecture in mind. For more information on Components, check out the [ECS Guide](../ecs/hytale-ecs-theory#components).
+
+Start by creating your custom component class. This will be extremely similar to how regular components are created, however we'll setup a custom Codec so the server can translate this data to BSON, or the server's internal json encoder.
+
+<Callout type="info">
+  Each variable you want to store in your component must have its own Codec field defined in the BuilderCodec.
+  For more information on how to create custom Codecs, check out the [ECS Codec Guide](../ecs/hytale-ecs-theory#codec).
+</Callout>
+
+```java
+public class YourPlayerData implements Component<EntityStore> {
+
+    // define some vars!
+    private int someInteger;
+    private String someString;
+    private Map<String, String> someMap;
+
+    public static final BuilderCodec<YourPlayerData> CODEC =
+            BuilderCodec.builder(YourPlayerData.class, YourPlayerData::new)
+            .append(new KeyedCodec<>("SomeInteger", Codec.INTEGER),
+                    (data, value) -> data.someInteger = value, // setter
+                    data -> data.someInteger) // getter
+            .addValidator(Validators.nonNull())
+            .add()
+            .append(new KeyedCodec<>("SomeString", Codec.STRING),
+                    (data, value) -> data.someString = value, // setter
+                    data -> data.someString) // getter
+            .add()
+            .append(new KeyedCodec<>("SomeMap",
+                            new MapCodec<>(Codec.STRING, HashMap::new, false)),
+                    (data, value) -> data.someMap = value, // setter
+                    data -> data.someMap) // getter
+            .add()
+            .build();
+
+
+
+    // Getters and Setters are for the purpose of this example omitted.
+
+    // constructor
+    public YourPlayerData() {
+        this.someInteger = 0;
+        this.someString = "";
+        this.someMap = new HashMap<>();
+    }
+
+    // copy constructor for cloning
+    public YourPlayerData(YourPlayerData clone) {
+        this.someInteger = clone.someInteger;
+        this.someString = clone.someString;
+        this.someMap = clone.someMap;
+    }
+
+    @Nonnull
+    @Override
+    public Component<EntityStore> clone() {
+        return new YourPlayerData(this);
+    }
+}
+```
+
+## Register your Component
+
+Inside your main class's `setup()` method, register your new Component.
+
+```java
+public class YourPlugin extends JavaPlugin {
+
+    private ComponentType<EntityStore, YourPlayerData> yourPlayerDataComponent;
+
+    public YourPlugin(@Nonnull JavaPluginInit init) {
+        super(init);
+    }
+
+    @Override
+    protected void setup(){
+        this.yourPlayerDataComponent = this.getEntityStoreRegistry().registerComponent(
+            YourPlayerData.class,
+            "YourPlayerDataComponent",
+            YourPlayerData.CODEC
+        );
+    }
+
+    public ComponentType<EntityStore, YourPlayerData> getYourPlayerDataComponent() {
+        return this.yourPlayerDataComponent;
+    }
+}
+```
+
+## Using your Component
+
+To use your newly created component, you can add the Component to a player using the `addComponent` method, although this only adds it temporarily, meaning when the player/entity leaves the world, the component is removed. You can use `putComponent` to ensure the component persists between sessions.
+
+```java
+// You will need the Ref and Store to apply components
+private void someEntryMethod(@Nonnull Ref<EntityStore> ref, @Nonnull Store<EntityStore> store)
+{
+       // Any entity will work, for now we will use the player
+      Player player = (Player) store.getComponent(ref, Player.getComponentType());
+
+      // since we're using putComponent, it could be useful to check if it already exists on the player in case we want to update it
+     if(store.getComponent(ref, YourPlugin.instance().getYourPlayerDataComponent()) != null)
+     {
+          // here we implement logic that updates the component
+         var comp = store.getComponent(ref, YourPlugin.instance().getYourPlayerDataComponent())
+         // declare public fields or methods in the component class
+         comp.SomeString = "An Updated Field";
+     } else {
+          // Here we put the component
+          var myCustomComp = new CustomComponent();
+          // declare public fields or methods in the component class
+          myCustomComp.SomeString = "Edited String";
+
+          // putComponent allows you to insert declared objects
+          store.putComponent(ref, YourPlugin.instance().getYourPlayerDataComponent(), myCustomComp);
+     }
+}
+```
+
+## Using your Data
+
+Your component will be stored within the `Store<EntityStore>` when added to the player. In the provided example,
+we'll fetch this data off the player using the `ensureAndGetComponent()` method, which will add the component to
+the player if it does not exist with the default values.
+
+```java
+public class IncompleteCustomCommand extends AbstractPlayerCommand {
+
+    public IncompleteCustomCommand() {
+        super("nope", "don't use this command");
+    }
+
+    @Override
+    protected void execute(
+        @NonNullDecl CommandContext commandContext,
+        @NonNullDecl Store<EntityStore> store,
+        @NonNullDecl Ref<EntityStore> ref,
+        @NonNullDecl PlayerRef playerRef,
+        @NonNullDecl World world
+    ) {
+        YourPlayerData customData = store.ensureAndGetComponent(ref, YourPlugin.instance().getYourPlayerDataComponent());
+        // ensureAndGetComponent adds the component to the ref, with the default values defined inside your component.
+ 		// use your data
+    }
+}
+```
+
+And that's it! Your data will now be saved and loaded automatically with the player.
+
+Using custom components to store persistent data on players is a powerful way to maintain state across sessions.
+By following the steps outlined above, you can easily create, register, and utilize your own data structures within the Hytale ECS framework.
+This approach ensures that your data is seamlessly integrated with the game's existing systems.
+For more information about Hytale's Entity Component System visit the [Hytale ECS Theory](https://hytalemodding.dev/en/docs/guides/ecs/hytale-ecs-theory) guide.
diff --git a/content/docs/lv-LV/guides/plugin/teleporting-players.mdx b/content/docs/lv-LV/guides/plugin/teleporting-players.mdx
index 57cee77f..32ce0435 100644
--- a/content/docs/lv-LV/guides/plugin/teleporting-players.mdx
+++ b/content/docs/lv-LV/guides/plugin/teleporting-players.mdx
@@ -1,26 +1,32 @@
 ---
 title: Teleporting the player
 description: Learn how to teleport the player.
+authors:
+  - name: oskarscot
+    url: https://oskar.scot
 ---
 
-To teleport players in Hytale, you will need to get a `World` object so we can safely run the teleport on the world thread. The world thread manages all entity updates, so modifying entities off-thread can crash the server or cause inconsistent state.
-Next, we get the entity store and make a `Teleport` object.
-We add a `Teleport` component to the player’s entity reference in the entity store. This triggers the teleportation logic for that player.
+Teleporting players in Hytale works by simply attaching a `Teleport` component to a player with the desired world and transform.
+You can only trigger teleports from a world where the player is currently present.
+Teleport itself is a component but it also provides factory methods to configure the Teleport. Just as with any entity component, an EntityStore and a Ref to the EntityStore is required
+
+We can create a simple teleport utility like this:
 
 ```java
-public static void teleportPlayer(Player player, int x, int y, int z) {
-        World world = player.getWorld();
-        if (world == null) return;
-        world.execute(() -> {
-            if (player.getReference() == null) return;
-            Store<EntityStore> store = player.getReference().getStore();
-            Teleport teleport = Teleport.createForPlayer(world,
-                new Vector3d(x ,y, z), // Target position
-                new Vector3f(0, 0, 0)  // Target rotation (pitch, yaw, roll)
-            );
+public static void teleportPlayer(Ref<EntityStore> ref, Store<EntityStore> store, World targetWorld, double x, double y, double z) {                                                                                       
+    Transform transform = new Transform(x, y, z);                                                                                                                           
+    Teleport teleport = Teleport.createForPlayer(targetWorld, transform);                                                                                                   
+    store.addComponent(ref, Teleport.getComponentType(), teleport);                                                                                                         
+}  
+```
 
-            store.addComponent(player.getReference(), Teleport.getComponentType(), teleport);
-        });
+A `Transform` is a representation of a position Vector3d and rotation Vector3f which works in the following way:
 
-}
+```java
+Transform transform = new Transform(
+    new Vector3d(x, y, z),      // Position
+    new Rotation(yaw, pitch, 0) // Rotation, last value seems to always be 0
+);
+Teleport teleport = Teleport.createForPlayer(targetWorld, transform);
+store.addComponent(ref, Teleport.getComponentType(), teleport);
 ```
diff --git a/content/docs/lv-LV/guides/plugin/tracking-mod-analytics-with-hstats.mdx b/content/docs/lv-LV/guides/plugin/tracking-mod-analytics-with-hstats.mdx
new file mode 100644
index 00000000..45c022e0
--- /dev/null
+++ b/content/docs/lv-LV/guides/plugin/tracking-mod-analytics-with-hstats.mdx
@@ -0,0 +1,65 @@
+---
+title: Tracking Mod Analytics with HStats
+description: Learn how you can track Analytics for your Hytale Mod for Free using hstats.dev
+authors:
+  - name: Al3x
+    url: https://hstats.dev
+---
+
+In this guide, you will learn how to integrate HStats into your Plugin/Mod which will allow you to track how many Servers are using it along with other stats.
+
+<Callout type="info">
+  HStats is a third-party tool and is not affiliated with HytaleModding or Hypixel Studios
+</Callout>
+
+# Step 1: Register your Mod to HStats
+
+Before you touch any code, you will need to add your mod to the HStats website which will give you a UUID for your mod.
+
+- Create or Login to an Account on https://hstats.dev
+- Navigate to the dashboard page (https://hstats.dev/dashboard)
+- On the left, type in your mod's name and click "Add Mod"
+- Keep note of the UUID generated for later.
+
+# Step 2: Add the HStats Class to Your Project
+
+To keep things simple, HStats uses a single Java class file that handles everything for you.
+
+- Download / Copy the File from the GitHub page (https://github.com/hstats-dev/HStatsExamplePlugin/blob/main/src/main/java/com/al3x/HStats.java)
+- Paste into your Project. You should now have a HStats.java file somewhere in your projects directory.
+- Update the package name from com.al3x to whatever fits your project.
+
+# Step 3: Initialize HStats in your code
+
+You only need to add one line of code to your mod's setup method in your main class to start tracking.
+
+`new HStats("YOUR-MOD-UUID", "1.0.0");`
+
+Replace `YOUR-MOD-UUID` with the Mod UUID we made note of earlier and change the `1.0.0` version to whatever version your mod is currently on.
+
+Your setup method should now look something like this:
+
+```java
+@Override
+protected void setup() {
+  super.setup();
+  new HStats("c34a2b2a-afd8-4d6a-821e-7a63e12c5ea6", "1.0.0");
+}
+```
+
+# Extras
+
+Your done! Your mod should now be listed under the Mods page (https://hstats.dev/mods) as well as under your dashboard.
+
+Servers using your mod should now post updates about every minute to HStats which you can view in the Dashboard.
+
+### Embeds
+
+HStats allows you to generate an Embed Card that you can place on your CurseForge or GitHub page. This is useful for server owners to be able to see how many other servers are using your mod.
+
+- In your dashboard, scroll down to the Embed Card section.
+- Customize the appearance (Light/Dark mode, layout, etc).
+- Copy the generated URL to display your "Active Servers" and "Players Online" live on your mod's description page
+
+Heres an example of what they look like:
+![HStats Example](https://api.hstats.dev/api/embed/d52fa672-6966-47b2-b501-1a11bddebac3/card.svg?theme=light\&layout=compact\&size=md\&show_id=true\&dark=false)
diff --git a/content/docs/lv-LV/guides/plugin/world-gen.mdx b/content/docs/lv-LV/guides/plugin/world-gen.mdx
index 4c23b0c9..7b193ffd 100644
--- a/content/docs/lv-LV/guides/plugin/world-gen.mdx
+++ b/content/docs/lv-LV/guides/plugin/world-gen.mdx
@@ -100,7 +100,7 @@ Biome biome = biomeGen.generateBiomeAt(zoneResult, seed, x, z);
 
 ### Zone & Cave Integration
 
-Each zone defines it's own cave patterns:
+Each zone defines its own cave patterns:
 
 ```java
 Zone zone = /* ... */;
diff --git a/content/docs/lv-LV/guides/prefabs.mdx b/content/docs/lv-LV/guides/prefabs.mdx
index 08404b30..b1a55109 100644
--- a/content/docs/lv-LV/guides/prefabs.mdx
+++ b/content/docs/lv-LV/guides/prefabs.mdx
@@ -14,7 +14,7 @@ Prefabs are Hytale's way of creating reusable structures.
 There are a few fundamental concepts to understand about prefabs:
 
 - Users interact with prefabs via a prefab editing world.
-- Prefabs the physical structures in the game world, and are saved as JSON files.
+- Prefabs are the physical structures in the game world, and are saved as JSON files.
 
 ## How to Create a Prefab
 
diff --git a/content/docs/lv-LV/official-documentation/custom-ui/common-styling.mdx b/content/docs/lv-LV/official-documentation/custom-ui/common-styling.mdx
new file mode 100644
index 00000000..c36e3e3a
--- /dev/null
+++ b/content/docs/lv-LV/official-documentation/custom-ui/common-styling.mdx
@@ -0,0 +1,50 @@
+---
+title: Common Styling
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# Common Styling
+
+## Common UI Styling Library
+
+This document describes the shared UI components and styles defined in `Common.ui`.
+
+---
+
+### Styles
+
+We are providing some styles that can be re-used in any custom UI that, provide a cohesive UI experience with the core game UI. These styles are available in the `Common.ui` file.
+
+You can find a list of all the styles defined with live examples by running the `/ui-gallery` command ingame.
+
+<Callout type="warning">
+  This command is not available yet, but will be in a future patch.
+</Callout>
+
+![Gallery](/assets/official-documentation/ui/gallery.png)
+
+### Importing
+
+To use these styles in your UI file:
+
+```
+$Common = "Common.ui";
+
+// Then reference styles and components:
+$Common.@TextButton { @Text = "My Button"; }
+$Common.@Container { ... }
+```
+
+<Callout type="info">
+  The `Common.ui` file is at `Common/UI/Custom/Common.ui` within the Hytale pack. If your custom ui document is in a subfolder of `Common/UI/Custom/`, reference it via relative path traversal:
+
+  ```
+  $Common = "../Common.ui";
+  ```
+
+  You can find more info about paths [here](markup#path).
+</Callout>
diff --git a/content/docs/lv-LV/official-documentation/custom-ui/index.mdx b/content/docs/lv-LV/official-documentation/custom-ui/index.mdx
new file mode 100644
index 00000000..f94c4e88
--- /dev/null
+++ b/content/docs/lv-LV/official-documentation/custom-ui/index.mdx
@@ -0,0 +1,125 @@
+---
+title: Custom UI
+icon: LayoutDashboard
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# Custom UI
+
+## What is Custom UI?
+
+Custom UI is Hytale's framework for creating **custom user interfaces** controlled by the game server. Unlike the built-in Client UI (which is part of the game client and cannot be modified), Server UI allows you to create interactive screens and HUD overlays through Java plugins and asset packs.
+
+As a modder, Custom UI gives you the power to:
+
+- **Create custom interactive pages** - Shop interfaces, quest dialogs, server settings menus, admin panels
+- **Add custom HUD overlays** - Quest trackers, status displays, custom health bars, server information
+- **Design with markup** - Use `.ui` files to define reusable UI templates
+- **Handle user interactions** - Respond to button clicks, form submissions, and other events
+- **Localize your UI** - Support multiple languages using the game's translation system
+
+## How Custom UI Fits Into Hytale's UI
+
+Hytale's user interface is divided into two main categories:
+
+### Client UI (Not Moddable)
+
+Built-in interfaces controlled by the C# game client:
+
+- Main menu and settings
+- Character creation
+- Built-in HUD (health, hotbar, chat)
+- Inventory and crafting screens
+- Development tools
+
+**You cannot modify these** - they are part of the core game client.
+
+### In-Game UI (Moddable via Server)
+
+Server-controlled interfaces that you can create and customize:
+
+#### Custom Pages
+
+Full-screen interactive overlays that appear during gameplay:
+
+- Can be dismissed by the player (ESC key)
+- Capture all input (keyboard and mouse)
+- Support loading states while waiting for server responses
+- Perfect for: shops, dialogs, menus, configuration screens
+
+#### Custom HUDs
+
+Persistent overlay elements drawn on top of the game world:
+
+- Display-only (no user interaction)
+- Always visible during gameplay
+- Lightweight and non-intrusive
+- Perfect for: quest objectives, status indicators, server info panels
+
+## Architecture Overview
+
+Server UI uses a **command-based architecture**:
+
+```
+┌─────────────────────┐         ┌──────────────────────┐
+│   Java Server       │         │    C# Client         │
+│   (Your Plugin)     │         │    (Game)            │
+├─────────────────────┤         ├──────────────────────┤
+│                     │         │                      │
+│ InteractiveCustomUI │         │   CustomPage or      │
+│ Page                │         │   CustomHud          │
+│   ↓ build()         ├────────→│     ↓ Apply          │
+│ UICommandBuilder    │         │   Element Tree       │
+│   - append()        │         │     ↓ Layout         │
+│   - set()           │         │   Rendered UI        │
+│   - clear()         │         │                      │
+│                     │         │                      │
+│ ↓ handleDataEvent() │← Events │   User Interaction   │
+│   Process input     │         │   (click, type, etc) │
+│   sendUpdate()      │         │                      │
+└─────────────────────┘         └──────────────────────┘
+```
+
+**The flow:**
+
+1. Your Java code builds UI using `UICommandBuilder`
+2. Commands are sent to the client as data
+3. Client parses `.ui` markup files and creates visual elements
+4. User interacts with the UI
+5. Events are sent back to your Java code
+6. You process events and send updates back
+
+## Key Principles
+
+### Declarative, Not Imperative
+
+You don't create UI objects directly. Instead, you send **commands** that describe what you want:
+
+- "Append this button template to that container"
+- "Set this label's text to 'Hello World'"
+- "Clear all children from this list"
+
+### Asset-Driven
+
+UI structure is defined in `.ui` markup files (assets), not hardcoded in Java. This enables:
+
+- Designers to modify layouts without touching code
+- Reusable UI components
+- Consistent visual language
+
+### Event-Driven
+
+User interactions trigger events that flow back to your server code. You register event bindings and handle them in `handleDataEvent()`.
+
+### Selector-Based
+
+You target specific UI elements using **selectors:**
+
+- `#MyButton` - Element with ID "MyButton"
+- `#List[0]` - First child of element "List"
+- `#List[0] #Title` - Element with ID "Title" in the first child of element "List"
+- `#Label.TextColor` - The TextColor property of element "Label"
diff --git a/content/docs/lv-LV/official-documentation/custom-ui/layout.mdx b/content/docs/lv-LV/official-documentation/custom-ui/layout.mdx
new file mode 100644
index 00000000..0a24ca09
--- /dev/null
+++ b/content/docs/lv-LV/official-documentation/custom-ui/layout.mdx
@@ -0,0 +1,492 @@
+---
+title: Layout
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# Layout
+
+The layout system determines how UI elements are positioned and sized on screen. Understanding layout is crucial for creating well-structured, responsive interfaces.
+
+## Layout Fundamentals
+
+Every UI element has:
+
+- **Container Rectangle** - The space allocated by the parent
+- **Anchor** - How the element positions/sizes itself within the container
+- **Padding** - Inner spacing that affects child layout
+- **LayoutMode** - How the element arranges its children (if it's a container)
+
+```
+┌─────────────────────────────────────┐
+│  Container Rectangle (from parent)  │
+│  ┌───────────────────────────────┐  │
+│  │  Anchored Rectangle           │  │
+│  │  ┌─────────────────────────┐  │  │
+│  │  │ Padding                 │  │  │
+│  │  │  ┌───────────────────┐  │  │  │
+│  │  │  │  Content Area     │  │  │  │
+│  │  │  └───────────────────┘  │  │  │
+│  │  └─────────────────────────┘  │  │
+│  └───────────────────────────────┘  │
+└─────────────────────────────────────┘
+```
+
+## Anchor
+
+`Anchor` controls how an element positions and sizes itself within its container rectangle.
+
+### Fixed Size
+
+```
+Button {
+    Anchor: (Width: 200, Height: 40);
+}
+```
+
+Creates a 200×40 pixel button.
+
+### Positioning
+
+```
+Label {
+    Anchor: (Top: 10, Left: 20, Width: 100, Height: 30);
+}
+```
+
+- **Top**: 10 pixels from container's top edge
+- **Left**: 20 pixels from container's left edge
+- **Width**: 100 pixels wide
+- **Height**: 30 pixels tall
+
+### Anchoring to Edges
+
+```
+Button {
+    Anchor: (Bottom: 10, Right: 10, Width: 100, Height: 30);
+}
+```
+
+Anchors the button to the bottom-right corner, 10 pixels from each edge.
+
+### Stretching
+
+```
+Group {
+    Anchor: (Top: 0, Bottom: 0, Left: 0, Right: 0);
+}
+```
+
+Stretches to fill the entire container (all edges at 0 pixels).
+
+**Shorthand:**
+
+```
+Group {
+    Anchor: (Full: 0);
+}
+```
+
+### Mixed Anchoring
+
+```
+Panel {
+    Anchor: (Top: 10, Bottom: 10, Left: 20, Width: 300);
+}
+```
+
+- Fixed width of 300 pixels
+- Stretches vertically between top and bottom edges
+- 10 pixels from top and bottom
+- 20 pixels from left
+
+## Padding
+
+`Padding` creates inner spacing, affecting where children are positioned.
+
+### Uniform Padding
+
+```
+Group {
+    Padding: (Full: 20);
+}
+```
+
+20 pixels of padding on all sides.
+
+### Directional Padding
+
+```
+Group {
+    Padding: (Top: 10, Bottom: 20, Left: 15, Right: 15);
+}
+```
+
+Different padding per edge.
+
+### Shorthand
+
+```
+// Horizontal and vertical
+Group {
+    Padding: (Horizontal: 20, Vertical: 10);
+}
+
+// Equivalent to:
+// Top: 10, Bottom: 10, Left: 20, Right: 20
+```
+
+### Effect on Children
+
+```
+Group {
+    Anchor: (Width: 200, Height: 100);
+    Padding: (Full: 10);
+
+    Label {
+        Anchor: (Full: 0);
+    }
+}
+```
+
+The label fills the group, but there's a 10-pixel gap on all sides due to padding.
+
+```
+┌──────────────────────┐
+│ Group (200×100)      │
+│  ┌────────────────┐  │
+│  │ Label          │  │ ← 10px padding all around
+│  │                │  │
+│  └────────────────┘  │
+└──────────────────────┘
+```
+
+## LayoutMode
+
+`LayoutMode` determines how a container arranges its children.
+
+### Top (Vertical Stack)
+
+```
+Group {
+    LayoutMode: Top;
+
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+}
+```
+
+Children stack vertically from top to bottom:
+
+```
+┌──────────┐
+│ Button 1 │
+├──────────┤
+│ Button 2 │
+├──────────┤
+│ Button 3 │
+└──────────┘
+
+
+```
+
+Each child's `Anchor.Bottom` adds spacing between elements:
+
+```
+Button { Anchor: (Height: 30, Bottom: 10); }  // 10px gap after this button
+```
+
+### Bottom (Vertical Stack)
+
+```
+Group {
+    LayoutMode: Bottom;
+
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+}
+```
+
+Children stack vertically from top to bottom but aligned to the bottom edge of the parent:
+
+```
+
+
+
+┌──────────┐
+│ Button 1 │
+├──────────┤
+│ Button 2 │
+├──────────┤
+│ Button 3 │
+└──────────┘
+```
+
+### Left (Horizontal Stack)
+
+```
+Group {
+    LayoutMode: Left;
+
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+}
+```
+
+Children arrange horizontally from left to right:
+
+```
+┌────────┬────────┬────────┐
+│ Button │ Button │ Button │
+│   1    │   2    │   3    │
+└────────┴────────┴────────┘
+```
+
+Use `Anchor.Right` for spacing between elements.
+
+### Right (Horizontal Stack)
+
+```
+Group {
+    LayoutMode: Right;
+
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+}
+```
+
+Children arrange horizontally from left to right but aligned to the right side of the parent:
+
+```
+                                                                 ┌────────┬────────┬────────┐
+                                                                 │ Button │ Button │ Button │
+                                                                 │   1    │   2    │   3    │
+                                                                 └────────┴────────┴────────┘
+```
+
+### Center
+
+```
+Group {
+    LayoutMode: Center;
+
+    Group #Dialog {
+        Anchor: (Width: 400, Height: 300);
+    }
+}
+```
+
+Centers the children horizontally.
+
+### Middle
+
+```
+Group {
+    LayoutMode: Middle;
+
+    Group #Dialog {
+        Anchor: (Width: 400, Height: 300);
+    }
+}
+```
+
+Centers the children vertically.
+
+### CenterMiddle (Horizontal Stack, Fully Centered)
+
+```
+Group {
+    LayoutMode: CenterMiddle;
+
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+}
+```
+
+Children stack horizontally from left to right, centered both horizontally and vertically within the parent:
+
+```
+┌────────────────────────────────────────────┐
+│                                            │
+│                                            │
+│         ┌──────┐ ┌──────┐ ┌──────┐         │
+│         │  B1  │ │  B2  │ │  B3  │         │
+│         └──────┘ └──────┘ └──────┘         │
+│                                            │
+│                                            │
+└────────────────────────────────────────────┘
+```
+
+---
+
+### MiddleCenter (Vertical Stack, Fully Centered)
+
+```
+Group {
+    LayoutMode: MiddleCenter;
+
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+}
+```
+
+Children stack vertically from top to bottom, centered both horizontally and vertically within the parent:
+
+```
+┌────────────────────────────────────────────┐
+│                                            │
+│              ┌──────────┐                  │
+│              │ Button 1 │                  │
+│              ├──────────┤                  │
+│              │ Button 2 │                  │
+│              ├──────────┤                  │
+│              │ Button 3 │                  │
+│              └──────────┘                  │
+│                                            │
+└────────────────────────────────────────────┘
+```
+
+---
+
+### Full
+
+```
+Group {
+    LayoutMode: Full;
+
+    Label {
+        Anchor: (Top: 20, Left: 20, Width: 100, Height: 30);
+    }
+}
+```
+
+Children use absolute positioning via their `Anchor` properties.
+
+### TopScrolling
+
+```
+Group {
+    LayoutMode: TopScrolling;
+    ScrollbarStyle: $Common.@DefaultScrollbar;
+
+    // ... many children
+}
+```
+
+Like `Top`, but adds a scrollbar if content exceeds container height.
+
+Or use `BottomScrolling` for bottom-aligned content.
+
+### LeftScrolling
+
+```
+Group {
+    LayoutMode: LeftScrolling;
+    ScrollbarStyle: $Common.@DefaultScrollbar;
+
+    // ... many children
+}
+```
+
+Like `Left`, but adds a scrollbar for horizontal scrolling.
+
+Or use `RightScrolling` for right-aligned content.
+
+### LeftCenterWrap (Wrapping Horizontal Stack, Horizontally Centered)
+
+```
+Group {
+    LayoutMode: LeftCenterWrap;
+
+    Button { Anchor: (Width: 80, Height: 30); }
+    Button { Anchor: (Width: 80, Height: 30); }
+    Button { Anchor: (Width: 80, Height: 30); }
+    Button { Anchor: (Width: 80, Height: 30); }
+    Button { Anchor: (Width: 80, Height: 30); }
+}
+```
+
+Children flow left to right. When there's no more horizontal space, they wrap to the next row. Each row is horizontally centered within the parent:
+
+```
+┌────────────────────────────────────────────┐
+│                                            │
+│       ┌──────┐ ┌──────┐ ┌──────┐           │
+│       │  B1  │ │  B2  │ │  B3  │           │
+│       └──────┘ └──────┘ └──────┘           │
+│            ┌──────┐ ┌──────┐               │
+│            │  B4  │ │  B5  │               │
+│            └──────┘ └──────┘               │
+│                                            │
+└────────────────────────────────────────────┘
+```
+
+## FlexWeight
+
+`FlexWeight` distributes remaining space among children.
+
+```
+Group {
+    LayoutMode: Left;
+    Anchor: (Width: 400);
+
+    Button {
+        Anchor: (Width: 100);
+    }
+
+    Group {
+        FlexWeight: 1;  // Takes all remaining space
+    }
+
+    Button {
+        Anchor: (Width: 100);
+    }
+}
+```
+
+Result:
+
+- First button: 100px
+- Middle group: 200px (400 - 100 - 100 = 200)
+- Last button: 100px
+
+### Multiple FlexWeights
+
+```
+Group {
+    LayoutMode: Left;
+    Anchor: (Width: 600);
+
+    Group { FlexWeight: 1; }
+    Group { FlexWeight: 2; }
+    Group { FlexWeight: 1; }
+}
+```
+
+Remaining space (600px) is split:
+
+- First group: 600 × (1/4) = 150px
+- Second group: 600 × (2/4) = 300px
+- Third group: 600 × (1/4) = 150px
+
+## Visibility
+
+```
+Button #HiddenButton {
+    Visible: false;
+}
+```
+
+**Effect:**
+
+- Element and its children are not displayed
+- Element is **not included in layout** (doesn't take up space)
diff --git a/content/docs/lv-LV/official-documentation/custom-ui/markup.mdx b/content/docs/lv-LV/official-documentation/custom-ui/markup.mdx
new file mode 100644
index 00000000..564110ed
--- /dev/null
+++ b/content/docs/lv-LV/official-documentation/custom-ui/markup.mdx
@@ -0,0 +1,226 @@
+---
+title: Markup
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# Markup
+
+## Markup
+
+An element is the basic building block of a user interface. There are various types of elements with different properties, which are documented below.
+
+Here's what the syntax looks like:
+
+```
+// Basic declaration of an element
+// with its Anchor property set to attach on all sides of its parent
+// with 10 pixels of margin
+Group { Anchor: (Left: 10, Top: 10, Right: 10, Bottom: 10); }
+
+Group { Anchor: (Full: 10); } // More concise version
+
+// Declaration of a Label with a name
+// (can be used to access the element from game code)
+Label #MyLabel {
+  Style: LabelStyle(FontSize: 16); // or just Style: (FontSize: 16), type can be inferred.
+  Text: "Hi! I am text.";
+}
+
+// Declaration of a Group containing 2 children
+// You can use FlexWeight to distribute any left-over space after explicit widths/heights have been subtracted
+Group {
+  LayoutMode: Left;
+  Label { Text: "Child 1"; FlexWeight: 2; }
+  Label { Text: "Child 2"; FlexWeight: 1; }
+}
+```
+
+### Documents
+
+A UI document (_.ui_ file) contains trees of elements. There can be multiple root elements.
+
+### Named Expressions
+
+Named expressions can be declared at any level of a document (including at the root) and will be scoped to that subtree, though they need to be declared at the top of the block.
+
+```
+// Example of named expressions, declared and used with @ prefix
+@Title = "Hytale";
+@ExtraSpacing = 5;
+
+Label {
+  Text: @Title;
+  Style: (LetterSpacing: 2 + @ExtraSpacing);
+}
+```
+
+You can use the spread operator `...` to reuse a named expression while overriding some of its fields:
+
+```
+@MyBaseStyle = LabelStyle(FontSize: 24, LetterSpacing: 2);
+
+Label {
+  Style: (...@MyBaseStyle, FontSize: 36);
+}
+```
+
+You can even layer multiple named expressions like so:
+
+```
+@TitleStyle = LabelStyle(FontSize: 24, HorizontalAlignment: Center);
+@SpacedTextStyle = LabelStyle(LetterSpacing: 2);
+
+Label {
+  Style: (...@BigTextStyle, ...@SpacedTextStyle);
+}
+```
+
+#### Document references
+
+A document can reference another document and access its named expressions.
+
+```
+// Document references are defined with $ prefix
+$Common = "../Common.ui";
+
+TextButton {
+  Style: $Common.@DefaultButtonStyle;
+}
+```
+
+### Templates
+
+You can declare a reusable bit of interface as a named expression and then instantiate it as many times as you want in the tree while customizing it.
+
+You can override local named expressions as well as insert additional children at any point in the template tree. However, local named expressions must be defined at the very top of the block, before properties and child elements.
+
+```
+// This is the template
+@Row = Group {
+  Anchor: (Height: 50);
+  Label #Label { Anchor: (Left: 0, Width: 100); Text: @LabelText; }
+  Group #Content { Anchor: (Left: 100); }
+};
+
+// Here we'll be using it twice in the document tree
+Group #Rows {
+  LayoutMode: TopScrolling;
+
+  @Row #MyFirstRow {
+    @LabelText = "First row";
+    #Content { TextInput {} }
+  }
+
+  @Row #MySecondRow {
+    @LabelText = "Second row";
+  }
+}
+```
+
+### Property Types
+
+#### Basic Types
+
+- **Boolean**
+  - `Visible: false;`
+  - `Visible: true;`
+- **Int**
+  - `Height: 20;`
+- **Float, Double, Decimal**
+  - `Min: 0.2;`
+- **String**
+  - `Text: "Hi!";`
+- **Char**
+  - `PasswordChar: "*";`
+  - _Note: The syntax is the same as a string, however a value of this type cannot contain more than one character!_
+- **Color**
+  - `Background: #ffffff;`&#x20;
+- **Objects**
+  - `Style: (Background: #ffffff)`
+- **Array**&#x20;
+  - `TextSpans: [(Text: "Hi", IsBold: true)]`
+
+#### Translations
+
+Translation keys can be referenced anywhere in markup where you can provide a string, and they are then converted to a string when an element gets instantiated.
+
+**Example:**
+
+```
+Label {
+  Text: %ui.general.cancel;
+}
+```
+
+#### Colors
+
+A color literal can be written as follows:
+
+- `#rrggbb`: 6-digit hexadecimal representation for red, green, blue (fully opaque)
+- `#rrggbb(a.a)`: 6-digit hexadecimal representation for red, green, blue with alpha between 0 and 1
+- `#rrggbbaa`: 8-digit hexadecimal representation for red, green, blue and alpha
+
+```
+Group {
+  Background: #000000(0.3);
+}
+```
+
+<Callout>
+  The `#rrggbb(a.a)` format is prefered over the `#rrggbbaa` format for
+  readability reasons.
+</Callout>
+
+#### Font Name
+
+Font names can be referenced directly by their string ID. Internally this is using a custom type called `UIFontName`, however strings will be converted automatically to this type in markup.
+
+```
+Label {
+  Text: "Hi";
+  Style: (FontName: "Secondary");
+}
+```
+
+**Available Font Names**
+
+- _Default_ - This is the default font that is used for most text and is always used unless a different option has been specified
+- _Secondary_ - This font is mostly used for headlines or elements that are supposed to stick out
+- _Mono_ - This is only used for development; For things such as profiling or error overlays.
+
+#### Path
+
+We can reference other UI assets with the `UIPath` type. Similar to `UIFontName`_,_ Strings are automatically converted to a `UIPath`. Paths are always relative to the file where they have been declared in. Looking up _MyButton.png_ in _Menu/MyAwesomeMenu.ui_ will result in _Menu/MyButton.png_. If you want to reference a file that is in a parent folder you can go back one directory by writing two dots (_../MyButton.png_).
+
+The markup syntax of a `UIPath` is the same as a String. (e.g. `Path: "Test.png"`)
+
+Here are some more examples:
+
+| UIPath             | .ui File                              | Resulting Path    |
+| ------------------ | ------------------------------------- | ----------------- |
+| MyButton.png       | Menu/MyAwesomeMenu.ui                 | Menu/MyButton.png |
+| ../MyButton.png    | Menu/MyAwesomeMenu.ui                 | MyButton.png      |
+| ../../MyButton.png | Menu/Popup/Templates/MyAwesomeMenu.ui | Menu/MyButton.png |
+
+#### Objects
+
+Objects contain a set of properties. In this example we are assigning an Anchor object to the _Anchor_ property:
+
+```
+Group {
+  Anchor: (
+   Height: 10,
+   Width: 20
+ );
+}
+```
+
+You can find all objects that can be used in markup [here](type-documentation#elements).
+
+## Visual Studio Code Extension
+
+There is an official extension for Visual Studio Code which adds syntax highlighting for .ui files. You can find it [here](https://marketplace.visualstudio.com/items?itemName=HypixelStudiosCanadaInc.vscode-hytaleui).
diff --git a/content/docs/lv-LV/official-documentation/custom-ui/type-documentation/index.mdx b/content/docs/lv-LV/official-documentation/custom-ui/type-documentation/index.mdx
new file mode 100644
index 00000000..69cea406
--- /dev/null
+++ b/content/docs/lv-LV/official-documentation/custom-ui/type-documentation/index.mdx
@@ -0,0 +1,127 @@
+---
+title: Type Documentation
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# Type Documentation
+
+This is a generated list of UI elements accessible by markup. More information about the User Interface framework can be found in the main documentation.
+
+## Elements
+
+- [ActionButton](type-documentation/elements/actionbutton)
+- [AssetImage](type-documentation/elements/assetimage)
+- [BackButton](type-documentation/elements/backbutton)
+- [BlockSelector](type-documentation/elements/blockselector)
+- [Button](type-documentation/elements/button)
+- [CharacterPreviewComponent](type-documentation/elements/characterpreviewcomponent)
+- [CheckBox](type-documentation/elements/checkbox)
+- [CheckBoxContainer](type-documentation/elements/checkboxcontainer)
+- [CircularProgressBar](type-documentation/elements/circularprogressbar)
+- [CodeEditor](type-documentation/elements/codeeditor)
+- [ColorOptionGrid](type-documentation/elements/coloroptiongrid)
+- [ColorPicker](type-documentation/lements/colorpicker)
+- [ColorPickerDropdownBox](type-documentation/elements/colorpickerdropdownbox)
+- [CompactTextField](type-documentation/elements/compacttextfield)
+- [DropdownBox](type-documentation/elements/dropdownbox)
+- [DropdownEntry](type-documentation/elements/dropdownentry)
+- [DynamicPane](type-documentation/elements/dynamicpane)
+- [DynamicPaneContainer](type-documentation/elements/dynamicpanecontainer)
+- [FloatSlider](type-documentation/elements/floatslider)
+- [FloatSliderNumberField](type-documentation/elements/floatslidernumberfield)
+- [Group](type-documentation/elements/group)
+- [HotkeyLabel](type-documentation/elements/hotkeylabel)
+- [ItemGrid](type-documentation/elements/itemgrid)
+- [ItemIcon](type-documentation/elements/itemicon)
+- [ItemPreviewComponent](type-documentation/elements/itempreviewcomponent)
+- [ItemSlot](type-documentation/elements/itemslot)
+- [ItemSlotButton](type-documentation/elements/itemslotbutton)
+- [Label](type-documentation/elements/label)
+- [LabeledCheckBox](type-documentation/elements/labeledcheckbox)
+- [MenuItem](type-documentation/elements/menuitem)
+- [MultilineTextField](type-documentation/elements/multilinetextfield)
+- [NumberField](type-documentation/elements/numberfield)
+- [Panel](type-documentation/elements/panel)
+- [ProgressBar](type-documentation/elements/progressbar)
+- [ReorderableList](type-documentation/elements/reorderablelist)
+- [ReorderableListGrip](type-documentation/elements/reorderablelistgrip)
+- [SceneBlur](type-documentation/elements/sceneblur)
+- [Slider](type-documentation/elements/slider)
+- [SliderNumberField](type-documentation/elements/slidernumberfield)
+- [Sprite](type-documentation/elements/sprite)
+- [TabButton](type-documentation/elements/tabbutton)
+- [TabNavigation](type-documentation/elements/tabnavigation)
+- [TextButton](type-documentation/elements/textbutton)
+- [TextField](type-documentation/elements/textfield)
+- [TimerLabel](type-documentation/elements/timerlabel)
+- [ToggleButton](type-documentation/elements/togglebutton)
+
+## Property Types
+
+- [Anchor](type-documentation/property-types/anchor)
+- [BlockSelectorStyle](type-documentation/property-types/blockselectorstyle)
+- [ButtonSounds](type-documentation/property-types/buttonsounds)
+- [ButtonStyle](type-documentation/property-types/buttonstyle)
+- [ButtonStyleState](type-documentation/property-types/buttonstylestate)
+- [CheckBoxStyle](type-documentation/property-types/checkboxstyle)
+- [CheckBoxStyleState](type-documentation/property-types/checkboxstylestate)
+- [ClientItemStack](type-documentation/property-types/clientitemstack)
+- [ColorOptionGridStyle](type-documentation/property-types/coloroptiongridstyle)
+- [ColorPickerDropdownBoxStateBackground](type-documentation/property-types/colorpickerdropdownboxstatebackground)
+- [ColorPickerDropdownBoxStyle](type-documentation/property-types/colorpickerdropdownboxstyle)
+- [ColorPickerStyle](type-documentation/property-types/colorpickerstyle)
+- [DropdownBoxSearchInputStyle](type-documentation/property-types/dropdownboxsearchinputstyle)
+- [DropdownBoxSounds](type-documentation/property-types/dropdownboxsounds)
+- [DropdownBoxStyle](type-documentation/property-types/dropdownboxstyle)
+- [InputFieldButtonStyle](type-documentation/property-types/inputfieldbuttonstyle)
+- [InputFieldDecorationStyle](type-documentation/property-types/inputfielddecorationstyle)
+- [InputFieldDecorationStyleState](type-documentation/property-types/inputfielddecorationstylestate)
+- [InputFieldIcon](type-documentation/property-types/inputfieldicon)
+- [InputFieldStyle](type-documentation/property-types/inputfieldstyle)
+- [ItemGridSlot](type-documentation/property-types/itemgridslot)
+- [ItemGridStyle](type-documentation/property-types/itemgridstyle)
+- [LabeledCheckBoxStyle](type-documentation/property-types/labeledcheckboxstyle)
+- [LabeledCheckBoxStyleState](type-documentation/property-types/labeledcheckboxstylestate)
+- [LabelSpan](type-documentation/property-types/labelspan)
+- [LabelStyle](type-documentation/property-types/labelstyle)
+- [NumberFieldFormat](type-documentation/property-types/numberfieldformat)
+- [Padding](type-documentation/property-types/padding)
+- [PatchStyle](type-documentation/property-types/patchstyle)
+- [PopupStyle](type-documentation/property-types/popupstyle)
+- [ScrollbarStyle](type-documentation/property-types/scrollbarstyle)
+- [SliderStyle](type-documentation/property-types/sliderstyle)
+- [SoundStyle](type-documentation/property-types/soundstyle)
+- [SpriteFrame](type-documentation/property-types/spriteframe)
+- [SubMenuItemStyle](type-documentation/property-types/submenuitemstyle)
+- [SubMenuItemStyleState](type-documentation/property-types/submenuitemstylestate)
+- [Tab](type-documentation/property-types/tab)
+- [TabNavigationStyle](type-documentation/property-types/tabnavigationstyle)
+- [TabStyle](type-documentation/property-types/tabstyle)
+- [TabStyleState](type-documentation/property-types/tabstylestate)
+- [TextButtonStyle](type-documentation/property-types/textbuttonstyle)
+- [TextButtonStyleState](type-documentation/property-types/textbuttonstylestate)
+- [TextTooltipStyle](type-documentation/property-types/texttooltipstyle)
+- [ToggleButtonStyle](type-documentation/property-types/togglebuttonstyle)
+- [ToggleButtonStyleState](type-documentation/property-types/togglebuttonstylestate)
+
+## Enums
+
+- [ActionButtonAlignment](type-documentation/enums/actionbuttonalignment)
+- [CodeEditorLanguage](type-documentation/enums/codeeditorlanguage)
+- [ColorFormat](type-documentation/enums/colorformat)
+- [DropdownBoxAlign](type-documentation/enums/dropdownboxalign)
+- [InputFieldButtonSide](type-documentation/enums/inputfieldbuttonside)
+- [InputFieldIconSide](type-documentation/enums/inputfieldiconside)
+- [ItemGridInfoDisplayMode](type-documentation/enums/itemgridinfodisplaymode)
+- [LabelAlignment](type-documentation/enums/labelalignment)
+- [LayoutMode](type-documentation/enums/layoutmode)
+- [MouseWheelScrollBehaviourType](type-documentation/enums/mousewheelscrollbehaviourtype)
+- [ProgressBarAlignment](type-documentation/enums/progressbaralignment)
+- [ProgressBarDirection](type-documentation/enums/progressbardirection)
+- [ResizeType](type-documentation/enums/resizetype)
+- [TimerDirection](type-documentation/enums/timerdirection)
+- [TooltipAlignment](type-documentation/enums/tooltipalignment)
diff --git a/content/docs/lv-LV/official-documentation/npc/2-getting-started-with-templates.mdx b/content/docs/lv-LV/official-documentation/npc/2-getting-started-with-templates.mdx
index 91081ca1..99d078e0 100644
--- a/content/docs/lv-LV/official-documentation/npc/2-getting-started-with-templates.mdx
+++ b/content/docs/lv-LV/official-documentation/npc/2-getting-started-with-templates.mdx
@@ -9,7 +9,7 @@ authors:
 
 There are no hard and fast rules for making a start on a template. I like to duplicate **BlankTemplate** and start from there because it already provides the basic structure of the file.
 
-This leaves me with the following template (`Template_Goblin_Ogre.json`): (note: the file could be looking different in the current version of the game)
+This leaves me with the following template (`Template_Goblin_Ogre.json`): (**note: the file could be looking different in the current version of the game**)
 
 ```json
 {
@@ -33,7 +33,7 @@ This leaves me with the following template (`Template_Goblin_Ogre.json`): (note:
     }
   },
   "Appearance": { "Compute": "Appearance" },
-  "DropList": { "Compute": "Droplist" },
+  "DropList": { "Compute": "DropList" },
   "MaxHealth": { "Compute": "MaxHealth" },
   "MotionControllerList": [
     {
@@ -65,10 +65,10 @@ And the following variant (`Goblin_Ogre.json`) next to the template. There's a t
   "Type": "Variant",
   "Reference": "Template_Goblin_Ogre",
   "Modify": {
-    "Appearance": "Goblin_Ogre",
+    "Appearance": "Goblin",
     "MaxHealth": 124
   }
 }
 ```
 
-Our artists have defined the `Goblin_Ogre` appearance already so I'm going to use that.
+Our artists have not yet finished animations for the `Goblin_Ogre`, for that sake of the tutorial I am going to use appearance `Goblin`, because it offers a more complete set of animations that we will need.
diff --git a/content/docs/lv-LV/official-documentation/worldgen/pack-tutorial/asset-packs.mdx b/content/docs/lv-LV/official-documentation/worldgen/pack-tutorial/asset-packs.mdx
index 38809fad..dcf1f3b9 100644
--- a/content/docs/lv-LV/official-documentation/worldgen/pack-tutorial/asset-packs.mdx
+++ b/content/docs/lv-LV/official-documentation/worldgen/pack-tutorial/asset-packs.mdx
@@ -9,13 +9,13 @@ authors:
 
 <OfficialDocumentationNotice />
 
-# How to modify Hytale
+# How to modify Hytale?
 
-## What's an Asset Pack
+## What's an Asset Pack?
 
-Hytales gameplay is driven by assets in the game that can be modified by creators. Asset Packs are our solution to let you override or add features to the base game with your own work. These can in the form of zip files of folders, which contain a custom set of assets. This is not the only way for a creator to change Hytale but this is the most accessible form.;
+Hytales gameplay is driven by assets in the game that can be modified by creators. Asset Packs are our solution to let you override or add features to the base game with your own work. These can be the form of zip files of folders, which contain a custom set of assets. This is not the only way for a creator to change Hytale but this is the most accessible form.;
 
-### How do I make an Asset Pack
+### How do I make an Asset Pack?
 
 <video controls className="my-6 aspect-video w-full rounded-lg border">
   <source src="https://cdn.internal.hytalemodding.dev/guides/official/how-to-asset-pack.mp4" type="video/mp4" />
@@ -48,7 +48,7 @@ An asset pack is typically a zip or folder, with a `manifest.json` inside. This
 }
 ```
 
-### Where are they stored
+### Where are they stored?
 
 Asset Packs are stored with other mods in the Mods folder.
 
@@ -76,7 +76,7 @@ C:\Users\<user>\AppData\Roaming\Hytale\UserData\Saves\New World 5\mods
 
 When you have Asset Packs or Mods installed, these will appear in the New World menu under the Options menu.;
 
-### How do I change an existing asset
+### How do I change an existing asset?
 
 <video controls className="my-6 aspect-video w-full rounded-lg border">
   <source src="https://cdn.internal.hytalemodding.dev/guides/official/how-to-asset.mp4" type="video/mp4" />
diff --git a/content/docs/lv-LV/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx b/content/docs/lv-LV/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx
index 44528376..24e628b5 100644
--- a/content/docs/lv-LV/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx
+++ b/content/docs/lv-LV/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx
@@ -106,7 +106,7 @@ If a BaseHeight is provided, the TopY and BottomY values are relative to the Bas
 
 Applies a Material Provider slot on a set of horizontal stripes of blocks of varying thickness and position. Below is an example image of basalt stripes into a stone cliff.
 
-{/* ![](https://540086904-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F7KAmBkOg6d13nZCkf9ku%2Fuploads%2FbcxO9LpArn8gPCaBwFg5%2Funknown.png?alt=media&token=1c72b67a-8253-4d03-8c64-1ad5f6830050) */}
+![Example of basalt stripes](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/basalt-stripes-example.png)
 
 #### Parameters:
 
diff --git a/content/docs/lv-LV/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx b/content/docs/lv-LV/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx
index 5e34acd4..a4418473 100644
--- a/content/docs/lv-LV/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx
+++ b/content/docs/lv-LV/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx
@@ -294,7 +294,7 @@ Combines all the positions into a single Positioins field.
 
 ---
 
-### SimpleHoritontal
+### SimpleHorizontal
 
 Keeps only the positions that are within the provided range.
 
diff --git a/content/docs/lv-LV/official-documentation/worldgen/worldgen-tutorial/README.mdx b/content/docs/lv-LV/official-documentation/worldgen/worldgen-tutorial/README.mdx
new file mode 100644
index 00000000..5f66d245
--- /dev/null
+++ b/content/docs/lv-LV/official-documentation/worldgen/worldgen-tutorial/README.mdx
@@ -0,0 +1,166 @@
+---
+title: How to edit and create Biomes
+description: Explores where world generation assets can be found and how to edit them.
+---
+
+### Where are the Assets
+
+World generation assets are kept in the HytaleGenerator directory within the assets.
+
+```
+/Server/HytaleGenerator/
+```
+
+<div className="flex flex-row rounded-lg border p-4">
+  <div className="flex-1/2 border-r pr-4">
+    ```
+    /Biomes
+    ```
+
+    Biome assets, with content configurations.
+  </div>
+
+  <div className="flex-1/2 pl-4">
+    ```
+    /WorldStructure
+    ```
+
+    Generator files that define which biomes spawn together.
+  </div>
+</div>
+
+<div className="flex flex-row rounded-lg border p-4">
+  <div className="flex-1/2 border-r pr-4">
+    ```
+    /Density
+    ```
+
+    Density assets that can be referenced by any other assets.
+  </div>
+
+  <div className="flex-1/2 pl-4">
+    ```
+    /Assignments
+    ```
+
+    Prop assets that can be referenced by any Biome assets.
+  </div>
+</div>
+
+***
+
+An example of this structure can be found bellow, packed in an asset pack with the instance configuration.
+
+[https://drive.google.com/file/d/1sIz_CluANIIe3n8vNiOi-4PQdeqCO0qY/view?usp=drive_link](https://drive.google.com/file/d/1sIz_CluANIIe3n8vNiOi-4PQdeqCO0qY/view?usp=drive_link)
+
+<Callout>
+  Ensure you place your asset pack in the correct directory, under Mods.
+</Callout>
+
+### How to visit our worlds
+
+https://drive.google.com/file/d/1BJurxyj-taE-PXWm04bk7Dl6X7ZHTH92/view?usp=sharing
+
+#### Requirements
+
+- You must be an **Operator** in the world.
+  - To do this, run <mark style="color:$danger;">`/op self`</mark>
+- You must be in **Creative mode**.
+  - Press the <mark style="color:$danger;">`O`</mark> key, O for Orange.&#x20;
+
+The generation assets define a set of generators but on their own you cannot visit these. Currently you require an Instance with a generator that will allow you to visit your work.
+
+```
+/Server/Instances/
+```
+
+Instances are separate worlds that players can join using the `/instances` command. Each instance has an `Instance.bson` configuration asset that specifies which generator to use, among other worldly settings.
+
+```json
+{
+  "WorldGen": {
+    "Type": "HytaleGenerator",
+    "WorldStructure": "Basic",
+    "playerSpawn" : {
+      "X" : 123,
+      "Y" : 480,
+      "Z" : 10000,
+      "Pitch" : 0,
+      "Yaw" : 0,
+      "Roll" : 0
+    }
+  }
+}
+```
+
+<Callout>
+  You can create custom instances for different world structures and biomes as you need them.
+</Callout>
+
+### How to edit Biomes
+
+<video>
+  <source src="https://cdn.internal.hytalemodding.dev/guides/official/How-to-edit-Biomes.mp4" type="video/mp4" />
+</video>
+
+We currently use the Hytale Node Editor when editing world generation assets. This can be accessed while in-game from the Content Creation menu when pressing B. The node editor is then found under the asset editor dropdown on the upper left.&#x20;
+
+![Node Editor 1](/assets/official-documentation/worldgen/worldgen-tutorial/biomes/node-editor-1.png)
+
+Once you have the Hytale Node Editor open, through the file menu you can open Biomes by navigating to the Biomes directory and selecting one from your pack.&#x20;
+
+```
+/Server/HytaleGenerator/Biomes/
+```
+
+### Biome Asset Structure
+
+Every Biome has a root Biome node, this node splits into 5 structures. This is covered briefly but more information on each field can be found on the World Generation Concepts page.
+
+![Node Editor 2](/assets/official-documentation/worldgen/worldgen-tutorial/biomes/node-editor-2.png)
+
+<Callout>
+  Each biome is for the most part self contained, meaning it has control over what appears with the biome. The only exception to this are Base Heights.
+</Callout>
+
+<Tabs>
+  <Tab value="Terrain">
+    Mathematical function nodes that calculate the physical shape of the Biome's terrain.
+  </Tab>
+
+  <Tab value="Materials">
+    Logical nodes that determine what materials (blocks) make up a Biome's terrain.
+  </Tab>
+
+  <Tab value="Props">
+    Function nodes that add objects like prefabs and decorations to the terrain.
+  </Tab>
+
+  <Tab value="Environments">
+    Logical nodes that determine the environment asset at a given coordinate within the biome. This asset determines things like weather, NPC spawns, and sounds.
+  </Tab>
+
+  <Tab value="Tints">
+    Logical function nodes that determine a colour code that can be used by certain blocks in the world. Typically this will be grasses and soils.
+  </Tab>
+</Tabs>
+
+### How to preview your work
+
+[https://drive.google.com/file/d/1mNcHn9LhFnWDF0DzWFH6_YllmKAUvUry/view?t=6](https://drive.google.com/file/d/1mNcHn9LhFnWDF0DzWFH6_YllmKAUvUry/view?t=6)
+
+Once you are in an Instance world with the Hytale Generator active you will only be able to see your work by generating new chunks. There are a few ways to do this.
+
+The viewport command selects an area around the Player that will live reload as you make changes to the generator.&#x20;
+
+```
+/viewport --radius 5 
+```
+
+You can also create a new world to show your changes.&#x20;
+
+```
+/instances spawn <instance> 
+```
+
+The last option is to simply fly south, new chunks will generate with the changes made.
diff --git a/content/docs/lv-LV/quick-start.mdx b/content/docs/lv-LV/quick-start.mdx
index 934f2325..d3774cf2 100644
--- a/content/docs/lv-LV/quick-start.mdx
+++ b/content/docs/lv-LV/quick-start.mdx
@@ -9,3 +9,8 @@ Sveicināts Hytale Modding dokumentācijā! Šeit atradīsi visu, kas vajadzīgs
 * [Darba vides uzstādīšana](./guides/plugin/setting-up-env)
 * [Entity Component System (ECS)](./guides/ecs)
 * [Publicē savu modu](./guides/publishing)
+
+### Useful Links
+
+* [Kaupenjoe's Modding Videos](https://www.youtube.com/@ModdingByKaupenjoe)
+* [TroubleDEV's Modding Videos](https://www.youtube.com/@TroubleDEV)
diff --git a/content/docs/lv-LV/server/argtypes.mdx b/content/docs/lv-LV/server/argtypes.mdx
new file mode 100644
index 00000000..e54a442e
--- /dev/null
+++ b/content/docs/lv-LV/server/argtypes.mdx
@@ -0,0 +1,61 @@
+---
+title: ArgTypes
+description: Available ArgTypes
+icon: List
+full: true
+authors:
+  - name: Valeena
+---
+
+| Name                        | Target Class                           | Description                                                                                                                               |   |
+| :-------------------------- | :------------------------------------- | :---------------------------------------------------------------------------------------------------------------------------------------- | - |
+| Boolean                     | java.lang.Boolean                      | A 'true' or 'false' input                                                                                                                 |   |
+| Integer                     | java.lang.Integer                      | A whole number                                                                                                                            |   |
+| String                      | java.lang.String                       | Words, text, numbers, letters. To input more than one word at a time, you may need to wrap it with double quotes (`"my fancy sentence"`). |   |
+| Float                       | java.lang.Float                        | A floating-pointer number                                                                                                                 |   |
+| Double                      | java.lang.Double                       | A decimal number                                                                                                                          |   |
+| UUID                        | java.util.UUID                         | A UUID (Universally Unique IDentifier)                                                                                                    |   |
+| Player_UUID                 | java.util.UUID                         | A UUID or an online player username                                                                                                       |   |
+| Game_Profile_Lookup_Async   | ProfileServiceClient.PublicGameProfile | A player UUID or username. If not found locally, performs a remote lookup via the Profile Service.                                        |   |
+| Relative_Double_Coord       | Coord                                  | An x, y, or z coordinate as a decimal, optionally relative by specifying a tilde (~) in front of the number                               |   |
+| Relative_Int_Coord          | IntCoord                               | An x, y, or z coordinate as a whole number, optionally relative by specifying a tilde (~) in front of the number                          |   |
+| Relative_Integer            | RelativeInteger                        | A tilde to mark an integer relative to a base                                                                                             |   |
+| Relative_Float              | RelativeFloat                          | A tilde to mark a float relative to a base                                                                                                |   |
+| Player_Ref                  | PlayerRef                              | A UUID or an online player's username                                                                                                     |   |
+| World                       | World                                  | A world folder name                                                                                                                       |   |
+| Model_Asset                 | ModelAsset                             | A reference to an Asset of type Model                                                                                                     |   |
+| Weather_Asset               | Weather                                | A reference to an Asset of type Weather                                                                                                   |   |
+| Interaction_Asset           | Interaction                            | A reference to an Asset of type Interaction                                                                                               |   |
+| Root_Interaction_Asset      | RootInteraction                        | A reference to an Asset of type Root Interaction                                                                                          |   |
+| Effect_Asset                | EntityEffect                           | A refernece to an Asset of type EntityEffect                                                                                              |   |
+| Environment_Asset           | Environment                            | A reference to an Asset of type Environment                                                                                               |   |
+| Item_Asset                  | Item                                   | A reference to an Asset of type Item                                                                                                      |   |
+| Block_Type_Asset            | BlockType                              | A reference to an Asset of type BlockType                                                                                                 |   |
+| Particle_System             | ParticleSystem                         | A reference to an Asset of type ParticleSystem                                                                                            |   |
+| Hitbox_Collision_Config     | HitboxCollisionConfig                  | A reference to an Asset of type HitboxCollisionConfig                                                                                     |   |
+| Repulsion_Config            | RepulsionConfig                        | A reference to an Asset of type RepulsionConfig                                                                                           |   |
+| Sound_Event_Asset           | SoundEvent                             | A reference to an Asset of type SoundEvent                                                                                                |   |
+| Ambiance_Fx_Asset           | AmbianceFX                             | A reference to an Asset of type AmbianceFX                                                                                                |   |
+| Sound_Category              | SoundCategory                          | A sound category (sfx, music, ambient, ui)                                                                                                |   |
+| Entity_ID                   | `ArgWrapper<EntityWrappedArg, UUID>`   | A UUID representing an entity id                                                                                                          |   |
+| Integer_Comparison_Operator | IntegerComparisonOperator              | A mathematical sign for integer comparison                                                                                                |   |
+| Integer_Operation           | IntegerOperation                       | A mathematical sign for performing an operation                                                                                           |   |
+| Int_Range                   | `Pair<Integer, Integer>`               | Two integers representing a minimum and maximum of a range                                                                                |   |
+| Relative_Int_Range          | RelativeIntRange                       | Two integers representing a minimum and maximum of a range                                                                                |   |
+| Vector2I                    | Vector2i                               | Two integers, generally corresponding to x/z axis                                                                                         |   |
+| Vector3I                    | Vector3i                               | Three integers, generally corresponding to x/y/z axis                                                                                     |   |
+| Relative_Vector3I           | RelativeVector3i                       | Three optionally relative integers, generally corresponding to x/y/z axis                                                                 |   |
+| Relative_Block_Position     | RelativeIntPosition                    | A position with three integer coordinates, representing a block's location in world space.                                                |   |
+| Relative_Position           | Relative                               | A position with three decimal coordinates, representing a location in world space.                                                        |   |
+| Relative_Chunk_Position     | RealtiveChunkPosition                  | A position with two integer coordinates (x, z), representing a chunk's location.                                                          |   |
+| Rotation                    | Vector3f                               | A rotation with three coordinates, representing the pitch, yaw, and roll respectively                                                     |   |
+| Block_Type_Key              | String                                 | A block type                                                                                                                              |   |
+| Block_ID                    | Integer                                | A block type, converted to an int id                                                                                                      |   |
+| Color                       | Integer                                | A color value in hex format, hex integer, or decimal integer                                                                              |   |
+| Weighted_Block_Type         | `Pair<Integer, String>`                | A weight corresponding to a blocktype                                                                                                     |   |
+| Weighted_Block_Entry        | String                                 | A block with optional weight prefix                                                                                                       |   |
+| Block_Pattern               | BlockPattern                           | A list of blocks with optional weights                                                                                                    |   |
+| Individual_Block_Mask       | BlockMask                              | Create a block mask using symbols and block names                                                                                         |   |
+| Block_Mask                  | BlockMask                              | A tick rate value (e.g., 30tps, 33ms, or 30)                                                                                              |   |
+| Tick_Rate                   | Integer                                | A list of block masks that combine together                                                                                               |   |
+| Game_Mode                   | GameMode                               | GameMode                                                                                                                                  |   |
diff --git a/content/docs/lv-LV/server/interaction-reference.mdx b/content/docs/lv-LV/server/interaction-reference.mdx
new file mode 100644
index 00000000..6c0d01b3
--- /dev/null
+++ b/content/docs/lv-LV/server/interaction-reference.mdx
@@ -0,0 +1,1586 @@
+---
+title: Interactions
+description: A list of most Interaction types provided by Hypixel, along with the meaning of their fields, and how they fit together.
+icon: List
+authors:
+  - name: Stephen Baynham
+    url: https://github.com/cannibalvox
+---
+
+### The Interaction Base Type
+
+All interactions of every type below are inherited from Interaction and have these fields.
+
+**Interaction Fields**
+
+| Field Name                | Type                                                                 | Required? | Notes                                                                                                                                                                                                                       |
+| ------------------------- | -------------------------------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| ViewDistance              | `Double`<br />(Default: 96.0)                                        | **No**    | Distance in blocks at which other players can see the effects from this interaction.                                                                                                                                        |
+| Effects                   | `InteractionEffects`                                                 | **No**    | Sound, animations, and particle effects that should trigger when this interaction begins executing.                                                                                                                         |
+| HorizontalSpeedMultiplier | `Float`<br />(Default: 1.0)                                          | **No**    | Multiplier applied to the User entity's movement speed while this interaction is executing                                                                                                                                  |
+| RunTime                   | `Float`                                                              | **No**    | If provided, this interaction will continue executing for at least this long before the interaction chain moves onto the next interaction.                                                                                  |
+| CancelOnItemChange        | `Boolean`<br />(Default: true)                                       | **No**    | If true, this interaction will be cancelled if the User entity's held item changes during execution. This can happen either due to the selected hotbar slot changing or the contents of the item's inventory slot changing. |
+| Rules                     | `InteractionRules`                                                   | **Yes**   | If provided, adds additional limitations and cancellation conditions to this interaction.                                                                                                                                   |
+| Settings                  | `Map`<br />(Key Type: `GameMode`, Value Type: `InteractionSettings`) | **No**    | If provided, adds additional per-GameMode settings to the interaction.                                                                                                                                                      |
+| Camera                    | `InteractionCameraSettings`                                          | **No**    | Arrays of camera motion keyframes for cutscenes and reveals.                                                                                                                                                                |
+
+**GameMode Values**
+
+- `Creative`: The game is currently in Creative Mode
+- `Adventure`: The game is currently in Adventure Mode
+
+**InteractionEffects Fields**
+
+| Field Name               | Type                                              | Required? | Notes                                                                                                                                                 |
+| ------------------------ | ------------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Particles                | `Array`<br />(Element Type: `ModelParticle`)      | **No**    | Particle systems to activate when this interaction begins if the player is in third-person mode.                                                      |
+| FirstPersonParticles     | `Array`<br />(Element Type: `ModelParticle`)      | **No**    | Particle systems to activate when this interaction begins if the player is in first-person mode.                                                      |
+| WorldSoundEventId        | `Asset`<br />(Asset Type: `SoundEvent`)           | **No**    | A sound to play in the world at the User entity's location when this interaction begins.<br />**The SoundEvent must be single-channel (mono) sound.** |
+| LocalSoundEventId        | `Asset`<br />(Asset Type: `SoundEvent`)           | **No**    | A 2D sound to play for the User entity when this interaction begins. Ignored if the User entity is not a player.                                      |
+| Trails                   | `Array`<br />(Element Type: `ModelTrail`)         | **No**    | Trail effects to activate on the User entity when this interaction begins.                                                                            |
+| WaitForAnimationToFinish | `Boolean`<br />(Default: false)                   | **No**    | If true, this interaction will continue executing for at least the length of any animations in this InteractionEffects object.                        |
+| ItemPlayerAnimationsId   | `Asset`<br />(Asset Type: `ItemPlayerAnimations`) | **No**    | If provided, the User entity will use this ItemPlayerAnimations set while this interaction is executing.                                              |
+| ItemAnimationId          | `String`                                          | **No**    | Id of an animation to trigger when this interaction begins executing.<br />**This animation id is not validated on server start.**                    |
+| ClearAnimationOnFinish   | `Boolean`<br />(Default: false)                   | **No**    | If true, animations triggered by this interaction will be halted when the interaction completes.                                                      |
+| ClearSoundEventOnFinish  | `Boolean`<br />(Default: false)                   | **No**    | If true, sounds triggered by this interaction will be halted when the interaction completes.                                                          |
+| CameraEffect             | `Asset`<br />(Asset Type: `CameraEffect` )        | **No**    | If provided, the CameraEffect will be applied while this interaction is executing.                                                                    |
+| MovementEffects          | `MovementEffects`                                 | **No**    | If provided, apply the movement effects to the User entity while this interaction is executing.                                                       |
+| StartDelay               | `Float`<br />(Default: 0.0f)                      | **No**    | The interaction will wait this many seconds before triggering the effects in this object.                                                             |
+
+**InteractionRules Fields**
+
+| Field Name          | Type                                                                                                | Required? | Notes                                                                                                                                                                                                                                     |
+| ------------------- | --------------------------------------------------------------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| BlockedBy           | `Array`<br />(Element Type: `InteractionType`)<br />(Default: Based on the chain's InteractionType) | **No**    | If provided, this RootInteraction cannot be executed while interaction chains of the provided types are executing.<br />**This field only functions for rules attached to a RootInteraction. It has no effect on an Interaction.**        |
+| Blocking            | `Array`<br />(Element Type: `InteractionType`)                                                      | **No**    | If provided, interaction chains with the specified InteractionTypes cannot be executed while this interaction is executing.                                                                                                               |
+| InterruptedBy       | `Array`<br />(Element Type: `InteractionType`)                                                      | **No**    | If provided, interaction chains with the specified InteractionTypes will cancel this interaction chain when they execute.<br />**This field only functions for rules attached to a RootInteraction. It has no effect on an Interaction.** |
+| Interrupting        | `Array`<br />(Element Type: `InteractionType`)                                                      | **No**    | If provided, interaction chains with the specified InteractionTypes will be canceled when this interaction begins.                                                                                                                        |
+| BlockedByBypass     | `String`                                                                                            | **No**    | If provided, this RootInteraction cannot be blocked by interaction chains whose RootInteraction has this value as an asset tag.                                                                                                           |
+| BlockingBypass      | `String`                                                                                            | **No**    | If provided, this interaction will not block RootInteractions that have the this value as an asset tag.                                                                                                                                   |
+| InterruptedByBypass | `String`                                                                                            | **No**    | If provided, this RootInteraction cannot be canceled by RootInteractions that have this value as an asset tag.                                                                                                                            |
+| InterruptingBypass  | `String`                                                                                            | **No**    | If provided, this interaction will not cancel interaction chains whose RootInteraction has this value as an asset tag.                                                                                                                    |
+
+**InteractionType Values**
+
+- `Primary`
+- `Secondary`
+- `Ability1`
+- `Ability2`
+- `Ability3`
+- `Use`
+- `Pick`
+- `Pickup`
+- `CollisionEnter`
+- `CollisionLeave`
+- `Collision`
+- `EntityStatEffect`
+- `SwapTo`
+- `SwapFrom`
+- `Death`
+- `Wielding`
+- `ProjectileSpawn`
+- `ProjectileHit`
+- `ProjectileMiss`
+- `ProjectileBounce`
+- `Held`
+- `HeldOffhand`
+- `Equipped`
+- `Dodge`
+- `GameModeSwap`
+
+**InteractionSettings Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                        |
+| ---------------- | ------------------------------- | --------- | -------------------------------------------------------------------------------------------- |
+| AllowSkipOnClick | `Boolean`<br />(Default: false) | **No**    | If true, the user will be able to skip this interaction by clicking shortly after it starts. |
+
+**InteractionCameraSettings Fields**
+
+| Field Name  | Type                                             | Required? | Notes                                                                                                                                                           |
+| ----------- | ------------------------------------------------ | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| FirstPerson | `Array`<br />(Element Type: `InteractionCamera`) | **No**    | A list of camera keyframes to be played if the player is in first-person.<br />**The time of each keyframe must be after the keyframe before it in the array.** |
+| ThirdPerson | `Array`<br />(Element Type: `InteractionCamera`) | **No**    | A list of camera keyframes to be played if the player is in third-person.<br />**The time of each keyframe must be after the keyframe before it in the array.** |
+
+**InteractionCamera Fields**
+
+| Field Name | Type                         | Required? | Notes                                                                                                                                       |
+| ---------- | ---------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------- |
+| Time       | `Float`<br />(Default: 0.1f) | **No**    | How long after the interaction begins executing that the camera should arrive at this keyframe.<br />**Cannot be less than or equal to 0.** |
+| Position   | `Vector3`                    | **Yes**   | Where the camera should be located when it arrives at this keyframe.                                                                        |
+| Rotation   | `Direction`                  | **Yes**   | Where the camera should be pointing when it arrives at this keyframe.                                                                       |
+
+### SimpleInteraction
+
+Most interaction types below are inherited from SimpleInteraction and have these
+fields.  If a type does not have these fields, the documentation will mention it.
+
+The purpose of SimpleInteraction is to facilitate Interaction chaining by taking different paths
+based on whether the Interaction succeeded or failed.  The circumstances under which
+a given Interaction fails are generally type-specific (and described in the documentation
+below), but all interactions will be marked failed if they are cancelled via one of the
+many, many mechanisms for doing so.
+
+It is valid to create an interaction asset of type "Simple", which can be valuable when you want to use the
+interaction fields with no additional functionality.
+
+**SimpleInteraction Fields**
+
+| Field Name | Type                                     | Required? | Notes                                                                                          |
+| ---------- | ---------------------------------------- | --------- | ---------------------------------------------------------------------------------------------- |
+| Next       | `Asset`<br />(Asset Type: `Interaction`) | **No**    | After this Interaction has finished, "Next" will be executed if this Interaction did not fail. |
+| Failed     | `Asset`<br />(Asset Type: `Interaction`) | **No**    | After this Interaction has finished, "Failed" will be executed if this Interaction failed.     |
+
+## Flow Control
+
+These are interaction types used to control the flow of an interaction chain and allow interactions
+to be composed into more complex behaviors.  These interaction types generally do not pertain to
+the game and instead pertain to the interaction system itself.
+
+### Condition
+
+This interaction will fail if one of the fields is provided but does not match the current state.
+
+**Condition Fields**
+
+| Field Name       | Type       | Required? | Notes                                                                                                                                                                                    |
+| ---------------- | ---------- | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| RequiredGameMode | `GameMode` | **No**    | If provided, the interaction will fail if the current GameMode does not match the provided value.                                                                                        |
+| Jumping          | `Boolean`  | **No**    | If provided, the interaction will fail if the player's Jumping state does not match the provided value. (i.e. if True, the player must be jumping, if False, the player must not be)     |
+| Swimming         | `Boolean`  | **No**    | If provided, the interaction will fail if the player's Swimming state does not match the provided value. (i.e. if True, the player must be swimming, if False, the player must not be)   |
+| Crouching        | `Boolean`  | **No**    | If provided, the interaction will fail if the player's Crouching state does not match the provided value. (i.e. if True, the player must be crouching, if False, the player must not be) |
+| Running          | `Boolean`  | **No**    | If provided, the interaction will fail if the player's Running state does not match the provided value. (i.e. if True, the player must be running, if False, the player must not be)     |
+| Flying           | `Boolean`  | **No**    | If provided, the interaction will fail if the player's Flying state does not match the provided value. (i.e. if True, the player must be flying, if False, the player must not be)       |
+
+**GameMode Values**
+
+- `Creative`: The game is currently in Creative Mode
+- `Adventure`: The game is currently in Adventure Mode
+
+### FirstClick
+
+This interaction does not inherit from SimpleInteraction and therefore has no Next or Failed fields.
+
+This interaction has two fields that each contain a reference to an Interaction: Click and Hold.  If the root interaction
+of the chain was initiated by a client button/key press (or simulated NPC input) and the input was a tap, then
+the Click interaction is run. if it was a longer press, then the Hold interaction is run.
+
+As a minor implementation detail, this interaction is internally marked as failed when the Hold path is followed.
+This generally shouldn't matter.  If the interaction was not initiated by a key press at all, the Click path will be followed,
+but it seems risky to rely on that behavior.
+
+**FirstClick Fields**
+
+| Field Name | Type                                     | Required? | Notes                                                                                                                                                    |
+| ---------- | ---------------------------------------- | --------- | -------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Click      | `Asset`<br />(Asset Type: `Interaction`) | **No**    | If provided and the root interaction of the chain was initiated by button/key press, this interaction is executed next if the press was a quick tap.     |
+| Hold       | `Asset`<br />(Asset Type: `Interaction`) | **No**    | If provided and the root interaction of the chain was initiated by a button/key press, this interaction is executed next if the press was a longer hold. |
+
+### Interrupt
+
+This interaction can be used to cancel one or more running interaction chains on an entity and **all forked interaction
+chains those chains have spawned that are still currently running**.  All interaction chains canceled in this manner will be marked as
+Failed, which may have additional implications if the canceled chains are themselves forked from
+other chains that are still running.
+
+**Interrupt Fields**
+
+| Field Name     | Type                                           | Required? | Notes                                                                                                                                                                                               |
+| -------------- | ---------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Entity         | `InteractionTarget`<br />(Default: User)       | **Yes**   | The entity that is the owner of the target interaction chains.  This field can indicate the Owner, User, or Target of this interaction chain.                                                       |
+| InterruptTypes | `Array`<br />(Element Type: `InteractionType`) | **No**    | A set of InteractionTypes that are to be interrupted. Only interactions of these types are affected. If null, all types will be interrupted.<br />**(Note: An empty set will interrupt NO TYPES.)** |
+| RequiredTag    | `String`                                       | **No**    | An asset tag that, if provided, the RootInteraction of the interaction chain must have in order to be canceled.                                                                                     |
+| ExcludedTag    | `String`                                       | **No**    | An asset tag that, if provided, the RootInteraction of the interaction chain must not have in order to be canceled.                                                                                 |
+
+**InteractionTarget Values**
+
+- `User` - The user of this interaction chain. The entity whose actions caused this interaction chain to be executed. This is usually the same as the Owner.
+- `Owner` - The owner of this interaction chain. The entity upon whom this interaction chain is executing.
+- `Target` - The entity target of this interaction chain, if any.  This value is mutable (and can therefore come from many places) but most commonly, it is an entity the User was targeting when this interaction chain began executing.
+
+**InteractionType Values**
+
+- `Primary`
+- `Secondary`
+- `Ability1`
+- `Ability2`
+- `Ability3`
+- `Use`
+- `Pick`
+- `Pickup`
+- `CollisionEnter`
+- `CollisionLeave`
+- `Collision`
+- `EntityStatEffect`
+- `SwapTo`
+- `SwapFrom`
+- `Death`
+- `Wielding`
+- `ProjectileSpawn`
+- `ProjectileHit`
+- `ProjectileMiss`
+- `ProjectileBounce`
+- `Held`
+- `HeldOffhand`
+- `Equipped`
+- `Dodge`
+- `GameModeSwap`
+
+### Parallel
+
+This interaction does not inherit from SimpleInteraction and therefore has no Next or Failed fields.
+
+This interaction has a field `Interactions` that is an array of RootInteraction assets. The list must contain at least
+two RootInteractions.  This interaction will fork all of its children except for the first into their
+own interaction chains and immediately complete. After this interaction completes, this interaction chain will
+execute the first RootInteraction in the `Interactions` list.
+
+This interaction does not have any failure conditions and is indifferent to the fate of the forked interaction chains.
+
+**Parallel Fields**
+
+| Field Name   | Type                                                | Required? | Notes                                                         |
+| ------------ | --------------------------------------------------- | --------- | ------------------------------------------------------------- |
+| Interactions | `AssetArray`<br />(Element Type: `RootInteraction`) | **Yes**   | An array of RootInteractions that will be forked or executed. |
+
+### Repeat
+
+This interaction has a field `ForkInteractions` that is an asset of type RootInteraction. This interaction will fork that
+RootInteraction into its own interaction chain and then wait for it to complete. If the RootInteraction fails, this
+interaction will complete immediately and be marked failed. Otherwise, the RootInteraction will be forked and run again,
+up to a specified total number of times.
+
+**Repeat Fields**
+
+| Field Name       | Type                                                                                   | Required? | Notes                                                                                                                                                                                                              |
+| ---------------- | -------------------------------------------------------------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| ForkInteractions | `Asset`<br />(Asset Type: `RootInteraction`)                                           | **Yes**   | A RootInteraction that will be forked.                                                                                                                                                                             |
+| Repeat           | `Integer`<br />(Default: 1)<br />**Must be -1 or a positive integer. 0 is not valid.** | **No**    | The total number of times to fork ForkInteractions. If -1 is provided, ForkInteractions will continue being forked and executed indefinitely, until this interaction is cancelled or until ForkInteractions fails. |
+
+### Replace
+
+This interaction does not inherit from SimpleInteraction and therefore has no Next or Failed fields.
+
+This interaction uses the InteractionVars system that is avaiable for items. InteractionVars are RootInteractions that
+can be attached to an Item asset with a name.
+
+This interaction specifies a var name, and if this interaction chain was executed through
+an item and that item has an InteractionVar of the same name, then this interaction will immediately execute
+the RootInteraction on the var.  Otherwise, it will execute the default RootInteraction specified in this interaction.
+If no default is specified, then this interaction will be marked as failed.
+
+**Replace Fields**
+
+| Field Name   | Type                                         | Required? | Notes                                                                                                                                                                                                           |
+| ------------ | -------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Var          | `String`                                     | **Yes**   | The name of the InteractionVar to execute.                                                                                                                                                                      |
+| DefaultValue | `Asset`<br />(Asset Type: `RootInteraction`) | **No**    | The RootInteraction to execute if the owning item does not have an InteractionVar by the specified name. If not provided, the interaction will be marked as failed instead.                                     |
+| DefaultOk    | `Boolean`<br />(Default: false)              | **No**    | If false, then an angry message will be printed to the server logs if the owning item does not have an InteractionVar by the specified name.  The functioning of this interaction will be otherwise unaffected. |
+
+### RunRootInteraction
+
+This interaction immediately executes the provided RootInteraction as part of this interaction chain. This interaction
+does not have any failure conditions.
+
+**RunRootInteraction Fields**
+
+| Field Name      | Type                                         | Required? | Notes                           |
+| --------------- | -------------------------------------------- | --------- | ------------------------------- |
+| RootInteraction | `Asset`<br />(Asset Type: `RootInteraction`) | **Yes**   | The RootInteraction to execute. |
+
+### Selector
+
+This interaction will execute a Selector to find entities and/or blocks (depending on the Selector) and fork off an
+interaction chain for each located entity or block. This interaction will not wait for those interaction chains
+to complete and is indifferent to their fate. The forked interaction chains will use the located entity/block as
+their target entity/target block. Each entity or block will only fork one interaction chain over the life of this
+interaction.  The Selector is guaranteed to run once for each execution of this interaction, but some Selectors
+are intended to be run over a period of time and sweep across an area to locate targets. In order to use those Selectors
+properly, you will need to extend the execution time of this interaction using `RunTime` or `WaitForAnimationToFinish`.
+The Selector will be executed repeatedly over the lifetime of the interaction.
+
+If the Selector is configured to locate entities, you can add additional sets of entity matching rules. If a located entity
+matches one of the rules, the matching RootInteraction will be forked instead of the standard `HitEntity` RootInteraction.
+
+Entities located by the Selector will be ignored if they do not have a NetworkId, if they are dead, or if they are invulnerable.
+The only exception to this rule is that players in Creative Mode that are marked to receive hits will not be ignored.
+
+This interaction's failure conditions are configurable via the `FailOn` field. You can configure this interaction to never
+fail, to fail if the Selector does not locate any blocks before this interaction finishes executing, to fail if the
+Selector does not locate any entities before this interaction finishes executing, or to fail in either case.
+
+**Selector Fields**
+
+| Field Name     | Type                                         | Required? | Notes                                                                                                                                                                                                                                     |
+| -------------- | -------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Selector       | `Selector`                                   | **Yes**   | The Selector is executed at least once and may be executed repeatedly to locate blocks and/or entities in an area.                                                                                                                        |
+| HitEntity      | `Asset`<br />(Asset Type: `RootInteraction`) | **No**    | If included and the `Selector` locates an entity that does not match any `HitEntityRules`, this RootInteraction will be forked into a new interaction chain with the located entity as the target entity.                                 |
+| HitEntityRules | `Array`<br />(Element Type: `HitEntity`)     | **No**    | If included, these rules will be matched against any entity located by the `Selector`. If an entity matches a set of rules, the RootInteraction associated with the rules will be forked instead of the standard `HitEntity` interaction. |
+| HitBlock       | `Asset`<br />(Asset Type: `RootInteraction`) | **No**    | If included and the `Selector` locates a block, this RootInteraction will be forked into a new interaction chain with the located block as the block target.                                                                              |
+| FailOn         | `FailOnType`<br />(Default: `Neither`)       | **No**    | Defines under what circumstances this interaction will fail.  It can be marked to fail when it completes without locating any blocks, it can be marked to fail when it completes without locating any entities, both, or neither.         |
+| IgnoreOwner    | `Boolean`<br />(Default: true)               | **No**    | If true, the Selector will not locate the User entity of this interaction.                                                                                                                                                                |
+
+**HitEntity Fields**
+
+| Field Name | Type                                         | Required? | Notes                                                                                                 |
+| ---------- | -------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------- |
+| Matchers   | `Array`<br />(Element Type: `EntityMatcher`) | **Yes**   | A set of rules that an entity must match. An entity must successful match all rules to be considered. |
+| Next       | `Asset`<br />(Asset Type: `RootInteraction`) | **Yes**   | The RootInteraction to fork if an entity matches all rules.                                           |
+
+**EntityMatcher Fields**
+
+| Field Name | Type                            | Required? | Notes                                                                                                     |
+| ---------- | ------------------------------- | --------- | --------------------------------------------------------------------------------------------------------- |
+| Type       | `String`                        | **Yes**   | If provided, specifies a type of EntityMatcher to use. Each matcher type may come with additional fields. |
+| Invert     | `Boolean`<br />(Default: false) | **No**    | If true, an entity must fail this rule for it to be marked as succeeded.                                  |
+
+**EntityMatcher Type: Player**
+
+This EntityMatcher will succesfully match the entity only if they are a player.
+
+**EntityMatcher Type: Vulnerable**
+
+This Entitymatcher will successfully match the entity only if they are not marked as invulnerable.
+
+**FailOnType Values**
+
+- `Neither`
+- `Entity`
+- `Block`
+- `Either`
+
+### Serial
+
+This interaction does not inherit from SimpleInteraction and therefore has no Next or Failed fields.
+
+This interaction has a field `Interactions` which is a list of Interaction assets. This interaction immediately
+completes and the interaction chain continues by executing the interactions in the list one at a time. This
+interaction does not have any failure conditions.
+
+**Serial Fields**
+
+| Field Name   | Type                                            | Required? | Notes                                      |
+| ------------ | ----------------------------------------------- | --------- | ------------------------------------------ |
+| Interactions | `AssetArray`<br />(Element Type: `Interaction`) | **Yes**   | An array of Interaction assets to execute. |
+
+## Cooldowns
+
+RootInteractions interface with a complex cooldown system that can be used for a variety of purposes. Aside from simply
+adding an important aspect of resource management to your game design, cooldowns can be used to ensure that click-activated
+interaction chains don't repeatedly spam if the player holds down the input.
+
+By default, every RootInteraction has a cooldown timer that is keyed to the RootInteraction name, and by default, it
+will launch a cooldown of 0.35 seconds when activated by client input.  Otherwise, no cooldown will be activated.  However,
+by configuring your RootInteraction, you can change the key for the cooldown (so that multiple RootInteractions can share
+a single cooldown), set the cooldown timer to whatever you like, and configure multiple charges that can build up over time
+to allow the entity to activate the RootInteraction multiple times before being forced to pause.
+
+One important concept to keep in mind is the difference between **cooldown** and **charge time**.  The cooldown, if any,
+is activated each time a RootInteraction triggers, even if the player has more available charges. If the RootInteraction
+is configured to use charges, then they will gradually build up over time. In order for a RootInteraction to be activated,
+the cooldown (if any) must be expired, and the RootInteraction must have at least one charge (if it has been
+configured to use charges).
+
+Bear in mind that the entire Cooldown configuration is shared between different RootInteractions with the same cooldown id.
+If you activate an ability with 5 charges and a short cooldown and then another ability with a much longer cooldown and no
+charges, the second ability will use the cooldown properties of the first ability until/unless the first ability finishes
+charging and is cleared from the system.  You should generally only have multiple RootInteractions share a cooldown id
+if they have the same configuration.
+
+The interactions below interact with the cooldown system to allow you to manipulate cooldowns via the interaction system. By
+using these interactions, you can have several interaction chains with different cooldown configurations share cooldowns
+that are checked and activated as part of the interaction chain itself, or have some components of an interaction change
+use a second cooldown separate from the main one.
+
+### CooldownCondition
+
+**CooldownCondition Fields**
+
+This interaction will fail if the specified cooldown id is on cooldown for the User entity.  This interaction will only
+function for players- the interaction will always succeed for NPCs.  In order for this interaction to succeed, the
+cooldown, if any, must have expired and at least one charge, if any, must have filled.
+
+| Field Name | Type     | Required? | Notes                     |
+| ---------- | -------- | --------- | ------------------------- |
+| Id         | `String` | **Yes**   | The cooldown id to check. |
+
+### IncrementCooldown
+
+**IncrementCooldown Fields**
+
+This interaction will modify a cooldown that is currently active on the User entity, allowing charges and remaining
+cooldown to be modified.
+Despite its name, this interaction can be used to reduce a cooldown as well as increase it. If the cooldown is not
+currently active, this interaction will have no effect. The interaction has no special failure conditions.
+
+| Field Name        | Type                        | Required? | Notes                                                                                                                                                                                                                                                                                     |
+| ----------------- | --------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Id                | `String`                    | **No**    | If provided, the cooldown id of the cooldown to be manipulated. If not provided, the cooldown id of the current chain's RootInteraction will be used.                                                                                                                                     |
+| Time              | `Float`<br />(Default: 0.0) | **No**    | The amount to increase the remaining cooldown by. Can be negative. The remaining cooldown time will not be reduced below zero or increased above the maximum cooldown time.                                                                                                               |
+| ChargeTime        | `Float`<br />(Default: 0.0) | **No**    | The amount to increase the remaining time until the next charge is filled by. Can be negative. The remaining charge time cannot be reduced below zero or increased above the maximum cooldown time. **This will not work on abilities that have a maximum of 1 charge, for some reason.** |
+| Charge            | `Integer`<br />(Default: 0) | **No**    | The amount to increase the number of charges by. Can be negative. The number of charges cannot be reduced below 0 or increased above the maximum.                                                                                                                                         |
+| InterruptRecharge | `Boolean`(Default: false)   | **No**    | If true and `Charge` is not 0, will reset the remaining time to the next charge to the maximum value after changing the charge count.                                                                                                                                                     |
+
+### ResetCooldown
+
+This interaction will trigger a cooldown on the User entity with a specified configuration. The charges will be refilled
+but the cooldown will be immediately triggered.  The mechanisms for deciding on the configuration are a little bit complicated.
+You may specify a cooldown configuration via the `Cooldown` field. If you do not include an `Id` field, then the
+interaction chain's RootInteraction will be used for any field not specified in the configuration. If there is an active
+cooldown under the specified `Id` (or under the RootInteraction's cooldown id if none is specified) then the fields
+from that active cooldown will overwrite data in the RootInteraction's cooldown, but not data in your `Cooldown` field.
+
+**ResetCooldown Fields**
+
+| Field Name | Type                  | Required? | Notes                                                        |
+| ---------- | --------------------- | --------- | ------------------------------------------------------------ |
+| Cooldown   | `InteractionCooldown` | **No**    | A cooldown configuration to use for the new, reset cooldown. |
+
+**InteractionCooldown Fields**
+
+| Field Name        | Type                                 | Required? | Notes                                                                                                                                                                                                 |
+| ----------------- | ------------------------------------ | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Id                | `String`                             | **No**    | The cooldown id to use for this cooldown. If not provided, the RootInteraction's cooldown id will be used, if any.                                                                                    |
+| Cooldown          | `Float`<br />(Default: 0.0)          | **No**    | The duration of the cooldown, in seconds.                                                                                                                                                             |
+| Charges           | `Array`<br />(Element Type: `Float`) | **No**    | If provided, a list of how many charges this cooldown can build, and how long each charge takes to build, in seconds.                                                                                 |
+| InterruptRecharge | `Boolean`<br />(Default: false)      | **No**    | If true, the charge time will be reset when the number of charges changes.                                                                                                                            |
+| ClickBypass       | `Boolean`<br />(Default: false)      | **No**    | If true, RootInteractions keyed to this cooldown can still be activated when it is on cooldown provided that the RootInteraction was triggered by a distinct key or mouse button press on the client. |
+
+### TriggerCooldown
+
+This interaction is similar to ResetCooldown, except instead of refilling the cooldown's charges, one charge will be deducted
+as normal.
+
+**TriggerCooldown Fields**
+
+| Field Name | Type                  | Required? | Notes                                                        |
+| ---------- | --------------------- | --------- | ------------------------------------------------------------ |
+| Cooldown   | `InteractionCooldown` | **No**    | A cooldown configuration to use for the new, reset cooldown. |
+
+**InteractionCooldown Fields**
+
+| Field Name        | Type                                 | Required? | Notes                                                                                                                                                                                                 |
+| ----------------- | ------------------------------------ | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Id                | `String`                             | **No**    | The cooldown id to use for this cooldown. If not provided, the RootInteraction's cooldown id will be used, if any.                                                                                    |
+| Cooldown          | `Float`<br />(Default: 0.0)          | **No**    | The duration of the cooldown, in seconds.                                                                                                                                                             |
+| Charges           | `Array`<br />(Element Type: `Float`) | **No**    | If provided, a list of how many charges this cooldown can build, and how long each charge takes to build, in seconds.                                                                                 |
+| InterruptRecharge | `Boolean`<br />(Default: false)      | **No**    | If true, the charge time will be reset when the number of charges changes.                                                                                                                            |
+| ClickBypass       | `Boolean`<br />(Default: false)      | **No**    | If true, RootInteractions keyed to this cooldown can still be activated when it is on cooldown provided that the RootInteraction was triggered by a distinct key or mouse button press on the client. |
+
+## Combo Chains
+
+Hytale additionally comes with a rich "combo chaining" system, which allows several inputs in a row to result in different
+attacks and special moves.  Rather than being attached to the RootInteraction like the cooldown system, these are
+primarily driven by the `Chaining` interaction.
+
+### Chaining
+
+This interaction does not inherit from SimpleInteraction and therefore has no Failed field. Its Next field works differently
+from most interaction types.
+
+Chaining is a type of flow control interaction- each time a Chaining interaction with the same `ChainId` is called, a single
+interaction in the `Next` list is chosen and the others are ignored. The first time the `ChainId` is used, the first
+interaction in the list is chosen, the next time the second, etc. Once the end of the list is reached, the first
+interaction will be chosen again.
+
+Bear in mind: the progress through the Next list is based on the **ChainId**, not the interaction!  That means that two
+different Chaining interactions can share a single combo chain. You could have a pair of daggers that attacks with
+the left when the left mouse button is clicked and with the right when the right mouse button is clicked.  You could give
+both interaction chains a Chaining interaction with the same `ChainId` and three `Next` entries that do a light-light-heavy
+combo.  Each specific hit would occur with either the left or the right knife based on which button you clicked, but
+the combo would be otherwise identical regardless of which you chose.
+
+The Chaining interaction also has a concept called "flags".  It is possible to attach named flags to a `ChainId` by using
+the ChainFlag interaction.  Then, you specify the flag name in Chaining's `Flags` field. If a Flag is active when the
+Chaining interaction is run, the Flag's interaction will be run instead of the appropriate interaction in `Next`.
+Bear in mind: the entity's progress through the `Next` list still advances, the resulting `Next` interaction is just not
+run.  Only one flag can be active at a time.
+
+Lastly, it is possible to cancel the entity's progress through the combo chain and reset them to the first interaction in
+the list. This can be done with the CancelChain interaction, but it will also happen automatically if the player does
+not trigger an interaction with the ChainId for the specified ChainingAllowance.  When either of these happen, all flags will be
+canceled as well.
+
+All of these effects are triggered on the User entity only. Non-players can use the chaining system, but Flags do not currently
+work for non-players.  This interaction has no special failure conditions.
+
+**Chaining Fields**
+
+| Field Name        | Type                                                       | Required? | Notes                                                                                                                                                                                                                       |
+| ----------------- | ---------------------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| ChainId           | `String`                                                   | **No**    | If provided, acts as a key that multiple Chaining interactions can use to share combo chain progress and flags. If not provided, a unique ChainId will be generated for this interaction.                                   |
+| ChainingAllowance | `Double`<br />(Default: 0.0)                               | **No**    | If, at the time this interaction is triggered, it has been this long in seconds since the last time a Chaining interaction with the same ChainId was executed, all state for this ChainId will be cleared before execution. |
+| Next              | `AssetArray`<br />(Element Type: `Interaction`)            | **Yes**   | A list of interactions to cycle between each time this interaction is run.                                                                                                                                                  |
+| Flags             | `Map`<br />(Key Type: `String`, Value Type: `Interaction`) | **No**    | A map of flag names to interactions to run if the flag is active when this interaction executes.                                                                                                                            |
+
+### CancelChain
+
+This interaction resets all progress and flag data on the User entity for the provided `ChainId`.  The next time a Chaining
+interaction is called for the provided `ChainId`, it will begin at the first interaction in the `Next` list. This
+interaction has no special failure conditions.
+
+**CancelChain Fields**
+
+| Field Name | Type     | Required? | Notes                                 |
+| ---------- | -------- | --------- | ------------------------------------- |
+| ChainId    | `String` | **Yes**   | A ChainId whose data should be reset. |
+
+### ChainFlag
+
+This interaction activates a flag on the User entity for the provided `ChainId`, which can be used to change behavior the
+next time a Chaining interaction with this `ChainId` is run. This will overwrite any flag that has
+already been raised. This interaction will have no effect for non-players. This interaction has no special failure
+conditions.
+
+| Field Name | Type     | Required? | Notes                                        |
+| ---------- | -------- | --------- | -------------------------------------------- |
+| ChainId    | `String` | **Yes**   | A ChainId on whom the flag should be raised. |
+| Flag       | `String` | **Yes**   | The name of the flag to raise.               |
+
+## Charging
+
+A unique flow-control interaction that is frequently used is the Charging interaction.  It is a flow-control interaction
+that delays while the input button used to trigger the interaction chain is held.  When it is released (or the interaction
+is forced to end), the interaction chain can continue with a different interaction based on how long the input was held
+for.
+
+These interactions are all related by either being the Charging interaction, or other interaction types that inherit the
+Charging interaction's behavior.
+
+### Charging
+
+This interaction does not inherit from SimpleInteraction and therefore its Next field works different from most interactions.
+This interaction adds its own Failed field which works the same way that SimpleInteraction's does.
+
+This interaction only works properly when its interaction chain was triggered by a client key or button press (or
+NPC-simulated equivalent). This interaction will continue executing for as long as the key or button press is held (with
+some exceptions, covered below) by the User entity.  Like other interactions, it has a `Next` field indicating which interaction to execute
+after this one, but the field is a map from `Float` values to `Interaction` assets. When this interaction ends, either
+due to the input being released or the charge duration completing, this interaction will determine the largest `Float` key that is less
+than the amount of time in seconds that the interaction was executing for.  The Interaction mapped to that key will be
+executed next.
+
+The interaction includes some cancellation conditions that are specific to this interaction. For instance, the interaction
+has a `CancelOnOtherClick` field that matches the field on RootInteraction. If it is active on this interaction but not
+the RootInteraction, then clicking while charging will cancel this interaction (and execute the `Failed` interaction rather
+than any of the `Next` interactions) but otherwise continue the interaction chain.
+
+Another valuable feature Charging has is the `Forks` field.  For input-triggered interactions that are triggered while the
+Charging interaction is executing, you can add an entry for the relevant InteractionType to this field and instead of
+triggering the usual interaction chain based on held item, targeted block, etc. the RootInteraction specified in the
+`Forks` field will be triggered.  This can unlock rich attack modes and behaviors. For instance, having a shield bash attack
+triggered off left click while blocking, or a special attack that triggers when both mouse buttons are pressed at the
+same time.
+
+There are two modes of operation for the Charging interaction. One is to have the ability charge for as long
+as the input is held and only end execution when the entity releases the input.  Bows in the main Hytale game work
+that way.  That is accomplished by setting `AllowIndefiniteHold` to true.  Another mode of operation is to have the
+interaction complete execution when the execution time has surpassed the largest key value in the `Next` field and
+immediately begin executing the Interaction mapped to that key.  Food in the main Hytale game work like this.  It
+is accomplished by setting `AllowIndefiniteHold` to false.
+
+One pitfall to be careful of when setting `AllowIndefiniteHold` to false is the way it interacts with cooldowns.\
+Normally, input-initiated interaction chains start a 0.35s cooldown on the triggered RootInteraction that prevents
+holding the mouse button from immediately spamming a new interaction when the first one completes.  However, if the
+duration of a Charging interaction is longer than 0.35s, then the cooldown will have already completed when the
+interaction chain finishes, which will often result in a new execution beginning immediately before the player can
+stop pressing the mouse button.  One solution for this problem is to add a `Simple` interaction to the end of your
+interaction chain with a `RunTime` of 0.35s to simulate the cooldown.  Alternatively, you can add a longer cooldown
+(the maximum duration of your Charging interaction plus 0.35s) to the RootInteraction. However, the longer cooldown is
+not always desirable, as the interaction may have ended prematurely, resulting in an unusually long lockout between
+executions.
+
+**Charging Fields**
+
+| Field Name                         | Type                                                                    | Required? | Notes                                                                                                                                                                                                                                                                                                                                                                                       |
+| ---------------------------------- | ----------------------------------------------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| FailOnDamage                       | `Boolean`<br />(Default: false)                                         | **No**    | If true, this interaction will fail and end immediately if the User entity takes any damage while it is executing.                                                                                                                                                                                                                                                                          |
+| CancelOnOtherClick                 | `Boolean`<br />(Default: true)                                          | **No**    | If true, this interaction will fail and end immediately if the User entity sends another button or key press while it is executing.                                                                                                                                                                                                                                                         |
+| Forks                              | `Map`<br />(Key Type: `InteractionType`, Value Type: `RootInteraction`) | **No**    | A map of InteractionType to RootInteraction. If entity input triggers the InteractionType while this interaction is executing, the mapped RootInteraction will be forked into its own interaction chain. This will happen instead of the usual handling for that InteractionType.  This fork will occur even if `CancelOnOtherClick` is set to true.                                        |
+| Failed                             | `Asset`<br />(Asset Type: `Interaction`)                                | **No**    | After this Interaction has finished, "Failed" will be executed if this Interaction failed.                                                                                                                                                                                                                                                                                                  |
+| AllowIndefiniteHold                | `Boolean`<br />(Default: false)                                         | **No**    | If true, this interaction will continue executing for as long as the User entity continues to hold the input. If false, execution will end as soon as the execution time in seconds reaches the largest key value in the `Next` map.                                                                                                                                                        |
+| DisplayProgress                    | `Boolean`<br />(Default: true)                                          | **No**    | If true, players executing this interaction will see a progress bar will be displayed below their cursor indicating how close to reaching the highest key value in `Next` they are.                                                                                                                                                                                                         |
+| Next                               | `Map`<br />(Key Type: `Float`, Value Type: `Interaction`)               | **No**    | A map from `Float` to `Interaction`.  When this interaction successfully finishes executing (either because the input was released or because the maximum duration was reached), this interaction will find the `Float` value with the largest duration in seconds that is less than the amount of time this interaction executed for. That key's mapped Interaction will then be executed. |
+| MouseSensitivityAdjustmentTarget   | `Float`<br />(Default: 1.0)                                             | **No**    | While charging, this mouse sensitivity multiplier will gradually be applied.                                                                                                                                                                                                                                                                                                                |
+| MouseSensitivityAdjustmentDuration | `Float`<br />(Default: 1.0)                                             | **No**    | Duration in seconds. After this many seconds, `MouseSensitivityAdjustmentTarget` will be fully applied to the mouse sensitivity.                                                                                                                                                                                                                                                            |
+| Delay                              | `ChargingDelay`                                                         | **No**    | Settings that allow charging progress to be pushed back when the User entity takes damage.                                                                                                                                                                                                                                                                                                  |
+
+**ChargingDelay Fields**
+
+| Field Name    | Type                        | Required? | Notes                                                                                                                                                                                                                                                                     |
+| ------------- | --------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| MinHealth     | `Float`<br />(Default: 0.0) | **No**    | Damage taken as a percentage of entity health (0.0-1.0). If a hit deals less than this much damage, no pushback will be applied.  If a hit deals exactly this much damage, `MinDelay` seconds worth of pushback will be applied.                                          |
+| MaxHealth     | `Float`<br />(Default: 0.0) | **No**    | Damage taken as a percentage of entity health (0.0-1.0). If a hit deals at least this much damage, `MaxDelay` seconds worth of pushback will be applied.                                                                                                                  |
+| MinDelay      | `Float`<br />(Default: 0)   | **No**    | The amount of pushback, in seconds, to apply if the entity takes a hit that deals `MinHealth` damage. The amount of pushback applied by a hit is a gradiant between `MinDelay` and `MaxDelay` based on the amount of damage between `MinHealth` and `MaxHealth`.          |
+| MaxDelay      | `Float`<br />(Default: 0)   | **No**    | The amount of pushback, in seconds, to apply if the entity takes a hit that deals at least `MaxHealth` damage. The amount of pushback applied by a hit is a gradiant between `MinDelay` and `MaxDelay` based on the amount of damage between `MinHealth` and `MaxHealth`. |
+| MaxTotalDelay | `Float`<br />(Deault: 0)    | **No**    | The maximum amount of pushback the entity can receive over the course of a single charge, regardless of how many times they are hit.                                                                                                                                      |
+
+**InteractionType Values**
+
+- `Primary`
+- `Secondary`
+- `Ability1`
+- `Ability2`
+- `Ability3`
+- `Use`
+- `Pick`
+- `Pickup`
+- `CollisionEnter`
+- `CollisionLeave`
+- `Collision`
+- `EntityStatEffect`
+- `SwapTo`
+- `SwapFrom`
+- `Death`
+- `Wielding`
+- `ProjectileSpawn`
+- `ProjectileHit`
+- `ProjectileMiss`
+- `ProjectileBounce`
+- `Held`
+- `HeldOffhand`
+- `Equipped`
+- `Dodge`
+- `GameModeSwap`
+
+### Wielding
+
+This interaction is inherited from Charging rather than SimpleInteraction.  However, its `Failed` and `Next` fields function
+identically to SimpleInteraction.  It does not inherit all fields from Charging, so be sure to pay close attention to
+the field list below.
+
+This interaction drives most blocking behavior in the game. While this interaction is executing, attacks made against
+the Owner entity will (conditionally) trigger effects defined in this interaction.  Unlike the Charging interaction,
+this interaction can always execute indefinitely and will only end when it fails or when the input is released.
+
+One option available in Wielding is `AngledWielding`, which allows damage and knockback modifiers to only be applied
+depending on the direction the attack against the Owner entity is coming from.  The AngledWielding type has a
+field `Angle` which determines which direction the protection points relative to the player (0 is the player's
+front), and `AngleDistance` which determines how wide the cone of protection extends around the player.  Block effects
+from this interaction (such as `BlockedEffects`, `BlockedInteractions`, and `StaminaCost`) will only apply if
+the DamageCause matches `DamageModifiers` OR if the DamageCause matches `AngledWielding.DamageModifiers` and
+the source of the damage matches `Angle` and `AngleDistance`.  It is possible for damage and knockback multipliers
+specified on both this interaction's modifier fields and `AngledWielding`'s modifier fields to stack, if both
+have entries for the same DamageCause.
+
+This interaction will only have an effect on damage taken by one of the DamageCause entries in `DamageModifiers` or
+`AngledWielding.DamageModifiers`.  If a DamageCause is in `DamageModifiers`, then the block effect will be triggered
+and the damage modifier applied regardless of what direction the Owner entity is attacked from.  If a DamageCause is in
+`AngledWielding.DamageModifiers`, then the damage modifier is only applied if the
+
+\*\* Wielding Fields\*\*
+
+| Field Name          | Type                                                                    | Required? | Notes                                                                                                                                                                                                                                                                                                                                                                                                      |
+| ------------------- | ----------------------------------------------------------------------- | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| FailOnDamage        | `Boolean`<br />(Default: false)                                         | **No**    | If true, this interaction will fail and end immediately if the User entity takes any damage while it is executing.                                                                                                                                                                                                                                                                                         |
+| CancelOnOtherClick  | `Boolean`<br />(Default: true)                                          | **No**    | If true, this interaction will fail and end immediately if the User entity sends another button or key press while it is executing.                                                                                                                                                                                                                                                                        |
+| Forks               | `Map`<br />(Key Type: `InteractionType`, Value Type: `RootInteraction`) | **No**    | A map of InteractionType to RootInteraction. If entity input triggers the InteractionType while this interaction is executing, the mapped RootInteraction will be forked into its own interaction chain. This will happen instead of the usual handling for that InteractionType.  This fork will occur even if `CancelOnOtherClick` is set to true (after which this interaction chain will be canceled). |
+| Next                | `Asset`<br />(Asset Type: `Interaction`)                                | **No**    | After this interaction has finished, "Next" will be executed if this interaction did not fail.                                                                                                                                                                                                                                                                                                             |
+| Failed              | `Asset`<br />(Asset Type: `Interaction`)                                | **No**    | After this interaction has finished, "Failed" will be executed if this interaction failed.                                                                                                                                                                                                                                                                                                                 |
+| DamageModifiers     | `Map`<br />(Key Type: `DamageCause`, Value Type: `Float`)               | **No**    | A map from DamageCause to Float, where the Float is multiplied against any damage received from the mapped DamageCause while this interaction is executing.                                                                                                                                                                                                                                                |
+| KnockbackModifiers  | `Map`<br />(Key Type: `DamageCause`, Value Type: `Float`)               | **No**    | A map from DamageCause to Float, where the Float is multiplied against any knockback force received from the mapped DamageCause while this interaction is executing.                                                                                                                                                                                                                                       |
+| AngledWielding      | `AngledWielding`                                                        | **No**    | Configuration to only trigger block effects from certain angles.                                                                                                                                                                                                                                                                                                                                           |
+| StaminaCost         | `StaminaCost`                                                           | **No**    | If the Owner entity receives damage that matches `DamageModifiers` or `AngledWielding` while this interaction is executing, then the entity's stamina will be deducted according to this configuration.                                                                                                                                                                                                    |
+| BlockedEffects      | `DamageEffects`                                                         | **No**    | If the Owner entity receives damage that matches `DamageModifiers` or `AngledWielding` while this interaction is executing, then these effects will be applied to the instance of damage.                                                                                                                                                                                                                  |
+| BlockedInteractions | `Asset`<br />(Asset Type: `RootInteraction`)                            | **No**    | If the Owner entity receives damage that matches `DamageModifiers` or `AngledWielding` while this interaction is executing, then this RootInteraction will be launched as a brand new interaction chain with the Owner entity as both Owner and User, and the attacker as the Target entity.  This new interaction chain is, notably, brand new, **not** forked from the current one.                      |
+
+**AngledWielding Fields**
+
+| Field Name         | Type                                                      | Required? | Notes                                                                                                                                                                                                            |
+| ------------------ | --------------------------------------------------------- | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Angle              | `Float`<br />(Default: 0.0)                               | **No**    | Angle in degrees relative to the Owner entity where the angled protection is centered. 0.0 means pointed towards the front of the Owner entity.                                                                  |
+| AngleDistance      | `Float`<br />(Default: 0.0)                               | **No**    | Angle in degrees indicating how wide the cone of protection is.                                                                                                                                                  |
+| DamageModifiers    | `Map`<br />(Key Type: `DamageCause`, Value Type: `Float`) | **No**    | A map from DamageCause to Float, where the Float is multiplied against any damage received from the mapped DamageCause received from within the cone of protection while this interaction is executing.          |
+| KnockbackModifiers | `Map`<br />(Key Type: `DamageCause`, Value Type: `Float`) | **No**    | A map from DamageCause to Float, where the Float is multiplied against any knockback force received from the mapped DamageCause received from within the cone of protection while this interaction is executing. |
+
+**StaminaCost Fields**
+
+| Field Name | Type                                             | Required? | Notes                                                                                                                                                                                                                                                |
+| ---------- | ------------------------------------------------ | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| CostType   | `CostType`<br />(Default: `MaxHealthPercentage`) | **No**    | How to calculate stamina consumed by blocking from the raw pre-block damage. If `Damage`, then the stamina consumed will be `rawDamage / Value`. If `MaxHealthPercentage`, then the stamina consumed will be `rawDamage / (EntityMaxHealth * Value)` |
+| Value      | `Float`<br />(Default: 0.04)                     | **No**    | The value to use in the `CostType` formula.                                                                                                                                                                                                          |
+
+**DamageEffects Fields**
+
+| Field Name             | Type                                         | Required? | Notes                                                                           |
+| ---------------------- | -------------------------------------------- | --------- | ------------------------------------------------------------------------------- |
+| ModelParticles         | `Array`<br />(Element Type: `ModelParticle`) | **No**    | Particle systems to trigger in the first-person view.                           |
+| WorldParticles         | `Array`<br />(Element Type: `WorldParticle`) | **No**    | Particle systems to trigger in the third-person view.                           |
+| LocalSoundEventId      | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | 2D sound to play locally to the attacking entity if they are a player.          |
+| WorldSoundEventId      | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | Sound to play in the world at the Owner entity's location.                      |
+| PlayerSoundEventId     | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | 2D sound to play locally to the Owner entity if they are a player.              |
+| ViewDistance           | `Double`<br />(Default: 75.0)                | **No**    | Distance at which these effects should play for other players.                  |
+| Knockback              | `Knockback`                                  | **No**    | The properties of the knockback that will be applied.                           |
+| CameraEffect           | `Asset`<br />(Asset Type: `CameraEffect`)    | **No**    | CameraEffect to briefly apply locally to the Owner entity if they are a player. |
+| StaminaDrainMultiplier | `Float`<br />(Default: 1.0)                  | **No**    | This multiplier is applied to the `StaminaCost`, if any.                        |
+
+**Knockback Fields**
+
+| Field Name     | Type                                       | Required? | Notes                                                                                                                      |
+| -------------- | ------------------------------------------ | --------- | -------------------------------------------------------------------------------------------------------------------------- |
+| Type           | `String`                                   | **No**    | If provided, specifies a type of knockback to use. Each knockback type may come with additional fields.                    |
+| Force          | `Double`<br />(Default: 0.0)               | **No**    | The amount of force to apply to the Owner entity.                                                                          |
+| Duration       | `Double`<br />(Default: 0.0)               | **No**    | If 0.0, apply the force as a single impulse.  If more, continuously apply the force over a period of time.                 |
+| VelocityType   | `ChangeVelocityType`<br />(Default: `Add`) | **No**    | How to apply the force, either adding it to the entity's current velocity, or setting the velocity to the knockback force. |
+| VelocityConfig | `VelocityConfig`                           | **No**    | Characteristics of friction as the Owner entity is thrown by this knockback.                                               |
+
+**Knockback Type: Force**
+
+Apply the calculated knockback force along the provided direction.
+
+| Field Name | Type                         | Required? | Notes                                                                                |
+| ---------- | ---------------------------- | --------- | ------------------------------------------------------------------------------------ |
+| Direction  | `Vector3`<br />(Default: Up) | **No**    | Which direction the player should be flung, relative to the direction of the attack. |
+
+**Knockback Type: Point**
+
+Apply the calculated knockback force laterally along the XZ plane, plus provided Y velocity.
+
+| Field Name | Type                        | Required? | Notes                                                                                                   |
+| ---------- | --------------------------- | --------- | ------------------------------------------------------------------------------------------------------- |
+| OffsetX    | `Integer`<br />(Default: 0) | **No**    | Offset the source position of the knockback left or right perpendicular to the direction of the attack. |
+| OffsetZ    | `Integer`<br />(Default: 0) | **No**    | Offset the source position of the knockback, forward or backward along the directon of the attack.      |
+| RotateY    | `Integer`<br />(Default: 0) | **No**    | Rotate the knockback direction around the Y axis, where 0 is the default attack direction.              |
+| VelocityY  | `Float`<br />(Default: 0.0) | **No**    | Add vertical velocity to the knockback force after the direction and force has been calculated.         |
+
+**Knockback Type: Directional**
+
+Apply the calculated knockback force along the attack direction, removing any vertical component and replacing it with a provided Y velocity.
+
+| Field Name | Type                      | Required? | Notes                                                                                                                                            |
+| ---------- | ------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------ |
+| RelativeX  | `Float`<br />(Default: 0) | **No**    | Apply additional force left or right perpendicular to the direction of the attack. The additional force is multiplied by the knockback strength. |
+| RelativeZ  | `Float`<br />(Default: 0) | **No**    | Apply additional force forward or backward along the attack direction. The additional force is multiplied by the knockback strength.             |
+| VelocityY  | `Float`<br />(Default: 0) | **No**    | Replace the vertical velocity of the knockback with this value.  This value is not multiplied by knockback strength.                             |
+
+**VelocityConfig Fields**
+
+| Field Name          | Type                                              | Required? | Notes                                                                                                                                                                                           |
+| ------------------- | ------------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| GroundResistance    | `Float`<br />(Default: 0.82)                      | **No**    | The minimum amount of friction applied when the entity is in contact with the ground.  1.0 = no friction, 0.0 = total friction                                                                  |
+| GroundResistanceMax | `Float`<br />(Default: 0.0)                       | **No**    | The maximum amount of friction applied when the entity is in contact with the ground.  1.0 = no friction, 0.0 = total friction                                                                  |
+| AirResistance       | `Float`<br />(Default: 0.96)                      | **No**    | The minimum amount of friction applied when the entity is in the air. 1.0 = no friction, 0.0 = total friction                                                                                   |
+| AirResistanceMax    | `Float`<br />(Default: 0.0)                       | **No**    | The maximum amount of friction applied when the entity is in the air. 1.0 = no friction, 0.0 = total friction                                                                                   |
+| Threshold           | `Float`<br />(Default: 1.0)                       | **No**    | The speed at which the maximum amount of friction will be applied to the entity. The amount of friction applied will increase from minimum to maximum as the entity moves from 0 to this speed. |
+| Style               | `VelocityThresholdStyle`<br />(Default: `Linear`) | **No**    | The curve that friction follows as the entity's speed increases toward the `Threshold`.                                                                                                         |
+
+**CostType Values**
+
+- `MaxHealthPercentage`
+- `Damage`
+
+**ChangeVelocityType Values**
+
+- `Add`
+- `Set`
+
+**VelocityThresholdStyle Values**
+
+- `Linear`
+- `Exp`
+
+## Blocks
+
+These are interaction types meant to reason about and modify blocks in the world.  The most important concept unique
+to these interactions is the Block Target.  Like the Entity Target, it is mutable and can come from many places.
+However, for interaction chains initiated by the client, the block target will initially be the block that the player's cursor was
+over, if any.
+
+Additionally, for interaction chains initiated by the client, the client will send along which face of the block is targeted,
+which is used by a few block-related interactions.
+It is left up to each interaction type that cares about block faces as to how to handle this behavior for simulated input
+(i.e. NPCs initiating chains that are normally initated by the client).  At the time of this writing, all block-related
+interactions choose the top face where relevant in simulated input.
+
+### BlockCondition
+
+This interaction has a field `Matchers` which specifies certain conditions, such as block type, state, etc.  This
+interaction fails if the current target block does not match all of them.
+
+**BlockCondition Fields**
+
+| Field Name       | Type                                        | Required? | Notes                                                                                                                                                                                                                                                                                                                                   |
+| ---------------- | ------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false)             | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction.                                                                                                                                                                                                       |
+| Matchers         | `Array`<br />(Element Type: `BlockMatcher`) | **Yes**   | A list of conditions that the target block must match or this condition will fail.<br />**Note: This field is technically not required but there is a bug that makes it dangerous to not provide at the time of this writing.**<br />**Note: If no conditions are added to this array, the interaction will fail, counterintuitively.** |
+
+**BlockMatcher Fields**
+
+| Field Name | Type                       | Required? | Notes                                                                          |
+| ---------- | -------------------------- | --------- | ------------------------------------------------------------------------------ |
+| Block      | `BlockIdMatcher`           | **No**    | If provided, requires the block itself match some set of conditions.           |
+| Face       | `BlockFace`                | **No**    | If provided and not 'None', requires a specific block face be targeted.        |
+| StaticFace | `Boolean` (Default: false) | **No**    | If false, the face condition will be adjusted by the block's current rotation. |
+
+**BlockFace Values**
+
+- `Up`
+- `Down`
+- `North`
+- `South`
+- `East`
+- `West`
+- `None`
+
+**BlockIdMatcher Fields**
+
+| Field Name | Type                                   | Required? | Notes                                                                      |
+| ---------- | -------------------------------------- | --------- | -------------------------------------------------------------------------- |
+| Id         | `Asset`<br />(Asset Type: `BlockType`) | **No**    | If provided, the block must match the specified `BlockType`.               |
+| State      | `String`                               | **No**    | If provided, the block's current state must match the provided state name. |
+| Tag        | `String`                               | **No**    | If provided, the block type's asset tags must contain the provided tag.    |
+
+### DestroyCondition
+
+This interaction fails if the current User entity cannot destroy the current target blcok.
+
+**DestroyCondition Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+
+### PlacementCountCondition
+
+This interaction accepts the name of a BlockType that has the TrackedPlacement BlockEntity. The interaction will fail if the number of
+blocks of the provided BlockType in the world do not match the provided condition.
+
+**PlacementCountCondition Fields**
+
+| Field Name | Type                           | Required? | Notes                                                                                                                                                                                                                                                           |
+| ---------- | ------------------------------ | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Block      | `String`                       | **Yes**   | The BlockType to examine. The number of instances of the BlockType in the world will be compared to Value.<br />**Note: The specified BlockType must have the TrackedPlacement BlockEntity. Otherwise, the number of blocks in the world will always be zero.** |
+| Value      | `Integer`<br />(Default: 0)    | **No**    | The value to compare the number of blocks in the world with.                                                                                                                                                                                                    |
+| LessThan   | \`Boolean<br />(Default: true) | **No**    | If true, the interaction will fail if the number of blocks in the world is greater than or equal to Value. If false, the interaction will fail if the number of blocks in the world is less than or equal to Value.                                             |
+
+### BreakBlock
+
+This interaction attempts to break the target block while acting as the User entity. The User entity must be a player. It
+is not guaranteed to work, depending on world settings and the User entity's current state, it may not work.  If it
+fails, it will fail the interaction under some circumstances, but not others.
+
+**Note: In particular, if `Harvest`=false and the player is in Survival mode, the player will simply execute a damage operation
+against the block. Even when the Tool field is specified, the player's currently-held item can impact the results in unintuitive
+ways.**
+
+This interaction will fail if there is no block target, if `Harvest`=true and the
+block is not harvestable, or if the world settings prevent the Harvest/Break operation.
+It will generally not fail otherwise, even if the block was not broken or damaged.
+The block will generally break every time if `Harvest`=true or the player is in
+Creative mode.
+
+**BreakBlock Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                                                                                                                                                                                                  |
+| ---------------- | ------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction.                                                                                                                                                                      |
+| Harvest          | `Boolean` (Default: false)      | **No**    | If true, harvest the block and deposit the drops in the player's inventory. This operation will generally always succeed.  If false, this interaction will effectively perform whatever action would have occurred if the player had left-clicked the block.                                           |
+| Tool             | `String`                        | **No**    | If `Harvest`=true, the player is in Survival mode, and this field is provided, then the break operation will be performed as though with this tool type.<br />**This field mostly doesn't work.  Your held item will be used for most block damage calculations regardless of this field's contents.** |
+| MatchTool        | `Boolean` (Default: false)      | **No**    | If true, `Harvest`=true, the player is in Survival mode, and `Tool` is provided, block breaking will be prevented unless `Tool` is a valid gathering tool for the target block. The interaction will not be failed, even if block breaking is prevented in this manner.                                |
+
+### ChangeBlock
+
+This interaction requires a mapping from one or more current BlockTypes to one or more target BlockTypes.  If the
+target block is one of the key BlockTypes, then it will be changed to the mapped target BlockType.  If the current
+BlockType of the target block does not appear as a key in the Changes field, then this interaction fails.
+
+**ChangeBlock Fields**
+
+| Field Name        | Type                                                        | Required? | Notes                                                                                                                             |
+| ----------------- | ----------------------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget  | `Boolean`<br />(Default: false)                             | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+| Changes           | `Map`<br />(Key Type: `BlockType`, Value Type: `BlockType`) | **No**    | A list of potential block type changes, with each entry having a current and new BlockType id.                                    |
+| WorldSoundEventId | `Asset`<br />(Asset Type: `SoundEvent`)                     | **No**    | If provided, this SoundEvent is played in the world at the position of the block if the block successfully changes.               |
+| RequireNotBroken  | `Boolean`<br />(Default: false)                             | **No**    | If true, this interaction will fail if the player's held item is broken (durability 0), and the block change will not take place. |
+
+### ChangeState
+
+This interaction requires a mapping from one or more current block state names to one or more state names. If the
+target block is in one of the key block states, then it will be changed to the mapped target blocks tate. If the
+current block state of the target block does nto appear as a key in the Changes field, then this interaction fails.
+
+All blocks start out with a null state by default.  This null state can be referenced by the key "default" and the block
+can be returned to that state with the value "default".
+
+**ChangeState Fields**
+
+| Field Name       | Type                                                  | Required? | Notes                                                                                                                                          |
+| ---------------- | ----------------------------------------------------- | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false)                       | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction.              |
+| Changes          | `Map`<br />(Key Type: `String`, Value Type: `String`) | **No**    | A list of potential block state changes, with each entry having a current and new state name.                                                  |
+| UpdateBlockState | `Boolean`<br />(Default: false)                       | **No**    | If true, performs a full refresh of the block's BlockEntity component and notifies nearby players as though a full block type change occurred. |
+
+### CycleBlockGroup
+
+This interaction will attempt to change the target block to the next block type in one of the BlockGroups it belongs to.
+If the block type belongs to multiple BlockGroups, which one is used is effectively arbitrary. The User entity must be
+a player. If the block cannot be changed for any reason (entity not a player, no block target, block does not belong
+to a BlockGroup, etc.). If the block is the only entry in the BlockGroup, this interaction will succeed and the block
+will be considered changed despite nothing happening.  Unlike most other block-changing interactions, this one will
+fail if the world settings prevent players from breaking blocks.
+
+**This interaction always reduces the player's held item's durability by a single 'hit' worth of damage if the block
+changes. There is no way to prevent it. The block type will change and the interaction will succeed even if the player's
+held item is broken, however.**
+
+**CycleBlockGroup Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+
+### DestroyBlock
+
+This interaction destroys the target block without dropping anything.  It will successfully destroy the block if the
+target block exists and this interaction has no failure conditions.
+
+**This interaction has no additional fields.**
+
+### PickBlock
+
+This interaction is effectively equivalent to using the middle mouse button in creative mode. In survival mode, the
+block's item will be moved to the user's current active hotbar slot if it is in the player's inventory.  This
+interaction is performed entirely on the client and cannot be performed by non-players.  It is unclear if this
+interaction has failure conditions.
+
+**PickBlock Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+
+### PlaceBlock
+
+This interaction is effectively identical to a right clicking while holding a block in their hand, with some
+additional options. For one, it can be executed with any LivingEntity as the User entity. For another, it has some
+useful fields.  For the most part, though, it follows the same behaviors and rules as any ordinary block placement
+by a player.
+
+It's not clear under what circumstances this interaction can fail. The server will not fail the interaction under any
+special circumstances (including when there is no target block, or when `BlockTypeToPlace` is not provided and the
+LivingEntity is not holding a block). However, the client is very involved with the function of this interaction and
+its behavior is unknown.
+
+**PlaceBlock Fields**
+
+| Field Name         | Type                                   | Required? | Notes                                                                                                                                                                                                                                                                                                                                                           |
+| ------------------ | -------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| BlockTypeToPlace   | `Asset`<br />(Asset Type: `BlockType`) | **No**    | If provided, the block placed by this interaction will be the specified BlockType. If not provided, the User entity's held item will be used, instead, if it is a block.                                                                                                                                                                                        |
+| RemoveItemInHand   | `Boolean`<br />(Default: True)         | **No**    | If true and the User entity is not a player in Creative mode, the item in the player's hand must match the block being placed and one quantity will be removed for each block placed. If the item does not match, the block cannot be placed.  If false, the player's hand item is ignored entirely.\*\*                                                        |
+| AllowDragPlacement | `Boolean`<br />(Default: True)         | **No**    | If true and the interaction was triggered on the client by a player, then the player can hold the input that was used to activate this interaction chain and move the mouse around in order to execute this interaction repeatedly and place several blocks. The interaction chain will not move onto the next interaction until the player releases the input. |
+
+### RunOnBlockTypes
+
+This interaction retrieves all blocks within a provided radius of the User entity. For each block that matches any of
+the provided BlockSets, a new interaction chain will be forked that uses the matching block as the target block.
+This interaction will continue executing until all forked interaction chains have completed.  The interaction will fail if no
+blocks within the radius match the provided BlockSets or if all of the forked interaction chains fail.
+
+**RunOnBlockTypes Fields**
+
+| Field Name   | Type                                         | Required?        | Notes                                                                                                                                                                                                                                                                                      |
+| ------------ | -------------------------------------------- | ---------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| Range        | `Integer`                                    | **Yes**          | The spherical radius around the User entity to search for blocks. Must be at least 1.                                                                                                                                                                                                      |
+| BlockSets    | `AssetArray`<br />(Element Type: `BlockSet`) | **No**           | A list of BlockSets to match nearby blocks again. Only blocks that match any of the BlockSets will have interaction chains forked for them.                                                                                                                                                |
+| MaxCount     | `Integer`                                    | **Yes**          | The maximum number of blocks that will be located with the search. Further blocks will be ignored. If there are more matching blocks within the radius than this number, the specific set of blocks that will be found is completely arbitrary and may change from execution to execution. |
+| Interactions | `Asset`<br />(Asset Type: `RootInteraction`) | **No, but yes.** | The RootInteraction that will be forked for each matching block.  This interaction will not fail to validate if it is missing, but every execution of this interaction will fail.                                                                                                          |
+
+### UseBlock
+
+If the target block has an interaction for this interaction chain's interaction type, execute it immediately as part of
+this interaction chain. The execution will be wrapped in UseBlockEvent.Pre and UseBlockEvent.Post events, and cancellations
+of the UserBlockEvent.Pre event are respected. The User entity is considered the triggering entity for both events.
+
+If the target block does not have an interaction for this interaction chain's interaction type, this interaction fails.
+
+**This interaction has no additional fields.**
+
+## Items
+
+These are interactions intended to interface with an entity's inventory. There is no concept of an "item target",
+unfortunately, so these generally either interact with the entity's held item or the entity's inventory at a high level.
+
+### AddItem
+
+Adds a specified quantity of a specified item to the User entity's inventory, preferring to add it to the
+entity's hotbar where possible. This interaction will have no effect on User entities that are not LivingEntities.
+This interaction has no failure states.
+
+**Note: This interaction has a bug in its field validators that will cause interactions that reference items declared
+in the same mod to fail validation on startup.  Additionally, this interaction has a bug that will cause it to
+fail and have no effect if the User entity has no block target. Use ModifyInventory instead.**
+
+**AddItem Fields**
+
+| Field Name       | Type                              | Required? | Notes                                                                                                                             |
+| ---------------- | --------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false)   | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+| ItemId           | `Asset`<br />(Asset Type: `Item`) | **Yes**   | The item id of the item to add to the player's inventory.                                                                         |
+| Quantity         | `Integer`<br />(Default: 0)       | **No**    | The quantity of the item to add to the player's inventory.                                                                        |
+
+### CheckUniqueItemUsage
+
+This interaction will check whether it has run once for the User entity with their currently-held item before. If it hasn't,
+it will succeed. If it has, it will fail. It will also fail if the User entity is not a player. The interaction will record
+the item id of the User entity's currently-held item on success, ensuring it cannot be successfully run with that player
+and item id combination again.
+
+**This interaction has no additional fields.**
+
+### ChangeActiveSlot
+
+This interaction does not inherit from SimpleInteraction and therefore has no Next or Failed fields.  The `CancelOnItemChange`
+field is ignored for this interaction and is always treated as false. This interaction will set the User entity's currently-
+active hotbar slot to the specified slot index. If none is specified, the interaction chain's target slot will be used,
+if any. Otherwise, slot 0 will be used.  If a slot is specified and it is already active, then this interaction will
+have no effect, but if no slot is specified and the interaction chain's target slot is already active, the logic in
+the next paragraph will still be executed. This interaction will also have no effect if the User entity is not a
+LivingEntity.
+
+Once the slot has changed, a new SwapTo interaction chain will be forked off for the selected slot.
+If a target slot was specified, then the interaction chain's current target slot will be set to the specified slot, as will
+the forked SwapTo interaction chain. If this interaction chain was initiated by a player swapping an item into or out of
+an occupied active hotbar slot, then the swap will be executed after the slot is changed and before the SwapTo
+interaction is forked. Not running this interaction in the resulting SwapFrom interaction chain is a way for the server
+to cancel players performing these sorts of swap interactions. The default behavior for these swap interactions is that
+the SwapFrom interaction chain will be initiated with the currently-active-slot as the target slot. As a result, the
+target slot will usually not change when this interaction runs, it merely exists as a signal for the server to continue the
+item swap.
+
+**ChangeActiveSlot Fields**
+
+| Field Name | Type      | Required? | Notes                                                                                                                                                                                                     |
+| ---------- | --------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| TargetSlot | `Integer` | **No**    | If not provided, indicates the slot the player's active hotbar slot should be changed to.  Otherwise, the interaction chain's target slot will be used (which is usually the already-active hotbar slot). |
+
+### EquipItem
+
+This interaction will equip the User entity's currently-held item into the appropriate armor slot, if it is armor. The
+interaction will fail if the item is armor but it cannot be equipped for some reason. The interaction will succeed but
+take no action if the User entity cannot equip armor or if the item is not armor.
+
+**This interaction has no additional fields.**
+
+### IncreaseBackpackCapacity
+
+This interaction will increase the User entity's backpack size by the provided amount.  **It will additionally remove one
+quantity from the player's currently-held item. There is no way to prevent this.**  This interaction will have no effect
+if the User entity is not a player.  This interaction has no special failure conditions, even if the User entity
+is not a player, or the player is not currently holding an item.
+
+| Field Name | Type                        | Required? | Notes                                                                                   |
+| ---------- | --------------------------- | --------- | --------------------------------------------------------------------------------------- |
+| Capacity   | `Integer`<br />(Default: 1) | **No**    | The additional backpack capacity to add to the player. **Must be between 1 and 32767.** |
+
+### ModifyInventory
+
+This interaction attempts to perform one or more inventory-modifying actions against the User entity. The User entity must
+be a player. If they are not, no actions will be performed, but the interaction will not fail. Any item removals performed
+by this interaction, either as a result of `ItemToRemove` or `AdjustHeldItemQuantity`, are both atomic (meaning the entire
+quantity must be removed, or none) and required (meaning that the interaction will fail and no further actions taken if
+the removal fails for any reason).  Item additions performed by this interaction, either as a result of `ItemToAdd` or
+`AdjustHeldItemQuantity` will drop excess items on the ground near the player if necesary and continue on.
+
+This interaction first executes the item removal in `ItemToRemove`, if any, then adjusts the held item as specified by
+`AdjustHeldItemQuantity`, if provided, then executes the item addition in `ItemToAdd`, if any, and then finally executes
+the damage/healing of the held item in `AdjustHeldItemDurability`, if provided.
+
+**ModifyDurability Fields**
+
+| Field Name               | Type                            | Required? | Notes                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
+| ------------------------ | ------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| RequiredGameMode         | `GameMode`                      | **No**    | If provided, only execute the inventory-modifying actions if the player is in the provided GameMode. The interaction will not fail if the GameMode doesn't match.                                                                                                                                                                                                                                                                                                                                                                               |
+| ItemToRemove             | `ItemStack`                     | **No**    | If provided, a matching item will be removed in the provided quantity. If there is no matching item in the player inventory in the required quantity, then the interaction will fail and further actions will not be executed.                                                                                                                                                                                                                                                                                                                  |
+| AdjustHeldItemQuantity   | `Integer`<br />(Default: 0)     | **No**    | The player's held item, if any, will have its quantity will be modified by the provided amount- subtracted from if this number is negative or added to if this item is positive.  If the player has no held item, then this field will have no effect regardless of its value and the interaction will NOT fail.  If the player's inventory does not have sufficient quantity of items to support the removal, this interaction will fail and further actions will not be executed. Excess items will be dropped on the ground near the player. |
+| ItemToAdd                | `ItemStack`                     | **No**    | If provided, the ItemStack will be added to the player's inventory. Excess items will be dropped on the ground near the player.                                                                                                                                                                                                                                                                                                                                                                                                                 |
+| AdjustHeldItemDurability | `Double`<br />(Default: 0.0)    | **No**    | The player's held item, if any, will have its durability adjusted by the specified amount.  The durability cannot go below 0 or raise above the item's maximum durability. Invalid durability values in this field will not cause the interaction to fail. Neither will it fail if the player has no held item.                                                                                                                                                                                                                                 |
+| BrokenItem               | `String`                        | **No**    | This field should contain an ItemId, but it is not validated by the server on startup, so be careful.  This field can have the value of "Empty" to specify no item, or an empty hand. If specified and the `AdjustHeldItemDurability` operation reduces the player's held item to 0 durability, the player's held item is changed to this ItemId. If the inventory replacement fails, this interaction will fail.                                                                                                                               |
+| NotifyOnBreak            | `Boolean`<br />(Default: false) | **No**    | If true and the `AdjustHeldItemDurability` operation reduces the player's held item to 0 durability, this interaction will perform the usual audiovisual feedback of a broken tool. It will play the usual tool breaking sound and send the player a text message in chat that their item has broken.                                                                                                                                                                                                                                           |
+| NotifyOnBreakMessage     | `String`                        | **No**    | If provided, and `NotifyOnBreak` is true, when the player is notified of a broken tool by this interaction, the message sent to their chat will instead be the translation key specified by this field. The translation key supports the templating parameter `{itemName}`. See the translation key `server.general.repair.itemBroken_Hoe` for an example.                                                                                                                                                                                      |
+
+**GameMode Values**
+
+- `Creative`: The game is currently in Creative Mode
+- `Adventure`: The game is currently in Adventure Mode
+
+**ItemStack Fields**
+
+| Field Name                   | Type                              | Required? | Notes                                                                                |
+| ---------------------------- | --------------------------------- | --------- | ------------------------------------------------------------------------------------ |
+| Id                           | `Asset`<br />(Asset Type: `Item`) | **Yes**   | The id of the Item asset this stack contains.                                        |
+| Quantity                     | `Integer`<br />(Default: 1)       | **No**    | The number of items in this stack.<br />**Must be greater than 0.**                  |
+| Durability                   | `Double`<br />(Default: 0.0)      | **No**    | The durability of the item stack.<br />**Cannot be negative.**                       |
+| MaxDurability                | `Double`<br />(Default: 0.0)      | **No**    | The maximum durability of the item this stack contains.<br />**Cannot be negative.** |
+| Metadata                     | `Bson Document`                   | **No**    | If provided, applies the bson to the item stack metadata.                            |
+| OverrideDroppedItemAnimation | `Boolean`\*(Default: false)       | **No**    | ???                                                                                  |
+
+### PickupItem
+
+This interaction will attempt to pick up the User entity's current target entity and add it to their inventory. It will
+fail if the User entity is not a player, if they do not have a target entity, or if the target entity is not an item
+located in the world.  It will not fail if the player simply cannot pick up the item.
+
+**This interaction has no additional fields.**
+
+### RefillContainer
+
+This interaction will fail if the User entity is not a player. The interaction will draw a ray from the player's head
+down their look direction until the edge of the player's held item's interaction range or until the first solid block.
+The nearest fluid block of a type listed in this interaction's `States` map will result in the one of the player's
+currently-held items being converted to the fluid's related item state.  If the `States` map indicates a durability
+for the new item state, then the converted item will use that durability. If the item is already in the fluid's related
+item state, then this interaction will fail if the player's held item is already at maximum durability (unless the
+`States` map indicates a durability value greater than the item's maximum, in which case the interaction will succeed
+but the item will not change).  Otherwise, the durability listed for the fluid in the `States` map will be added to the
+item's current durability.
+
+If the interaction has not failed by this point, the fluid block in the world may be transformed to a different type if one is listed
+in the `States` map.
+
+If any part of this process does not proceed for any reason (for instance, if the player is not holding an item),
+then this interaction will fail.
+
+**RefillContainer Fields**
+
+| Field Name | Type                                                       | Required? | Notes                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| ---------- | ---------------------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| States     | `Map`<br />(Key Type: `String`, Value Type: `RefillState`) | **Yes**   | A map from item state names to `RefillState` objects, which contain information such as acceptable fluid block types, durability increases, and what fluid type to convert the targeted fluid block to after refill, if any. If the player targets a fluid block that matches one of the fluid types in the `RefillState`, the item will be converted to the keyed item state and the `RefillState` will be used to decide what happens next. |
+
+**RefillState Fields**
+
+| Field Name     | Type                                  | Required? | Notes                                                                                                                                                                                                                                                                                                                           |
+| -------------- | ------------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| AllowedFluids  | `Array`<br />(Element Type: `String`) | **Yes**   | If any of these fluids are targeted by the player, the player's held item will be converted to the keyed item state and `Durability` and `TransformFluid` will be used.                                                                                                                                                         |
+| Durability     | `Double`<br />(Default: -1.0)         | **No**    | If the player's held item changes item states, this value is the new item's durability, unless it is negative, in which case the item will begin at full durability. If the player's held item is already in the item state, and the item is not already at full durability, this value will be added to the item's durability. |
+| TransformFluid | `String`                              | **No**    | If provided, this field is a fluid id that the targeted fluid block should be transformed to if the player's held item is successfully updated.                                                                                                                                                                                 |
+
+## Entities
+
+### DamageEntity
+
+This interaction does not inherit from SimpleInteraction, but adds its own Next and Failed fields that
+work similarly.
+
+This interaction will cause the User entity to damage the Target entity.  It has the capability to apply different
+damage based on the direction of the attack or what body part was targeted by the User entity, with each possibility
+providing different damage calculations, effects, and Next interaction. If multiple entires match the attack, `TargetedDamage`
+(body part damage) takes highest priority, then the first matching `AngledDamage` in the list, then the default
+damage in the base interaction fields.  It is possible for elements of these different damage priorities to be taken peacemeal if higher-priority
+damage fields do not overwrite lower-priority damage fields. For instance,
+damage calculation could be taken from `TargetedDamage`, the damage effects could be taken from the first matching
+`AngledDamage`, and the Next interaction coming from the default damage field.
+
+If all damage dealt by this interaction is cancelled, then this interaction will fail, and the `Failed` interaction
+will be executed next in the chain. If any damage dealt by this interaction is blocked, then this interaction will
+succeed, but the `Blocked` interaction wil lbe executed next in the chain. Otherwise, the highest-precedent matching
+`Next` interaction that you provide will be executed.  For instance, if you provide `Next` interactions for all
+`TargetedDamage` and `AngledDamage` entries, and one in the interaction's `Next` field, then a headshot could result
+in a unique `Next` interaction being executed, even if there is a matching `AngledDamage` entry. However, if you leave
+the `Next` interaction out of your `TargetedDamage` entries, a special `Next` interaction for backstabs could be
+executed.  Otherwise, the `Next` field in the root of the interaction will be executed instead.
+
+DamageEntity has an unusual relationship with `RunTime`. This interaction always ends immediately after its first tick,
+regardless of the status of `RunTime` or `WaitForAnimationToFinish`.  However, if damage dealt by this interaction is
+calculated as `DamageCalculatorType` `Dps`, then the `RunTime` will be used to determine the precise amount of damage to
+deal. If `RunTime` is 0, then no damage will be dealt.
+
+**DamageEntity Fields**
+
+| Field Name       | Type                                                          | Required?                                                                                                                    | Notes                                                                                                                                                                                                                                                                                                                                                                         |
+| ---------------- | ------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| DamageCalculator | `DamageCalculator`                                            | **No**                                                                                                                       | If provided, describes the damage amounts and types to apply to the Target entity.                                                                                                                                                                                                                                                                                            |
+| DamageEffects    | `DamageEffects`                                               | **No**                                                                                                                       | If provided, describes particles, sounds, knockback, etc. to apply to the target entity on damage.                                                                                                                                                                                                                                                                            |
+| Next             | `Asset`<br />(Asset Type: `Interaction`)                      | **No**  After this interaction has finished, "Next" will be executed if damage was dealt to the target and none was blocked. |                                                                                                                                                                                                                                                                                                                                                                               |
+| AngledDamage     | `Array`<br />(Element Type: `AngledDamage`)                   | **No**                                                                                                                       | If provided, allows alternative `DamageCalculator`, `DamageEffects`, and `Next` entries for attacks that approach the target from certain angles.                                                                                                                                                                                                                             |
+| TargetedDamage   | `Map`<br />(Key Type: `String`, Value Type: `TargetedDamage`) | **Yes**                                                                                                                      | This field must be provided, but is not required to have any entries.  This is a map from body part names to `TargetedDamage` values. Hypixel only uses one body part name: `Head`, and it is not clear whether there are others.  If provided, allows alternative `DamageCalculator`, `DamageEffects`, and `Next` entries for attacks that damage specific enemy body parts. |
+| EntityStatsOnHit | `Array`<br />(Element Type: `EntityStatOnHit`)                | **No**                                                                                                                       | If provided, allows this attack to reduce enemy stats other than health.  Each individual damage application dealt by the same ability will apply stat reductions, at diminishing returns. All damage dealt in interaction chains forked by a Selector interaction will share the number of hits across all targets.                                                          |
+| Failed           | `Asset`<br />(Asset Type: `Interaction`)                      | **No**                                                                                                                       | After this interaction has finished, "Failed" will be executed if no damage hits were applied to the player, or if all damage hits were cancelled.                                                                                                                                                                                                                            |
+| Blocked          | `Asset`<br />(Asset Type: `Interaction`)                      | **No**                                                                                                                       | After this interaction has finished, "Blocked" will be executed if any damage hits were blocked by the target.                                                                                                                                                                                                                                                                |
+
+**DamageCalculator Fields**
+
+| Field Name                | Type                                                      | Required? | Notes                                                                                                                                                                                                                                                 |
+| ------------------------- | --------------------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Type                      | `DamageCalculatorType`<br />(Default: Absolute)           | **No**    | Whether the damage being applied is `Absolute` or \`Dps'.                                                                                                                                                                                             |
+| Class                     | `DamageClass`<br />(Default: Unknown)                     | **No**    | The type of attack producing the damage. Some weapon systems apply equipment modifiers based on this value.                                                                                                                                           |
+| BaseDamage                | `Map`<br />(Key Type: `DamageCause`, Value Type: `Float`) | **No**    | A set of DamageCauses and how much base damage is dealt for each.                                                                                                                                                                                     |
+| SequentialModifierStep    | `Float`<br />(Default: 0.0)                               | **No**    | Value between 0.0-1.0. Each additional hit from a single ability will have its damage reduced by this much as a percentage. All damage dealt in interaction chains forked by a Selector interaction will share the number of hits across all targets. |
+| SequentialModifierMinimum | `Float`<br />(Default: 0.0)                               | **No**    | Value between 0.0-1.0. `SequentialModifierStep` cannot reduce damage below this percentage regardless of the number of hits.                                                                                                                          |
+| RandomPercentageModifier  | `Float`<br />(Default: 0.0)                               | **No**    | A random value between +/- this amount multiplied by the base damage will be added to the base damage.                                                                                                                                                |
+
+**DamageEffects Fields**
+
+| Field Name             | Type                                         | Required? | Notes                                                                                   |
+| ---------------------- | -------------------------------------------- | --------- | --------------------------------------------------------------------------------------- |
+| ModelParticles         | `Array`<br />(Element Type: `ModelParticle`) | **No**    | Particle systems to trigger in the first-person view.                                   |
+| WorldParticles         | `Array`<br />(Element Type: `WorldParticle`) | **No**    | Particle systems to trigger in the third-person view.                                   |
+| LocalSoundEventId      | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | 2D sound to play locally to the attacking entity if they are a player.                  |
+| WorldSoundEventId      | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | Sound to play in the world at the Target entity's location.                             |
+| PlayerSoundEventId     | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | 2D sound to play locally to the Target entity if they are a player.                     |
+| ViewDistance           | `Double`<br />(Default: 75.0)                | **No**    | Distance at which these effects should play for other players.                          |
+| Knockback              | `Knockback`                                  | **No**    | The properties of the knockback that will be applied.                                   |
+| CameraEffect           | `Asset`<br />(Asset Type: `CameraEffect`)    | **No**    | CameraEffect to briefly apply locally to the Target entity if they are a player.        |
+| StaminaDrainMultiplier | `Float`<br />(Default: 1.0)                  | **No**    | This multiplier is applied to the stamina cost incurred by the target blocking, if any. |
+
+**AngledDamage Fields**
+
+| Field Name       | Type                                     | Required? | Notes                                                                                                                                                                                                     |
+| ---------------- | ---------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| AngleDistance    | `Float`<br />(Default: 0)                | **No**    | The width in degrees of the matching arc around the Target entity. If the attack against the Target originates from within the arc, then the properties below will be applied to the attack, if provided. |
+| Angle            | `Float`<br />(Default: 0.0)              | **No**    | The angle in degrees around the Target entity at which the matching arc is centered.                                                                                                                      |
+| DamageCalculator | `DamageCalculator`                       | **No**    | If provided and the attack against the Target entity originates from within the provided arc, this DamageCalculator will override the interaction's `DamageCalculator` field.                             |
+| DamageEffects    | `DamageEffects`                          | **No**    | If provided and the attack against the Target entity originates from within the provided arc, this DamageEffects will override the interaction's `DamageEffects` field.                                   |
+| Next             | `Asset`<br />(Asset Type: `Interaction`) | **No**    | If provided and the attack against the Target entity originates from within the provided arc, this Interaction will override the interaction's `Next` field.                                              |
+
+**TargetedDamage Fields**
+
+| Field Name       | Type                                     | Required? | Notes                                                                                                                                                                                            |
+| ---------------- | ---------------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| DamageCalculator | `DamageCalculator`                       | **No**    | If provided and this TargetedDamage was matched, this DamageCalculator will override the interaction's `DamageCalculator` field and the `DamageCalculator` field of any matching `AngledDamage`. |
+| DamageEffects    | `DamageEffects`                          | **No**    | If provided and this TargetedDamage was matched, this DamageEffects will override the interaction's `DamageEffects` field and the `DamageEffects` field of any matching `AngledDamage`.          |
+| Next             | `Asset`<br />(Asset Type: `Interaction`) | **No**    | If provided and this TargetedDamage was matched, this Interaction will override the interaction's `Next` field and the `Next` field of any matching `AngledDamage`.                              |
+
+**EntityStatOnHit Fields**
+
+| Field Name                  | Type                                                                       | Required? | Notes                                                                                                                                                                                                                                                                                        |
+| --------------------------- | -------------------------------------------------------------------------- | --------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| EntityStatId                | `Asset`<br />(AssetType: `EntityStatType`)                                 | **Yes**   | Which entity stat to affect.                                                                                                                                                                                                                                                                 |
+| Amount                      | `Float`<br />(Default: 0.0)                                                | **No**    | How much of the stat to apply for each damage application. Use negative numbers to reduce stats.                                                                                                                                                                                             |
+| MultipliersPerEntitiesHit   | `Array`<br />(Element Type: `Float`, Default: `[1.0, 0.6, 0.4, 0.2, 0.1]`) | **No**    | The diminishing returns curve to be applied for multiple damage applications by the same ability. Each hit's stat impact will be multiplied by the next value in the list.  If there are more hits than array elements, subsequent hits will be multiplied by `MultiplierPerExtraEntityHit`. |
+| MultiplierPerExtraEntityHit | `Float`<br />(Default: 0.05)                                               | **No**    | If an ability carries out more damage applications than there are elements in the `MultipliersPerEntitiesHit` array, then subsequent stat values will be multiplied by this number.                                                                                                          |
+
+**Knockback Fields**
+
+| Field Name     | Type                                       | Required? | Notes                                                                                                                      |
+| -------------- | ------------------------------------------ | --------- | -------------------------------------------------------------------------------------------------------------------------- |
+| Type           | `String`                                   | **No**    | If provided, specifies a type of knockback to use. Each Target type may come with additional fields.                       |
+| Force          | `Double`<br />(Default: 0.0)               | **No**    | The amount of force to apply to the Owner entity.                                                                          |
+| Duration       | `Double`<br />(Default: 0.0)               | **No**    | If 0.0, apply the force as a single impulse.  If more, continuously apply the force over a period of time.                 |
+| VelocityType   | `ChangeVelocityType`<br />(Default: `Add`) | **No**    | How to apply the force, either adding it to the entity's current velocity, or setting the velocity to the knockback force. |
+| VelocityConfig | `VelocityConfig`                           | **No**    | Characteristics of friction as the Owner entity is thrown by this knockback.                                               |
+
+**Knockback Type: Force**
+
+Apply the calculated knockback force along the provided direction.
+
+| Field Name | Type                         | Required? | Notes                                                                                |
+| ---------- | ---------------------------- | --------- | ------------------------------------------------------------------------------------ |
+| Direction  | `Vector3`<br />(Default: Up) | **No**    | Which direction the entity should be flung, relative to the direction of the attack. |
+
+**Knockback Type: Point**
+
+Apply the calculated knockback force laterally along the XZ plane, plus provided Y velocity.
+
+| Field Name | Type                        | Required? | Notes                                                                                                   |
+| ---------- | --------------------------- | --------- | ------------------------------------------------------------------------------------------------------- |
+| OffsetX    | `Integer`<br />(Default: 0) | **No**    | Offset the source position of the knockback left or right perpendicular to the direction of the attack. |
+| OffsetZ    | `Integer`<br />(Default: 0) | **No**    | Offset the source position of the knockback, forward or backward along the directon of the attack.      |
+| RotateY    | `Integer`<br />(Default: 0) | **No**    | Rotate the knockback direction around the Y axis, where 0 is the default attack direction.              |
+| VelocityY  | `Float`<br />(Default: 0.0) | **No**    | Add vertical velocity to the knockback force after the direction and force has been calculated.         |
+
+**Knockback Type: Directional**
+
+Apply the calculated knockback force along the attack direction, removing any vertical component and replacing it with a provided Y velocity.
+
+| Field Name | Type                      | Required? | Notes                                                                                                                                            |
+| ---------- | ------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------ |
+| RelativeX  | `Float`<br />(Default: 0) | **No**    | Apply additional force left or right perpendicular to the direction of the attack. The additional force is multiplied by the knockback strength. |
+| RelativeZ  | `Float`<br />(Default: 0) | **No**    | Apply additional force forward or backward along the attack direction. The additional force is multiplied by the knockback strength.             |
+| VelocityY  | `Float`<br />(Default: 0) | **No**    | Replace the vertical velocity of the knockback with this value.  This value is not multiplied by knockback strength.                             |
+
+**VelocityConfig Fields**
+
+| Field Name          | Type                                              | Required? | Notes                                                                                                                                                                                           |
+| ------------------- | ------------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| GroundResistance    | `Float`<br />(Default: 0.82)                      | **No**    | The minimum amount of friction applied when the entity is in contact with the ground.  1.0 = no friction, 0.0 = total friction                                                                  |
+| GroundResistanceMax | `Float`<br />(Default: 0.0)                       | **No**    | The maximum amount of friction applied when the entity is in contact with the ground.  1.0 = no friction, 0.0 = total friction                                                                  |
+| AirResistance       | `Float`<br />(Default: 0.96)                      | **No**    | The minimum amount of friction applied when the entity is in the air. 1.0 = no friction, 0.0 = total friction                                                                                   |
+| AirResistanceMax    | `Float`<br />(Default: 0.0)                       | **No**    | The maximum amount of friction applied when the entity is in the air. 1.0 = no friction, 0.0 = total friction                                                                                   |
+| Threshold           | `Float`<br />(Default: 1.0)                       | **No**    | The speed at which the maximum amount of friction will be applied to the entity. The amount of friction applied will increase from minimum to maximum as the entity moves from 0 to this speed. |
+| Style               | `VelocityThresholdStyle`<br />(Default: `Linear`) | **No**    | The curve that friction follows as the entity's speed increases toward the `Threshold`.                                                                                                         |
+
+**DamageCalculatorType Values**
+
+- `Absolute`
+- `Dps`
+
+**DamageClass Values**
+
+- `Unknown`
+- `Light`
+- `Charged`
+- `Signature`
+
+**ChangeVelocityType Values**
+
+- `Add`
+- `Set`
+
+**VelocityThresholdStyle Values**
+
+- `Linear`
+- `Exp`
+
+### LaunchProjectile
+
+This is just a worse version of Projectile and is slated to be removed.  Use Projectile.
+
+### Projectile
+
+This interaction will spawn a new projectile at the User entity's eye position that will travel in its look direction.
+
+| Field Name | Type                                          | Required? | Notes                                                  |
+| ---------- | --------------------------------------------- | --------- | ------------------------------------------------------ |
+| Config     | `Asset`<br />(Asset Type: `ProjectileConfig`) | **No**    | Configuration describing the projectile to be spawned. |
+
+### RemoveEntity
+
+Despawns the specified entity from the world. This interaction will have no effect if the specified entity is a player. This
+interaction has no special failure conditions.
+
+| Field Name | Type                                     | Required? | Notes                  |
+| ---------- | ---------------------------------------- | --------- | ---------------------- |
+| Entity     | `InteractionTarget`<br />(Default: User) | **No**    | The entity to despawn. |
+
+**InteractionTarget Values**
+
+- `User` - The user of this interaction chain. The entity whose actions caused this interaction chain to be executed. This is usually the same as the Owner.
+- `Owner` - The owner of this interaction chain. The entity upon whom this interaction chain is executing.
+- `Target` - The entity target of this interaction chain, if any.  This value is mutable (and can therefore come from many places) but most commonly, it is an entity the User was targeting when this interaction chain began executing.
+
+### SendMessage
+
+This interaction sends a message to the Owner entity if that entity can receive messages.  Otherwise, the message
+is written to the server logs.  If the entity is a player, the message will appear in the player's chat window.
+
+\*\*SendMessage
+
+| Field Name | Type     | Required? | Notes                                                                                                                 |
+| ---------- | -------- | --------- | --------------------------------------------------------------------------------------------------------------------- |
+| Message    | `String` | **No**    | A text message to be sent to the Owner entity.  If this field is not provided, `Key` is used instead.                 |
+| Key        | `String` | **No**    | A translation key for a message to be sent to the Owner entity. If `Message` is provided, then this field is ignored. |
+
+### UseEntity
+
+This interaction is not in use by Hypixel and has some unusual qualities that mean it probably won't do what you want it
+to.  Do not use it.
+
+This interaction will retrieve the entity currently targeted by the client (NOT the interaction chain's current Target
+entity) and execute that entity's RootInteraction for this interaction chain's current interaction type. The
+RootInteraction will be executed as part of this current interaction chain. None of the properties of this interaction
+chain will be modified.
+
+This interaction will fail if the client is not currently targeting an entity, or if no interaction for the current
+interaction type exists on the entity.
+
+## Stats
+
+Hytale's resource system has been written about fairly extensively.  You can use these interactions to modify stats in
+response to actions or use stats as a cost for abilities.
+
+### ChangeStat
+
+This interaction applies a set of raw stat changes to the User entity. It has no special failure conditions.
+
+| Field Name    | Type                                                         | Required? | Notes                                                                                                                                                                                                                      |
+| ------------- | ------------------------------------------------------------ | --------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| StatModifiers | `Map`<br />(Key Type: `EntityStatType`, Value Type: `Float`) | **Yes**   | A set of stats to modify and what value to apply to them.                                                                                                                                                                  |
+| ValueType     | `ValueType`<br />(Default: Absolute)                         | **No**    | Whether the values in the `StatModifiers` map represent flat values to apply to the stat total, or percentages (0.0-100.0). Percentage values are percentage of the difference between the maximum and minimum stat value. |
+| Behaviour     | `ChangeStatBehavior`<br />(Default: Add)                     | **No**    | Whether the values in the `StatModifiers` map represent deltas to add into the User entity's current stat values, or fixed values to set the entity's stats to.                                                            |
+
+**ValueType Values**
+
+- `Absolute`
+- `Percent`
+
+**ChangeStatBehaviour Values**
+
+- `Add`
+- `Set`
+
+### ChangeStatWithModifier
+
+This interaction is like ChangeStat, except an armor stat modifier can be chosen which will apply bonuses and penalties
+to a stat from the User entity's equipped armor before it is applied.
+
+| Field Name            | Type                                                         | Required? | Notes                                                                                                                                                                                                                      |
+| --------------------- | ------------------------------------------------------------ | --------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| StatModifiers         | `Map`<br />(Key Type: `EntityStatType`, Value Type: `Float`) | **Yes**   | A set of stats to modify and what value to apply to them.                                                                                                                                                                  |
+| ValueType             | `ValueType`<br />(Default: Absolute)                         | **No**    | Whether the values in the `StatModifiers` map represent flat values to apply to the stat total, or percentages (0.0-100.0). Percentage values are percentage of the difference between the maximum and minimum stat value. |
+| Behaviour             | `ChangeStatBehavior`<br />(Default: Add)                     | **No**    | Whether the values in the `StatModifiers` map represent deltas to add into the User entity's current stat values, or fixed values to set the entity's stats to.                                                            |
+| InteractionModifierId | `InteractionModifierId`                                      | **Yes**   | The armor interaction modifier to apply bonuses and penalties for.                                                                                                                                                         |
+
+**ValueType Values**
+
+- `Absolute`
+- `Percent`
+
+**ChangeStatBehaviour Values**
+
+- `Add`
+- `Set`
+
+**InteractionModifierId Values**
+
+- `Dodge`
+
+### StatsCondition
+
+This interaction will fail if the User entity cannot afford the specified stats costs, or if it does not have the
+requested stats.
+
+| Field Name | Type                                                         | Required? | Notes                                                                                                                                                                                    |
+| ---------- | ------------------------------------------------------------ | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Costs      | `Map`<br />(Key Type:` EntityStatType`, Value Type: `Float`) | **Yes**   | A set of costs that the User entity needs to be able to afford for this interaction to succeed.                                                                                          |
+| ValueType  | `ValueType`<br />(Default: Absolute)                         | **No**    | Whether the values in the `Costs` map represetn flat values or percentages (0.0-100.0).  Percentage values are percentage of the difference between the maximum and minimum value.       |
+| LessThan   | `Boolean`<br />(Default: false)                              | **No**    | If true, this interaction will fail unless the User entity's current stat values are at or **below** the specified levels.  If false, they must be at or **above** the specified levels. |
+| Lenient    | `Boolean`<br />(Default: false)                              | **No**    | If true and `LessThan` is true, and a player's minimum stat value is below zero, then the player can afford a stat cost if the current value of a stat if above 0.                       |
+
+**ValueType Values**
+
+- `Absolute`
+- `Percent`
+
+### StatsConditionWithModifier
+
+This interaction is like StatsCondition, except an armor stat modifier can be chosen which will apply bonuses and penalties
+to a stat's cost from the User entity's equipped armor before it is compared.
+
+| Field Name            | Type                                                         | Required? | Notes                                                                                                                                                                                    |
+| --------------------- | ------------------------------------------------------------ | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Costs                 | `Map`<br />(Key Type:` EntityStatType`, Value Type: `Float`) | **Yes**   | A set of costs that the User entity needs to be able to afford for this interaction to succeed.                                                                                          |
+| ValueType             | `ValueType`<br />(Default: Absolute)                         | **No**    | Whether the values in the `Costs` map represetn flat values or percentages (0.0-100.0).  Percentage values are percentage of the difference between the maximum and minimum value.       |
+| LessThan              | `Boolean`<br />(Default: false)                              | **No**    | If true, this interaction will fail unless the User entity's current stat values are at or **below** the specified levels.  If false, they must be at or **above** the specified levels. |
+| Lenient               | `Boolean`<br />(Default: false)                              | **No**    | If true and `LessThan` is true, and a player's minimum stat value is below zero, then the player can afford a stat cost if the current value of a stat if above 0.                       |
+| InteractionModifierId | `InteractionModifierId`                                      | **Yes**   | The armor interaction modifier to apply bonuses and penalties for.                                                                                                                       |
+
+**ValueType Values**
+
+- `Absolute`
+- `Percent`
+
+**InteractionModifierId Values**
+
+- `Dodge`
+
+## EntityEffects
+
+EntityEffects are buff or debuff effects that can be applied to a LivingEntity.  These can have a variety of effects from
+movement speed changes to periodic damage.
+
+### EffectCondition
+
+This interaction will fail if the specified entity's EntityEffects do not match the provided conditions.
+
+**EffectCondition Fields**
+
+| Field Name      | Type                                             | Required? | Notes                                                                                                                                                                                                             |
+| --------------- | ------------------------------------------------ | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Entity          | `InteractionTarget`<br />(Default: User)         | **Yes**   | The entity to examine for EntityEffects. This field can indicate the Owner, User, or Target of this interaction chain.                                                                                            |
+| Match           | `Match`<br />(Default: All)                      | **No**    | If `All`, then this interaction will fail if any EntityEffect in the `EntityEffectIds` is not on the specified entity. If `None`, then this interaction will fail if any EntityEffect IS on the specified entity. |
+| EntityEffectIds | `AssetArray`<br />(Element Type: `EntityEffect`) | **Yes**   | The set of EntityEffects to check against the specified entity and `Match`.                                                                                                                                       |
+
+**InteractionTarget Values**
+
+- `User` - The user of this interaction chain. The entity whose actions caused this interaction chain to be executed. This is usually the same as the Owner.
+- `Owner` - The owner of this interaction chain. The entity upon whom this interaction chain is executing.
+- `Target` - The entity target of this interaction chain, if any.  This value is mutable (and can therefore come from many places) but most commonly, it is an entity the User was targeting when this interaction chain began executing.
+
+**Match Values**
+
+- `All` - All EntityEffects must be on the specified entity for this interaction to succeed.
+- `None` - None of the EntityEffects must be on the specified entity for this interaction to succeed.
+
+### ApplyEffect
+
+This interaction will apply the specified EntityEffect to the specified Entity.  It has no special failure conditions.
+
+**ApplyEffect Fields**
+
+| Field Name | Type                                      | Required? | Notes                                                                                                                  |
+| ---------- | ----------------------------------------- | --------- | ---------------------------------------------------------------------------------------------------------------------- |
+| Entity     | `InteractionTarget`<br />(Default: User)  | **Yes**   | The entity to apply the EntityEffect to. This field can indicate the Owner, User, or Target of this interaction chain. |
+| EffectId   | `Asset`<br />(Asset Type: `EntityEffect`) | **Yes**   | The effect to apply.                                                                                                   |
+
+**InteractionTarget Values**
+
+- `User` - The user of this interaction chain. The entity whose actions caused this interaction chain to be executed. This is usually the same as the Owner.
+- `Owner` - The owner of this interaction chain. The entity upon whom this interaction chain is executing.
+- `Target` - The entity target of this interaction chain, if any.  This value is mutable (and can therefore come from many places) but most commonly, it is an entity the User was targeting when this interaction chain began executing.
+
+### ClearEntityEffect
+
+This interaction will remove the specified EntityEffect from the specified Entity. It has no special failure conditions.
+It will not fail if the Entity does not have the EntityEffect.
+
+**ClearEntityEffect Fields**
+
+| Field Name | Type                                      | Required? | Notes                                                                                                                     |
+| ---------- | ----------------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------- |
+| Entity     | `InteractionTarget`<br />(Default: User)  | **Yes**   | The entity to remove the EntityEffect from. This field can indicate the Owner, User, or Target of this interaction chain. |
+| EffectId   | `Asset`<br />(Asset Type: `EntityEffect`) | **Yes**   | The effect to remove.                                                                                                     |
+
+**InteractionTarget Values**
+
+- `User` - The user of this interaction chain. The entity whose actions caused this interaction chain to be executed. This is usually the same as the Owner.
+- `Owner` - The owner of this interaction chain. The entity upon whom this interaction chain is executing.
+- `Target` - The entity target of this interaction chain, if any.  This value is mutable (and can therefore come from many places) but most commonly, it is an entity the User was targeting when this interaction chain began executing.
+
+## Farming
+
+These are interaction types built to support the in-game farming system in Hytale. They are mostly block-related interactions
+with a few exceptions.
+
+### ChangeFarmingStage
+
+If the target block is a farming block, this interaction will attempt to modify the current farming stage in one of
+three ways.  The interaction can optionally specify which StageSet to use for the new stage. If it is not specified,
+the current StageSet will be used. If any part of the the process of changing the growth stage fails, this interaction
+will fail, with the one exception that attempting to set the stage to the crop's existing stage will have no effect but
+still succeed.
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                                                                                                                                                                          |
+| ---------------- | ------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction.                                                                                                                                              |
+| StageSet         | `String`                        | **No**    | If provided, set the block's current stage to one in the provided StageSet. Otherwise, use the crop's current StageSet.                                                                                                                                                        |
+| Increase         | `Integer`                       | **No**    | If provided, increase the current stage by the specified amount. If the specified stage does not exist, the block will be set to the closest extant stage.                                                                                                                     |
+| Decrease         | `Integer`                       | **No**    | If provided and `Increase` is not provided, decrease the current stage by the specified amount. If the specified stage does not exist, the block will be set to the closest extant stage.                                                                                      |
+| Stage            | `Integer`<br />(Default: -1)    | **No**    | If provided and `Increase`/`Decrease` are not provided, set the current stage to the specified stage. If this value is less than 0, set the current stage to the final growth stage. If the specified stage does not exist, the block will be set to the closest extant stage. |
+
+### FertilizeSoil
+
+If the target block is unfertilized tilled soil or a farming block on top of unfertilized tilled soil, fertilizes the soil.
+The interaction will fail otherwise.
+
+**FertilizeSoil Fields**
+
+| Field Name       | Type                                  | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false)       | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+| RefreshModifiers | `Array`<br />(Element Type: `String`) | **No**    | Does nothing.                                                                                                                     |
+
+### HarvestCrop
+
+This interaction will attempt to execute the harvest action on the current block target and add the crop's drops to the User entity's
+inventory.  The block will either be destroyed or set to its post-harvest growth stage, depending on the farming
+configuration of the block.  This will happen (and the player will receive the full harvest drops) regardless of the
+block's current growth stage. This interaction has no special failure conditions, even if the block target isn't a
+farming block or gathering isn't permitted in the current world, but nothing will occur in those cases.
+
+**HarvestCrop Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+
+### UseWateringCan
+
+If the target block is tilled soil or a farming block on top of tilled soil, waters the soil for the specified duration.
+The interaction will fail otherwise.
+
+**UseWateringCan Fields**
+
+| Field Name       | Type                                  | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false)       | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+| Duration         | `Integer`<br />(Default: 0)           | **No**    | The duration in seconds to water the soil for.                                                                                    |
+| RefreshModifiers | `Array`<br />(Element Type: `String`) | **No**    | Does nothing.                                                                                                                     |
diff --git a/content/docs/nl-NL/contributing/pr-guidelines.mdx b/content/docs/nl-NL/contributing/pr-guidelines.mdx
index 7a251032..c226da04 100644
--- a/content/docs/nl-NL/contributing/pr-guidelines.mdx
+++ b/content/docs/nl-NL/contributing/pr-guidelines.mdx
@@ -19,6 +19,8 @@ To ensure a smooth and efficient review process, both contributors and reviewers
 4. **Code Quality**
    - Ensure your code follows the project's coding standards and best practices.
    - Include comments where necessary to explain complex logic.
+   - Always test your changes locally before submitting the PR to catch any issues early.
+   - Format your code using `bun format` to maintain consistency across the codebase.
 5. **Testing**
    - Test your changes thoroughly before submitting the PR.
    - If applicable, include unit tests or integration tests to verify your changes.
diff --git a/content/docs/nl-NL/contributing/translate.mdx b/content/docs/nl-NL/contributing/translate.mdx
new file mode 100644
index 00000000..c62ffdde
--- /dev/null
+++ b/content/docs/nl-NL/contributing/translate.mdx
@@ -0,0 +1,74 @@
+---
+title: Translate
+description: How to translate HytaleModding to your language
+---
+
+# Translating HytaleModding
+
+HytaleModding is translated with the help of the community using **Crowdin**. If you want to help translate or improve existing translations, this is the right place.
+
+## Steps to Translate
+
+All translations are managed **via Crowdin**.
+
+1. Visit [our Crowdin project](https://crowdin.com/project/hytalemodding) and log in if required.
+2. Click on your language.
+3. Click on the file/article you wish to translate. We recommend starting with Official Documentation, and then Server Plugin Documentation.
+4. Start translating!
+5. Approved translations will appear on the website.
+
+### Video Guide
+
+<iframe src="https://www.youtube.com/embed/NHiG1rDRgks" allowFullScreen />
+
+## How to discuss
+
+You can always report issues or discuss specific topics directly on Crowdin, but we recommend using Discord instead of the Crowdin comment system to keep everything organized in one place.
+
+1. Join [our Discord](https://discord.gg/hytalemodding)
+2. Open `#translations` channel. Here you can discuss or ask questions that are not related to a specific language.
+3. If you want to join a thread, you are required to run `/translator <your-language>` command here. The bot will add you to the thread for your language.
+
+## Translation Guidelines
+
+- You need to be confident in what you are translating. You should be able to read the text you just translated and understand the meaning of it very easily.
+- It should use the simplest form of language possible. Use English words if the translation is unknown to the majority in your country.
+- Use your imagination, trust yourself. Feel free to change any context as you wish as long as it can still get the same point across and is understandable.
+- These guidelines are more important than language-specific guidelines, but less important than Hytale terminology and rules.
+
+## What not to translate
+
+We request you all to not translate these specific sections of the website:
+
+### Callout types
+
+Callouts are the boxes that contain important information. We request you to not translate the types as they only work in English.
+
+**Example:**
+
+```mdx
+<Callout type="warning" title="Translate this title!">
+Translate the text inside the callout!
+</Callout>
+```
+
+In this example, please don't translate the word warning, the rest you can translate.
+
+### Icons
+
+Icon names must not be translated.
+They are technical identifiers mapped directly to existing icons. Translating them will break the icon rendering.
+
+```mdx
+icon: Globe
+```
+
+---
+
+{/* 
+For translators who will edit this page:
+
+- You are required to translate the Guidelines as they change.
+- General guidelines should be translated but not edited.
+- Learn how to use Markdown from writing_guides.mdx
+*/}
diff --git a/content/docs/nl-NL/established-information/server/content-categories/art-assets.mdx b/content/docs/nl-NL/established-information/server/content-categories/art-assets.mdx
index 39c2ed37..1e926874 100644
--- a/content/docs/nl-NL/established-information/server/content-categories/art-assets.mdx
+++ b/content/docs/nl-NL/established-information/server/content-categories/art-assets.mdx
@@ -14,7 +14,7 @@ Hytale provides comprehensive support for 3D modeling and texture art creation,
 Hytale uses **Blockbench** as the primary tool for 3D modeling and animation:
 
 * **Official support**: Used for "creating Hytale models, textures, and animations"
-* **Special plugin**: Hytale will have a dedicated Blockbench plugin, to be released ASAP
+* **Special plugin**: Hytale has a dedicated [Blockbench Plugin](https://www.blockbench.net/plugins/hytale_plugin).
 * **Direct compatibility**: The plugin allows creators to "create Hytale-compatible models, textures, and animations directly in Blockbench"
 * **Replaces legacy tools**: Fully replaces the old Hytale Model Maker to better support established creative workflows in the community
 * **Safety features**: Only allows you to add things compatible with the engine, so no need to worry about breaking anything
diff --git a/content/docs/nl-NL/guides/ecs/block-components.mdx b/content/docs/nl-NL/guides/ecs/block-components.mdx
new file mode 100644
index 00000000..ca68b38a
--- /dev/null
+++ b/content/docs/nl-NL/guides/ecs/block-components.mdx
@@ -0,0 +1,247 @@
+---
+title: Block Components
+description: Learn how to use the block components.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+  - name: oskarscot
+    link: https://oskar.scot
+---
+
+# Overview
+
+In this guide, you'll learn how to use block components to create a ticking block.
+
+<Callout>
+  For a more complete reference, you may also want to review FarmingSystems.Ticking, as much of the underlying logic is based on its implementation.
+</Callout>
+
+## Steps
+
+### 1. ExampleBlock - holds block behavior
+
+```java
+public class ExampleBlock implements Component<ChunkStore> {
+
+    public static final BuilderCodec CODEC = BuilderCodec.builder(ExampleBlock.class, ExampleBlock::new).build();
+
+    // Components usually require a copy constructor as well but since we don't actually hold any data in this component this is not neccessary
+    public ExampleBlock() { }
+
+    public static ComponentType getComponentType() {
+        return ExamplePlugin.get().getExampleBlockComponentType();
+    }
+
+    @Nullable
+    public Component<ChunkStore> clone() {
+        return new ExampleBlock();
+    }
+}
+```
+
+ExampleBlock is a custom component that stores the behavior and data for your ticking block. Here, it simply places an Ice Block at x + 1 relative to its current position when it ticks.
+
+---
+
+### 2. ExampleInitializer - marks blocks as ticking when placed
+
+```java
+public class ExampleInitializer extends RefSystem {
+
+    @Override
+    public void onEntityAdded(@Nonnull Ref ref, @Nonnull AddReason reason, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+        BlockModule.BlockStateInfo info = (BlockModule.BlockStateInfo) commandBuffer.getComponent(ref, BlockModule.BlockStateInfo.getComponentType());
+        if (info == null) return;
+
+        ExampleBlock generator = (ExampleBlock) commandBuffer.getComponent(ref, ExamplePlugin.get().getExampleBlockComponentType());
+        if (generator != null) {
+            int x = ChunkUtil.xFromBlockInColumn(info.getIndex());
+            int y = ChunkUtil.yFromBlockInColumn(info.getIndex());
+            int z = ChunkUtil.zFromBlockInColumn(info.getIndex());
+
+            WorldChunk worldChunk = (WorldChunk) commandBuffer.getComponent(info.getChunkRef(), WorldChunk.getComponentType());
+            if (worldChunk != null) {
+				worldChunk.setTicking(x, y, z, true);
+            }
+        }
+    }
+
+    @Override
+    public void onEntityRemove(@Nonnull Ref ref, @Nonnull RemoveReason reason, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+    }
+
+    @Override
+    public Query getQuery() {
+        return Query.and(BlockModule.BlockStateInfo.getComponentType(), ExamplePlugin.get().getExampleBlockComponentType());
+    }
+}
+```
+
+ExampleInitializer is a RefSystem that reacts when block entities with the ExampleBlock component are added or removed. This is crucial for marking blocks as ticking when they're first placed.
+
+**Key Points:**
+
+- Tells the game that this block should tick, allowing `ExampleSystem` to process it.
+
+```java
+worldChunk.setTicking(x, y, z, true);
+```
+
+---
+
+### 3. ExampleSystem - handles ticking
+
+```java
+public class ExampleSystem extends EntityTickingSystem {
+
+    public void tick(float dt, int index, @Nonnull ArchetypeChunk archetypeChunk, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+        BlockSection blocks = (BlockSection) archetypeChunk.getComponent(index, BlockSection.getComponentType());
+
+        assert blocks != null;
+
+        if (blocks.getTickingBlocksCountCopy() != 0) {
+            ChunkSection section = (ChunkSection) archetypeChunk.getComponent(index, ChunkSection.getComponentType());
+
+            assert section != null;
+
+            BlockComponentChunk blockComponentChunk = (BlockComponentChunk) commandBuffer.getComponent(section.getChunkColumnReference(), BlockComponentChunk.getComponentType());
+
+            assert blockComponentChunk != null;
+
+            blocks.forEachTicking(blockComponentChunk, commandBuffer, section.getY(), (blockComponentChunk1, commandBuffer1, localX, localY, localZ, blockId) -> {
+                Ref<ChunkStore> blockRef = blockComponentChunk.getEntityReference(ChunkUtil.indexBlockInColumn(localX, localY, localZ));
+                if (blockRef == null) {
+                    return BlockTickStrategy.IGNORED;
+                } else {
+                    ExampleBlock exampleBlock = (ExampleBlock) commandBuffer1.getComponent(blockRef, ExampleBlock.getComponentType());
+                    if (exampleBlock != null) {
+                        WorldChunk worldChunk = (WorldChunk) commandBuffer.getComponent(section.getChunkColumnReference(), WorldChunk.getComponentType());
+                        World world = worldChunk.getWorld();
+
+                        int globalX = localX + (worldChunk.getX() * 32);
+                        int globalZ = localZ + (worldChunk.getZ() * 32);
+
+                        // We need to execute setBlock on the world thread as you cannot call store functions from a system
+                        // This is because of the architecture of the server, depending on your needs you can also use the CommandBuffer
+                        world.execute(() -> {
+                            world.setBlock(globalX + 1, localY, globalZ, "Rock_Ice");
+                        });
+
+                        return BlockTickStrategy.CONTINUE;
+
+                    } else {
+                        return BlockTickStrategy.IGNORED;
+                    }
+                }
+            });
+        }
+    }
+
+    @Nullable
+    public Query getQuery() {
+        return Query.and(BlockSection.getComponentType(), ChunkSection.getComponentType());;
+    }
+}
+```
+
+ExampleSystem is an EntityTickingSystem that runs every tick to execute the logic for all ticking blocks with the ExampleBlock component.
+
+**Key Points:**
+
+- **Get the block component**
+
+```java
+ExampleBlock exampleBlock = (ExampleBlock) commandBuffer.getComponent(blockRef, ExampleBlock.getComponentType());
+```
+
+- **Convert local chunk coordinates to world coordinates**
+
+```java
+int globalX = localX + (worldChunk.getX() * 32);
+int globalZ = localZ + (worldChunk.getZ() * 32);
+```
+
+- **Run the block logic**
+
+```java
+exampleBlock.runBlockAction(globalX, localY, globalZ, worldChunk.getWorld());
+```
+
+- **Keep the block ticking in the next tick**
+
+```java
+return BlockTickStrategy.CONTINUE;
+```
+
+---
+
+### 4. ExamplePlugin - registers components and systems
+
+```java
+public class ExamplePlugin extends JavaPlugin {
+    protected static ExamplePlugin instance;
+    private static final HytaleLogger LOGGER = HytaleLogger.forEnclosingClass();
+    private ComponentType exampleBlockComponentType;
+
+    public static ExamplePlugin get() {
+        return instance;
+    }
+
+    public ExamplePlugin(@Nonnull JavaPluginInit init) {
+        super(init);
+        LOGGER.atInfo().log("Hello from " + this.getName() + " version " + this.getManifest().getVersion().toString());
+    }
+
+    @Override
+    protected void setup() {
+        instance = this;
+        LOGGER.atInfo().log("Setting up plugin " + this.getName());
+        this.exampleBlockComponentType = this.getChunkStoreRegistry().registerComponent(ExampleBlock.class, "ExampleBlock", ExampleBlock.CODEC);
+    }
+	
+	@Override
+	protected void start() {
+		this.getChunkStoreRegistry().registerSystem(new ExampleSystem());
+		this.getChunkStoreRegistry().registerSystem(new ExampleInitializer());
+	}
+
+    public ComponentType getExampleBlockComponentType() {
+        return this.exampleBlockComponentType;
+    }
+}
+```
+
+---
+
+### 5. Configure In-Game
+
+![block-component-1](/assets/guides/block-component-1.png)
+
+![block-component-2](/assets/guides/block-component-2.png)
+
+With this logic, the block will now continuously place an Ice Block at the coordinates x + 1 relative to its current position every time it ticks.
+
+---
+
+## Common Issues
+
+### NullPointerException on Startup
+
+**Error message:**
+
+```java
+java.lang.NullPointerException: Cannot invoke "com.hypixel.hytale.component.query.Query.validateRegistry(com.hypixel.hytale.component.ComponentRegistry)" because "query" is null
+```
+
+**Cause:**
+This error occurs when your module is loaded **before** the required Hytale modules.
+
+**Fix:**
+Add `EntityModule` and `BlockModule` as dependencies in your `manifest.json` to ensure proper load order.
+
+```json
+"Dependencies": {
+  "Hytale:EntityModule": "*",
+  "Hytale:BlockModule": "*"
+}
+```
diff --git a/content/docs/nl-NL/guides/ecs/hytale-ecs-theory.mdx b/content/docs/nl-NL/guides/ecs/hytale-ecs-theory.mdx
index 20c3a94d..52d8b1f5 100644
--- a/content/docs/nl-NL/guides/ecs/hytale-ecs-theory.mdx
+++ b/content/docs/nl-NL/guides/ecs/hytale-ecs-theory.mdx
@@ -29,7 +29,7 @@ for now this is the basic understanding for the `ChunkStore`. You can use it to
 
 ## Holder
 
-A Holder is essentially a blueprint for an entity. Before an entity exists in the Store (and thus in the world), is exists as a `Holder`. It collects and holds all the necessary components (data). You can compare it analogous to shopping cart. You grab all components you need and once you have everything, check out at the store which will take your cart and create a valid entity ID and hand you back a receipt (a Ref).
+A Holder is essentially a blueprint for an entity. Before an entity exists in the Store (and thus in the world), it exists as a `Holder`. It collects and holds all the necessary components (data). You can compare it analogous to shopping cart. You grab all components you need and once you have everything, check out at the store which will take your cart and create a valid entity ID and hand you back a receipt (a Ref).
 
 Let's take a look at an example: initializing players. In `Universe`, the `addPlayer` method demonstrates it perfectly.
 When a player connects, we don't immediately throw them into the ECS. We first construct their data in a Holder.
@@ -167,7 +167,7 @@ MyComponent comp = commandBuffer.getComponent(ref, componentType);
 
 Codecs handle serialization and deserialization of components. Hytale uses them to save and load entity data to and from disk as well as sending component data over the network. When creating a custom component, you must also create a corresponding Codec.
 
-There are mutliple Codec types already implemented in the default Codec Interface:
+There are multiple Codec types already implemented in the default Codec Interface:
 
 - Codec.STRING
 - Codec.BOOLEAN
@@ -215,7 +215,7 @@ This might seem tedious at first but it ensures that your component can be corre
   KeyedCodec<Integer> exampleInt = new KeyedCodec<Integer>("ExampleIntIdForCodec", Codec.INTEGER);
   ```
 
-- **Setter Function**: This is a lambda function that takes an instance of your component and returns the value of the field you want to serialize. For example, if you have a field called `myCustomField` in your custom component, your getter function would look like this:
+- **Setter Function**: This is a lambda function that takes an instance of your component + the value to set and sets the field value on the component. For example, if you have a field called `myCustomField` in your custom component, your setter function would look like this:
   ```java
   (data, value) -> data.myCustomField = value
   ```
@@ -276,7 +276,7 @@ public class PoisonComponent implements Component<EntityStore> {
 
 You can also add validators to your Codec fields to ensure that the data being serialized/deserialized meets certain criteria. For example, if you want to ensure that the `damagePerTick` field is always non-negative or the poison name is never null, you can add a validator like this:
 
-````java
+```java
 .append(
     new KeyedCodec<Float>("DamagePerTick", Codec.FLOAT),
     (data, value) -> data.damagePerTick = value,
@@ -292,14 +292,15 @@ You can also add validators to your Codec fields to ensure that the data being s
 )
 .addValidator(Validators.nonNull())
 .add()
+```
 
 ### Complex Codec Examples
 
-If you want to have a map inside your component, you can use the MapCodec class to build a KeyedCoded for it. Here's an example of how to create a Codec for a Map field:
+If you want to have a map inside your component, you can use the MapCodec class to build a KeyedCodec for it. Here's an example of how to create a Codec for a Map field:
 
 ```java
 var damagePerTick = new KeyedCodec<>("DamagePerTick", new MapCodec<>(Codec.FLOAT, HashMap<String, Float>::new));
-````
+```
 
 <Callout type="info">
   This also works with custom Objects as long as you have a Codec defined for the Object type.
diff --git a/content/docs/nl-NL/guides/java-basics/00-introduction.mdx b/content/docs/nl-NL/guides/java-basics/00-introduction.mdx
index a03ad638..b0130d74 100644
--- a/content/docs/nl-NL/guides/java-basics/00-introduction.mdx
+++ b/content/docs/nl-NL/guides/java-basics/00-introduction.mdx
@@ -7,7 +7,7 @@ Welcome to your journey into Java Programming! This guide is designed to introdu
 
 ## What is Java?
 
-Java is a powerful, object-oriented programming language created in 1995. It's one of the most popular programming languages in the world and is used for everything from mobile apps to enterprise software. Most importantly for us, it's the language Hytale uses for it's servers & modding API.
+Java is a powerful, object-oriented programming language created in 1995. It's one of the most popular programming languages in the world and is used for everything from mobile apps to enterprise software. Most importantly for us, it's the language Hytale uses for its servers & modding API.
 
 ## What You'll Learn
 
diff --git a/content/docs/nl-NL/guides/java-basics/02-operators.mdx b/content/docs/nl-NL/guides/java-basics/02-operators.mdx
index a132b1c0..18634665 100644
--- a/content/docs/nl-NL/guides/java-basics/02-operators.mdx
+++ b/content/docs/nl-NL/guides/java-basics/02-operators.mdx
@@ -119,7 +119,7 @@ String greetingWithName = "Hello, " + name + "!"; // "Hello, Alice!"
 
 ## Operator Precedence
 
-Operator Precendence means which operator gets evaluated first in an line of code. Think of it like BODMAS/PEMDAS in math!
+Operator Precedence means which operator gets evaluated first in an line of code. Think of it like BODMAS/PEMDAS in math!
 
 ```java
 int result = 10 + 5 * 2; // result is 20, not 30
diff --git a/content/docs/nl-NL/guides/java-basics/03-control-flow-if.mdx b/content/docs/nl-NL/guides/java-basics/03-control-flow-if.mdx
index b9d6c479..af2d1c22 100644
--- a/content/docs/nl-NL/guides/java-basics/03-control-flow-if.mdx
+++ b/content/docs/nl-NL/guides/java-basics/03-control-flow-if.mdx
@@ -7,7 +7,7 @@ Programs need to make decisions. If statements let your code choose different pa
 
 ## Basic If Statement
 
-The simplest form checks one condition;
+The simplest form checks one condition:
 
 ```java
 int health = 20;
diff --git a/content/docs/nl-NL/guides/java-basics/08-access-modifiers.mdx b/content/docs/nl-NL/guides/java-basics/08-access-modifiers.mdx
index af560932..da2bf33b 100644
--- a/content/docs/nl-NL/guides/java-basics/08-access-modifiers.mdx
+++ b/content/docs/nl-NL/guides/java-basics/08-access-modifiers.mdx
@@ -484,7 +484,7 @@ class Data {
     // Static member:
     // cannot access to non-static variables
     public static void bar() {
-        x = 100; // Error: non-static variable x cannot be renference from a static context
+        x = 100; // Error: non-static variable x cannot be referenced from a static context
         y = 100; // OK
     }
 }
@@ -504,7 +504,7 @@ Data.x = 1000; // Error: cannot access instanced variables in a static context
 
 ### Static Fields
 
-A static field represents a data member owned by the class type rather then the object. Static fields are also stored in a specific memory location that's been shared between all the object instances that are created.
+A static field represents a data member owned by the class type rather than the object. Static fields are also stored in a specific memory location that's been shared between all the object instances that are created.
 
 It is declared as following:
 
diff --git a/content/docs/nl-NL/guides/plugin/animated-block-textures.mdx b/content/docs/nl-NL/guides/plugin/animated-block-textures.mdx
new file mode 100644
index 00000000..42bfa51f
--- /dev/null
+++ b/content/docs/nl-NL/guides/plugin/animated-block-textures.mdx
@@ -0,0 +1,101 @@
+---
+title: Animated Block Textures
+description: Learn how to attach a .blockyanim to a block
+authors:
+  - name: Burkino
+---
+
+import { File, Folder, Files } from 'fumadocs-ui/components/files';
+
+So, you want to make your blocks feel more alive through animations, do you?\
+Now for the most part this is the exact same as [Creating custom blocks](./creating-block).
+![blue fire gif](/assets/guides/blue_fire.gif)
+
+## Prerequisites
+
+This is NOT a guide on animating or texturing or even using BlockBench, why? Because I don't know how to do that.\
+The only thing we will be doing is taking the fire texture, changing the color, and applying it to our new fire block.
+
+## Setup
+
+To start, you're obviously going to want to grab the `Common/VFX/Fire/Fire.png` file. How you do it is up to you, in the Asset Editor you'll need to switch to the Common tab.\
+I'll assume you know how colorize or change the hue of an image, so go ahead and do that now and save it as `Blue_Fire.png`.
+
+The other assets used in this guide are `Common/VFX/Fire/Fire.blockymodel` and `Common/Blocks/Animations/Fire/Fire_Burn.blockyanim` (both renamed to `Blue_Fire`) but since we won't be changing them it's probably fine to leave them. I will reference the `Blue_Fire` versions as a way to point out what should be custom assets.\
+I will also duplicate `Server/Item/Item/Deco/Deco_Fire.json` and call it `Deco_Blue_Fire.json`.
+
+## Applying the changes
+
+The `Deco_Blue_Fire` block is actually just a particle emitter, however we will not be using particles, so lets start by removing them in `Block > Particles`.\
+Next we want to set the Block Model (called `CustomModel` in JSON) to `VFX/Blue_Fire/Blue_Fire.blockymodel` and Block Model Textures (`CustomModelTexture` in JSON) to
+
+```json
+[
+    {
+        "Texture": "VFX/Blue_Fire/Blue_Fire.png",
+        "Weight": 1
+    }
+]
+```
+
+Finally, we will apply the .blockyanim to our model, this is done through the Block Model Animation property (`CustomModelAnimation` in JSON) and the value should be `Blocks/Animations/Blue_Fire/Blue_Fire_Burn.blockyanim`.
+
+## Final Code
+
+With that your new blue fire should be done. Here is the minimal JSON for our blue fire.\
+There is an additional `Looping` and `RequiresAlphaBlending` property that I have not gone over, however I hope it is self-explanatory.
+
+```json
+{
+  "BlockType": {
+    "DrawType": "Model",
+    "CustomModel": "VFX/Blue_Fire/Blue_Fire.blockymodel",
+    "CustomModelAnimation": "Blocks/Animations/Blue_Fire/Blue_Fire_Burn.blockyanim",
+    "CustomModelTexture": [
+      {
+        "Texture": "VFX/Blue_Fire/Blue_Fire.png",
+        "Weight": 1
+      }
+    ],
+    "Looping": true,
+    "RequiresAlphaBlending": false
+  },
+  "PlayerAnimationsId": "Block"
+}
+```
+
+<Files>
+  <Folder name="resources" defaultOpen>
+    <Folder name="Server" defaultOpen>
+      <Folder name="Item" defaultOpen>
+        <Folder name="Items" defaultOpen>
+          <Folder name="Deco" defaultOpen>
+            <File name="Deco_Blue_Fire.json" />
+          </Folder>
+        </Folder>
+      </Folder>
+    </Folder>
+
+    <Folder name="Common" defaultOpen>
+      <Folder name="Blocks" defaultOpen>
+        <Folder name="Animations" defaultOpen>
+          <Folder name="Blue_Fire" defaultOpen>
+            <File name="Blue_Fire_Burn.blockyanim" />
+          </Folder>
+        </Folder>
+      </Folder>
+
+      <Folder name="VFX" defaultOpen>
+        <Folder name="Blue_Fire" defaultOpen>
+          <File name="Blue_Fire.blockymodel" />
+
+          <File name="Blue_Fire.png" />
+        </Folder>
+      </Folder>
+    </Folder>
+  </Folder>
+</Files>
+
+## Next steps
+
+Now that you know how to attach an animation to a block, try adding it to a block state.
diff --git a/content/docs/nl-NL/guides/plugin/build-and-test.mdx b/content/docs/nl-NL/guides/plugin/build-and-test.mdx
index 0e7fe7eb..f37534c3 100644
--- a/content/docs/nl-NL/guides/plugin/build-and-test.mdx
+++ b/content/docs/nl-NL/guides/plugin/build-and-test.mdx
@@ -9,18 +9,18 @@ If you followed along with the [Setting Up Your Development Environment](./setti
 
 ## Building Your Mod
 
-In our case, we've **Maven** as the build system. Maven is a powerful build automation tool that manages dependencies, compiles your code, and packages everything into a distributable JAR file.
+In our case, we've **Gradle** as the build system. Gradle is a powerful build automation tool that manages dependencies, compiles your code, and packages everything into a distributable JAR file.
 
-### Understanding Maven
+### Understanding Gradle
 
-Maven uses a `pom.xml` file (Project Object Model) to define your project's configuration, dependencies, and build settings. You can learn more about Maven at the [official Apache Maven website](https://maven.apache.org/).
+Gradle can use a `build.gradle.kts` file (Kotlin DSL) to define your project's configuration, dependencies, and build settings. You can learn more about Gradle at the [official Gradle website](https://gradle.org/).
 
-### Building with Maven
+### Building with Gradle
 
 To build your mod, open a terminal in your project directory and run:
 
 ```bash
-mvn package
+./gradlew build
 ```
 
 This command will:
@@ -29,16 +29,35 @@ This command will:
 2. Run any tests (if present)
 3. Package everything into a JAR file
 
+<Callout type="info">
+  If you are using the plugin template from the [Setting Up Your Development Environment](./setting-up-env) guide, then the build script is already set up for you. It includes paths to your Hytale game library and handles the packaging of your mod, managing hytale dependencies and manifest changes.
+
+  If you have a different path to your Hytale installation, you may receive the following error:
+
+  ```bash
+  FAILURE: Build failed with an exception.
+
+  * What went wrong:
+  Failed to find Hytale at the expected location. Please make sure you have installed the game. The expected location can be changed using the hytale.home_path property. Currently looking in 'C:\Path\To\Hytale'
+  ```
+
+  You can change the path by adding a property to your `gradle.properties` file (if it doesn't exist, create it in the root of your project):
+
+  ```properties
+  hytale.home_path=C:\Correct\Path\To\Hytale
+  ```
+</Callout>
+
 ### Build Output
 
-Once the build completes successfully, your mod will be located in the `target` directory and named:
+Once the build completes successfully, your mod will be located in the `build/libs` directory and named:
 
 ```
-ExamplePlugin-1.0-SNAPSHOT.jar
+ExamplePlugin-1.0.jar
 ```
 
 <Callout type="info">
-  The exact name may vary depending on what you configured in your `pom.xml` file. Check the `artifactId` and `version` fields to see what your JAR will be named.
+  The exact name may vary depending on what you configured in your `build.gradle.kts` and `settings.gradle.kts` file. Check the `rootProject.name` and `version` fields to see what your JAR will be named.
 </Callout>
 
 ## Testing Your Mod
@@ -49,11 +68,11 @@ Now that you've built your mod, it's time to test it in Hytale!
 
 First, you need to find Hytale's mods directory:
 
-1. Press **Win + R** on your keyboard
-2. Type `%appdata%` and press Enter
-3. Navigate to: `Hytale\UserData\Mods`
+1. Go to your Hytale installation directory (The default location is usually in your AppData folder)
+   > On Windows, you can access it by clicking `windows + R` and typing `%appdata%`.
+2. Navigate to: `/UserData/Mods`
 
-The full path should look like:
+The default path would look like:
 
 ```
 C:\Users\YourUsername\AppData\Roaming\Hytale\UserData\Mods
@@ -65,7 +84,7 @@ C:\Users\YourUsername\AppData\Roaming\Hytale\UserData\Mods
 
 ### 2. Copy Your Mod
 
-Copy the `ExamplePlugin-1.0-SNAPSHOT.jar` file from your project's `target` directory into the `Mods` folder you just located.
+Copy the `ExamplePlugin-1.0.jar` file from your project's `build/libs` directory into the `Mods` folder you just located.
 
 ### 3. Launch Hytale and Verify
 
@@ -84,7 +103,7 @@ If your mod doesn't appear in the mods list:
 - Make sure the JAR file is in the correct `Mods` folder
 - Check that your `manifest.json` file is properly configured
 - Look for any error messages in the Hytale logs
-- Verify that you're using the correct version of Java and Maven
+- Verify that you're using the correct version of Java and Gradle
 
 ## Next Steps
 
diff --git a/content/docs/nl-NL/guides/plugin/creating-commands.mdx b/content/docs/nl-NL/guides/plugin/creating-commands.mdx
index d33597f3..08572f16 100644
--- a/content/docs/nl-NL/guides/plugin/creating-commands.mdx
+++ b/content/docs/nl-NL/guides/plugin/creating-commands.mdx
@@ -8,6 +8,8 @@ authors:
     url: https://oskar.scot
   - name: jacobwojoski
     url: https://github.com/jacobwojoski
+  - name: Marcel-TO
+    url: https://marcel-to.net
 ---
 
 In this guide, you will learn how to create custom commands for your Hytale mod.
@@ -36,7 +38,7 @@ The most basic command is an `AbstractAsyncCommand`. It has very minimal data av
   `AbstractAsyncCommand` runs on its own background thread. This means its execute is not tied to any world instance and because of this it can not edit any **Stores** or **Refs** without getting the desired world first. To access this data any of the other command types would be preferred and are likely what you will want to use instead.
 </Callout>
 
-The main purpose for a command like this would be for something that can happen everywhere and is not tied to a specific world. For example a `serverRules` command to tell the user thats running the command in chat what the servers rules are nomatter what world they are in.
+The main purpose for a command like this would be for something that can happen everywhere and is not tied to a specific world. For example a `serverRules` command to tell the user that's running the command in chat what the server's rules are no matter what world they are in.
 
 ```java
 // Command that can be run that lists the server rules in chat to the player
@@ -49,7 +51,7 @@ public class ServerRulesCommand extends AbstractAsyncCommand {
     }
 
     // Run the command
-    // conetext - info about who ran the command. Server console?, Some player?
+    // context - info about who ran the command. Server console?, Some player?
     @Override
     protected CompletableFuture<Void> executeAsync(@Nonnull CommandContext context) {
         context.sendMessage(Message.raw("The only rule is there are no rules."));
@@ -134,7 +136,7 @@ Uses a Ray to see what the player is looking at and tries to run the command on
 
 ## Adding Arguments
 
-Arguments are additional fields that the user can input when running a command. The different types of arguments along with small snipits and a large example can be seen below.
+Arguments are additional fields that the user can input when running a command. The different types of arguments along with small snippets and a large example can be seen below.
 
 ### Command Argument Types
 
@@ -163,14 +165,14 @@ this.messageArg = this.withOptionalArg("message", "Message to print while healin
 
 ### Default Arguments
 
-Adding a default argument has two additional arguemnt for the default value and default value description. You need to use `withDefaultArg` method.
+Adding a default argument has two additional argument for the default value and default value description. You need to use `withDefaultArg` method.
 
 ```java
 // args <Command String> <Description> <Default Value> <Desc of default value>
 this.healthArg = this.withDefaultArg("health", "Amount to heal player", ArgTypes.FLOAT, (float)100, "Desc of Default: 100");
 ```
 
-### Flag Arguemnts
+### Flag Arguments
 
 Similar as above but the flags return is either true if it exists or false if it does not. You need to use `withFlagArg` method.
 
@@ -181,20 +183,13 @@ this.debugArg = this.withFlagArg("debug", "Add debug logs");
 
 ### ArgTypes
 
-The following ArgTypes are available (only lists common types):
-
-- `ArgTypes.STRING`
-- `ArgTypes.INTEGER`
-- `ArgTypes.BOOLEAN`
-- `ArgTypes.FLOAT`
-- `ArgTypes.DOUBLE`
-- `ArgTypes.UUID`
+You can find all the available argument types on the [ArgTypes](../../argtypes) page.
 
 ### Example Command Arg Types
 
-Shows all Command arguemnt types with different various input types.
+Shows all Command argument types with different various input types.
 
-**NOTE:** When getting the value of an argument during execute you need to pass the context with `someArg.get(commandContext)`. Where `commandContext` is the first variable in the execute funtion.
+**NOTE:** When getting the value of an argument during execute you need to pass the context with `someArg.get(commandContext)`. Where `commandContext` is the first variable in the execute function.
 
 ```java
 // Example usage: /healplayer --health 50 --message "Feels Good" --debug
@@ -204,7 +199,7 @@ public class HealPlayerCommand extends AbstractTargetPlayerCommand {
     private final FlagArg debugArg;
 
     public HealPlayerCommand() {
-        super("healplayer", "Healing a player for an <input> ammount of HP (default: 100)");
+        super("healplayer", "Healing a player for an <input> amount of HP (default: 100)");
 
         // Abstract TargetPlayerCommand passes the player that ran the command by default and implements
         // the use of `--player <value>` to specify someone else
@@ -213,10 +208,10 @@ public class HealPlayerCommand extends AbstractTargetPlayerCommand {
         this.healthArg = this.withDefaultArg("health", "Amount to heal player", ArgTypes.FLOAT, (float)100, "Desc of Default: 100");
 
         // Or you could do the following making the health value required instead of with a default.
-        //    You would need to change the decleration to RequiredArg<Float>
+        //    You would need to change the declaration to RequiredArg<Float>
         // this.healthArg = this.withRequiredArg("health", "Amount to heal player", ArgTypes.FLOAT);
 
-        // Optional args reguare the user the input `--<key> <value>` so the following would require `--message "Good Luck"`
+// Optional args require the user the input `--<key> <value>` so the following would require `--message "Good Luck"`
         this.messageArg = this.withOptionalArg("message", "Message to print while healing", ArgTypes.STRING);
 
         // No type needed due to being a bool
@@ -230,7 +225,7 @@ public class HealPlayerCommand extends AbstractTargetPlayerCommand {
             commandContext.sendMessage(Message.raw("We are debugging"));
         }
 
-        // Health is stored in a generic stat map to allowing mods/future contect to easily add more stats if desired.
+        // Health is stored in a generic stat map to allowing mods/future content to easily add more stats if desired.
         EntityStatMap stats = store.getComponent(ref, EntityStatMap.getComponentType());
         int healthIdx = DefaultEntityStatTypes.getHealth();
         EntityStatValue health = stats.get(healthIdx);
@@ -252,7 +247,7 @@ public class HealPlayerCommand extends AbstractTargetPlayerCommand {
 
 ## Argument Validators
 
-Argument validators are a way to check the command before the command gets executed. They are added with the `addValidator` method on an argument when calling `withXxxArg`. They provide a nice output to the user when an input value is invalid.
+Argument validators are a way to check the command before the command gets executed. They are added with the `addValidator` method on an argument when calling `withXxxArg`. They provide a nice output to the user when an input value is invalid. There are some common validators provided in the `Validators` class such as `greaterThan`, `lessThan`, and `or`, `max`, `range`, etc.
 
 ```java
 ...
@@ -260,18 +255,59 @@ Argument validators are a way to check the command before the command gets execu
     OptionalArg<Integer> healAmount = withOptionalArg("amount", "Heal Amount", ArgTypes.INTEGER)
         .addValidator(Validators.greaterThan(0))
         .addValidator(Validators.lessThan(1000));
-
-    // Custom check example
-    OptionalArg<Integer> healAmount = withOptionalArg("amount", "Heal Amount", ArgTypes.INTEGER)
-            .addValidator( value -> {
-                if (value != null && value <= 0) {
-                    return ValidationResult.error("ammount argument must be a positive number");
-                }
-                return ValidationResult.success();
-            });
 ...
 ```
 
+### Custom Validators
+
+You can also create custom validators by implementing the `com.hypixel.hytale.codec.validation.Validator` interface. The interfaces forces you to implement the `accept` and `updateSchema` method. The `accept` method takes in the argument value and validates it. If the validation fails, you can use the `fail` method of the `com.hypixel.hytale.codec.validation.ValidationResults` class to return an error message.
+The `updateSchema` method is used to update the schema of the command argument. This is used for commands that have dynamic schemas based on the input value. For example, if you have a command that takes in a player name as an argument, you can use the `updateSchema` method to update the schema to include a list of online players for validation.
+
+Here is an example of a custom validator that checks if a string value is equal to a banned word. In this example, the banned word is "badword". If the input value is "badword", the validator will fail and return an error message.
+
+```java
+import com.hypixel.hytale.codec.schema.SchemaContext;
+import com.hypixel.hytale.codec.schema.config.Schema;
+import com.hypixel.hytale.codec.validation.ValidationResults;
+import com.hypixel.hytale.codec.validation.Validator;
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+
+public class MyCustomValidator implements Validator<String> {
+    @Nonnull
+    private final String value;
+
+    public MyCustomValidator(@Nonnull String value) {
+        this.value = value;
+    }
+
+    @Override
+    public void accept(@Nullable String input, @Nonnull ValidationResults results) {
+        if (this.value.equalsIgnoreCase(input)) {
+            results.fail("The given role has been banned.");
+        }
+    }
+
+    @Override
+    public void updateSchema(SchemaContext context, @Nonnull Schema target) {
+        // This method can be used to update the schema of the command argument. This is useful for commands that have dynamic schemas based on the input value. For example, if you have a command that takes in a player name as an argument, you can use the `updateSchema` method to update the schema to include a list of online players for validation.
+        throw new UnsupportedOperationException("Not implemented yet.");
+    }
+}
+```
+
+After the custom validator is created, you can add it to an argument like the following example. In this example, we add the `MyCustomValidator` to a string argument called "role". If the user inputs "badword" as the role, the command will fail and return the error message defined in the `MyCustomValidator`.
+
+```java
+    ...
+    // Custom validator example
+    String bannedRole = "badword";
+
+    OptionalArg<String> roleArg = withOptionalArg("role", "Role to assign", ArgTypes.STRING)
+        .addValidator(new MyCustomValidator(bannedRole));
+    ...
+```
+
 ---
 
 ## Permissions
@@ -312,7 +348,7 @@ This allows the server to control who has access to specific commands. You add t
 
 If you want variants of the same command without doing argument parsing you can instead use `addUsageVariant(new OtherCommandClass())` in the original commands constructor.
 
-The only difference is in the `OtherCommandClass()` constrcutor you don't pass the command name to the super class.
+The only difference is in the `OtherCommandClass()` constructor you don't pass the command name to the super class.
 
 <Callout type="info">
   You can also use `addAliases("some_alias", "some_other_alias")` as a way to add shorthand or other ways to write the same command.
@@ -387,7 +423,7 @@ public class AdminCommand extends AbstractCommandCollection {
     public AdminCommand () {
         super("admin", "Admin commands");
         addSubCommand(new UserCommandCollection());
-        addSybCommand(new ServerCommandCollection);
+        addSubCommand(new ServerCommandCollection);
     }
 }
 ```
@@ -417,5 +453,5 @@ public class MyPlugin extends JavaPlugin {
 
 ## Video Link
 
-_Special Thanks to [TroubleDev](https://www.youtube.com/@TroubleDEV) for his excelent video guide on all of these features._
+_Special Thanks to [TroubleDev](https://www.youtube.com/@TroubleDEV) for his excellent video guide on all of these features._
 _Video Link: [TroubleDev - Hytale's Command API Explained](https://www.youtube.com/watch?v=KnmhG9MDMgo)_
diff --git a/content/docs/nl-NL/guides/plugin/creating-events.mdx b/content/docs/nl-NL/guides/plugin/creating-events.mdx
index 95863990..d3f0925d 100644
--- a/content/docs/nl-NL/guides/plugin/creating-events.mdx
+++ b/content/docs/nl-NL/guides/plugin/creating-events.mdx
@@ -1,6 +1,6 @@
 ---
-title: Creating Events
-description: Learn how to create custom events for your Hytale mod.
+title: Creating Events Listeners
+description: Learn how to create event listeners for your Hytale mod.
 authors:
   - name: Neil Revin
     url: https://itsneil.dev
@@ -10,7 +10,7 @@ authors:
 
 ## Event Class
 
-You can import a Event class and create a function with the Event as a argument. [Click here](../../server/events) to look at all available events.
+You can import an Event class and create a function with the Event as an argument. [Click here](../../server/events) to look at all available events.
 
 Example plugin when a player is ready (joins a server):
 
diff --git a/content/docs/nl-NL/guides/plugin/item-registry.mdx b/content/docs/nl-NL/guides/plugin/item-registry.mdx
new file mode 100644
index 00000000..9a0fd53a
--- /dev/null
+++ b/content/docs/nl-NL/guides/plugin/item-registry.mdx
@@ -0,0 +1,95 @@
+---
+title: Working with the Item Registry
+description: Learn how to access and query the game's item registry to list all items, check if items exist, and retrieve item properties.
+authors:
+  - name: Denis
+---
+
+In this guide, you'll learn how to work with Hytale's Item Registry system. This is useful when you need to programmatically list all available items, validate item IDs, or retrieve item properties at runtime.
+
+## Prerequisites
+
+Before diving in, you should be familiar with:
+
+- [Setting up your development environment](./setting-up-env)
+- [Creating commands](./creating-commands) (optional, for testing)
+
+## Required Imports
+
+To work with the Item Registry, you'll need the following imports:
+
+```java
+import com.hypixel.hytale.assetstore.map.DefaultAssetMap;
+import com.hypixel.hytale.server.core.asset.type.item.config.Item;
+```
+
+## Getting the Item Registry
+
+The Item Registry is accessed through the `Item.getAssetMap()` method, which returns a `DefaultAssetMap<String, Item>` containing all registered items in the game:
+
+```java
+DefaultAssetMap<String, Item> itemMap = Item.getAssetMap();
+```
+
+## Listing All Items
+
+To iterate through all items in the registry, you can get the underlying map and loop through its entries:
+
+```java
+DefaultAssetMap<String, Item> itemMap = Item.getAssetMap();
+var map = itemMap.getAssetMap();
+
+for (var entry : map.entrySet()) {
+    String itemId = String.valueOf(entry.getKey());
+    Item item = entry.getValue();
+    
+    // Do something with the item
+    LOGGER.atInfo().log("Item ID: " + itemId);
+}
+```
+
+You can also get the total count of registered items:
+
+```java
+int totalItems = map.size();
+```
+
+## Checking if an Item Exists
+
+To check if a specific item exists in the registry, use `getAsset()` and verify the result:
+
+```java
+public boolean itemExists(String itemId) {
+    var assetMap = Item.getAssetMap();
+    if (assetMap != null) {
+        Item item = assetMap.getAsset(itemId);
+        return item != null && item != Item.UNKNOWN;
+    }
+    return false;
+}
+```
+
+<Callout type="info">
+  The `Item.UNKNOWN` constant represents an invalid or unrecognized item. Always check for both `null` and `Item.UNKNOWN` when validating items.
+</Callout>
+
+## Accessing Item Properties
+
+Once you have an `Item` instance, you can access various properties:
+
+```java
+var assetMap = Item.getAssetMap();
+Item item = assetMap.getAsset("Soil_Grass");
+
+if (item != null && item != Item.UNKNOWN) {
+    String id = item.getId(); // Soil_Grass
+    int maxStack = item.getMaxStack(); // 100
+    boolean isBlock = item.hasBlockType(); // true
+    boolean isConsumable = item.isConsumable(); // false
+}
+```
+
+## Related Guides
+
+- [Inventory Management](./inventory-management) - Learn how to add and remove items from player inventories
+- [Create Custom Item and Interaction](./item-interaction) - Learn how to create your own custom items
diff --git a/content/docs/nl-NL/guides/plugin/permission-management.mdx b/content/docs/nl-NL/guides/plugin/permission-management.mdx
index 6b7cfd46..55f06101 100644
--- a/content/docs/nl-NL/guides/plugin/permission-management.mdx
+++ b/content/docs/nl-NL/guides/plugin/permission-management.mdx
@@ -10,132 +10,569 @@ authors:
     link: https://discord.com/users/292656109939064833
   - name: Ivan
     link: https://discord.com/users/505770451218333717
+  - name: ZenithDevHQ
+    link: https://github.com/ZenithDevHQ
 ---
 
-In this guide, you'll learn how to manage permission nodes and groups in your Hytale plugin.
+In this guide, you'll learn how to manage permission nodes and groups in your Hytale plugin. Permissions control what actions players can perform on your server, from basic commands to advanced administrative functions.
 
-## The `PermissionsModule` class
+## What Are Permissions?
 
-The `PermissionsModule` class is responsible for managing permission nodes and groups in your plugin. It provides methods to check, grant and revoke permissions and groups for players. It allows the following operations
+Permissions are string identifiers that control access to features and commands. When a player tries to perform an action (like using a command), the server checks if they have the required permission.
 
-- Add permissions to user
-- Remove permissions from user
-- Add permissions to group (this also creates the group if it doesn't exist)
-- Remove permissions from group
-- Add user to group
-- Remove user from group
-- List all groups for a user
-- Check if a user has a permission (it checks both user and group permissions for the given player UUID)
+**Example permission nodes:**
 
-With this class you cannot:
+- `hytale.command.gamemode` - Permission to use the gamemode command
+- `hytale.editor.brush.use` - Permission to use brush tools
+- `myplugin.teleport.home` - A custom permission for your plugin
 
-- List all defined groups
-- Remove a group
+Permissions follow a hierarchical naming pattern: `namespace.category.action`
 
-### Adding Permission Nodes
+## Key Concepts
 
-You need a `Set<String>` containing all the permission nodes you want to add, these are added on top of the already existing permission nodes the user may have, it is not a replacement.
+Before diving into code, let's understand the core concepts:
+
+| Concept             | Description                                                                |
+| ------------------- | -------------------------------------------------------------------------- |
+| **Permission Node** | A string like `myplugin.feature.use` that represents a specific permission |
+| **Group**           | A named collection of permissions (e.g., "Admin", "VIP", "Default")        |
+| **Provider**        | The backend that stores and retrieves permissions                          |
+| **Wildcard**        | A pattern like `*` or `myplugin.*` that matches multiple permissions       |
+
+### How Permissions Are Checked
+
+When checking if a player has a permission, Hytale follows this order:
+
+1. **User's direct permissions** - Permissions granted directly to the player
+2. **Group permissions** - Permissions from groups the player belongs to
+3. **Virtual groups** - Game-mode-based permissions (e.g., Creative mode grants builder tools)
+4. **Default value** - Falls back to `false` if no match found
+
+<Callout type="info">
+  The first definitive match wins. If a player has a permission granted at the user level, group permissions won't override it.
+</Callout>
+
+---
+
+## The `PermissionsModule` Class
+
+The `PermissionsModule` class is the central hub for managing permissions. Access it using the singleton pattern:
 
 ```java
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.addUserPermission(playerUUID, permissions);
 ```
 
-### Removing Permission Nodes
+### Available Operations
+
+The module supports these operations:
+
+| Operation                     | Method                                          |
+| ----------------------------- | ----------------------------------------------- |
+| Add permissions to user       | `addUserPermission(uuid, permissions)`          |
+| Remove permissions from user  | `removeUserPermission(uuid, permissions)`       |
+| Add permissions to group      | `addGroupPermission(groupName, permissions)`    |
+| Remove permissions from group | `removeGroupPermission(groupName, permissions)` |
+| Add user to group             | `addUserToGroup(uuid, groupName)`               |
+| Remove user from group        | `removeUserFromGroup(uuid, groupName)`          |
+| Get user's groups             | `getGroupsForUser(uuid)`                        |
+| Check permission              | `hasPermission(uuid, permissionNode)`           |
+
+<Callout type="warning">
+  The module does **not** support:
+
+  - Listing all defined groups
+  - Deleting a group entirely
+
+  Groups are implicitly created when you first add permissions to them.
+</Callout>
+
+---
 
-Same as above, we just use the `removeUserPermission` method instead to remove permission nodes.
+## Checking Permissions
+
+The most common operation is checking if a player has a permission.
+
+### Basic Permission Check
+
+```java
+// Returns true if player has the permission, false otherwise
+boolean canUse = PermissionsModule.get().hasPermission(playerUUID, "myplugin.feature.use");
+
+if (canUse) {
+    // Player has permission, allow the action
+} else {
+    // Player lacks permission, deny or show error
+}
+```
+
+### Permission Check with Default Value
+
+You can specify what to return when no permission is explicitly set:
+
+```java
+// Returns true by default if no explicit permission is found
+boolean canUse = PermissionsModule.get().hasPermission(playerUUID, "myplugin.feature.use", true);
+```
+
+This is useful for features that should be enabled by default but can be revoked.
+
+### Using PermissionHolder Interface
+
+Players and command senders implement `PermissionHolder`, allowing direct checks:
+
+```java
+// In a command or event handler where you have access to the player
+if (player.hasPermission("myplugin.admin.manage")) {
+    // Player has admin permission
+}
+```
+
+---
+
+## Managing User Permissions
+
+### Adding Permissions to a User
+
+Permissions are additive - new permissions are added on top of existing ones, not replaced.
+
+```java
+PermissionsModule perms = PermissionsModule.get();
+
+// Add a single permission
+perms.addUserPermission(playerUUID, Set.of("myplugin.vip.chat"));
+
+// Add multiple permissions at once
+Set<String> newPerms = Set.of(
+    "myplugin.vip.chat",
+    "myplugin.vip.fly",
+    "myplugin.vip.kit"
+);
+perms.addUserPermission(playerUUID, newPerms);
+```
+
+### Removing Permissions from a User
 
 ```java
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.removeUserPermission(playerUUID, permissions);
+
+// Remove specific permissions
+Set<String> toRemove = Set.of("myplugin.vip.fly");
+perms.removeUserPermission(playerUUID, toRemove);
 ```
 
-### Add permissions to group
+---
+
+## Managing Groups
+
+Groups let you assign a collection of permissions to multiple players. This is more manageable than assigning permissions individually.
+
+### Adding Permissions to a Group
+
+If the group doesn't exist, it will be created automatically.
 
 ```java
-String groupName = "testGroup";
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.addGroupPermission(groupName, permissions);
+
+// Create/update the "VIP" group with permissions
+Set<String> vipPerms = Set.of(
+    "myplugin.vip.chat",
+    "myplugin.vip.fly",
+    "myplugin.vip.kit"
+);
+perms.addGroupPermission("VIP", vipPerms);
 ```
 
-### Remove permissions from group
+### Removing Permissions from a Group
 
 ```java
-String groupName = "testGroup";
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.removeGroupPermission(groupName, permissions);
+
+// Remove specific permissions from the group
+Set<String> toRemove = Set.of("myplugin.vip.fly");
+perms.removeGroupPermission("VIP", toRemove);
 ```
 
-### Add user to group
+### Adding a User to a Group
 
 ```java
-String groupName = "testGroup";
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.addUserToGroup(playerUUID, groupName);
+
+// Add player to the VIP group - they now have all VIP permissions
+perms.addUserToGroup(playerUUID, "VIP");
 ```
 
-### Remove user from group
+### Removing a User from a Group
 
 ```java
-String groupName = "testGroup";
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.removeUserFromGroup(playerUUID, groupName);
+
+// Remove player from VIP group
+perms.removeUserFromGroup(playerUUID, "VIP");
 ```
 
-### List all groups for a user
+### Getting a User's Groups
 
 ```java
 PermissionsModule perms = PermissionsModule.get();
-perms.getGroupsForUser(playerUUID);
+
+// Get all groups the player belongs to
+Set<String> groups = perms.getGroupsForUser(playerUUID);
+
+for (String group : groups) {
+    System.out.println("Player is in group: " + group);
+}
 ```
 
-### Check Permission Nodes
+---
+
+## Built-in Groups
+
+Hytale includes two default groups:
+
+| Group     | Default Permissions   | Purpose                           |
+| --------- | --------------------- | --------------------------------- |
+| `OP`      | `*` (all permissions) | Server operators with full access |
+| `Default` | None                  | Base group for all players        |
+
+Players without any explicit group assignment are automatically part of the `Default` group.
 
-To check if a player has a specific permission node, you can use the `hasPermission` method.
+---
+
+## Wildcards
+
+Wildcards let you grant or deny multiple permissions with a single pattern.
+
+### Wildcard Patterns
+
+| Pattern             | Meaning                                          |
+| ------------------- | ------------------------------------------------ |
+| `*`                 | Grants **all** permissions                       |
+| `myplugin.*`        | Grants all permissions starting with `myplugin.` |
+| `-*`                | Denies **all** permissions                       |
+| `-myplugin.admin.*` | Denies all admin permissions in your plugin      |
+
+### Example: Admin Group with Wildcards
 
 ```java
-boolean hasPermission = PermissionsModule.hasPermission(playerUUID, "permission.node");
+// Grant all permissions to admins
+perms.addGroupPermission("Admin", Set.of("*"));
+
+// Grant all plugin permissions to moderators
+perms.addGroupPermission("Moderator", Set.of("myplugin.*"));
+
+// Grant all permissions except admin commands
+perms.addGroupPermission("Helper", Set.of(
+    "*",
+    "-myplugin.admin.*"  // Deny admin permissions
+));
 ```
 
-## Additional: Defining your own provider for permissions and groups
+<Callout type="warning">
+  Negation permissions (starting with `-`) take precedence at each level. Use them carefully to avoid accidentally blocking permissions.
+</Callout>
+
+---
+
+## Built-in Permission Nodes
+
+Hytale provides constants for common permissions in the `HytalePermissions` class:
+
+### Command Permissions
+
+```java
+// Generate permission for a command
+String perm = HytalePermissions.fromCommand("gamemode");
+// Result: "hytale.command.gamemode"
+
+// Generate permission for a subcommand
+String perm = HytalePermissions.fromCommand("gamemode", "creative");
+// Result: "hytale.command.gamemode.creative"
+```
+
+### Common Permission Nodes
+
+| Permission                    | Description                  |
+| ----------------------------- | ---------------------------- |
+| `hytale.command.op.add`       | Add players to OP group      |
+| `hytale.command.op.remove`    | Remove players from OP group |
+| `hytale.editor.brush.use`     | Use brush tools              |
+| `hytale.editor.prefab.use`    | Use prefabs                  |
+| `hytale.editor.selection.use` | Use selection tools          |
+| `hytale.editor.history`       | Undo/redo operations         |
+| `hytale.camera.flycam`        | Use fly camera mode          |
+
+---
+
+## Listening to Permission Events
+
+You can react to permission changes using Hytale's event system.
+
+### Available Events
+
+| Event                                            | Triggered When                   |
+| ------------------------------------------------ | -------------------------------- |
+| `PlayerPermissionChangeEvent.PermissionsAdded`   | Permissions added to a user      |
+| `PlayerPermissionChangeEvent.PermissionsRemoved` | Permissions removed from a user  |
+| `PlayerGroupEvent.Added`                         | User added to a group            |
+| `PlayerGroupEvent.Removed`                       | User removed from a group        |
+| `GroupPermissionChangeEvent.Added`               | Permissions added to a group     |
+| `GroupPermissionChangeEvent.Removed`             | Permissions removed from a group |
 
-The PermissionsModule also enables us to define our own PermissionProvider's, this can be useful for:
+### Example: Reacting to Permission Changes
 
-- Cross server permission systems
-- Implementing features missing in the `HytalePermissionsProvider` like permission expiry
+```java
+public class PermissionListener {
+
+    public static void onPermissionsAdded(PlayerPermissionChangeEvent.PermissionsAdded event) {
+        UUID playerUUID = event.getPlayerUuid();
+        Set<String> added = event.getAddedPermissions();
+
+        System.out.println("Permissions added to " + playerUUID + ": " + added);
 
-To implement our PermissionProvider, first we need to define a provider class that implements PermissionProvider:
+        // Maybe notify the player or update cached data
+    }
+
+    public static void onGroupAdded(PlayerGroupEvent.Added event) {
+        UUID playerUUID = event.getPlayerUuid();
+        String groupName = event.getGroupName();
+
+        System.out.println("Player " + playerUUID + " joined group: " + groupName);
+    }
+}
+```
+
+### Registering the Events
 
 ```java
-public class DatabasePermissionProvider implements PermissionProvider
+public class MyPlugin extends JavaPlugin {
+
+    @Override
+    public void setup() {
+        EventRegistry events = this.getEventRegistry();
+
+        events.registerGlobal(
+            PlayerPermissionChangeEvent.PermissionsAdded.class,
+            PermissionListener::onPermissionsAdded
+        );
+
+        events.registerGlobal(
+            PlayerGroupEvent.Added.class,
+            PermissionListener::onGroupAdded
+        );
+    }
+}
 ```
 
-Then we just implement the required methods using a database implementation.
+---
+
+## Creating a Custom Permission Provider
+
+For advanced use cases, you can create your own permission provider. This is useful for:
+
+- Database-backed permissions (MySQL, MongoDB, etc.)
+- Cross-server permission synchronization
+- Custom features like permission expiry or contexts
+
+### Implementing PermissionProvider
+
+```java
+public class DatabasePermissionProvider implements PermissionProvider {
+
+    @Nonnull
+    @Override
+    public String getName() {
+        return "DatabasePermissionProvider";
+    }
+
+    // User permission methods
+    @Override
+    public void addUserPermissions(@Nonnull UUID uuid, @Nonnull Set<String> permissions) {
+        // Save to your database
+    }
+
+    @Override
+    public void removeUserPermissions(@Nonnull UUID uuid, @Nonnull Set<String> permissions) {
+        // Remove from your database
+    }
+
+    @Override
+    public Set<String> getUserPermissions(@Nonnull UUID uuid) {
+        // Query your database
+        return Set.of();
+    }
+
+    // Group permission methods
+    @Override
+    public void addGroupPermissions(@Nonnull String group, @Nonnull Set<String> permissions) {
+        // Save to your database
+    }
+
+    @Override
+    public void removeGroupPermissions(@Nonnull String group, @Nonnull Set<String> permissions) {
+        // Remove from your database
+    }
+
+    @Override
+    public Set<String> getGroupPermissions(@Nonnull String group) {
+        // Query your database
+        return Set.of();
+    }
+
+    // User-group membership methods
+    @Override
+    public void addUserToGroup(@Nonnull UUID uuid, @Nonnull String group) {
+        // Save to your database
+    }
+
+    @Override
+    public void removeUserFromGroup(@Nonnull UUID uuid, @Nonnull String group) {
+        // Remove from your database
+    }
+
+    @Override
+    public Set<String> getGroupsForUser(@Nonnull UUID uuid) {
+        // Query your database
+        return Set.of("Default");
+    }
+}
+```
 
 <Callout type="warning">
-  Hytale will try to use the first available permissions provider to add/remove gamemode groups (i.e. `Creative`, `Adventure`).
+  Hytale automatically assigns players to game-mode groups (like `Creative` or `Adventure`) using the first available provider.
+
+  If your provider throws an error when the group doesn't exist, the player will be disconnected! Always handle missing groups gracefully.
+</Callout>
+
+### Registering Your Provider
 
-  If your provider throws an error (for instance, if the group does not exist) when the server is preparing the player, the player will be disconnected.
+```java
+public class MyPlugin extends JavaPlugin {
+
+    @Override
+    public void setup() {
+        // Add your provider alongside the default one
+        PermissionsModule.get().addProvider(new DatabasePermissionProvider());
+    }
+}
+```
+
+The `PermissionsModule` aggregates permissions from all registered providers. This means:
+
+- Permission checks query all providers
+- Write operations (add/remove) use the **first** provider
+
+### Replacing the Default Provider
+
+If you want full control, you can remove the default provider:
+
+```java
+public class MyPlugin extends JavaPlugin {
+
+    @Override
+    public void setup() {
+        PermissionsModule perms = PermissionsModule.get();
+
+        // Remove the default provider FIRST
+        perms.removeProvider(perms.getFirstPermissionProvider());
+
+        // Then add your provider
+        perms.addProvider(new DatabasePermissionProvider());
+    }
+}
+```
+
+<Callout type="info">
+  When you remove the default provider, the `/op self` command will stop working since it checks for provider tampering.
 </Callout>
 
-We can then register the provider using the built-in permission module:
+---
+
+## Best Practices
+
+### Permission Naming Conventions
+
+Follow the pattern: `namespace.category.action`
 
 ```java
-PermissionsModule.get().addProvider(new DatabasePermissionProvider());
+// Good - clear hierarchy
+"myplugin.admin.ban"
+"myplugin.user.teleport.home"
+"myplugin.vip.chat.color"
+
+// Bad - unclear structure
+"myplugin_ban"
+"teleport"
+"vipChatColor"
 ```
 
-Please note that the `HytalePermissionsProvider` will still be enabled alongside your provider.
-The `PermissionsModule` will aggregate groups and permissions from all available providers.
+### Use Constants for Permissions
 
-If you want to disable the default `HytalePermissionsProvider`, you can use:
+Define your permissions as constants to avoid typos:
 
 ```java
-// put this **before** you add your provider
-PermissionsModule.get().removeProvider(PermissionsModule.get().getFirstPermissionProvider());
+public final class MyPermissions {
+    public static final String ADMIN_BAN = "myplugin.admin.ban";
+    public static final String ADMIN_KICK = "myplugin.admin.kick";
+    public static final String USER_HOME = "myplugin.user.home";
+    public static final String VIP_FLY = "myplugin.vip.fly";
+}
+
+// Usage
+if (player.hasPermission(MyPermissions.ADMIN_BAN)) {
+    // ...
+}
 ```
+
+### Don't Over-Permission
+
+Only create permissions for actions that genuinely need access control. Not everything needs a permission check.
+
+### Thread Safety
+
+If you create a custom provider, ensure it's thread-safe. Permission checks can occur from multiple threads simultaneously. Use `ReadWriteLock` or `ConcurrentHashMap` for your data structures.
+
+---
+
+## In-Game Commands
+
+Hytale provides built-in commands for managing permissions:
+
+### `/op` Command
+
+| Command               | Description                                                        |
+| --------------------- | ------------------------------------------------------------------ |
+| `/op self`            | Toggle your own OP status (singleplayer or with `--allow-op` flag) |
+| `/op add <player>`    | Add a player to the OP group                                       |
+| `/op remove <player>` | Remove a player from the OP group                                  |
+
+### `/perm` Command
+
+Use `/perm --help` in-game for full usage. Common operations:
+
+| Command                                  | Description                   |
+| ---------------------------------------- | ----------------------------- |
+| `/perm user list <uuid>`                 | List user's permissions       |
+| `/perm user add <uuid> <perm>`           | Add permission to user        |
+| `/perm user remove <uuid> <perm>`        | Remove permission from user   |
+| `/perm user group list <uuid>`           | List user's groups            |
+| `/perm user group add <uuid> <group>`    | Add user to group             |
+| `/perm user group remove <uuid> <group>` | Remove user from group        |
+| `/perm group list <group>`               | List group's permissions      |
+| `/perm group add <group> <perm>`         | Add permission to group       |
+| `/perm group remove <group> <perm>`      | Remove permission from group  |
+| `/perm test <perm>`                      | Test if you have a permission |
+
+---
+
+## Summary
+
+You've learned how to:
+
+- **Check permissions** using `PermissionsModule.hasPermission()`
+- **Manage user permissions** with `addUserPermission()` and `removeUserPermission()`
+- **Work with groups** using `addGroupPermission()`, `addUserToGroup()`, etc.
+- **Use wildcards** like `*` and `myplugin.*` for bulk permissions
+- **Listen to events** for permission changes
+- **Create custom providers** for database-backed permissions
+
+For more advanced permission systems with features like inheritance, expiry, and contexts, we're looking into expanding this guide with advanced permission management techniques in the future.
diff --git a/content/docs/nl-NL/guides/plugin/setting-up-env.mdx b/content/docs/nl-NL/guides/plugin/setting-up-env.mdx
index d2718098..5be5e9e0 100644
--- a/content/docs/nl-NL/guides/plugin/setting-up-env.mdx
+++ b/content/docs/nl-NL/guides/plugin/setting-up-env.mdx
@@ -4,6 +4,10 @@ description: Learn how to set up your development environment for modding Hytale
 authors:
   - name: Neil Revin
     link: https://itsneil.dev
+  - name: Marcel-TO
+    url: https://marcel-to.net
+  - name: Ádám Liszkai
+    link: https://adaliszk.dev
 ---
 
 This guide will walk you through setting up a complete development environment for Hytale modding, including all necessary tools and dependencies.
@@ -19,24 +23,73 @@ Before we begin, make sure you have:
 
 ## Required Software
 
-### 1. Java Development Kit (JDK)
+### Integrated Development Environment (IDE)
 
+We recommend IntelliJ IDEA Community Edition for Hytale modding. If you use IntelliJ IDEA, **almost everything is built-in**. You can clone a template, open a new project, and start working right away!
+
+1. Download from [JetBrains website](https://www.jetbrains.com/idea/download/)
+2. Install with default settings
+3. Launch and complete the initial setup wizard
+
+When opening a project, wait for indexing to finish, then start coding.
+Now, IDEA may say "No JDK configured" at the top of the source file you have.
+In that case, you can click Download JDK and choose JetBrains JDK 25.
+
+<Callout type="success">
+  If IDEA opened the project without errors, your environment is ready.
+</Callout>
+
+More details by [JetBrains](https://www.jetbrains.com/help/idea/2026.1/run-for-the-first-time.html)
+help page, where we recommend that you also check the
+[SDK configuration](https://www.jetbrains.com/help/idea/2026.1/sdk.html) guide.
+
+<Callout type="info">
+  We recommened following
+  [TheNullicorn's](https://gist.github.com/TheNullicorn/90a619796c40f20ae1fcf13094c1a57d) guide to ensure
+  you are using the correct `Nonnull` in your projects.
+</Callout>
+
+#### What the IDE Does for You
+
+When opened in IntelliJ IDEA, the project automatically:
+
+- Detects and configures Gradle or Maven
+- Downloads all dependencies
+- Sets up project structure and classpaths
+- Configures run/build tasks
+
+You do **not** need to manually install or configure Maven or Gradle if you stay inside the IDE.
+
+Skip to the [Setting Up Your Workspace](#setting-up-your-workspace).
+
+### Manual Setup: Java Development Kit (JDK)
+
+For any other setup, you will need to install and configure your system to have and load Java.
 Hytale modding requires Java 25 or later. We recommend using OpenJDK.
 
-#### Windows
+#### Windows via Installer
 
 1. Download OpenJDK 25 from [Adoptium](https://adoptium.net/)
 2. Run the installer with default settings
+   - Optionally enable feature `Set or Override JAVA_HOME variable` to resolve version related build issues with your project.
 3. Verify installation by opening Command Prompt and running:
 
+#### Windows via Scoop
+
+1. Install Scoop via PowerShell using [scoop.sh](https://scoop.sh/)
+2. Install OpenJDK 25:
+
 ```bash
-java -version
+scoop bucket add java
+scoop install java/openjdk25
 ```
 
 #### macOS
 
+1. Install Brew via Terminal using [brew.sh](https://brew.sh)
+2. Install JDK via Homebrew:
+
 ```bash
-# Using Homebrew
 brew install openjdk@25
 ```
 
@@ -51,22 +104,41 @@ brew install openjdk@25
 
 #### Linux (Ubuntu/Debian)
 
+1. Install JDK via the built-in package repository:
+
 ```bash
 sudo apt update
 sudo apt install openjdk-25-jdk
 ```
 
-### 2. Integrated Development Environment (IDE)
+### Verify installation:
 
-We recommend IntelliJ IDEA Community Edition for Hytale modding.
+Run the following command to see what version of Java you have:
 
-1. Download from [JetBrains website](https://www.jetbrains.com/idea/download/)
-2. Install with default settings
-3. Launch and complete the initial setup wizard
+```bash
+java -version
+```
+
+### Java Build Tool (Optional)
+
+We recommend using a Gradle Wrapper for managing dependencies and building your Hytale plugins. It provides benefits by eliminating the need for a system-wide Gradle installation and ensuring consistent Gradle versions across different environments. (Alternatively you can use Maven, but this guide focuses on Gradle since it is the default for our plugin template.)
+
+The plugin template in the following sections includes a Gradle Wrapper, so you can skip this step if you plan to use the template.
+
+#### Choosing Gradle (if not using the template)
+
+If you prefer to install Gradle manually, follow these steps:
 
-### 3) Java Build Tool
+1. Visit the official website: https://gradle.org/releases/
+2. Download the newest gradle binary: `gradle-9.3.1-bin.zip` (Binary zip archive)
+3. Unzip it
+4. Add the `gradle-9.3.1/bin/` folder to your PATH
+
+You can now try the command `gradle -version` to verify Gradle is installed correctly. Make sure to do this in a fresh new terminal instead of one you had opened from before!
+
+#### Choosing Maven (if not using the template)
 
-We recommend using Apache Maven for managing dependencies and building your Hytale plugins. (Alternatively you can use Gradle, but this guide focuses on Maven.)
+If you prefer to use Maven instead of Gradle, follow these steps to install Maven:
 
 1. Visit the official website: https://maven.apache.org/download.cgi
 2. Download this file: `apache-maven-3.9.12-bin.zip` (Binary zip archive)
@@ -89,22 +161,61 @@ cd MyFirstMod
 
 If you don't have Git installed, you can download the ZIP file from the repository page and extract it to a folder named `MyFirstMod`.
 
-### 2. Open Plugin in your IDEA
+### 2. Open Plugin in your IDE
 
-1. Open IntelliJ IDEA
+1. Open Your IDE (e.g., IntelliJ IDEA)
 2. Click "Open" and navigate to your `MyFirstMod` directory
-3. IntelliJ will automatically detect it as a Maven project
+3. Most IDEs like IntelliJ will automatically detect it as a Gradle project
 4. Wait for the project to index and dependencies to download
 
-<Callout type="info">
-  We recommened following [this](https://gist.github.com/TheNullicorn/90a619796c40f20ae1fcf13094c1a57d) guide to ensure you are using the correct `Nonnull` in your projects.
-</Callout>
+## Alternate Approach: Hytale Dependency
+
+If you prefer to set up your project from scratch without using the template and importing the hytale dependencies manually, ensure your build configuration includes the Hytale repositories and dependencies:
+
+For Gradle, add the following to your `build.gradle.kts`:
+
+```kotlin
+repositories {
+    mavenCentral()
+    maven {
+        name = "hytale"
+        url = uri("https://maven.hytale.com/release") // Or "hytale-pre-release" for pre-release versions
+    }
+}
+dependencies {
+    // + here means the latest version, but you can hard-wire any known version!
+    implementation("com.hypixel.hytale:Server:+")
+}
+```
+
+For Maven, add the following to your `pom.xml`:
+
+```xml
+<project>
+    <repositories>
+        <repository>
+            <id>hytale-release</id> <!-- Or "hytale-pre-release" for pre-release versions -->
+            <url>https://maven.hytale.com/release</url> <!-- Or "https://maven.hytale.com/pre-release" -->
+        </repository>
+    </repositories>
+
+    <dependencies>
+        <dependency>
+            <groupId>com.hypixel.hytale</groupId>
+            <artifactId>Server</artifactId>
+            <!-- Replace with latest version, Hytale provides jars for the last five releases -->
+            <version>LATEST_VERSION_HERE</version>
+            <scope>provided</scope>
+        </dependency>
+    </dependencies>
+</project>
+```
 
 ## Next Steps
 
 Now that you have your development environment set up with the plugin template:
 
-1. **Customize the template** - Edit the `pom.xml` and `manifest.json` file to change your mod's name and details
+1. **Customize the template** - Edit the `settings.gradle.kts`, `build.gradle.kts` and `manifest.json` file to change your mod's name and details
 2. **Explore the code structure** - Familiarize yourself with the template's organization
 3. **Start modding** - Begin writing your first Hytale plugin!
 
diff --git a/content/docs/nl-NL/guides/plugin/spawning-entities.mdx b/content/docs/nl-NL/guides/plugin/spawning-entities.mdx
index e12c0aea..15be2fb3 100644
--- a/content/docs/nl-NL/guides/plugin/spawning-entities.mdx
+++ b/content/docs/nl-NL/guides/plugin/spawning-entities.mdx
@@ -36,7 +36,7 @@ Store<EntityStore> store = world.getEntityStore().getStore();
 
 ## Creating Entities
 
-Once you have the `EntityStore` instance, you can start to create a entity and give it components. Entities are just instances of `Holder<EntityStore>` with several components attached to them.
+Once you have the `EntityStore` instance, you can start to create an entity and give it components. Entities are just instances of `Holder<EntityStore>` with several components attached to them.
 
 <Callout type="warning">
   To interact with the `World` instance, some methods require you to run the code inside the world's execution context.
@@ -118,3 +118,48 @@ Finally, we can add the entity to the world by calling the `addEntity` method on
 ```java
 store.addEntity(holder, AddReason.SPAWN);
 ```
+
+## Making the entity persist
+
+Hytale automatically saves all entities, but the `NetworkId` component (required for players to be able to see the entity) needs to be manually added every time the entity is loaded.
+
+### Using a system
+
+If you have a component that is unique to your entities, this can be done by creating and registering a custom system as follows:
+
+```java
+public class AddNetworkIdToMyEntitySystem extends HolderSystem<EntityStore> {
+    private final ComponentType<EntityStore, MyEntityComponent> myEntityComponentType = MyEntityComponent.getComponentType();
+    private final ComponentType<EntityStore, NetworkId> networkIdComponentType = NetworkId.getComponentType();
+    private final Query<EntityStore> query = Query.and(this.myEntityComponentType, Query.not(this.networkIdComponentType));
+
+    @Override
+    public void onEntityAdd(@NotNull Holder<EntityStore> holder, @NotNull AddReason reason, @NotNull Store<EntityStore> store) {
+        if (!holder.getArchetype().contains(NetworkId.getComponentType())) {
+            holder.addComponent(NetworkId.getComponentType(), new NetworkId(store.getExternalData().takeNextNetworkId()));
+        }
+    }
+
+    @Override
+    public void onEntityRemoved(@NotNull Holder<EntityStore> holder, @NotNull RemoveReason reason, @NotNull Store<EntityStore> store) {}
+
+    @Override
+    public @Nullable Query<EntityStore> getQuery() {
+        return query;
+    }
+}
+```
+
+In your plugin's `setup()` function
+
+```java
+this.getEntityStoreRegistry().registerSystem(new AddNetworkIdToMyEntitySystem())
+```
+
+### Using PropComponent
+
+Alternatively you can add `PropComponent` to your entity. Hytale adds `PropComponent` to entities spawned with the Entity Tool, and such entities automatically get `NetworkId` and `PrefabCopyableComponent` (which makes the entity work with prefabs).
+
+<Callout type="warning">
+  There is no guarantee, that Hytale will not add some other behavior to this component in the future, which may break your entity, so be careful if you decide to rely on it.
+</Callout>
diff --git a/content/docs/nl-NL/guides/plugin/store-persistent-data.mdx b/content/docs/nl-NL/guides/plugin/store-persistent-data.mdx
new file mode 100644
index 00000000..1071dff3
--- /dev/null
+++ b/content/docs/nl-NL/guides/plugin/store-persistent-data.mdx
@@ -0,0 +1,171 @@
+---
+title: Storing Persistent Data on the Player
+description: Learn how to save and load persistent data using Components
+authors:
+  - name: Neil Revin
+    url: https://itsneil.dev/
+  - name: ArcticDev
+    url: https://github.com/ArcticRaven
+  - name: oskarscot
+    url: https://oskar.scot
+  - name: JammingEng
+    url: https://github.com/JammingEnd
+---
+
+Here is how to store persistent data using a custom component on a Player.
+
+## Build your Component Class
+
+Creating a custom component class leverages the Component system made with the ECS architecture in mind. For more information on Components, check out the [ECS Guide](../ecs/hytale-ecs-theory#components).
+
+Start by creating your custom component class. This will be extremely similar to how regular components are created, however we'll setup a custom Codec so the server can translate this data to BSON, or the server's internal json encoder.
+
+<Callout type="info">
+  Each variable you want to store in your component must have its own Codec field defined in the BuilderCodec.
+  For more information on how to create custom Codecs, check out the [ECS Codec Guide](../ecs/hytale-ecs-theory#codec).
+</Callout>
+
+```java
+public class YourPlayerData implements Component<EntityStore> {
+
+    // define some vars!
+    private int someInteger;
+    private String someString;
+    private Map<String, String> someMap;
+
+    public static final BuilderCodec<YourPlayerData> CODEC =
+            BuilderCodec.builder(YourPlayerData.class, YourPlayerData::new)
+            .append(new KeyedCodec<>("SomeInteger", Codec.INTEGER),
+                    (data, value) -> data.someInteger = value, // setter
+                    data -> data.someInteger) // getter
+            .addValidator(Validators.nonNull())
+            .add()
+            .append(new KeyedCodec<>("SomeString", Codec.STRING),
+                    (data, value) -> data.someString = value, // setter
+                    data -> data.someString) // getter
+            .add()
+            .append(new KeyedCodec<>("SomeMap",
+                            new MapCodec<>(Codec.STRING, HashMap::new, false)),
+                    (data, value) -> data.someMap = value, // setter
+                    data -> data.someMap) // getter
+            .add()
+            .build();
+
+
+
+    // Getters and Setters are for the purpose of this example omitted.
+
+    // constructor
+    public YourPlayerData() {
+        this.someInteger = 0;
+        this.someString = "";
+        this.someMap = new HashMap<>();
+    }
+
+    // copy constructor for cloning
+    public YourPlayerData(YourPlayerData clone) {
+        this.someInteger = clone.someInteger;
+        this.someString = clone.someString;
+        this.someMap = clone.someMap;
+    }
+
+    @Nonnull
+    @Override
+    public Component<EntityStore> clone() {
+        return new YourPlayerData(this);
+    }
+}
+```
+
+## Register your Component
+
+Inside your main class's `setup()` method, register your new Component.
+
+```java
+public class YourPlugin extends JavaPlugin {
+
+    private ComponentType<EntityStore, YourPlayerData> yourPlayerDataComponent;
+
+    public YourPlugin(@Nonnull JavaPluginInit init) {
+        super(init);
+    }
+
+    @Override
+    protected void setup(){
+        this.yourPlayerDataComponent = this.getEntityStoreRegistry().registerComponent(
+            YourPlayerData.class,
+            "YourPlayerDataComponent",
+            YourPlayerData.CODEC
+        );
+    }
+
+    public ComponentType<EntityStore, YourPlayerData> getYourPlayerDataComponent() {
+        return this.yourPlayerDataComponent;
+    }
+}
+```
+
+## Using your Component
+
+To use your newly created component, you can add the Component to a player using the `addComponent` method, although this only adds it temporarily, meaning when the player/entity leaves the world, the component is removed. You can use `putComponent` to ensure the component persists between sessions.
+
+```java
+// You will need the Ref and Store to apply components
+private void someEntryMethod(@Nonnull Ref<EntityStore> ref, @Nonnull Store<EntityStore> store)
+{
+       // Any entity will work, for now we will use the player
+      Player player = (Player) store.getComponent(ref, Player.getComponentType());
+
+      // since we're using putComponent, it could be useful to check if it already exists on the player in case we want to update it
+     if(store.getComponent(ref, YourPlugin.instance().getYourPlayerDataComponent()) != null)
+     {
+          // here we implement logic that updates the component
+         var comp = store.getComponent(ref, YourPlugin.instance().getYourPlayerDataComponent())
+         // declare public fields or methods in the component class
+         comp.SomeString = "An Updated Field";
+     } else {
+          // Here we put the component
+          var myCustomComp = new CustomComponent();
+          // declare public fields or methods in the component class
+          myCustomComp.SomeString = "Edited String";
+
+          // putComponent allows you to insert declared objects
+          store.putComponent(ref, YourPlugin.instance().getYourPlayerDataComponent(), myCustomComp);
+     }
+}
+```
+
+## Using your Data
+
+Your component will be stored within the `Store<EntityStore>` when added to the player. In the provided example,
+we'll fetch this data off the player using the `ensureAndGetComponent()` method, which will add the component to
+the player if it does not exist with the default values.
+
+```java
+public class IncompleteCustomCommand extends AbstractPlayerCommand {
+
+    public IncompleteCustomCommand() {
+        super("nope", "don't use this command");
+    }
+
+    @Override
+    protected void execute(
+        @NonNullDecl CommandContext commandContext,
+        @NonNullDecl Store<EntityStore> store,
+        @NonNullDecl Ref<EntityStore> ref,
+        @NonNullDecl PlayerRef playerRef,
+        @NonNullDecl World world
+    ) {
+        YourPlayerData customData = store.ensureAndGetComponent(ref, YourPlugin.instance().getYourPlayerDataComponent());
+        // ensureAndGetComponent adds the component to the ref, with the default values defined inside your component.
+ 		// use your data
+    }
+}
+```
+
+And that's it! Your data will now be saved and loaded automatically with the player.
+
+Using custom components to store persistent data on players is a powerful way to maintain state across sessions.
+By following the steps outlined above, you can easily create, register, and utilize your own data structures within the Hytale ECS framework.
+This approach ensures that your data is seamlessly integrated with the game's existing systems.
+For more information about Hytale's Entity Component System visit the [Hytale ECS Theory](https://hytalemodding.dev/en/docs/guides/ecs/hytale-ecs-theory) guide.
diff --git a/content/docs/nl-NL/guides/plugin/teleporting-players.mdx b/content/docs/nl-NL/guides/plugin/teleporting-players.mdx
index 57cee77f..32ce0435 100644
--- a/content/docs/nl-NL/guides/plugin/teleporting-players.mdx
+++ b/content/docs/nl-NL/guides/plugin/teleporting-players.mdx
@@ -1,26 +1,32 @@
 ---
 title: Teleporting the player
 description: Learn how to teleport the player.
+authors:
+  - name: oskarscot
+    url: https://oskar.scot
 ---
 
-To teleport players in Hytale, you will need to get a `World` object so we can safely run the teleport on the world thread. The world thread manages all entity updates, so modifying entities off-thread can crash the server or cause inconsistent state.
-Next, we get the entity store and make a `Teleport` object.
-We add a `Teleport` component to the player’s entity reference in the entity store. This triggers the teleportation logic for that player.
+Teleporting players in Hytale works by simply attaching a `Teleport` component to a player with the desired world and transform.
+You can only trigger teleports from a world where the player is currently present.
+Teleport itself is a component but it also provides factory methods to configure the Teleport. Just as with any entity component, an EntityStore and a Ref to the EntityStore is required
+
+We can create a simple teleport utility like this:
 
 ```java
-public static void teleportPlayer(Player player, int x, int y, int z) {
-        World world = player.getWorld();
-        if (world == null) return;
-        world.execute(() -> {
-            if (player.getReference() == null) return;
-            Store<EntityStore> store = player.getReference().getStore();
-            Teleport teleport = Teleport.createForPlayer(world,
-                new Vector3d(x ,y, z), // Target position
-                new Vector3f(0, 0, 0)  // Target rotation (pitch, yaw, roll)
-            );
+public static void teleportPlayer(Ref<EntityStore> ref, Store<EntityStore> store, World targetWorld, double x, double y, double z) {                                                                                       
+    Transform transform = new Transform(x, y, z);                                                                                                                           
+    Teleport teleport = Teleport.createForPlayer(targetWorld, transform);                                                                                                   
+    store.addComponent(ref, Teleport.getComponentType(), teleport);                                                                                                         
+}  
+```
 
-            store.addComponent(player.getReference(), Teleport.getComponentType(), teleport);
-        });
+A `Transform` is a representation of a position Vector3d and rotation Vector3f which works in the following way:
 
-}
+```java
+Transform transform = new Transform(
+    new Vector3d(x, y, z),      // Position
+    new Rotation(yaw, pitch, 0) // Rotation, last value seems to always be 0
+);
+Teleport teleport = Teleport.createForPlayer(targetWorld, transform);
+store.addComponent(ref, Teleport.getComponentType(), teleport);
 ```
diff --git a/content/docs/nl-NL/guides/plugin/tracking-mod-analytics-with-hstats.mdx b/content/docs/nl-NL/guides/plugin/tracking-mod-analytics-with-hstats.mdx
new file mode 100644
index 00000000..45c022e0
--- /dev/null
+++ b/content/docs/nl-NL/guides/plugin/tracking-mod-analytics-with-hstats.mdx
@@ -0,0 +1,65 @@
+---
+title: Tracking Mod Analytics with HStats
+description: Learn how you can track Analytics for your Hytale Mod for Free using hstats.dev
+authors:
+  - name: Al3x
+    url: https://hstats.dev
+---
+
+In this guide, you will learn how to integrate HStats into your Plugin/Mod which will allow you to track how many Servers are using it along with other stats.
+
+<Callout type="info">
+  HStats is a third-party tool and is not affiliated with HytaleModding or Hypixel Studios
+</Callout>
+
+# Step 1: Register your Mod to HStats
+
+Before you touch any code, you will need to add your mod to the HStats website which will give you a UUID for your mod.
+
+- Create or Login to an Account on https://hstats.dev
+- Navigate to the dashboard page (https://hstats.dev/dashboard)
+- On the left, type in your mod's name and click "Add Mod"
+- Keep note of the UUID generated for later.
+
+# Step 2: Add the HStats Class to Your Project
+
+To keep things simple, HStats uses a single Java class file that handles everything for you.
+
+- Download / Copy the File from the GitHub page (https://github.com/hstats-dev/HStatsExamplePlugin/blob/main/src/main/java/com/al3x/HStats.java)
+- Paste into your Project. You should now have a HStats.java file somewhere in your projects directory.
+- Update the package name from com.al3x to whatever fits your project.
+
+# Step 3: Initialize HStats in your code
+
+You only need to add one line of code to your mod's setup method in your main class to start tracking.
+
+`new HStats("YOUR-MOD-UUID", "1.0.0");`
+
+Replace `YOUR-MOD-UUID` with the Mod UUID we made note of earlier and change the `1.0.0` version to whatever version your mod is currently on.
+
+Your setup method should now look something like this:
+
+```java
+@Override
+protected void setup() {
+  super.setup();
+  new HStats("c34a2b2a-afd8-4d6a-821e-7a63e12c5ea6", "1.0.0");
+}
+```
+
+# Extras
+
+Your done! Your mod should now be listed under the Mods page (https://hstats.dev/mods) as well as under your dashboard.
+
+Servers using your mod should now post updates about every minute to HStats which you can view in the Dashboard.
+
+### Embeds
+
+HStats allows you to generate an Embed Card that you can place on your CurseForge or GitHub page. This is useful for server owners to be able to see how many other servers are using your mod.
+
+- In your dashboard, scroll down to the Embed Card section.
+- Customize the appearance (Light/Dark mode, layout, etc).
+- Copy the generated URL to display your "Active Servers" and "Players Online" live on your mod's description page
+
+Heres an example of what they look like:
+![HStats Example](https://api.hstats.dev/api/embed/d52fa672-6966-47b2-b501-1a11bddebac3/card.svg?theme=light\&layout=compact\&size=md\&show_id=true\&dark=false)
diff --git a/content/docs/nl-NL/guides/plugin/world-gen.mdx b/content/docs/nl-NL/guides/plugin/world-gen.mdx
index 4c23b0c9..7b193ffd 100644
--- a/content/docs/nl-NL/guides/plugin/world-gen.mdx
+++ b/content/docs/nl-NL/guides/plugin/world-gen.mdx
@@ -100,7 +100,7 @@ Biome biome = biomeGen.generateBiomeAt(zoneResult, seed, x, z);
 
 ### Zone & Cave Integration
 
-Each zone defines it's own cave patterns:
+Each zone defines its own cave patterns:
 
 ```java
 Zone zone = /* ... */;
diff --git a/content/docs/nl-NL/guides/prefabs.mdx b/content/docs/nl-NL/guides/prefabs.mdx
index 08404b30..b1a55109 100644
--- a/content/docs/nl-NL/guides/prefabs.mdx
+++ b/content/docs/nl-NL/guides/prefabs.mdx
@@ -14,7 +14,7 @@ Prefabs are Hytale's way of creating reusable structures.
 There are a few fundamental concepts to understand about prefabs:
 
 - Users interact with prefabs via a prefab editing world.
-- Prefabs the physical structures in the game world, and are saved as JSON files.
+- Prefabs are the physical structures in the game world, and are saved as JSON files.
 
 ## How to Create a Prefab
 
diff --git a/content/docs/nl-NL/official-documentation/custom-ui/common-styling.mdx b/content/docs/nl-NL/official-documentation/custom-ui/common-styling.mdx
new file mode 100644
index 00000000..c36e3e3a
--- /dev/null
+++ b/content/docs/nl-NL/official-documentation/custom-ui/common-styling.mdx
@@ -0,0 +1,50 @@
+---
+title: Common Styling
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# Common Styling
+
+## Common UI Styling Library
+
+This document describes the shared UI components and styles defined in `Common.ui`.
+
+---
+
+### Styles
+
+We are providing some styles that can be re-used in any custom UI that, provide a cohesive UI experience with the core game UI. These styles are available in the `Common.ui` file.
+
+You can find a list of all the styles defined with live examples by running the `/ui-gallery` command ingame.
+
+<Callout type="warning">
+  This command is not available yet, but will be in a future patch.
+</Callout>
+
+![Gallery](/assets/official-documentation/ui/gallery.png)
+
+### Importing
+
+To use these styles in your UI file:
+
+```
+$Common = "Common.ui";
+
+// Then reference styles and components:
+$Common.@TextButton { @Text = "My Button"; }
+$Common.@Container { ... }
+```
+
+<Callout type="info">
+  The `Common.ui` file is at `Common/UI/Custom/Common.ui` within the Hytale pack. If your custom ui document is in a subfolder of `Common/UI/Custom/`, reference it via relative path traversal:
+
+  ```
+  $Common = "../Common.ui";
+  ```
+
+  You can find more info about paths [here](markup#path).
+</Callout>
diff --git a/content/docs/nl-NL/official-documentation/custom-ui/index.mdx b/content/docs/nl-NL/official-documentation/custom-ui/index.mdx
new file mode 100644
index 00000000..f94c4e88
--- /dev/null
+++ b/content/docs/nl-NL/official-documentation/custom-ui/index.mdx
@@ -0,0 +1,125 @@
+---
+title: Custom UI
+icon: LayoutDashboard
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# Custom UI
+
+## What is Custom UI?
+
+Custom UI is Hytale's framework for creating **custom user interfaces** controlled by the game server. Unlike the built-in Client UI (which is part of the game client and cannot be modified), Server UI allows you to create interactive screens and HUD overlays through Java plugins and asset packs.
+
+As a modder, Custom UI gives you the power to:
+
+- **Create custom interactive pages** - Shop interfaces, quest dialogs, server settings menus, admin panels
+- **Add custom HUD overlays** - Quest trackers, status displays, custom health bars, server information
+- **Design with markup** - Use `.ui` files to define reusable UI templates
+- **Handle user interactions** - Respond to button clicks, form submissions, and other events
+- **Localize your UI** - Support multiple languages using the game's translation system
+
+## How Custom UI Fits Into Hytale's UI
+
+Hytale's user interface is divided into two main categories:
+
+### Client UI (Not Moddable)
+
+Built-in interfaces controlled by the C# game client:
+
+- Main menu and settings
+- Character creation
+- Built-in HUD (health, hotbar, chat)
+- Inventory and crafting screens
+- Development tools
+
+**You cannot modify these** - they are part of the core game client.
+
+### In-Game UI (Moddable via Server)
+
+Server-controlled interfaces that you can create and customize:
+
+#### Custom Pages
+
+Full-screen interactive overlays that appear during gameplay:
+
+- Can be dismissed by the player (ESC key)
+- Capture all input (keyboard and mouse)
+- Support loading states while waiting for server responses
+- Perfect for: shops, dialogs, menus, configuration screens
+
+#### Custom HUDs
+
+Persistent overlay elements drawn on top of the game world:
+
+- Display-only (no user interaction)
+- Always visible during gameplay
+- Lightweight and non-intrusive
+- Perfect for: quest objectives, status indicators, server info panels
+
+## Architecture Overview
+
+Server UI uses a **command-based architecture**:
+
+```
+┌─────────────────────┐         ┌──────────────────────┐
+│   Java Server       │         │    C# Client         │
+│   (Your Plugin)     │         │    (Game)            │
+├─────────────────────┤         ├──────────────────────┤
+│                     │         │                      │
+│ InteractiveCustomUI │         │   CustomPage or      │
+│ Page                │         │   CustomHud          │
+│   ↓ build()         ├────────→│     ↓ Apply          │
+│ UICommandBuilder    │         │   Element Tree       │
+│   - append()        │         │     ↓ Layout         │
+│   - set()           │         │   Rendered UI        │
+│   - clear()         │         │                      │
+│                     │         │                      │
+│ ↓ handleDataEvent() │← Events │   User Interaction   │
+│   Process input     │         │   (click, type, etc) │
+│   sendUpdate()      │         │                      │
+└─────────────────────┘         └──────────────────────┘
+```
+
+**The flow:**
+
+1. Your Java code builds UI using `UICommandBuilder`
+2. Commands are sent to the client as data
+3. Client parses `.ui` markup files and creates visual elements
+4. User interacts with the UI
+5. Events are sent back to your Java code
+6. You process events and send updates back
+
+## Key Principles
+
+### Declarative, Not Imperative
+
+You don't create UI objects directly. Instead, you send **commands** that describe what you want:
+
+- "Append this button template to that container"
+- "Set this label's text to 'Hello World'"
+- "Clear all children from this list"
+
+### Asset-Driven
+
+UI structure is defined in `.ui` markup files (assets), not hardcoded in Java. This enables:
+
+- Designers to modify layouts without touching code
+- Reusable UI components
+- Consistent visual language
+
+### Event-Driven
+
+User interactions trigger events that flow back to your server code. You register event bindings and handle them in `handleDataEvent()`.
+
+### Selector-Based
+
+You target specific UI elements using **selectors:**
+
+- `#MyButton` - Element with ID "MyButton"
+- `#List[0]` - First child of element "List"
+- `#List[0] #Title` - Element with ID "Title" in the first child of element "List"
+- `#Label.TextColor` - The TextColor property of element "Label"
diff --git a/content/docs/nl-NL/official-documentation/custom-ui/layout.mdx b/content/docs/nl-NL/official-documentation/custom-ui/layout.mdx
new file mode 100644
index 00000000..0a24ca09
--- /dev/null
+++ b/content/docs/nl-NL/official-documentation/custom-ui/layout.mdx
@@ -0,0 +1,492 @@
+---
+title: Layout
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# Layout
+
+The layout system determines how UI elements are positioned and sized on screen. Understanding layout is crucial for creating well-structured, responsive interfaces.
+
+## Layout Fundamentals
+
+Every UI element has:
+
+- **Container Rectangle** - The space allocated by the parent
+- **Anchor** - How the element positions/sizes itself within the container
+- **Padding** - Inner spacing that affects child layout
+- **LayoutMode** - How the element arranges its children (if it's a container)
+
+```
+┌─────────────────────────────────────┐
+│  Container Rectangle (from parent)  │
+│  ┌───────────────────────────────┐  │
+│  │  Anchored Rectangle           │  │
+│  │  ┌─────────────────────────┐  │  │
+│  │  │ Padding                 │  │  │
+│  │  │  ┌───────────────────┐  │  │  │
+│  │  │  │  Content Area     │  │  │  │
+│  │  │  └───────────────────┘  │  │  │
+│  │  └─────────────────────────┘  │  │
+│  └───────────────────────────────┘  │
+└─────────────────────────────────────┘
+```
+
+## Anchor
+
+`Anchor` controls how an element positions and sizes itself within its container rectangle.
+
+### Fixed Size
+
+```
+Button {
+    Anchor: (Width: 200, Height: 40);
+}
+```
+
+Creates a 200×40 pixel button.
+
+### Positioning
+
+```
+Label {
+    Anchor: (Top: 10, Left: 20, Width: 100, Height: 30);
+}
+```
+
+- **Top**: 10 pixels from container's top edge
+- **Left**: 20 pixels from container's left edge
+- **Width**: 100 pixels wide
+- **Height**: 30 pixels tall
+
+### Anchoring to Edges
+
+```
+Button {
+    Anchor: (Bottom: 10, Right: 10, Width: 100, Height: 30);
+}
+```
+
+Anchors the button to the bottom-right corner, 10 pixels from each edge.
+
+### Stretching
+
+```
+Group {
+    Anchor: (Top: 0, Bottom: 0, Left: 0, Right: 0);
+}
+```
+
+Stretches to fill the entire container (all edges at 0 pixels).
+
+**Shorthand:**
+
+```
+Group {
+    Anchor: (Full: 0);
+}
+```
+
+### Mixed Anchoring
+
+```
+Panel {
+    Anchor: (Top: 10, Bottom: 10, Left: 20, Width: 300);
+}
+```
+
+- Fixed width of 300 pixels
+- Stretches vertically between top and bottom edges
+- 10 pixels from top and bottom
+- 20 pixels from left
+
+## Padding
+
+`Padding` creates inner spacing, affecting where children are positioned.
+
+### Uniform Padding
+
+```
+Group {
+    Padding: (Full: 20);
+}
+```
+
+20 pixels of padding on all sides.
+
+### Directional Padding
+
+```
+Group {
+    Padding: (Top: 10, Bottom: 20, Left: 15, Right: 15);
+}
+```
+
+Different padding per edge.
+
+### Shorthand
+
+```
+// Horizontal and vertical
+Group {
+    Padding: (Horizontal: 20, Vertical: 10);
+}
+
+// Equivalent to:
+// Top: 10, Bottom: 10, Left: 20, Right: 20
+```
+
+### Effect on Children
+
+```
+Group {
+    Anchor: (Width: 200, Height: 100);
+    Padding: (Full: 10);
+
+    Label {
+        Anchor: (Full: 0);
+    }
+}
+```
+
+The label fills the group, but there's a 10-pixel gap on all sides due to padding.
+
+```
+┌──────────────────────┐
+│ Group (200×100)      │
+│  ┌────────────────┐  │
+│  │ Label          │  │ ← 10px padding all around
+│  │                │  │
+│  └────────────────┘  │
+└──────────────────────┘
+```
+
+## LayoutMode
+
+`LayoutMode` determines how a container arranges its children.
+
+### Top (Vertical Stack)
+
+```
+Group {
+    LayoutMode: Top;
+
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+}
+```
+
+Children stack vertically from top to bottom:
+
+```
+┌──────────┐
+│ Button 1 │
+├──────────┤
+│ Button 2 │
+├──────────┤
+│ Button 3 │
+└──────────┘
+
+
+```
+
+Each child's `Anchor.Bottom` adds spacing between elements:
+
+```
+Button { Anchor: (Height: 30, Bottom: 10); }  // 10px gap after this button
+```
+
+### Bottom (Vertical Stack)
+
+```
+Group {
+    LayoutMode: Bottom;
+
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+}
+```
+
+Children stack vertically from top to bottom but aligned to the bottom edge of the parent:
+
+```
+
+
+
+┌──────────┐
+│ Button 1 │
+├──────────┤
+│ Button 2 │
+├──────────┤
+│ Button 3 │
+└──────────┘
+```
+
+### Left (Horizontal Stack)
+
+```
+Group {
+    LayoutMode: Left;
+
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+}
+```
+
+Children arrange horizontally from left to right:
+
+```
+┌────────┬────────┬────────┐
+│ Button │ Button │ Button │
+│   1    │   2    │   3    │
+└────────┴────────┴────────┘
+```
+
+Use `Anchor.Right` for spacing between elements.
+
+### Right (Horizontal Stack)
+
+```
+Group {
+    LayoutMode: Right;
+
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+}
+```
+
+Children arrange horizontally from left to right but aligned to the right side of the parent:
+
+```
+                                                                 ┌────────┬────────┬────────┐
+                                                                 │ Button │ Button │ Button │
+                                                                 │   1    │   2    │   3    │
+                                                                 └────────┴────────┴────────┘
+```
+
+### Center
+
+```
+Group {
+    LayoutMode: Center;
+
+    Group #Dialog {
+        Anchor: (Width: 400, Height: 300);
+    }
+}
+```
+
+Centers the children horizontally.
+
+### Middle
+
+```
+Group {
+    LayoutMode: Middle;
+
+    Group #Dialog {
+        Anchor: (Width: 400, Height: 300);
+    }
+}
+```
+
+Centers the children vertically.
+
+### CenterMiddle (Horizontal Stack, Fully Centered)
+
+```
+Group {
+    LayoutMode: CenterMiddle;
+
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+}
+```
+
+Children stack horizontally from left to right, centered both horizontally and vertically within the parent:
+
+```
+┌────────────────────────────────────────────┐
+│                                            │
+│                                            │
+│         ┌──────┐ ┌──────┐ ┌──────┐         │
+│         │  B1  │ │  B2  │ │  B3  │         │
+│         └──────┘ └──────┘ └──────┘         │
+│                                            │
+│                                            │
+└────────────────────────────────────────────┘
+```
+
+---
+
+### MiddleCenter (Vertical Stack, Fully Centered)
+
+```
+Group {
+    LayoutMode: MiddleCenter;
+
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+}
+```
+
+Children stack vertically from top to bottom, centered both horizontally and vertically within the parent:
+
+```
+┌────────────────────────────────────────────┐
+│                                            │
+│              ┌──────────┐                  │
+│              │ Button 1 │                  │
+│              ├──────────┤                  │
+│              │ Button 2 │                  │
+│              ├──────────┤                  │
+│              │ Button 3 │                  │
+│              └──────────┘                  │
+│                                            │
+└────────────────────────────────────────────┘
+```
+
+---
+
+### Full
+
+```
+Group {
+    LayoutMode: Full;
+
+    Label {
+        Anchor: (Top: 20, Left: 20, Width: 100, Height: 30);
+    }
+}
+```
+
+Children use absolute positioning via their `Anchor` properties.
+
+### TopScrolling
+
+```
+Group {
+    LayoutMode: TopScrolling;
+    ScrollbarStyle: $Common.@DefaultScrollbar;
+
+    // ... many children
+}
+```
+
+Like `Top`, but adds a scrollbar if content exceeds container height.
+
+Or use `BottomScrolling` for bottom-aligned content.
+
+### LeftScrolling
+
+```
+Group {
+    LayoutMode: LeftScrolling;
+    ScrollbarStyle: $Common.@DefaultScrollbar;
+
+    // ... many children
+}
+```
+
+Like `Left`, but adds a scrollbar for horizontal scrolling.
+
+Or use `RightScrolling` for right-aligned content.
+
+### LeftCenterWrap (Wrapping Horizontal Stack, Horizontally Centered)
+
+```
+Group {
+    LayoutMode: LeftCenterWrap;
+
+    Button { Anchor: (Width: 80, Height: 30); }
+    Button { Anchor: (Width: 80, Height: 30); }
+    Button { Anchor: (Width: 80, Height: 30); }
+    Button { Anchor: (Width: 80, Height: 30); }
+    Button { Anchor: (Width: 80, Height: 30); }
+}
+```
+
+Children flow left to right. When there's no more horizontal space, they wrap to the next row. Each row is horizontally centered within the parent:
+
+```
+┌────────────────────────────────────────────┐
+│                                            │
+│       ┌──────┐ ┌──────┐ ┌──────┐           │
+│       │  B1  │ │  B2  │ │  B3  │           │
+│       └──────┘ └──────┘ └──────┘           │
+│            ┌──────┐ ┌──────┐               │
+│            │  B4  │ │  B5  │               │
+│            └──────┘ └──────┘               │
+│                                            │
+└────────────────────────────────────────────┘
+```
+
+## FlexWeight
+
+`FlexWeight` distributes remaining space among children.
+
+```
+Group {
+    LayoutMode: Left;
+    Anchor: (Width: 400);
+
+    Button {
+        Anchor: (Width: 100);
+    }
+
+    Group {
+        FlexWeight: 1;  // Takes all remaining space
+    }
+
+    Button {
+        Anchor: (Width: 100);
+    }
+}
+```
+
+Result:
+
+- First button: 100px
+- Middle group: 200px (400 - 100 - 100 = 200)
+- Last button: 100px
+
+### Multiple FlexWeights
+
+```
+Group {
+    LayoutMode: Left;
+    Anchor: (Width: 600);
+
+    Group { FlexWeight: 1; }
+    Group { FlexWeight: 2; }
+    Group { FlexWeight: 1; }
+}
+```
+
+Remaining space (600px) is split:
+
+- First group: 600 × (1/4) = 150px
+- Second group: 600 × (2/4) = 300px
+- Third group: 600 × (1/4) = 150px
+
+## Visibility
+
+```
+Button #HiddenButton {
+    Visible: false;
+}
+```
+
+**Effect:**
+
+- Element and its children are not displayed
+- Element is **not included in layout** (doesn't take up space)
diff --git a/content/docs/nl-NL/official-documentation/custom-ui/markup.mdx b/content/docs/nl-NL/official-documentation/custom-ui/markup.mdx
new file mode 100644
index 00000000..564110ed
--- /dev/null
+++ b/content/docs/nl-NL/official-documentation/custom-ui/markup.mdx
@@ -0,0 +1,226 @@
+---
+title: Markup
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# Markup
+
+## Markup
+
+An element is the basic building block of a user interface. There are various types of elements with different properties, which are documented below.
+
+Here's what the syntax looks like:
+
+```
+// Basic declaration of an element
+// with its Anchor property set to attach on all sides of its parent
+// with 10 pixels of margin
+Group { Anchor: (Left: 10, Top: 10, Right: 10, Bottom: 10); }
+
+Group { Anchor: (Full: 10); } // More concise version
+
+// Declaration of a Label with a name
+// (can be used to access the element from game code)
+Label #MyLabel {
+  Style: LabelStyle(FontSize: 16); // or just Style: (FontSize: 16), type can be inferred.
+  Text: "Hi! I am text.";
+}
+
+// Declaration of a Group containing 2 children
+// You can use FlexWeight to distribute any left-over space after explicit widths/heights have been subtracted
+Group {
+  LayoutMode: Left;
+  Label { Text: "Child 1"; FlexWeight: 2; }
+  Label { Text: "Child 2"; FlexWeight: 1; }
+}
+```
+
+### Documents
+
+A UI document (_.ui_ file) contains trees of elements. There can be multiple root elements.
+
+### Named Expressions
+
+Named expressions can be declared at any level of a document (including at the root) and will be scoped to that subtree, though they need to be declared at the top of the block.
+
+```
+// Example of named expressions, declared and used with @ prefix
+@Title = "Hytale";
+@ExtraSpacing = 5;
+
+Label {
+  Text: @Title;
+  Style: (LetterSpacing: 2 + @ExtraSpacing);
+}
+```
+
+You can use the spread operator `...` to reuse a named expression while overriding some of its fields:
+
+```
+@MyBaseStyle = LabelStyle(FontSize: 24, LetterSpacing: 2);
+
+Label {
+  Style: (...@MyBaseStyle, FontSize: 36);
+}
+```
+
+You can even layer multiple named expressions like so:
+
+```
+@TitleStyle = LabelStyle(FontSize: 24, HorizontalAlignment: Center);
+@SpacedTextStyle = LabelStyle(LetterSpacing: 2);
+
+Label {
+  Style: (...@BigTextStyle, ...@SpacedTextStyle);
+}
+```
+
+#### Document references
+
+A document can reference another document and access its named expressions.
+
+```
+// Document references are defined with $ prefix
+$Common = "../Common.ui";
+
+TextButton {
+  Style: $Common.@DefaultButtonStyle;
+}
+```
+
+### Templates
+
+You can declare a reusable bit of interface as a named expression and then instantiate it as many times as you want in the tree while customizing it.
+
+You can override local named expressions as well as insert additional children at any point in the template tree. However, local named expressions must be defined at the very top of the block, before properties and child elements.
+
+```
+// This is the template
+@Row = Group {
+  Anchor: (Height: 50);
+  Label #Label { Anchor: (Left: 0, Width: 100); Text: @LabelText; }
+  Group #Content { Anchor: (Left: 100); }
+};
+
+// Here we'll be using it twice in the document tree
+Group #Rows {
+  LayoutMode: TopScrolling;
+
+  @Row #MyFirstRow {
+    @LabelText = "First row";
+    #Content { TextInput {} }
+  }
+
+  @Row #MySecondRow {
+    @LabelText = "Second row";
+  }
+}
+```
+
+### Property Types
+
+#### Basic Types
+
+- **Boolean**
+  - `Visible: false;`
+  - `Visible: true;`
+- **Int**
+  - `Height: 20;`
+- **Float, Double, Decimal**
+  - `Min: 0.2;`
+- **String**
+  - `Text: "Hi!";`
+- **Char**
+  - `PasswordChar: "*";`
+  - _Note: The syntax is the same as a string, however a value of this type cannot contain more than one character!_
+- **Color**
+  - `Background: #ffffff;`&#x20;
+- **Objects**
+  - `Style: (Background: #ffffff)`
+- **Array**&#x20;
+  - `TextSpans: [(Text: "Hi", IsBold: true)]`
+
+#### Translations
+
+Translation keys can be referenced anywhere in markup where you can provide a string, and they are then converted to a string when an element gets instantiated.
+
+**Example:**
+
+```
+Label {
+  Text: %ui.general.cancel;
+}
+```
+
+#### Colors
+
+A color literal can be written as follows:
+
+- `#rrggbb`: 6-digit hexadecimal representation for red, green, blue (fully opaque)
+- `#rrggbb(a.a)`: 6-digit hexadecimal representation for red, green, blue with alpha between 0 and 1
+- `#rrggbbaa`: 8-digit hexadecimal representation for red, green, blue and alpha
+
+```
+Group {
+  Background: #000000(0.3);
+}
+```
+
+<Callout>
+  The `#rrggbb(a.a)` format is prefered over the `#rrggbbaa` format for
+  readability reasons.
+</Callout>
+
+#### Font Name
+
+Font names can be referenced directly by their string ID. Internally this is using a custom type called `UIFontName`, however strings will be converted automatically to this type in markup.
+
+```
+Label {
+  Text: "Hi";
+  Style: (FontName: "Secondary");
+}
+```
+
+**Available Font Names**
+
+- _Default_ - This is the default font that is used for most text and is always used unless a different option has been specified
+- _Secondary_ - This font is mostly used for headlines or elements that are supposed to stick out
+- _Mono_ - This is only used for development; For things such as profiling or error overlays.
+
+#### Path
+
+We can reference other UI assets with the `UIPath` type. Similar to `UIFontName`_,_ Strings are automatically converted to a `UIPath`. Paths are always relative to the file where they have been declared in. Looking up _MyButton.png_ in _Menu/MyAwesomeMenu.ui_ will result in _Menu/MyButton.png_. If you want to reference a file that is in a parent folder you can go back one directory by writing two dots (_../MyButton.png_).
+
+The markup syntax of a `UIPath` is the same as a String. (e.g. `Path: "Test.png"`)
+
+Here are some more examples:
+
+| UIPath             | .ui File                              | Resulting Path    |
+| ------------------ | ------------------------------------- | ----------------- |
+| MyButton.png       | Menu/MyAwesomeMenu.ui                 | Menu/MyButton.png |
+| ../MyButton.png    | Menu/MyAwesomeMenu.ui                 | MyButton.png      |
+| ../../MyButton.png | Menu/Popup/Templates/MyAwesomeMenu.ui | Menu/MyButton.png |
+
+#### Objects
+
+Objects contain a set of properties. In this example we are assigning an Anchor object to the _Anchor_ property:
+
+```
+Group {
+  Anchor: (
+   Height: 10,
+   Width: 20
+ );
+}
+```
+
+You can find all objects that can be used in markup [here](type-documentation#elements).
+
+## Visual Studio Code Extension
+
+There is an official extension for Visual Studio Code which adds syntax highlighting for .ui files. You can find it [here](https://marketplace.visualstudio.com/items?itemName=HypixelStudiosCanadaInc.vscode-hytaleui).
diff --git a/content/docs/nl-NL/official-documentation/custom-ui/type-documentation/index.mdx b/content/docs/nl-NL/official-documentation/custom-ui/type-documentation/index.mdx
new file mode 100644
index 00000000..69cea406
--- /dev/null
+++ b/content/docs/nl-NL/official-documentation/custom-ui/type-documentation/index.mdx
@@ -0,0 +1,127 @@
+---
+title: Type Documentation
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# Type Documentation
+
+This is a generated list of UI elements accessible by markup. More information about the User Interface framework can be found in the main documentation.
+
+## Elements
+
+- [ActionButton](type-documentation/elements/actionbutton)
+- [AssetImage](type-documentation/elements/assetimage)
+- [BackButton](type-documentation/elements/backbutton)
+- [BlockSelector](type-documentation/elements/blockselector)
+- [Button](type-documentation/elements/button)
+- [CharacterPreviewComponent](type-documentation/elements/characterpreviewcomponent)
+- [CheckBox](type-documentation/elements/checkbox)
+- [CheckBoxContainer](type-documentation/elements/checkboxcontainer)
+- [CircularProgressBar](type-documentation/elements/circularprogressbar)
+- [CodeEditor](type-documentation/elements/codeeditor)
+- [ColorOptionGrid](type-documentation/elements/coloroptiongrid)
+- [ColorPicker](type-documentation/lements/colorpicker)
+- [ColorPickerDropdownBox](type-documentation/elements/colorpickerdropdownbox)
+- [CompactTextField](type-documentation/elements/compacttextfield)
+- [DropdownBox](type-documentation/elements/dropdownbox)
+- [DropdownEntry](type-documentation/elements/dropdownentry)
+- [DynamicPane](type-documentation/elements/dynamicpane)
+- [DynamicPaneContainer](type-documentation/elements/dynamicpanecontainer)
+- [FloatSlider](type-documentation/elements/floatslider)
+- [FloatSliderNumberField](type-documentation/elements/floatslidernumberfield)
+- [Group](type-documentation/elements/group)
+- [HotkeyLabel](type-documentation/elements/hotkeylabel)
+- [ItemGrid](type-documentation/elements/itemgrid)
+- [ItemIcon](type-documentation/elements/itemicon)
+- [ItemPreviewComponent](type-documentation/elements/itempreviewcomponent)
+- [ItemSlot](type-documentation/elements/itemslot)
+- [ItemSlotButton](type-documentation/elements/itemslotbutton)
+- [Label](type-documentation/elements/label)
+- [LabeledCheckBox](type-documentation/elements/labeledcheckbox)
+- [MenuItem](type-documentation/elements/menuitem)
+- [MultilineTextField](type-documentation/elements/multilinetextfield)
+- [NumberField](type-documentation/elements/numberfield)
+- [Panel](type-documentation/elements/panel)
+- [ProgressBar](type-documentation/elements/progressbar)
+- [ReorderableList](type-documentation/elements/reorderablelist)
+- [ReorderableListGrip](type-documentation/elements/reorderablelistgrip)
+- [SceneBlur](type-documentation/elements/sceneblur)
+- [Slider](type-documentation/elements/slider)
+- [SliderNumberField](type-documentation/elements/slidernumberfield)
+- [Sprite](type-documentation/elements/sprite)
+- [TabButton](type-documentation/elements/tabbutton)
+- [TabNavigation](type-documentation/elements/tabnavigation)
+- [TextButton](type-documentation/elements/textbutton)
+- [TextField](type-documentation/elements/textfield)
+- [TimerLabel](type-documentation/elements/timerlabel)
+- [ToggleButton](type-documentation/elements/togglebutton)
+
+## Property Types
+
+- [Anchor](type-documentation/property-types/anchor)
+- [BlockSelectorStyle](type-documentation/property-types/blockselectorstyle)
+- [ButtonSounds](type-documentation/property-types/buttonsounds)
+- [ButtonStyle](type-documentation/property-types/buttonstyle)
+- [ButtonStyleState](type-documentation/property-types/buttonstylestate)
+- [CheckBoxStyle](type-documentation/property-types/checkboxstyle)
+- [CheckBoxStyleState](type-documentation/property-types/checkboxstylestate)
+- [ClientItemStack](type-documentation/property-types/clientitemstack)
+- [ColorOptionGridStyle](type-documentation/property-types/coloroptiongridstyle)
+- [ColorPickerDropdownBoxStateBackground](type-documentation/property-types/colorpickerdropdownboxstatebackground)
+- [ColorPickerDropdownBoxStyle](type-documentation/property-types/colorpickerdropdownboxstyle)
+- [ColorPickerStyle](type-documentation/property-types/colorpickerstyle)
+- [DropdownBoxSearchInputStyle](type-documentation/property-types/dropdownboxsearchinputstyle)
+- [DropdownBoxSounds](type-documentation/property-types/dropdownboxsounds)
+- [DropdownBoxStyle](type-documentation/property-types/dropdownboxstyle)
+- [InputFieldButtonStyle](type-documentation/property-types/inputfieldbuttonstyle)
+- [InputFieldDecorationStyle](type-documentation/property-types/inputfielddecorationstyle)
+- [InputFieldDecorationStyleState](type-documentation/property-types/inputfielddecorationstylestate)
+- [InputFieldIcon](type-documentation/property-types/inputfieldicon)
+- [InputFieldStyle](type-documentation/property-types/inputfieldstyle)
+- [ItemGridSlot](type-documentation/property-types/itemgridslot)
+- [ItemGridStyle](type-documentation/property-types/itemgridstyle)
+- [LabeledCheckBoxStyle](type-documentation/property-types/labeledcheckboxstyle)
+- [LabeledCheckBoxStyleState](type-documentation/property-types/labeledcheckboxstylestate)
+- [LabelSpan](type-documentation/property-types/labelspan)
+- [LabelStyle](type-documentation/property-types/labelstyle)
+- [NumberFieldFormat](type-documentation/property-types/numberfieldformat)
+- [Padding](type-documentation/property-types/padding)
+- [PatchStyle](type-documentation/property-types/patchstyle)
+- [PopupStyle](type-documentation/property-types/popupstyle)
+- [ScrollbarStyle](type-documentation/property-types/scrollbarstyle)
+- [SliderStyle](type-documentation/property-types/sliderstyle)
+- [SoundStyle](type-documentation/property-types/soundstyle)
+- [SpriteFrame](type-documentation/property-types/spriteframe)
+- [SubMenuItemStyle](type-documentation/property-types/submenuitemstyle)
+- [SubMenuItemStyleState](type-documentation/property-types/submenuitemstylestate)
+- [Tab](type-documentation/property-types/tab)
+- [TabNavigationStyle](type-documentation/property-types/tabnavigationstyle)
+- [TabStyle](type-documentation/property-types/tabstyle)
+- [TabStyleState](type-documentation/property-types/tabstylestate)
+- [TextButtonStyle](type-documentation/property-types/textbuttonstyle)
+- [TextButtonStyleState](type-documentation/property-types/textbuttonstylestate)
+- [TextTooltipStyle](type-documentation/property-types/texttooltipstyle)
+- [ToggleButtonStyle](type-documentation/property-types/togglebuttonstyle)
+- [ToggleButtonStyleState](type-documentation/property-types/togglebuttonstylestate)
+
+## Enums
+
+- [ActionButtonAlignment](type-documentation/enums/actionbuttonalignment)
+- [CodeEditorLanguage](type-documentation/enums/codeeditorlanguage)
+- [ColorFormat](type-documentation/enums/colorformat)
+- [DropdownBoxAlign](type-documentation/enums/dropdownboxalign)
+- [InputFieldButtonSide](type-documentation/enums/inputfieldbuttonside)
+- [InputFieldIconSide](type-documentation/enums/inputfieldiconside)
+- [ItemGridInfoDisplayMode](type-documentation/enums/itemgridinfodisplaymode)
+- [LabelAlignment](type-documentation/enums/labelalignment)
+- [LayoutMode](type-documentation/enums/layoutmode)
+- [MouseWheelScrollBehaviourType](type-documentation/enums/mousewheelscrollbehaviourtype)
+- [ProgressBarAlignment](type-documentation/enums/progressbaralignment)
+- [ProgressBarDirection](type-documentation/enums/progressbardirection)
+- [ResizeType](type-documentation/enums/resizetype)
+- [TimerDirection](type-documentation/enums/timerdirection)
+- [TooltipAlignment](type-documentation/enums/tooltipalignment)
diff --git a/content/docs/nl-NL/official-documentation/npc/2-getting-started-with-templates.mdx b/content/docs/nl-NL/official-documentation/npc/2-getting-started-with-templates.mdx
index 91081ca1..99d078e0 100644
--- a/content/docs/nl-NL/official-documentation/npc/2-getting-started-with-templates.mdx
+++ b/content/docs/nl-NL/official-documentation/npc/2-getting-started-with-templates.mdx
@@ -9,7 +9,7 @@ authors:
 
 There are no hard and fast rules for making a start on a template. I like to duplicate **BlankTemplate** and start from there because it already provides the basic structure of the file.
 
-This leaves me with the following template (`Template_Goblin_Ogre.json`): (note: the file could be looking different in the current version of the game)
+This leaves me with the following template (`Template_Goblin_Ogre.json`): (**note: the file could be looking different in the current version of the game**)
 
 ```json
 {
@@ -33,7 +33,7 @@ This leaves me with the following template (`Template_Goblin_Ogre.json`): (note:
     }
   },
   "Appearance": { "Compute": "Appearance" },
-  "DropList": { "Compute": "Droplist" },
+  "DropList": { "Compute": "DropList" },
   "MaxHealth": { "Compute": "MaxHealth" },
   "MotionControllerList": [
     {
@@ -65,10 +65,10 @@ And the following variant (`Goblin_Ogre.json`) next to the template. There's a t
   "Type": "Variant",
   "Reference": "Template_Goblin_Ogre",
   "Modify": {
-    "Appearance": "Goblin_Ogre",
+    "Appearance": "Goblin",
     "MaxHealth": 124
   }
 }
 ```
 
-Our artists have defined the `Goblin_Ogre` appearance already so I'm going to use that.
+Our artists have not yet finished animations for the `Goblin_Ogre`, for that sake of the tutorial I am going to use appearance `Goblin`, because it offers a more complete set of animations that we will need.
diff --git a/content/docs/nl-NL/official-documentation/worldgen/pack-tutorial/asset-packs.mdx b/content/docs/nl-NL/official-documentation/worldgen/pack-tutorial/asset-packs.mdx
index 38809fad..dcf1f3b9 100644
--- a/content/docs/nl-NL/official-documentation/worldgen/pack-tutorial/asset-packs.mdx
+++ b/content/docs/nl-NL/official-documentation/worldgen/pack-tutorial/asset-packs.mdx
@@ -9,13 +9,13 @@ authors:
 
 <OfficialDocumentationNotice />
 
-# How to modify Hytale
+# How to modify Hytale?
 
-## What's an Asset Pack
+## What's an Asset Pack?
 
-Hytales gameplay is driven by assets in the game that can be modified by creators. Asset Packs are our solution to let you override or add features to the base game with your own work. These can in the form of zip files of folders, which contain a custom set of assets. This is not the only way for a creator to change Hytale but this is the most accessible form.;
+Hytales gameplay is driven by assets in the game that can be modified by creators. Asset Packs are our solution to let you override or add features to the base game with your own work. These can be the form of zip files of folders, which contain a custom set of assets. This is not the only way for a creator to change Hytale but this is the most accessible form.;
 
-### How do I make an Asset Pack
+### How do I make an Asset Pack?
 
 <video controls className="my-6 aspect-video w-full rounded-lg border">
   <source src="https://cdn.internal.hytalemodding.dev/guides/official/how-to-asset-pack.mp4" type="video/mp4" />
@@ -48,7 +48,7 @@ An asset pack is typically a zip or folder, with a `manifest.json` inside. This
 }
 ```
 
-### Where are they stored
+### Where are they stored?
 
 Asset Packs are stored with other mods in the Mods folder.
 
@@ -76,7 +76,7 @@ C:\Users\<user>\AppData\Roaming\Hytale\UserData\Saves\New World 5\mods
 
 When you have Asset Packs or Mods installed, these will appear in the New World menu under the Options menu.;
 
-### How do I change an existing asset
+### How do I change an existing asset?
 
 <video controls className="my-6 aspect-video w-full rounded-lg border">
   <source src="https://cdn.internal.hytalemodding.dev/guides/official/how-to-asset.mp4" type="video/mp4" />
diff --git a/content/docs/nl-NL/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx b/content/docs/nl-NL/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx
index 44528376..24e628b5 100644
--- a/content/docs/nl-NL/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx
+++ b/content/docs/nl-NL/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx
@@ -106,7 +106,7 @@ If a BaseHeight is provided, the TopY and BottomY values are relative to the Bas
 
 Applies a Material Provider slot on a set of horizontal stripes of blocks of varying thickness and position. Below is an example image of basalt stripes into a stone cliff.
 
-{/* ![](https://540086904-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F7KAmBkOg6d13nZCkf9ku%2Fuploads%2FbcxO9LpArn8gPCaBwFg5%2Funknown.png?alt=media&token=1c72b67a-8253-4d03-8c64-1ad5f6830050) */}
+![Example of basalt stripes](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/basalt-stripes-example.png)
 
 #### Parameters:
 
diff --git a/content/docs/nl-NL/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx b/content/docs/nl-NL/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx
index 5e34acd4..a4418473 100644
--- a/content/docs/nl-NL/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx
+++ b/content/docs/nl-NL/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx
@@ -294,7 +294,7 @@ Combines all the positions into a single Positioins field.
 
 ---
 
-### SimpleHoritontal
+### SimpleHorizontal
 
 Keeps only the positions that are within the provided range.
 
diff --git a/content/docs/nl-NL/official-documentation/worldgen/worldgen-tutorial/README.mdx b/content/docs/nl-NL/official-documentation/worldgen/worldgen-tutorial/README.mdx
new file mode 100644
index 00000000..5f66d245
--- /dev/null
+++ b/content/docs/nl-NL/official-documentation/worldgen/worldgen-tutorial/README.mdx
@@ -0,0 +1,166 @@
+---
+title: How to edit and create Biomes
+description: Explores where world generation assets can be found and how to edit them.
+---
+
+### Where are the Assets
+
+World generation assets are kept in the HytaleGenerator directory within the assets.
+
+```
+/Server/HytaleGenerator/
+```
+
+<div className="flex flex-row rounded-lg border p-4">
+  <div className="flex-1/2 border-r pr-4">
+    ```
+    /Biomes
+    ```
+
+    Biome assets, with content configurations.
+  </div>
+
+  <div className="flex-1/2 pl-4">
+    ```
+    /WorldStructure
+    ```
+
+    Generator files that define which biomes spawn together.
+  </div>
+</div>
+
+<div className="flex flex-row rounded-lg border p-4">
+  <div className="flex-1/2 border-r pr-4">
+    ```
+    /Density
+    ```
+
+    Density assets that can be referenced by any other assets.
+  </div>
+
+  <div className="flex-1/2 pl-4">
+    ```
+    /Assignments
+    ```
+
+    Prop assets that can be referenced by any Biome assets.
+  </div>
+</div>
+
+***
+
+An example of this structure can be found bellow, packed in an asset pack with the instance configuration.
+
+[https://drive.google.com/file/d/1sIz_CluANIIe3n8vNiOi-4PQdeqCO0qY/view?usp=drive_link](https://drive.google.com/file/d/1sIz_CluANIIe3n8vNiOi-4PQdeqCO0qY/view?usp=drive_link)
+
+<Callout>
+  Ensure you place your asset pack in the correct directory, under Mods.
+</Callout>
+
+### How to visit our worlds
+
+https://drive.google.com/file/d/1BJurxyj-taE-PXWm04bk7Dl6X7ZHTH92/view?usp=sharing
+
+#### Requirements
+
+- You must be an **Operator** in the world.
+  - To do this, run <mark style="color:$danger;">`/op self`</mark>
+- You must be in **Creative mode**.
+  - Press the <mark style="color:$danger;">`O`</mark> key, O for Orange.&#x20;
+
+The generation assets define a set of generators but on their own you cannot visit these. Currently you require an Instance with a generator that will allow you to visit your work.
+
+```
+/Server/Instances/
+```
+
+Instances are separate worlds that players can join using the `/instances` command. Each instance has an `Instance.bson` configuration asset that specifies which generator to use, among other worldly settings.
+
+```json
+{
+  "WorldGen": {
+    "Type": "HytaleGenerator",
+    "WorldStructure": "Basic",
+    "playerSpawn" : {
+      "X" : 123,
+      "Y" : 480,
+      "Z" : 10000,
+      "Pitch" : 0,
+      "Yaw" : 0,
+      "Roll" : 0
+    }
+  }
+}
+```
+
+<Callout>
+  You can create custom instances for different world structures and biomes as you need them.
+</Callout>
+
+### How to edit Biomes
+
+<video>
+  <source src="https://cdn.internal.hytalemodding.dev/guides/official/How-to-edit-Biomes.mp4" type="video/mp4" />
+</video>
+
+We currently use the Hytale Node Editor when editing world generation assets. This can be accessed while in-game from the Content Creation menu when pressing B. The node editor is then found under the asset editor dropdown on the upper left.&#x20;
+
+![Node Editor 1](/assets/official-documentation/worldgen/worldgen-tutorial/biomes/node-editor-1.png)
+
+Once you have the Hytale Node Editor open, through the file menu you can open Biomes by navigating to the Biomes directory and selecting one from your pack.&#x20;
+
+```
+/Server/HytaleGenerator/Biomes/
+```
+
+### Biome Asset Structure
+
+Every Biome has a root Biome node, this node splits into 5 structures. This is covered briefly but more information on each field can be found on the World Generation Concepts page.
+
+![Node Editor 2](/assets/official-documentation/worldgen/worldgen-tutorial/biomes/node-editor-2.png)
+
+<Callout>
+  Each biome is for the most part self contained, meaning it has control over what appears with the biome. The only exception to this are Base Heights.
+</Callout>
+
+<Tabs>
+  <Tab value="Terrain">
+    Mathematical function nodes that calculate the physical shape of the Biome's terrain.
+  </Tab>
+
+  <Tab value="Materials">
+    Logical nodes that determine what materials (blocks) make up a Biome's terrain.
+  </Tab>
+
+  <Tab value="Props">
+    Function nodes that add objects like prefabs and decorations to the terrain.
+  </Tab>
+
+  <Tab value="Environments">
+    Logical nodes that determine the environment asset at a given coordinate within the biome. This asset determines things like weather, NPC spawns, and sounds.
+  </Tab>
+
+  <Tab value="Tints">
+    Logical function nodes that determine a colour code that can be used by certain blocks in the world. Typically this will be grasses and soils.
+  </Tab>
+</Tabs>
+
+### How to preview your work
+
+[https://drive.google.com/file/d/1mNcHn9LhFnWDF0DzWFH6_YllmKAUvUry/view?t=6](https://drive.google.com/file/d/1mNcHn9LhFnWDF0DzWFH6_YllmKAUvUry/view?t=6)
+
+Once you are in an Instance world with the Hytale Generator active you will only be able to see your work by generating new chunks. There are a few ways to do this.
+
+The viewport command selects an area around the Player that will live reload as you make changes to the generator.&#x20;
+
+```
+/viewport --radius 5 
+```
+
+You can also create a new world to show your changes.&#x20;
+
+```
+/instances spawn <instance> 
+```
+
+The last option is to simply fly south, new chunks will generate with the changes made.
diff --git a/content/docs/nl-NL/quick-start.mdx b/content/docs/nl-NL/quick-start.mdx
index 653644f4..249d803a 100644
--- a/content/docs/nl-NL/quick-start.mdx
+++ b/content/docs/nl-NL/quick-start.mdx
@@ -9,3 +9,8 @@ Welcome to the Hytale modding documentation! Here you'll find everything you nee
 * [Setting up your dev environment](./guides/plugin/setting-up-env)
 * [Entity Component System (ECS)](./guides/ecs/entity-component-system)
 * [Publishing your mod](./publishing)
+
+### Useful Links
+
+* [Kaupenjoe's Modding Videos](https://www.youtube.com/@ModdingByKaupenjoe)
+* [TroubleDEV's Modding Videos](https://www.youtube.com/@TroubleDEV)
diff --git a/content/docs/nl-NL/server/argtypes.mdx b/content/docs/nl-NL/server/argtypes.mdx
new file mode 100644
index 00000000..e54a442e
--- /dev/null
+++ b/content/docs/nl-NL/server/argtypes.mdx
@@ -0,0 +1,61 @@
+---
+title: ArgTypes
+description: Available ArgTypes
+icon: List
+full: true
+authors:
+  - name: Valeena
+---
+
+| Name                        | Target Class                           | Description                                                                                                                               |   |
+| :-------------------------- | :------------------------------------- | :---------------------------------------------------------------------------------------------------------------------------------------- | - |
+| Boolean                     | java.lang.Boolean                      | A 'true' or 'false' input                                                                                                                 |   |
+| Integer                     | java.lang.Integer                      | A whole number                                                                                                                            |   |
+| String                      | java.lang.String                       | Words, text, numbers, letters. To input more than one word at a time, you may need to wrap it with double quotes (`"my fancy sentence"`). |   |
+| Float                       | java.lang.Float                        | A floating-pointer number                                                                                                                 |   |
+| Double                      | java.lang.Double                       | A decimal number                                                                                                                          |   |
+| UUID                        | java.util.UUID                         | A UUID (Universally Unique IDentifier)                                                                                                    |   |
+| Player_UUID                 | java.util.UUID                         | A UUID or an online player username                                                                                                       |   |
+| Game_Profile_Lookup_Async   | ProfileServiceClient.PublicGameProfile | A player UUID or username. If not found locally, performs a remote lookup via the Profile Service.                                        |   |
+| Relative_Double_Coord       | Coord                                  | An x, y, or z coordinate as a decimal, optionally relative by specifying a tilde (~) in front of the number                               |   |
+| Relative_Int_Coord          | IntCoord                               | An x, y, or z coordinate as a whole number, optionally relative by specifying a tilde (~) in front of the number                          |   |
+| Relative_Integer            | RelativeInteger                        | A tilde to mark an integer relative to a base                                                                                             |   |
+| Relative_Float              | RelativeFloat                          | A tilde to mark a float relative to a base                                                                                                |   |
+| Player_Ref                  | PlayerRef                              | A UUID or an online player's username                                                                                                     |   |
+| World                       | World                                  | A world folder name                                                                                                                       |   |
+| Model_Asset                 | ModelAsset                             | A reference to an Asset of type Model                                                                                                     |   |
+| Weather_Asset               | Weather                                | A reference to an Asset of type Weather                                                                                                   |   |
+| Interaction_Asset           | Interaction                            | A reference to an Asset of type Interaction                                                                                               |   |
+| Root_Interaction_Asset      | RootInteraction                        | A reference to an Asset of type Root Interaction                                                                                          |   |
+| Effect_Asset                | EntityEffect                           | A refernece to an Asset of type EntityEffect                                                                                              |   |
+| Environment_Asset           | Environment                            | A reference to an Asset of type Environment                                                                                               |   |
+| Item_Asset                  | Item                                   | A reference to an Asset of type Item                                                                                                      |   |
+| Block_Type_Asset            | BlockType                              | A reference to an Asset of type BlockType                                                                                                 |   |
+| Particle_System             | ParticleSystem                         | A reference to an Asset of type ParticleSystem                                                                                            |   |
+| Hitbox_Collision_Config     | HitboxCollisionConfig                  | A reference to an Asset of type HitboxCollisionConfig                                                                                     |   |
+| Repulsion_Config            | RepulsionConfig                        | A reference to an Asset of type RepulsionConfig                                                                                           |   |
+| Sound_Event_Asset           | SoundEvent                             | A reference to an Asset of type SoundEvent                                                                                                |   |
+| Ambiance_Fx_Asset           | AmbianceFX                             | A reference to an Asset of type AmbianceFX                                                                                                |   |
+| Sound_Category              | SoundCategory                          | A sound category (sfx, music, ambient, ui)                                                                                                |   |
+| Entity_ID                   | `ArgWrapper<EntityWrappedArg, UUID>`   | A UUID representing an entity id                                                                                                          |   |
+| Integer_Comparison_Operator | IntegerComparisonOperator              | A mathematical sign for integer comparison                                                                                                |   |
+| Integer_Operation           | IntegerOperation                       | A mathematical sign for performing an operation                                                                                           |   |
+| Int_Range                   | `Pair<Integer, Integer>`               | Two integers representing a minimum and maximum of a range                                                                                |   |
+| Relative_Int_Range          | RelativeIntRange                       | Two integers representing a minimum and maximum of a range                                                                                |   |
+| Vector2I                    | Vector2i                               | Two integers, generally corresponding to x/z axis                                                                                         |   |
+| Vector3I                    | Vector3i                               | Three integers, generally corresponding to x/y/z axis                                                                                     |   |
+| Relative_Vector3I           | RelativeVector3i                       | Three optionally relative integers, generally corresponding to x/y/z axis                                                                 |   |
+| Relative_Block_Position     | RelativeIntPosition                    | A position with three integer coordinates, representing a block's location in world space.                                                |   |
+| Relative_Position           | Relative                               | A position with three decimal coordinates, representing a location in world space.                                                        |   |
+| Relative_Chunk_Position     | RealtiveChunkPosition                  | A position with two integer coordinates (x, z), representing a chunk's location.                                                          |   |
+| Rotation                    | Vector3f                               | A rotation with three coordinates, representing the pitch, yaw, and roll respectively                                                     |   |
+| Block_Type_Key              | String                                 | A block type                                                                                                                              |   |
+| Block_ID                    | Integer                                | A block type, converted to an int id                                                                                                      |   |
+| Color                       | Integer                                | A color value in hex format, hex integer, or decimal integer                                                                              |   |
+| Weighted_Block_Type         | `Pair<Integer, String>`                | A weight corresponding to a blocktype                                                                                                     |   |
+| Weighted_Block_Entry        | String                                 | A block with optional weight prefix                                                                                                       |   |
+| Block_Pattern               | BlockPattern                           | A list of blocks with optional weights                                                                                                    |   |
+| Individual_Block_Mask       | BlockMask                              | Create a block mask using symbols and block names                                                                                         |   |
+| Block_Mask                  | BlockMask                              | A tick rate value (e.g., 30tps, 33ms, or 30)                                                                                              |   |
+| Tick_Rate                   | Integer                                | A list of block masks that combine together                                                                                               |   |
+| Game_Mode                   | GameMode                               | GameMode                                                                                                                                  |   |
diff --git a/content/docs/nl-NL/server/interaction-reference.mdx b/content/docs/nl-NL/server/interaction-reference.mdx
new file mode 100644
index 00000000..6c0d01b3
--- /dev/null
+++ b/content/docs/nl-NL/server/interaction-reference.mdx
@@ -0,0 +1,1586 @@
+---
+title: Interactions
+description: A list of most Interaction types provided by Hypixel, along with the meaning of their fields, and how they fit together.
+icon: List
+authors:
+  - name: Stephen Baynham
+    url: https://github.com/cannibalvox
+---
+
+### The Interaction Base Type
+
+All interactions of every type below are inherited from Interaction and have these fields.
+
+**Interaction Fields**
+
+| Field Name                | Type                                                                 | Required? | Notes                                                                                                                                                                                                                       |
+| ------------------------- | -------------------------------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| ViewDistance              | `Double`<br />(Default: 96.0)                                        | **No**    | Distance in blocks at which other players can see the effects from this interaction.                                                                                                                                        |
+| Effects                   | `InteractionEffects`                                                 | **No**    | Sound, animations, and particle effects that should trigger when this interaction begins executing.                                                                                                                         |
+| HorizontalSpeedMultiplier | `Float`<br />(Default: 1.0)                                          | **No**    | Multiplier applied to the User entity's movement speed while this interaction is executing                                                                                                                                  |
+| RunTime                   | `Float`                                                              | **No**    | If provided, this interaction will continue executing for at least this long before the interaction chain moves onto the next interaction.                                                                                  |
+| CancelOnItemChange        | `Boolean`<br />(Default: true)                                       | **No**    | If true, this interaction will be cancelled if the User entity's held item changes during execution. This can happen either due to the selected hotbar slot changing or the contents of the item's inventory slot changing. |
+| Rules                     | `InteractionRules`                                                   | **Yes**   | If provided, adds additional limitations and cancellation conditions to this interaction.                                                                                                                                   |
+| Settings                  | `Map`<br />(Key Type: `GameMode`, Value Type: `InteractionSettings`) | **No**    | If provided, adds additional per-GameMode settings to the interaction.                                                                                                                                                      |
+| Camera                    | `InteractionCameraSettings`                                          | **No**    | Arrays of camera motion keyframes for cutscenes and reveals.                                                                                                                                                                |
+
+**GameMode Values**
+
+- `Creative`: The game is currently in Creative Mode
+- `Adventure`: The game is currently in Adventure Mode
+
+**InteractionEffects Fields**
+
+| Field Name               | Type                                              | Required? | Notes                                                                                                                                                 |
+| ------------------------ | ------------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Particles                | `Array`<br />(Element Type: `ModelParticle`)      | **No**    | Particle systems to activate when this interaction begins if the player is in third-person mode.                                                      |
+| FirstPersonParticles     | `Array`<br />(Element Type: `ModelParticle`)      | **No**    | Particle systems to activate when this interaction begins if the player is in first-person mode.                                                      |
+| WorldSoundEventId        | `Asset`<br />(Asset Type: `SoundEvent`)           | **No**    | A sound to play in the world at the User entity's location when this interaction begins.<br />**The SoundEvent must be single-channel (mono) sound.** |
+| LocalSoundEventId        | `Asset`<br />(Asset Type: `SoundEvent`)           | **No**    | A 2D sound to play for the User entity when this interaction begins. Ignored if the User entity is not a player.                                      |
+| Trails                   | `Array`<br />(Element Type: `ModelTrail`)         | **No**    | Trail effects to activate on the User entity when this interaction begins.                                                                            |
+| WaitForAnimationToFinish | `Boolean`<br />(Default: false)                   | **No**    | If true, this interaction will continue executing for at least the length of any animations in this InteractionEffects object.                        |
+| ItemPlayerAnimationsId   | `Asset`<br />(Asset Type: `ItemPlayerAnimations`) | **No**    | If provided, the User entity will use this ItemPlayerAnimations set while this interaction is executing.                                              |
+| ItemAnimationId          | `String`                                          | **No**    | Id of an animation to trigger when this interaction begins executing.<br />**This animation id is not validated on server start.**                    |
+| ClearAnimationOnFinish   | `Boolean`<br />(Default: false)                   | **No**    | If true, animations triggered by this interaction will be halted when the interaction completes.                                                      |
+| ClearSoundEventOnFinish  | `Boolean`<br />(Default: false)                   | **No**    | If true, sounds triggered by this interaction will be halted when the interaction completes.                                                          |
+| CameraEffect             | `Asset`<br />(Asset Type: `CameraEffect` )        | **No**    | If provided, the CameraEffect will be applied while this interaction is executing.                                                                    |
+| MovementEffects          | `MovementEffects`                                 | **No**    | If provided, apply the movement effects to the User entity while this interaction is executing.                                                       |
+| StartDelay               | `Float`<br />(Default: 0.0f)                      | **No**    | The interaction will wait this many seconds before triggering the effects in this object.                                                             |
+
+**InteractionRules Fields**
+
+| Field Name          | Type                                                                                                | Required? | Notes                                                                                                                                                                                                                                     |
+| ------------------- | --------------------------------------------------------------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| BlockedBy           | `Array`<br />(Element Type: `InteractionType`)<br />(Default: Based on the chain's InteractionType) | **No**    | If provided, this RootInteraction cannot be executed while interaction chains of the provided types are executing.<br />**This field only functions for rules attached to a RootInteraction. It has no effect on an Interaction.**        |
+| Blocking            | `Array`<br />(Element Type: `InteractionType`)                                                      | **No**    | If provided, interaction chains with the specified InteractionTypes cannot be executed while this interaction is executing.                                                                                                               |
+| InterruptedBy       | `Array`<br />(Element Type: `InteractionType`)                                                      | **No**    | If provided, interaction chains with the specified InteractionTypes will cancel this interaction chain when they execute.<br />**This field only functions for rules attached to a RootInteraction. It has no effect on an Interaction.** |
+| Interrupting        | `Array`<br />(Element Type: `InteractionType`)                                                      | **No**    | If provided, interaction chains with the specified InteractionTypes will be canceled when this interaction begins.                                                                                                                        |
+| BlockedByBypass     | `String`                                                                                            | **No**    | If provided, this RootInteraction cannot be blocked by interaction chains whose RootInteraction has this value as an asset tag.                                                                                                           |
+| BlockingBypass      | `String`                                                                                            | **No**    | If provided, this interaction will not block RootInteractions that have the this value as an asset tag.                                                                                                                                   |
+| InterruptedByBypass | `String`                                                                                            | **No**    | If provided, this RootInteraction cannot be canceled by RootInteractions that have this value as an asset tag.                                                                                                                            |
+| InterruptingBypass  | `String`                                                                                            | **No**    | If provided, this interaction will not cancel interaction chains whose RootInteraction has this value as an asset tag.                                                                                                                    |
+
+**InteractionType Values**
+
+- `Primary`
+- `Secondary`
+- `Ability1`
+- `Ability2`
+- `Ability3`
+- `Use`
+- `Pick`
+- `Pickup`
+- `CollisionEnter`
+- `CollisionLeave`
+- `Collision`
+- `EntityStatEffect`
+- `SwapTo`
+- `SwapFrom`
+- `Death`
+- `Wielding`
+- `ProjectileSpawn`
+- `ProjectileHit`
+- `ProjectileMiss`
+- `ProjectileBounce`
+- `Held`
+- `HeldOffhand`
+- `Equipped`
+- `Dodge`
+- `GameModeSwap`
+
+**InteractionSettings Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                        |
+| ---------------- | ------------------------------- | --------- | -------------------------------------------------------------------------------------------- |
+| AllowSkipOnClick | `Boolean`<br />(Default: false) | **No**    | If true, the user will be able to skip this interaction by clicking shortly after it starts. |
+
+**InteractionCameraSettings Fields**
+
+| Field Name  | Type                                             | Required? | Notes                                                                                                                                                           |
+| ----------- | ------------------------------------------------ | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| FirstPerson | `Array`<br />(Element Type: `InteractionCamera`) | **No**    | A list of camera keyframes to be played if the player is in first-person.<br />**The time of each keyframe must be after the keyframe before it in the array.** |
+| ThirdPerson | `Array`<br />(Element Type: `InteractionCamera`) | **No**    | A list of camera keyframes to be played if the player is in third-person.<br />**The time of each keyframe must be after the keyframe before it in the array.** |
+
+**InteractionCamera Fields**
+
+| Field Name | Type                         | Required? | Notes                                                                                                                                       |
+| ---------- | ---------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------- |
+| Time       | `Float`<br />(Default: 0.1f) | **No**    | How long after the interaction begins executing that the camera should arrive at this keyframe.<br />**Cannot be less than or equal to 0.** |
+| Position   | `Vector3`                    | **Yes**   | Where the camera should be located when it arrives at this keyframe.                                                                        |
+| Rotation   | `Direction`                  | **Yes**   | Where the camera should be pointing when it arrives at this keyframe.                                                                       |
+
+### SimpleInteraction
+
+Most interaction types below are inherited from SimpleInteraction and have these
+fields.  If a type does not have these fields, the documentation will mention it.
+
+The purpose of SimpleInteraction is to facilitate Interaction chaining by taking different paths
+based on whether the Interaction succeeded or failed.  The circumstances under which
+a given Interaction fails are generally type-specific (and described in the documentation
+below), but all interactions will be marked failed if they are cancelled via one of the
+many, many mechanisms for doing so.
+
+It is valid to create an interaction asset of type "Simple", which can be valuable when you want to use the
+interaction fields with no additional functionality.
+
+**SimpleInteraction Fields**
+
+| Field Name | Type                                     | Required? | Notes                                                                                          |
+| ---------- | ---------------------------------------- | --------- | ---------------------------------------------------------------------------------------------- |
+| Next       | `Asset`<br />(Asset Type: `Interaction`) | **No**    | After this Interaction has finished, "Next" will be executed if this Interaction did not fail. |
+| Failed     | `Asset`<br />(Asset Type: `Interaction`) | **No**    | After this Interaction has finished, "Failed" will be executed if this Interaction failed.     |
+
+## Flow Control
+
+These are interaction types used to control the flow of an interaction chain and allow interactions
+to be composed into more complex behaviors.  These interaction types generally do not pertain to
+the game and instead pertain to the interaction system itself.
+
+### Condition
+
+This interaction will fail if one of the fields is provided but does not match the current state.
+
+**Condition Fields**
+
+| Field Name       | Type       | Required? | Notes                                                                                                                                                                                    |
+| ---------------- | ---------- | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| RequiredGameMode | `GameMode` | **No**    | If provided, the interaction will fail if the current GameMode does not match the provided value.                                                                                        |
+| Jumping          | `Boolean`  | **No**    | If provided, the interaction will fail if the player's Jumping state does not match the provided value. (i.e. if True, the player must be jumping, if False, the player must not be)     |
+| Swimming         | `Boolean`  | **No**    | If provided, the interaction will fail if the player's Swimming state does not match the provided value. (i.e. if True, the player must be swimming, if False, the player must not be)   |
+| Crouching        | `Boolean`  | **No**    | If provided, the interaction will fail if the player's Crouching state does not match the provided value. (i.e. if True, the player must be crouching, if False, the player must not be) |
+| Running          | `Boolean`  | **No**    | If provided, the interaction will fail if the player's Running state does not match the provided value. (i.e. if True, the player must be running, if False, the player must not be)     |
+| Flying           | `Boolean`  | **No**    | If provided, the interaction will fail if the player's Flying state does not match the provided value. (i.e. if True, the player must be flying, if False, the player must not be)       |
+
+**GameMode Values**
+
+- `Creative`: The game is currently in Creative Mode
+- `Adventure`: The game is currently in Adventure Mode
+
+### FirstClick
+
+This interaction does not inherit from SimpleInteraction and therefore has no Next or Failed fields.
+
+This interaction has two fields that each contain a reference to an Interaction: Click and Hold.  If the root interaction
+of the chain was initiated by a client button/key press (or simulated NPC input) and the input was a tap, then
+the Click interaction is run. if it was a longer press, then the Hold interaction is run.
+
+As a minor implementation detail, this interaction is internally marked as failed when the Hold path is followed.
+This generally shouldn't matter.  If the interaction was not initiated by a key press at all, the Click path will be followed,
+but it seems risky to rely on that behavior.
+
+**FirstClick Fields**
+
+| Field Name | Type                                     | Required? | Notes                                                                                                                                                    |
+| ---------- | ---------------------------------------- | --------- | -------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Click      | `Asset`<br />(Asset Type: `Interaction`) | **No**    | If provided and the root interaction of the chain was initiated by button/key press, this interaction is executed next if the press was a quick tap.     |
+| Hold       | `Asset`<br />(Asset Type: `Interaction`) | **No**    | If provided and the root interaction of the chain was initiated by a button/key press, this interaction is executed next if the press was a longer hold. |
+
+### Interrupt
+
+This interaction can be used to cancel one or more running interaction chains on an entity and **all forked interaction
+chains those chains have spawned that are still currently running**.  All interaction chains canceled in this manner will be marked as
+Failed, which may have additional implications if the canceled chains are themselves forked from
+other chains that are still running.
+
+**Interrupt Fields**
+
+| Field Name     | Type                                           | Required? | Notes                                                                                                                                                                                               |
+| -------------- | ---------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Entity         | `InteractionTarget`<br />(Default: User)       | **Yes**   | The entity that is the owner of the target interaction chains.  This field can indicate the Owner, User, or Target of this interaction chain.                                                       |
+| InterruptTypes | `Array`<br />(Element Type: `InteractionType`) | **No**    | A set of InteractionTypes that are to be interrupted. Only interactions of these types are affected. If null, all types will be interrupted.<br />**(Note: An empty set will interrupt NO TYPES.)** |
+| RequiredTag    | `String`                                       | **No**    | An asset tag that, if provided, the RootInteraction of the interaction chain must have in order to be canceled.                                                                                     |
+| ExcludedTag    | `String`                                       | **No**    | An asset tag that, if provided, the RootInteraction of the interaction chain must not have in order to be canceled.                                                                                 |
+
+**InteractionTarget Values**
+
+- `User` - The user of this interaction chain. The entity whose actions caused this interaction chain to be executed. This is usually the same as the Owner.
+- `Owner` - The owner of this interaction chain. The entity upon whom this interaction chain is executing.
+- `Target` - The entity target of this interaction chain, if any.  This value is mutable (and can therefore come from many places) but most commonly, it is an entity the User was targeting when this interaction chain began executing.
+
+**InteractionType Values**
+
+- `Primary`
+- `Secondary`
+- `Ability1`
+- `Ability2`
+- `Ability3`
+- `Use`
+- `Pick`
+- `Pickup`
+- `CollisionEnter`
+- `CollisionLeave`
+- `Collision`
+- `EntityStatEffect`
+- `SwapTo`
+- `SwapFrom`
+- `Death`
+- `Wielding`
+- `ProjectileSpawn`
+- `ProjectileHit`
+- `ProjectileMiss`
+- `ProjectileBounce`
+- `Held`
+- `HeldOffhand`
+- `Equipped`
+- `Dodge`
+- `GameModeSwap`
+
+### Parallel
+
+This interaction does not inherit from SimpleInteraction and therefore has no Next or Failed fields.
+
+This interaction has a field `Interactions` that is an array of RootInteraction assets. The list must contain at least
+two RootInteractions.  This interaction will fork all of its children except for the first into their
+own interaction chains and immediately complete. After this interaction completes, this interaction chain will
+execute the first RootInteraction in the `Interactions` list.
+
+This interaction does not have any failure conditions and is indifferent to the fate of the forked interaction chains.
+
+**Parallel Fields**
+
+| Field Name   | Type                                                | Required? | Notes                                                         |
+| ------------ | --------------------------------------------------- | --------- | ------------------------------------------------------------- |
+| Interactions | `AssetArray`<br />(Element Type: `RootInteraction`) | **Yes**   | An array of RootInteractions that will be forked or executed. |
+
+### Repeat
+
+This interaction has a field `ForkInteractions` that is an asset of type RootInteraction. This interaction will fork that
+RootInteraction into its own interaction chain and then wait for it to complete. If the RootInteraction fails, this
+interaction will complete immediately and be marked failed. Otherwise, the RootInteraction will be forked and run again,
+up to a specified total number of times.
+
+**Repeat Fields**
+
+| Field Name       | Type                                                                                   | Required? | Notes                                                                                                                                                                                                              |
+| ---------------- | -------------------------------------------------------------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| ForkInteractions | `Asset`<br />(Asset Type: `RootInteraction`)                                           | **Yes**   | A RootInteraction that will be forked.                                                                                                                                                                             |
+| Repeat           | `Integer`<br />(Default: 1)<br />**Must be -1 or a positive integer. 0 is not valid.** | **No**    | The total number of times to fork ForkInteractions. If -1 is provided, ForkInteractions will continue being forked and executed indefinitely, until this interaction is cancelled or until ForkInteractions fails. |
+
+### Replace
+
+This interaction does not inherit from SimpleInteraction and therefore has no Next or Failed fields.
+
+This interaction uses the InteractionVars system that is avaiable for items. InteractionVars are RootInteractions that
+can be attached to an Item asset with a name.
+
+This interaction specifies a var name, and if this interaction chain was executed through
+an item and that item has an InteractionVar of the same name, then this interaction will immediately execute
+the RootInteraction on the var.  Otherwise, it will execute the default RootInteraction specified in this interaction.
+If no default is specified, then this interaction will be marked as failed.
+
+**Replace Fields**
+
+| Field Name   | Type                                         | Required? | Notes                                                                                                                                                                                                           |
+| ------------ | -------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Var          | `String`                                     | **Yes**   | The name of the InteractionVar to execute.                                                                                                                                                                      |
+| DefaultValue | `Asset`<br />(Asset Type: `RootInteraction`) | **No**    | The RootInteraction to execute if the owning item does not have an InteractionVar by the specified name. If not provided, the interaction will be marked as failed instead.                                     |
+| DefaultOk    | `Boolean`<br />(Default: false)              | **No**    | If false, then an angry message will be printed to the server logs if the owning item does not have an InteractionVar by the specified name.  The functioning of this interaction will be otherwise unaffected. |
+
+### RunRootInteraction
+
+This interaction immediately executes the provided RootInteraction as part of this interaction chain. This interaction
+does not have any failure conditions.
+
+**RunRootInteraction Fields**
+
+| Field Name      | Type                                         | Required? | Notes                           |
+| --------------- | -------------------------------------------- | --------- | ------------------------------- |
+| RootInteraction | `Asset`<br />(Asset Type: `RootInteraction`) | **Yes**   | The RootInteraction to execute. |
+
+### Selector
+
+This interaction will execute a Selector to find entities and/or blocks (depending on the Selector) and fork off an
+interaction chain for each located entity or block. This interaction will not wait for those interaction chains
+to complete and is indifferent to their fate. The forked interaction chains will use the located entity/block as
+their target entity/target block. Each entity or block will only fork one interaction chain over the life of this
+interaction.  The Selector is guaranteed to run once for each execution of this interaction, but some Selectors
+are intended to be run over a period of time and sweep across an area to locate targets. In order to use those Selectors
+properly, you will need to extend the execution time of this interaction using `RunTime` or `WaitForAnimationToFinish`.
+The Selector will be executed repeatedly over the lifetime of the interaction.
+
+If the Selector is configured to locate entities, you can add additional sets of entity matching rules. If a located entity
+matches one of the rules, the matching RootInteraction will be forked instead of the standard `HitEntity` RootInteraction.
+
+Entities located by the Selector will be ignored if they do not have a NetworkId, if they are dead, or if they are invulnerable.
+The only exception to this rule is that players in Creative Mode that are marked to receive hits will not be ignored.
+
+This interaction's failure conditions are configurable via the `FailOn` field. You can configure this interaction to never
+fail, to fail if the Selector does not locate any blocks before this interaction finishes executing, to fail if the
+Selector does not locate any entities before this interaction finishes executing, or to fail in either case.
+
+**Selector Fields**
+
+| Field Name     | Type                                         | Required? | Notes                                                                                                                                                                                                                                     |
+| -------------- | -------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Selector       | `Selector`                                   | **Yes**   | The Selector is executed at least once and may be executed repeatedly to locate blocks and/or entities in an area.                                                                                                                        |
+| HitEntity      | `Asset`<br />(Asset Type: `RootInteraction`) | **No**    | If included and the `Selector` locates an entity that does not match any `HitEntityRules`, this RootInteraction will be forked into a new interaction chain with the located entity as the target entity.                                 |
+| HitEntityRules | `Array`<br />(Element Type: `HitEntity`)     | **No**    | If included, these rules will be matched against any entity located by the `Selector`. If an entity matches a set of rules, the RootInteraction associated with the rules will be forked instead of the standard `HitEntity` interaction. |
+| HitBlock       | `Asset`<br />(Asset Type: `RootInteraction`) | **No**    | If included and the `Selector` locates a block, this RootInteraction will be forked into a new interaction chain with the located block as the block target.                                                                              |
+| FailOn         | `FailOnType`<br />(Default: `Neither`)       | **No**    | Defines under what circumstances this interaction will fail.  It can be marked to fail when it completes without locating any blocks, it can be marked to fail when it completes without locating any entities, both, or neither.         |
+| IgnoreOwner    | `Boolean`<br />(Default: true)               | **No**    | If true, the Selector will not locate the User entity of this interaction.                                                                                                                                                                |
+
+**HitEntity Fields**
+
+| Field Name | Type                                         | Required? | Notes                                                                                                 |
+| ---------- | -------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------- |
+| Matchers   | `Array`<br />(Element Type: `EntityMatcher`) | **Yes**   | A set of rules that an entity must match. An entity must successful match all rules to be considered. |
+| Next       | `Asset`<br />(Asset Type: `RootInteraction`) | **Yes**   | The RootInteraction to fork if an entity matches all rules.                                           |
+
+**EntityMatcher Fields**
+
+| Field Name | Type                            | Required? | Notes                                                                                                     |
+| ---------- | ------------------------------- | --------- | --------------------------------------------------------------------------------------------------------- |
+| Type       | `String`                        | **Yes**   | If provided, specifies a type of EntityMatcher to use. Each matcher type may come with additional fields. |
+| Invert     | `Boolean`<br />(Default: false) | **No**    | If true, an entity must fail this rule for it to be marked as succeeded.                                  |
+
+**EntityMatcher Type: Player**
+
+This EntityMatcher will succesfully match the entity only if they are a player.
+
+**EntityMatcher Type: Vulnerable**
+
+This Entitymatcher will successfully match the entity only if they are not marked as invulnerable.
+
+**FailOnType Values**
+
+- `Neither`
+- `Entity`
+- `Block`
+- `Either`
+
+### Serial
+
+This interaction does not inherit from SimpleInteraction and therefore has no Next or Failed fields.
+
+This interaction has a field `Interactions` which is a list of Interaction assets. This interaction immediately
+completes and the interaction chain continues by executing the interactions in the list one at a time. This
+interaction does not have any failure conditions.
+
+**Serial Fields**
+
+| Field Name   | Type                                            | Required? | Notes                                      |
+| ------------ | ----------------------------------------------- | --------- | ------------------------------------------ |
+| Interactions | `AssetArray`<br />(Element Type: `Interaction`) | **Yes**   | An array of Interaction assets to execute. |
+
+## Cooldowns
+
+RootInteractions interface with a complex cooldown system that can be used for a variety of purposes. Aside from simply
+adding an important aspect of resource management to your game design, cooldowns can be used to ensure that click-activated
+interaction chains don't repeatedly spam if the player holds down the input.
+
+By default, every RootInteraction has a cooldown timer that is keyed to the RootInteraction name, and by default, it
+will launch a cooldown of 0.35 seconds when activated by client input.  Otherwise, no cooldown will be activated.  However,
+by configuring your RootInteraction, you can change the key for the cooldown (so that multiple RootInteractions can share
+a single cooldown), set the cooldown timer to whatever you like, and configure multiple charges that can build up over time
+to allow the entity to activate the RootInteraction multiple times before being forced to pause.
+
+One important concept to keep in mind is the difference between **cooldown** and **charge time**.  The cooldown, if any,
+is activated each time a RootInteraction triggers, even if the player has more available charges. If the RootInteraction
+is configured to use charges, then they will gradually build up over time. In order for a RootInteraction to be activated,
+the cooldown (if any) must be expired, and the RootInteraction must have at least one charge (if it has been
+configured to use charges).
+
+Bear in mind that the entire Cooldown configuration is shared between different RootInteractions with the same cooldown id.
+If you activate an ability with 5 charges and a short cooldown and then another ability with a much longer cooldown and no
+charges, the second ability will use the cooldown properties of the first ability until/unless the first ability finishes
+charging and is cleared from the system.  You should generally only have multiple RootInteractions share a cooldown id
+if they have the same configuration.
+
+The interactions below interact with the cooldown system to allow you to manipulate cooldowns via the interaction system. By
+using these interactions, you can have several interaction chains with different cooldown configurations share cooldowns
+that are checked and activated as part of the interaction chain itself, or have some components of an interaction change
+use a second cooldown separate from the main one.
+
+### CooldownCondition
+
+**CooldownCondition Fields**
+
+This interaction will fail if the specified cooldown id is on cooldown for the User entity.  This interaction will only
+function for players- the interaction will always succeed for NPCs.  In order for this interaction to succeed, the
+cooldown, if any, must have expired and at least one charge, if any, must have filled.
+
+| Field Name | Type     | Required? | Notes                     |
+| ---------- | -------- | --------- | ------------------------- |
+| Id         | `String` | **Yes**   | The cooldown id to check. |
+
+### IncrementCooldown
+
+**IncrementCooldown Fields**
+
+This interaction will modify a cooldown that is currently active on the User entity, allowing charges and remaining
+cooldown to be modified.
+Despite its name, this interaction can be used to reduce a cooldown as well as increase it. If the cooldown is not
+currently active, this interaction will have no effect. The interaction has no special failure conditions.
+
+| Field Name        | Type                        | Required? | Notes                                                                                                                                                                                                                                                                                     |
+| ----------------- | --------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Id                | `String`                    | **No**    | If provided, the cooldown id of the cooldown to be manipulated. If not provided, the cooldown id of the current chain's RootInteraction will be used.                                                                                                                                     |
+| Time              | `Float`<br />(Default: 0.0) | **No**    | The amount to increase the remaining cooldown by. Can be negative. The remaining cooldown time will not be reduced below zero or increased above the maximum cooldown time.                                                                                                               |
+| ChargeTime        | `Float`<br />(Default: 0.0) | **No**    | The amount to increase the remaining time until the next charge is filled by. Can be negative. The remaining charge time cannot be reduced below zero or increased above the maximum cooldown time. **This will not work on abilities that have a maximum of 1 charge, for some reason.** |
+| Charge            | `Integer`<br />(Default: 0) | **No**    | The amount to increase the number of charges by. Can be negative. The number of charges cannot be reduced below 0 or increased above the maximum.                                                                                                                                         |
+| InterruptRecharge | `Boolean`(Default: false)   | **No**    | If true and `Charge` is not 0, will reset the remaining time to the next charge to the maximum value after changing the charge count.                                                                                                                                                     |
+
+### ResetCooldown
+
+This interaction will trigger a cooldown on the User entity with a specified configuration. The charges will be refilled
+but the cooldown will be immediately triggered.  The mechanisms for deciding on the configuration are a little bit complicated.
+You may specify a cooldown configuration via the `Cooldown` field. If you do not include an `Id` field, then the
+interaction chain's RootInteraction will be used for any field not specified in the configuration. If there is an active
+cooldown under the specified `Id` (or under the RootInteraction's cooldown id if none is specified) then the fields
+from that active cooldown will overwrite data in the RootInteraction's cooldown, but not data in your `Cooldown` field.
+
+**ResetCooldown Fields**
+
+| Field Name | Type                  | Required? | Notes                                                        |
+| ---------- | --------------------- | --------- | ------------------------------------------------------------ |
+| Cooldown   | `InteractionCooldown` | **No**    | A cooldown configuration to use for the new, reset cooldown. |
+
+**InteractionCooldown Fields**
+
+| Field Name        | Type                                 | Required? | Notes                                                                                                                                                                                                 |
+| ----------------- | ------------------------------------ | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Id                | `String`                             | **No**    | The cooldown id to use for this cooldown. If not provided, the RootInteraction's cooldown id will be used, if any.                                                                                    |
+| Cooldown          | `Float`<br />(Default: 0.0)          | **No**    | The duration of the cooldown, in seconds.                                                                                                                                                             |
+| Charges           | `Array`<br />(Element Type: `Float`) | **No**    | If provided, a list of how many charges this cooldown can build, and how long each charge takes to build, in seconds.                                                                                 |
+| InterruptRecharge | `Boolean`<br />(Default: false)      | **No**    | If true, the charge time will be reset when the number of charges changes.                                                                                                                            |
+| ClickBypass       | `Boolean`<br />(Default: false)      | **No**    | If true, RootInteractions keyed to this cooldown can still be activated when it is on cooldown provided that the RootInteraction was triggered by a distinct key or mouse button press on the client. |
+
+### TriggerCooldown
+
+This interaction is similar to ResetCooldown, except instead of refilling the cooldown's charges, one charge will be deducted
+as normal.
+
+**TriggerCooldown Fields**
+
+| Field Name | Type                  | Required? | Notes                                                        |
+| ---------- | --------------------- | --------- | ------------------------------------------------------------ |
+| Cooldown   | `InteractionCooldown` | **No**    | A cooldown configuration to use for the new, reset cooldown. |
+
+**InteractionCooldown Fields**
+
+| Field Name        | Type                                 | Required? | Notes                                                                                                                                                                                                 |
+| ----------------- | ------------------------------------ | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Id                | `String`                             | **No**    | The cooldown id to use for this cooldown. If not provided, the RootInteraction's cooldown id will be used, if any.                                                                                    |
+| Cooldown          | `Float`<br />(Default: 0.0)          | **No**    | The duration of the cooldown, in seconds.                                                                                                                                                             |
+| Charges           | `Array`<br />(Element Type: `Float`) | **No**    | If provided, a list of how many charges this cooldown can build, and how long each charge takes to build, in seconds.                                                                                 |
+| InterruptRecharge | `Boolean`<br />(Default: false)      | **No**    | If true, the charge time will be reset when the number of charges changes.                                                                                                                            |
+| ClickBypass       | `Boolean`<br />(Default: false)      | **No**    | If true, RootInteractions keyed to this cooldown can still be activated when it is on cooldown provided that the RootInteraction was triggered by a distinct key or mouse button press on the client. |
+
+## Combo Chains
+
+Hytale additionally comes with a rich "combo chaining" system, which allows several inputs in a row to result in different
+attacks and special moves.  Rather than being attached to the RootInteraction like the cooldown system, these are
+primarily driven by the `Chaining` interaction.
+
+### Chaining
+
+This interaction does not inherit from SimpleInteraction and therefore has no Failed field. Its Next field works differently
+from most interaction types.
+
+Chaining is a type of flow control interaction- each time a Chaining interaction with the same `ChainId` is called, a single
+interaction in the `Next` list is chosen and the others are ignored. The first time the `ChainId` is used, the first
+interaction in the list is chosen, the next time the second, etc. Once the end of the list is reached, the first
+interaction will be chosen again.
+
+Bear in mind: the progress through the Next list is based on the **ChainId**, not the interaction!  That means that two
+different Chaining interactions can share a single combo chain. You could have a pair of daggers that attacks with
+the left when the left mouse button is clicked and with the right when the right mouse button is clicked.  You could give
+both interaction chains a Chaining interaction with the same `ChainId` and three `Next` entries that do a light-light-heavy
+combo.  Each specific hit would occur with either the left or the right knife based on which button you clicked, but
+the combo would be otherwise identical regardless of which you chose.
+
+The Chaining interaction also has a concept called "flags".  It is possible to attach named flags to a `ChainId` by using
+the ChainFlag interaction.  Then, you specify the flag name in Chaining's `Flags` field. If a Flag is active when the
+Chaining interaction is run, the Flag's interaction will be run instead of the appropriate interaction in `Next`.
+Bear in mind: the entity's progress through the `Next` list still advances, the resulting `Next` interaction is just not
+run.  Only one flag can be active at a time.
+
+Lastly, it is possible to cancel the entity's progress through the combo chain and reset them to the first interaction in
+the list. This can be done with the CancelChain interaction, but it will also happen automatically if the player does
+not trigger an interaction with the ChainId for the specified ChainingAllowance.  When either of these happen, all flags will be
+canceled as well.
+
+All of these effects are triggered on the User entity only. Non-players can use the chaining system, but Flags do not currently
+work for non-players.  This interaction has no special failure conditions.
+
+**Chaining Fields**
+
+| Field Name        | Type                                                       | Required? | Notes                                                                                                                                                                                                                       |
+| ----------------- | ---------------------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| ChainId           | `String`                                                   | **No**    | If provided, acts as a key that multiple Chaining interactions can use to share combo chain progress and flags. If not provided, a unique ChainId will be generated for this interaction.                                   |
+| ChainingAllowance | `Double`<br />(Default: 0.0)                               | **No**    | If, at the time this interaction is triggered, it has been this long in seconds since the last time a Chaining interaction with the same ChainId was executed, all state for this ChainId will be cleared before execution. |
+| Next              | `AssetArray`<br />(Element Type: `Interaction`)            | **Yes**   | A list of interactions to cycle between each time this interaction is run.                                                                                                                                                  |
+| Flags             | `Map`<br />(Key Type: `String`, Value Type: `Interaction`) | **No**    | A map of flag names to interactions to run if the flag is active when this interaction executes.                                                                                                                            |
+
+### CancelChain
+
+This interaction resets all progress and flag data on the User entity for the provided `ChainId`.  The next time a Chaining
+interaction is called for the provided `ChainId`, it will begin at the first interaction in the `Next` list. This
+interaction has no special failure conditions.
+
+**CancelChain Fields**
+
+| Field Name | Type     | Required? | Notes                                 |
+| ---------- | -------- | --------- | ------------------------------------- |
+| ChainId    | `String` | **Yes**   | A ChainId whose data should be reset. |
+
+### ChainFlag
+
+This interaction activates a flag on the User entity for the provided `ChainId`, which can be used to change behavior the
+next time a Chaining interaction with this `ChainId` is run. This will overwrite any flag that has
+already been raised. This interaction will have no effect for non-players. This interaction has no special failure
+conditions.
+
+| Field Name | Type     | Required? | Notes                                        |
+| ---------- | -------- | --------- | -------------------------------------------- |
+| ChainId    | `String` | **Yes**   | A ChainId on whom the flag should be raised. |
+| Flag       | `String` | **Yes**   | The name of the flag to raise.               |
+
+## Charging
+
+A unique flow-control interaction that is frequently used is the Charging interaction.  It is a flow-control interaction
+that delays while the input button used to trigger the interaction chain is held.  When it is released (or the interaction
+is forced to end), the interaction chain can continue with a different interaction based on how long the input was held
+for.
+
+These interactions are all related by either being the Charging interaction, or other interaction types that inherit the
+Charging interaction's behavior.
+
+### Charging
+
+This interaction does not inherit from SimpleInteraction and therefore its Next field works different from most interactions.
+This interaction adds its own Failed field which works the same way that SimpleInteraction's does.
+
+This interaction only works properly when its interaction chain was triggered by a client key or button press (or
+NPC-simulated equivalent). This interaction will continue executing for as long as the key or button press is held (with
+some exceptions, covered below) by the User entity.  Like other interactions, it has a `Next` field indicating which interaction to execute
+after this one, but the field is a map from `Float` values to `Interaction` assets. When this interaction ends, either
+due to the input being released or the charge duration completing, this interaction will determine the largest `Float` key that is less
+than the amount of time in seconds that the interaction was executing for.  The Interaction mapped to that key will be
+executed next.
+
+The interaction includes some cancellation conditions that are specific to this interaction. For instance, the interaction
+has a `CancelOnOtherClick` field that matches the field on RootInteraction. If it is active on this interaction but not
+the RootInteraction, then clicking while charging will cancel this interaction (and execute the `Failed` interaction rather
+than any of the `Next` interactions) but otherwise continue the interaction chain.
+
+Another valuable feature Charging has is the `Forks` field.  For input-triggered interactions that are triggered while the
+Charging interaction is executing, you can add an entry for the relevant InteractionType to this field and instead of
+triggering the usual interaction chain based on held item, targeted block, etc. the RootInteraction specified in the
+`Forks` field will be triggered.  This can unlock rich attack modes and behaviors. For instance, having a shield bash attack
+triggered off left click while blocking, or a special attack that triggers when both mouse buttons are pressed at the
+same time.
+
+There are two modes of operation for the Charging interaction. One is to have the ability charge for as long
+as the input is held and only end execution when the entity releases the input.  Bows in the main Hytale game work
+that way.  That is accomplished by setting `AllowIndefiniteHold` to true.  Another mode of operation is to have the
+interaction complete execution when the execution time has surpassed the largest key value in the `Next` field and
+immediately begin executing the Interaction mapped to that key.  Food in the main Hytale game work like this.  It
+is accomplished by setting `AllowIndefiniteHold` to false.
+
+One pitfall to be careful of when setting `AllowIndefiniteHold` to false is the way it interacts with cooldowns.\
+Normally, input-initiated interaction chains start a 0.35s cooldown on the triggered RootInteraction that prevents
+holding the mouse button from immediately spamming a new interaction when the first one completes.  However, if the
+duration of a Charging interaction is longer than 0.35s, then the cooldown will have already completed when the
+interaction chain finishes, which will often result in a new execution beginning immediately before the player can
+stop pressing the mouse button.  One solution for this problem is to add a `Simple` interaction to the end of your
+interaction chain with a `RunTime` of 0.35s to simulate the cooldown.  Alternatively, you can add a longer cooldown
+(the maximum duration of your Charging interaction plus 0.35s) to the RootInteraction. However, the longer cooldown is
+not always desirable, as the interaction may have ended prematurely, resulting in an unusually long lockout between
+executions.
+
+**Charging Fields**
+
+| Field Name                         | Type                                                                    | Required? | Notes                                                                                                                                                                                                                                                                                                                                                                                       |
+| ---------------------------------- | ----------------------------------------------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| FailOnDamage                       | `Boolean`<br />(Default: false)                                         | **No**    | If true, this interaction will fail and end immediately if the User entity takes any damage while it is executing.                                                                                                                                                                                                                                                                          |
+| CancelOnOtherClick                 | `Boolean`<br />(Default: true)                                          | **No**    | If true, this interaction will fail and end immediately if the User entity sends another button or key press while it is executing.                                                                                                                                                                                                                                                         |
+| Forks                              | `Map`<br />(Key Type: `InteractionType`, Value Type: `RootInteraction`) | **No**    | A map of InteractionType to RootInteraction. If entity input triggers the InteractionType while this interaction is executing, the mapped RootInteraction will be forked into its own interaction chain. This will happen instead of the usual handling for that InteractionType.  This fork will occur even if `CancelOnOtherClick` is set to true.                                        |
+| Failed                             | `Asset`<br />(Asset Type: `Interaction`)                                | **No**    | After this Interaction has finished, "Failed" will be executed if this Interaction failed.                                                                                                                                                                                                                                                                                                  |
+| AllowIndefiniteHold                | `Boolean`<br />(Default: false)                                         | **No**    | If true, this interaction will continue executing for as long as the User entity continues to hold the input. If false, execution will end as soon as the execution time in seconds reaches the largest key value in the `Next` map.                                                                                                                                                        |
+| DisplayProgress                    | `Boolean`<br />(Default: true)                                          | **No**    | If true, players executing this interaction will see a progress bar will be displayed below their cursor indicating how close to reaching the highest key value in `Next` they are.                                                                                                                                                                                                         |
+| Next                               | `Map`<br />(Key Type: `Float`, Value Type: `Interaction`)               | **No**    | A map from `Float` to `Interaction`.  When this interaction successfully finishes executing (either because the input was released or because the maximum duration was reached), this interaction will find the `Float` value with the largest duration in seconds that is less than the amount of time this interaction executed for. That key's mapped Interaction will then be executed. |
+| MouseSensitivityAdjustmentTarget   | `Float`<br />(Default: 1.0)                                             | **No**    | While charging, this mouse sensitivity multiplier will gradually be applied.                                                                                                                                                                                                                                                                                                                |
+| MouseSensitivityAdjustmentDuration | `Float`<br />(Default: 1.0)                                             | **No**    | Duration in seconds. After this many seconds, `MouseSensitivityAdjustmentTarget` will be fully applied to the mouse sensitivity.                                                                                                                                                                                                                                                            |
+| Delay                              | `ChargingDelay`                                                         | **No**    | Settings that allow charging progress to be pushed back when the User entity takes damage.                                                                                                                                                                                                                                                                                                  |
+
+**ChargingDelay Fields**
+
+| Field Name    | Type                        | Required? | Notes                                                                                                                                                                                                                                                                     |
+| ------------- | --------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| MinHealth     | `Float`<br />(Default: 0.0) | **No**    | Damage taken as a percentage of entity health (0.0-1.0). If a hit deals less than this much damage, no pushback will be applied.  If a hit deals exactly this much damage, `MinDelay` seconds worth of pushback will be applied.                                          |
+| MaxHealth     | `Float`<br />(Default: 0.0) | **No**    | Damage taken as a percentage of entity health (0.0-1.0). If a hit deals at least this much damage, `MaxDelay` seconds worth of pushback will be applied.                                                                                                                  |
+| MinDelay      | `Float`<br />(Default: 0)   | **No**    | The amount of pushback, in seconds, to apply if the entity takes a hit that deals `MinHealth` damage. The amount of pushback applied by a hit is a gradiant between `MinDelay` and `MaxDelay` based on the amount of damage between `MinHealth` and `MaxHealth`.          |
+| MaxDelay      | `Float`<br />(Default: 0)   | **No**    | The amount of pushback, in seconds, to apply if the entity takes a hit that deals at least `MaxHealth` damage. The amount of pushback applied by a hit is a gradiant between `MinDelay` and `MaxDelay` based on the amount of damage between `MinHealth` and `MaxHealth`. |
+| MaxTotalDelay | `Float`<br />(Deault: 0)    | **No**    | The maximum amount of pushback the entity can receive over the course of a single charge, regardless of how many times they are hit.                                                                                                                                      |
+
+**InteractionType Values**
+
+- `Primary`
+- `Secondary`
+- `Ability1`
+- `Ability2`
+- `Ability3`
+- `Use`
+- `Pick`
+- `Pickup`
+- `CollisionEnter`
+- `CollisionLeave`
+- `Collision`
+- `EntityStatEffect`
+- `SwapTo`
+- `SwapFrom`
+- `Death`
+- `Wielding`
+- `ProjectileSpawn`
+- `ProjectileHit`
+- `ProjectileMiss`
+- `ProjectileBounce`
+- `Held`
+- `HeldOffhand`
+- `Equipped`
+- `Dodge`
+- `GameModeSwap`
+
+### Wielding
+
+This interaction is inherited from Charging rather than SimpleInteraction.  However, its `Failed` and `Next` fields function
+identically to SimpleInteraction.  It does not inherit all fields from Charging, so be sure to pay close attention to
+the field list below.
+
+This interaction drives most blocking behavior in the game. While this interaction is executing, attacks made against
+the Owner entity will (conditionally) trigger effects defined in this interaction.  Unlike the Charging interaction,
+this interaction can always execute indefinitely and will only end when it fails or when the input is released.
+
+One option available in Wielding is `AngledWielding`, which allows damage and knockback modifiers to only be applied
+depending on the direction the attack against the Owner entity is coming from.  The AngledWielding type has a
+field `Angle` which determines which direction the protection points relative to the player (0 is the player's
+front), and `AngleDistance` which determines how wide the cone of protection extends around the player.  Block effects
+from this interaction (such as `BlockedEffects`, `BlockedInteractions`, and `StaminaCost`) will only apply if
+the DamageCause matches `DamageModifiers` OR if the DamageCause matches `AngledWielding.DamageModifiers` and
+the source of the damage matches `Angle` and `AngleDistance`.  It is possible for damage and knockback multipliers
+specified on both this interaction's modifier fields and `AngledWielding`'s modifier fields to stack, if both
+have entries for the same DamageCause.
+
+This interaction will only have an effect on damage taken by one of the DamageCause entries in `DamageModifiers` or
+`AngledWielding.DamageModifiers`.  If a DamageCause is in `DamageModifiers`, then the block effect will be triggered
+and the damage modifier applied regardless of what direction the Owner entity is attacked from.  If a DamageCause is in
+`AngledWielding.DamageModifiers`, then the damage modifier is only applied if the
+
+\*\* Wielding Fields\*\*
+
+| Field Name          | Type                                                                    | Required? | Notes                                                                                                                                                                                                                                                                                                                                                                                                      |
+| ------------------- | ----------------------------------------------------------------------- | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| FailOnDamage        | `Boolean`<br />(Default: false)                                         | **No**    | If true, this interaction will fail and end immediately if the User entity takes any damage while it is executing.                                                                                                                                                                                                                                                                                         |
+| CancelOnOtherClick  | `Boolean`<br />(Default: true)                                          | **No**    | If true, this interaction will fail and end immediately if the User entity sends another button or key press while it is executing.                                                                                                                                                                                                                                                                        |
+| Forks               | `Map`<br />(Key Type: `InteractionType`, Value Type: `RootInteraction`) | **No**    | A map of InteractionType to RootInteraction. If entity input triggers the InteractionType while this interaction is executing, the mapped RootInteraction will be forked into its own interaction chain. This will happen instead of the usual handling for that InteractionType.  This fork will occur even if `CancelOnOtherClick` is set to true (after which this interaction chain will be canceled). |
+| Next                | `Asset`<br />(Asset Type: `Interaction`)                                | **No**    | After this interaction has finished, "Next" will be executed if this interaction did not fail.                                                                                                                                                                                                                                                                                                             |
+| Failed              | `Asset`<br />(Asset Type: `Interaction`)                                | **No**    | After this interaction has finished, "Failed" will be executed if this interaction failed.                                                                                                                                                                                                                                                                                                                 |
+| DamageModifiers     | `Map`<br />(Key Type: `DamageCause`, Value Type: `Float`)               | **No**    | A map from DamageCause to Float, where the Float is multiplied against any damage received from the mapped DamageCause while this interaction is executing.                                                                                                                                                                                                                                                |
+| KnockbackModifiers  | `Map`<br />(Key Type: `DamageCause`, Value Type: `Float`)               | **No**    | A map from DamageCause to Float, where the Float is multiplied against any knockback force received from the mapped DamageCause while this interaction is executing.                                                                                                                                                                                                                                       |
+| AngledWielding      | `AngledWielding`                                                        | **No**    | Configuration to only trigger block effects from certain angles.                                                                                                                                                                                                                                                                                                                                           |
+| StaminaCost         | `StaminaCost`                                                           | **No**    | If the Owner entity receives damage that matches `DamageModifiers` or `AngledWielding` while this interaction is executing, then the entity's stamina will be deducted according to this configuration.                                                                                                                                                                                                    |
+| BlockedEffects      | `DamageEffects`                                                         | **No**    | If the Owner entity receives damage that matches `DamageModifiers` or `AngledWielding` while this interaction is executing, then these effects will be applied to the instance of damage.                                                                                                                                                                                                                  |
+| BlockedInteractions | `Asset`<br />(Asset Type: `RootInteraction`)                            | **No**    | If the Owner entity receives damage that matches `DamageModifiers` or `AngledWielding` while this interaction is executing, then this RootInteraction will be launched as a brand new interaction chain with the Owner entity as both Owner and User, and the attacker as the Target entity.  This new interaction chain is, notably, brand new, **not** forked from the current one.                      |
+
+**AngledWielding Fields**
+
+| Field Name         | Type                                                      | Required? | Notes                                                                                                                                                                                                            |
+| ------------------ | --------------------------------------------------------- | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Angle              | `Float`<br />(Default: 0.0)                               | **No**    | Angle in degrees relative to the Owner entity where the angled protection is centered. 0.0 means pointed towards the front of the Owner entity.                                                                  |
+| AngleDistance      | `Float`<br />(Default: 0.0)                               | **No**    | Angle in degrees indicating how wide the cone of protection is.                                                                                                                                                  |
+| DamageModifiers    | `Map`<br />(Key Type: `DamageCause`, Value Type: `Float`) | **No**    | A map from DamageCause to Float, where the Float is multiplied against any damage received from the mapped DamageCause received from within the cone of protection while this interaction is executing.          |
+| KnockbackModifiers | `Map`<br />(Key Type: `DamageCause`, Value Type: `Float`) | **No**    | A map from DamageCause to Float, where the Float is multiplied against any knockback force received from the mapped DamageCause received from within the cone of protection while this interaction is executing. |
+
+**StaminaCost Fields**
+
+| Field Name | Type                                             | Required? | Notes                                                                                                                                                                                                                                                |
+| ---------- | ------------------------------------------------ | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| CostType   | `CostType`<br />(Default: `MaxHealthPercentage`) | **No**    | How to calculate stamina consumed by blocking from the raw pre-block damage. If `Damage`, then the stamina consumed will be `rawDamage / Value`. If `MaxHealthPercentage`, then the stamina consumed will be `rawDamage / (EntityMaxHealth * Value)` |
+| Value      | `Float`<br />(Default: 0.04)                     | **No**    | The value to use in the `CostType` formula.                                                                                                                                                                                                          |
+
+**DamageEffects Fields**
+
+| Field Name             | Type                                         | Required? | Notes                                                                           |
+| ---------------------- | -------------------------------------------- | --------- | ------------------------------------------------------------------------------- |
+| ModelParticles         | `Array`<br />(Element Type: `ModelParticle`) | **No**    | Particle systems to trigger in the first-person view.                           |
+| WorldParticles         | `Array`<br />(Element Type: `WorldParticle`) | **No**    | Particle systems to trigger in the third-person view.                           |
+| LocalSoundEventId      | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | 2D sound to play locally to the attacking entity if they are a player.          |
+| WorldSoundEventId      | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | Sound to play in the world at the Owner entity's location.                      |
+| PlayerSoundEventId     | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | 2D sound to play locally to the Owner entity if they are a player.              |
+| ViewDistance           | `Double`<br />(Default: 75.0)                | **No**    | Distance at which these effects should play for other players.                  |
+| Knockback              | `Knockback`                                  | **No**    | The properties of the knockback that will be applied.                           |
+| CameraEffect           | `Asset`<br />(Asset Type: `CameraEffect`)    | **No**    | CameraEffect to briefly apply locally to the Owner entity if they are a player. |
+| StaminaDrainMultiplier | `Float`<br />(Default: 1.0)                  | **No**    | This multiplier is applied to the `StaminaCost`, if any.                        |
+
+**Knockback Fields**
+
+| Field Name     | Type                                       | Required? | Notes                                                                                                                      |
+| -------------- | ------------------------------------------ | --------- | -------------------------------------------------------------------------------------------------------------------------- |
+| Type           | `String`                                   | **No**    | If provided, specifies a type of knockback to use. Each knockback type may come with additional fields.                    |
+| Force          | `Double`<br />(Default: 0.0)               | **No**    | The amount of force to apply to the Owner entity.                                                                          |
+| Duration       | `Double`<br />(Default: 0.0)               | **No**    | If 0.0, apply the force as a single impulse.  If more, continuously apply the force over a period of time.                 |
+| VelocityType   | `ChangeVelocityType`<br />(Default: `Add`) | **No**    | How to apply the force, either adding it to the entity's current velocity, or setting the velocity to the knockback force. |
+| VelocityConfig | `VelocityConfig`                           | **No**    | Characteristics of friction as the Owner entity is thrown by this knockback.                                               |
+
+**Knockback Type: Force**
+
+Apply the calculated knockback force along the provided direction.
+
+| Field Name | Type                         | Required? | Notes                                                                                |
+| ---------- | ---------------------------- | --------- | ------------------------------------------------------------------------------------ |
+| Direction  | `Vector3`<br />(Default: Up) | **No**    | Which direction the player should be flung, relative to the direction of the attack. |
+
+**Knockback Type: Point**
+
+Apply the calculated knockback force laterally along the XZ plane, plus provided Y velocity.
+
+| Field Name | Type                        | Required? | Notes                                                                                                   |
+| ---------- | --------------------------- | --------- | ------------------------------------------------------------------------------------------------------- |
+| OffsetX    | `Integer`<br />(Default: 0) | **No**    | Offset the source position of the knockback left or right perpendicular to the direction of the attack. |
+| OffsetZ    | `Integer`<br />(Default: 0) | **No**    | Offset the source position of the knockback, forward or backward along the directon of the attack.      |
+| RotateY    | `Integer`<br />(Default: 0) | **No**    | Rotate the knockback direction around the Y axis, where 0 is the default attack direction.              |
+| VelocityY  | `Float`<br />(Default: 0.0) | **No**    | Add vertical velocity to the knockback force after the direction and force has been calculated.         |
+
+**Knockback Type: Directional**
+
+Apply the calculated knockback force along the attack direction, removing any vertical component and replacing it with a provided Y velocity.
+
+| Field Name | Type                      | Required? | Notes                                                                                                                                            |
+| ---------- | ------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------ |
+| RelativeX  | `Float`<br />(Default: 0) | **No**    | Apply additional force left or right perpendicular to the direction of the attack. The additional force is multiplied by the knockback strength. |
+| RelativeZ  | `Float`<br />(Default: 0) | **No**    | Apply additional force forward or backward along the attack direction. The additional force is multiplied by the knockback strength.             |
+| VelocityY  | `Float`<br />(Default: 0) | **No**    | Replace the vertical velocity of the knockback with this value.  This value is not multiplied by knockback strength.                             |
+
+**VelocityConfig Fields**
+
+| Field Name          | Type                                              | Required? | Notes                                                                                                                                                                                           |
+| ------------------- | ------------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| GroundResistance    | `Float`<br />(Default: 0.82)                      | **No**    | The minimum amount of friction applied when the entity is in contact with the ground.  1.0 = no friction, 0.0 = total friction                                                                  |
+| GroundResistanceMax | `Float`<br />(Default: 0.0)                       | **No**    | The maximum amount of friction applied when the entity is in contact with the ground.  1.0 = no friction, 0.0 = total friction                                                                  |
+| AirResistance       | `Float`<br />(Default: 0.96)                      | **No**    | The minimum amount of friction applied when the entity is in the air. 1.0 = no friction, 0.0 = total friction                                                                                   |
+| AirResistanceMax    | `Float`<br />(Default: 0.0)                       | **No**    | The maximum amount of friction applied when the entity is in the air. 1.0 = no friction, 0.0 = total friction                                                                                   |
+| Threshold           | `Float`<br />(Default: 1.0)                       | **No**    | The speed at which the maximum amount of friction will be applied to the entity. The amount of friction applied will increase from minimum to maximum as the entity moves from 0 to this speed. |
+| Style               | `VelocityThresholdStyle`<br />(Default: `Linear`) | **No**    | The curve that friction follows as the entity's speed increases toward the `Threshold`.                                                                                                         |
+
+**CostType Values**
+
+- `MaxHealthPercentage`
+- `Damage`
+
+**ChangeVelocityType Values**
+
+- `Add`
+- `Set`
+
+**VelocityThresholdStyle Values**
+
+- `Linear`
+- `Exp`
+
+## Blocks
+
+These are interaction types meant to reason about and modify blocks in the world.  The most important concept unique
+to these interactions is the Block Target.  Like the Entity Target, it is mutable and can come from many places.
+However, for interaction chains initiated by the client, the block target will initially be the block that the player's cursor was
+over, if any.
+
+Additionally, for interaction chains initiated by the client, the client will send along which face of the block is targeted,
+which is used by a few block-related interactions.
+It is left up to each interaction type that cares about block faces as to how to handle this behavior for simulated input
+(i.e. NPCs initiating chains that are normally initated by the client).  At the time of this writing, all block-related
+interactions choose the top face where relevant in simulated input.
+
+### BlockCondition
+
+This interaction has a field `Matchers` which specifies certain conditions, such as block type, state, etc.  This
+interaction fails if the current target block does not match all of them.
+
+**BlockCondition Fields**
+
+| Field Name       | Type                                        | Required? | Notes                                                                                                                                                                                                                                                                                                                                   |
+| ---------------- | ------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false)             | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction.                                                                                                                                                                                                       |
+| Matchers         | `Array`<br />(Element Type: `BlockMatcher`) | **Yes**   | A list of conditions that the target block must match or this condition will fail.<br />**Note: This field is technically not required but there is a bug that makes it dangerous to not provide at the time of this writing.**<br />**Note: If no conditions are added to this array, the interaction will fail, counterintuitively.** |
+
+**BlockMatcher Fields**
+
+| Field Name | Type                       | Required? | Notes                                                                          |
+| ---------- | -------------------------- | --------- | ------------------------------------------------------------------------------ |
+| Block      | `BlockIdMatcher`           | **No**    | If provided, requires the block itself match some set of conditions.           |
+| Face       | `BlockFace`                | **No**    | If provided and not 'None', requires a specific block face be targeted.        |
+| StaticFace | `Boolean` (Default: false) | **No**    | If false, the face condition will be adjusted by the block's current rotation. |
+
+**BlockFace Values**
+
+- `Up`
+- `Down`
+- `North`
+- `South`
+- `East`
+- `West`
+- `None`
+
+**BlockIdMatcher Fields**
+
+| Field Name | Type                                   | Required? | Notes                                                                      |
+| ---------- | -------------------------------------- | --------- | -------------------------------------------------------------------------- |
+| Id         | `Asset`<br />(Asset Type: `BlockType`) | **No**    | If provided, the block must match the specified `BlockType`.               |
+| State      | `String`                               | **No**    | If provided, the block's current state must match the provided state name. |
+| Tag        | `String`                               | **No**    | If provided, the block type's asset tags must contain the provided tag.    |
+
+### DestroyCondition
+
+This interaction fails if the current User entity cannot destroy the current target blcok.
+
+**DestroyCondition Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+
+### PlacementCountCondition
+
+This interaction accepts the name of a BlockType that has the TrackedPlacement BlockEntity. The interaction will fail if the number of
+blocks of the provided BlockType in the world do not match the provided condition.
+
+**PlacementCountCondition Fields**
+
+| Field Name | Type                           | Required? | Notes                                                                                                                                                                                                                                                           |
+| ---------- | ------------------------------ | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Block      | `String`                       | **Yes**   | The BlockType to examine. The number of instances of the BlockType in the world will be compared to Value.<br />**Note: The specified BlockType must have the TrackedPlacement BlockEntity. Otherwise, the number of blocks in the world will always be zero.** |
+| Value      | `Integer`<br />(Default: 0)    | **No**    | The value to compare the number of blocks in the world with.                                                                                                                                                                                                    |
+| LessThan   | \`Boolean<br />(Default: true) | **No**    | If true, the interaction will fail if the number of blocks in the world is greater than or equal to Value. If false, the interaction will fail if the number of blocks in the world is less than or equal to Value.                                             |
+
+### BreakBlock
+
+This interaction attempts to break the target block while acting as the User entity. The User entity must be a player. It
+is not guaranteed to work, depending on world settings and the User entity's current state, it may not work.  If it
+fails, it will fail the interaction under some circumstances, but not others.
+
+**Note: In particular, if `Harvest`=false and the player is in Survival mode, the player will simply execute a damage operation
+against the block. Even when the Tool field is specified, the player's currently-held item can impact the results in unintuitive
+ways.**
+
+This interaction will fail if there is no block target, if `Harvest`=true and the
+block is not harvestable, or if the world settings prevent the Harvest/Break operation.
+It will generally not fail otherwise, even if the block was not broken or damaged.
+The block will generally break every time if `Harvest`=true or the player is in
+Creative mode.
+
+**BreakBlock Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                                                                                                                                                                                                  |
+| ---------------- | ------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction.                                                                                                                                                                      |
+| Harvest          | `Boolean` (Default: false)      | **No**    | If true, harvest the block and deposit the drops in the player's inventory. This operation will generally always succeed.  If false, this interaction will effectively perform whatever action would have occurred if the player had left-clicked the block.                                           |
+| Tool             | `String`                        | **No**    | If `Harvest`=true, the player is in Survival mode, and this field is provided, then the break operation will be performed as though with this tool type.<br />**This field mostly doesn't work.  Your held item will be used for most block damage calculations regardless of this field's contents.** |
+| MatchTool        | `Boolean` (Default: false)      | **No**    | If true, `Harvest`=true, the player is in Survival mode, and `Tool` is provided, block breaking will be prevented unless `Tool` is a valid gathering tool for the target block. The interaction will not be failed, even if block breaking is prevented in this manner.                                |
+
+### ChangeBlock
+
+This interaction requires a mapping from one or more current BlockTypes to one or more target BlockTypes.  If the
+target block is one of the key BlockTypes, then it will be changed to the mapped target BlockType.  If the current
+BlockType of the target block does not appear as a key in the Changes field, then this interaction fails.
+
+**ChangeBlock Fields**
+
+| Field Name        | Type                                                        | Required? | Notes                                                                                                                             |
+| ----------------- | ----------------------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget  | `Boolean`<br />(Default: false)                             | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+| Changes           | `Map`<br />(Key Type: `BlockType`, Value Type: `BlockType`) | **No**    | A list of potential block type changes, with each entry having a current and new BlockType id.                                    |
+| WorldSoundEventId | `Asset`<br />(Asset Type: `SoundEvent`)                     | **No**    | If provided, this SoundEvent is played in the world at the position of the block if the block successfully changes.               |
+| RequireNotBroken  | `Boolean`<br />(Default: false)                             | **No**    | If true, this interaction will fail if the player's held item is broken (durability 0), and the block change will not take place. |
+
+### ChangeState
+
+This interaction requires a mapping from one or more current block state names to one or more state names. If the
+target block is in one of the key block states, then it will be changed to the mapped target blocks tate. If the
+current block state of the target block does nto appear as a key in the Changes field, then this interaction fails.
+
+All blocks start out with a null state by default.  This null state can be referenced by the key "default" and the block
+can be returned to that state with the value "default".
+
+**ChangeState Fields**
+
+| Field Name       | Type                                                  | Required? | Notes                                                                                                                                          |
+| ---------------- | ----------------------------------------------------- | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false)                       | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction.              |
+| Changes          | `Map`<br />(Key Type: `String`, Value Type: `String`) | **No**    | A list of potential block state changes, with each entry having a current and new state name.                                                  |
+| UpdateBlockState | `Boolean`<br />(Default: false)                       | **No**    | If true, performs a full refresh of the block's BlockEntity component and notifies nearby players as though a full block type change occurred. |
+
+### CycleBlockGroup
+
+This interaction will attempt to change the target block to the next block type in one of the BlockGroups it belongs to.
+If the block type belongs to multiple BlockGroups, which one is used is effectively arbitrary. The User entity must be
+a player. If the block cannot be changed for any reason (entity not a player, no block target, block does not belong
+to a BlockGroup, etc.). If the block is the only entry in the BlockGroup, this interaction will succeed and the block
+will be considered changed despite nothing happening.  Unlike most other block-changing interactions, this one will
+fail if the world settings prevent players from breaking blocks.
+
+**This interaction always reduces the player's held item's durability by a single 'hit' worth of damage if the block
+changes. There is no way to prevent it. The block type will change and the interaction will succeed even if the player's
+held item is broken, however.**
+
+**CycleBlockGroup Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+
+### DestroyBlock
+
+This interaction destroys the target block without dropping anything.  It will successfully destroy the block if the
+target block exists and this interaction has no failure conditions.
+
+**This interaction has no additional fields.**
+
+### PickBlock
+
+This interaction is effectively equivalent to using the middle mouse button in creative mode. In survival mode, the
+block's item will be moved to the user's current active hotbar slot if it is in the player's inventory.  This
+interaction is performed entirely on the client and cannot be performed by non-players.  It is unclear if this
+interaction has failure conditions.
+
+**PickBlock Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+
+### PlaceBlock
+
+This interaction is effectively identical to a right clicking while holding a block in their hand, with some
+additional options. For one, it can be executed with any LivingEntity as the User entity. For another, it has some
+useful fields.  For the most part, though, it follows the same behaviors and rules as any ordinary block placement
+by a player.
+
+It's not clear under what circumstances this interaction can fail. The server will not fail the interaction under any
+special circumstances (including when there is no target block, or when `BlockTypeToPlace` is not provided and the
+LivingEntity is not holding a block). However, the client is very involved with the function of this interaction and
+its behavior is unknown.
+
+**PlaceBlock Fields**
+
+| Field Name         | Type                                   | Required? | Notes                                                                                                                                                                                                                                                                                                                                                           |
+| ------------------ | -------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| BlockTypeToPlace   | `Asset`<br />(Asset Type: `BlockType`) | **No**    | If provided, the block placed by this interaction will be the specified BlockType. If not provided, the User entity's held item will be used, instead, if it is a block.                                                                                                                                                                                        |
+| RemoveItemInHand   | `Boolean`<br />(Default: True)         | **No**    | If true and the User entity is not a player in Creative mode, the item in the player's hand must match the block being placed and one quantity will be removed for each block placed. If the item does not match, the block cannot be placed.  If false, the player's hand item is ignored entirely.\*\*                                                        |
+| AllowDragPlacement | `Boolean`<br />(Default: True)         | **No**    | If true and the interaction was triggered on the client by a player, then the player can hold the input that was used to activate this interaction chain and move the mouse around in order to execute this interaction repeatedly and place several blocks. The interaction chain will not move onto the next interaction until the player releases the input. |
+
+### RunOnBlockTypes
+
+This interaction retrieves all blocks within a provided radius of the User entity. For each block that matches any of
+the provided BlockSets, a new interaction chain will be forked that uses the matching block as the target block.
+This interaction will continue executing until all forked interaction chains have completed.  The interaction will fail if no
+blocks within the radius match the provided BlockSets or if all of the forked interaction chains fail.
+
+**RunOnBlockTypes Fields**
+
+| Field Name   | Type                                         | Required?        | Notes                                                                                                                                                                                                                                                                                      |
+| ------------ | -------------------------------------------- | ---------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| Range        | `Integer`                                    | **Yes**          | The spherical radius around the User entity to search for blocks. Must be at least 1.                                                                                                                                                                                                      |
+| BlockSets    | `AssetArray`<br />(Element Type: `BlockSet`) | **No**           | A list of BlockSets to match nearby blocks again. Only blocks that match any of the BlockSets will have interaction chains forked for them.                                                                                                                                                |
+| MaxCount     | `Integer`                                    | **Yes**          | The maximum number of blocks that will be located with the search. Further blocks will be ignored. If there are more matching blocks within the radius than this number, the specific set of blocks that will be found is completely arbitrary and may change from execution to execution. |
+| Interactions | `Asset`<br />(Asset Type: `RootInteraction`) | **No, but yes.** | The RootInteraction that will be forked for each matching block.  This interaction will not fail to validate if it is missing, but every execution of this interaction will fail.                                                                                                          |
+
+### UseBlock
+
+If the target block has an interaction for this interaction chain's interaction type, execute it immediately as part of
+this interaction chain. The execution will be wrapped in UseBlockEvent.Pre and UseBlockEvent.Post events, and cancellations
+of the UserBlockEvent.Pre event are respected. The User entity is considered the triggering entity for both events.
+
+If the target block does not have an interaction for this interaction chain's interaction type, this interaction fails.
+
+**This interaction has no additional fields.**
+
+## Items
+
+These are interactions intended to interface with an entity's inventory. There is no concept of an "item target",
+unfortunately, so these generally either interact with the entity's held item or the entity's inventory at a high level.
+
+### AddItem
+
+Adds a specified quantity of a specified item to the User entity's inventory, preferring to add it to the
+entity's hotbar where possible. This interaction will have no effect on User entities that are not LivingEntities.
+This interaction has no failure states.
+
+**Note: This interaction has a bug in its field validators that will cause interactions that reference items declared
+in the same mod to fail validation on startup.  Additionally, this interaction has a bug that will cause it to
+fail and have no effect if the User entity has no block target. Use ModifyInventory instead.**
+
+**AddItem Fields**
+
+| Field Name       | Type                              | Required? | Notes                                                                                                                             |
+| ---------------- | --------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false)   | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+| ItemId           | `Asset`<br />(Asset Type: `Item`) | **Yes**   | The item id of the item to add to the player's inventory.                                                                         |
+| Quantity         | `Integer`<br />(Default: 0)       | **No**    | The quantity of the item to add to the player's inventory.                                                                        |
+
+### CheckUniqueItemUsage
+
+This interaction will check whether it has run once for the User entity with their currently-held item before. If it hasn't,
+it will succeed. If it has, it will fail. It will also fail if the User entity is not a player. The interaction will record
+the item id of the User entity's currently-held item on success, ensuring it cannot be successfully run with that player
+and item id combination again.
+
+**This interaction has no additional fields.**
+
+### ChangeActiveSlot
+
+This interaction does not inherit from SimpleInteraction and therefore has no Next or Failed fields.  The `CancelOnItemChange`
+field is ignored for this interaction and is always treated as false. This interaction will set the User entity's currently-
+active hotbar slot to the specified slot index. If none is specified, the interaction chain's target slot will be used,
+if any. Otherwise, slot 0 will be used.  If a slot is specified and it is already active, then this interaction will
+have no effect, but if no slot is specified and the interaction chain's target slot is already active, the logic in
+the next paragraph will still be executed. This interaction will also have no effect if the User entity is not a
+LivingEntity.
+
+Once the slot has changed, a new SwapTo interaction chain will be forked off for the selected slot.
+If a target slot was specified, then the interaction chain's current target slot will be set to the specified slot, as will
+the forked SwapTo interaction chain. If this interaction chain was initiated by a player swapping an item into or out of
+an occupied active hotbar slot, then the swap will be executed after the slot is changed and before the SwapTo
+interaction is forked. Not running this interaction in the resulting SwapFrom interaction chain is a way for the server
+to cancel players performing these sorts of swap interactions. The default behavior for these swap interactions is that
+the SwapFrom interaction chain will be initiated with the currently-active-slot as the target slot. As a result, the
+target slot will usually not change when this interaction runs, it merely exists as a signal for the server to continue the
+item swap.
+
+**ChangeActiveSlot Fields**
+
+| Field Name | Type      | Required? | Notes                                                                                                                                                                                                     |
+| ---------- | --------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| TargetSlot | `Integer` | **No**    | If not provided, indicates the slot the player's active hotbar slot should be changed to.  Otherwise, the interaction chain's target slot will be used (which is usually the already-active hotbar slot). |
+
+### EquipItem
+
+This interaction will equip the User entity's currently-held item into the appropriate armor slot, if it is armor. The
+interaction will fail if the item is armor but it cannot be equipped for some reason. The interaction will succeed but
+take no action if the User entity cannot equip armor or if the item is not armor.
+
+**This interaction has no additional fields.**
+
+### IncreaseBackpackCapacity
+
+This interaction will increase the User entity's backpack size by the provided amount.  **It will additionally remove one
+quantity from the player's currently-held item. There is no way to prevent this.**  This interaction will have no effect
+if the User entity is not a player.  This interaction has no special failure conditions, even if the User entity
+is not a player, or the player is not currently holding an item.
+
+| Field Name | Type                        | Required? | Notes                                                                                   |
+| ---------- | --------------------------- | --------- | --------------------------------------------------------------------------------------- |
+| Capacity   | `Integer`<br />(Default: 1) | **No**    | The additional backpack capacity to add to the player. **Must be between 1 and 32767.** |
+
+### ModifyInventory
+
+This interaction attempts to perform one or more inventory-modifying actions against the User entity. The User entity must
+be a player. If they are not, no actions will be performed, but the interaction will not fail. Any item removals performed
+by this interaction, either as a result of `ItemToRemove` or `AdjustHeldItemQuantity`, are both atomic (meaning the entire
+quantity must be removed, or none) and required (meaning that the interaction will fail and no further actions taken if
+the removal fails for any reason).  Item additions performed by this interaction, either as a result of `ItemToAdd` or
+`AdjustHeldItemQuantity` will drop excess items on the ground near the player if necesary and continue on.
+
+This interaction first executes the item removal in `ItemToRemove`, if any, then adjusts the held item as specified by
+`AdjustHeldItemQuantity`, if provided, then executes the item addition in `ItemToAdd`, if any, and then finally executes
+the damage/healing of the held item in `AdjustHeldItemDurability`, if provided.
+
+**ModifyDurability Fields**
+
+| Field Name               | Type                            | Required? | Notes                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
+| ------------------------ | ------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| RequiredGameMode         | `GameMode`                      | **No**    | If provided, only execute the inventory-modifying actions if the player is in the provided GameMode. The interaction will not fail if the GameMode doesn't match.                                                                                                                                                                                                                                                                                                                                                                               |
+| ItemToRemove             | `ItemStack`                     | **No**    | If provided, a matching item will be removed in the provided quantity. If there is no matching item in the player inventory in the required quantity, then the interaction will fail and further actions will not be executed.                                                                                                                                                                                                                                                                                                                  |
+| AdjustHeldItemQuantity   | `Integer`<br />(Default: 0)     | **No**    | The player's held item, if any, will have its quantity will be modified by the provided amount- subtracted from if this number is negative or added to if this item is positive.  If the player has no held item, then this field will have no effect regardless of its value and the interaction will NOT fail.  If the player's inventory does not have sufficient quantity of items to support the removal, this interaction will fail and further actions will not be executed. Excess items will be dropped on the ground near the player. |
+| ItemToAdd                | `ItemStack`                     | **No**    | If provided, the ItemStack will be added to the player's inventory. Excess items will be dropped on the ground near the player.                                                                                                                                                                                                                                                                                                                                                                                                                 |
+| AdjustHeldItemDurability | `Double`<br />(Default: 0.0)    | **No**    | The player's held item, if any, will have its durability adjusted by the specified amount.  The durability cannot go below 0 or raise above the item's maximum durability. Invalid durability values in this field will not cause the interaction to fail. Neither will it fail if the player has no held item.                                                                                                                                                                                                                                 |
+| BrokenItem               | `String`                        | **No**    | This field should contain an ItemId, but it is not validated by the server on startup, so be careful.  This field can have the value of "Empty" to specify no item, or an empty hand. If specified and the `AdjustHeldItemDurability` operation reduces the player's held item to 0 durability, the player's held item is changed to this ItemId. If the inventory replacement fails, this interaction will fail.                                                                                                                               |
+| NotifyOnBreak            | `Boolean`<br />(Default: false) | **No**    | If true and the `AdjustHeldItemDurability` operation reduces the player's held item to 0 durability, this interaction will perform the usual audiovisual feedback of a broken tool. It will play the usual tool breaking sound and send the player a text message in chat that their item has broken.                                                                                                                                                                                                                                           |
+| NotifyOnBreakMessage     | `String`                        | **No**    | If provided, and `NotifyOnBreak` is true, when the player is notified of a broken tool by this interaction, the message sent to their chat will instead be the translation key specified by this field. The translation key supports the templating parameter `{itemName}`. See the translation key `server.general.repair.itemBroken_Hoe` for an example.                                                                                                                                                                                      |
+
+**GameMode Values**
+
+- `Creative`: The game is currently in Creative Mode
+- `Adventure`: The game is currently in Adventure Mode
+
+**ItemStack Fields**
+
+| Field Name                   | Type                              | Required? | Notes                                                                                |
+| ---------------------------- | --------------------------------- | --------- | ------------------------------------------------------------------------------------ |
+| Id                           | `Asset`<br />(Asset Type: `Item`) | **Yes**   | The id of the Item asset this stack contains.                                        |
+| Quantity                     | `Integer`<br />(Default: 1)       | **No**    | The number of items in this stack.<br />**Must be greater than 0.**                  |
+| Durability                   | `Double`<br />(Default: 0.0)      | **No**    | The durability of the item stack.<br />**Cannot be negative.**                       |
+| MaxDurability                | `Double`<br />(Default: 0.0)      | **No**    | The maximum durability of the item this stack contains.<br />**Cannot be negative.** |
+| Metadata                     | `Bson Document`                   | **No**    | If provided, applies the bson to the item stack metadata.                            |
+| OverrideDroppedItemAnimation | `Boolean`\*(Default: false)       | **No**    | ???                                                                                  |
+
+### PickupItem
+
+This interaction will attempt to pick up the User entity's current target entity and add it to their inventory. It will
+fail if the User entity is not a player, if they do not have a target entity, or if the target entity is not an item
+located in the world.  It will not fail if the player simply cannot pick up the item.
+
+**This interaction has no additional fields.**
+
+### RefillContainer
+
+This interaction will fail if the User entity is not a player. The interaction will draw a ray from the player's head
+down their look direction until the edge of the player's held item's interaction range or until the first solid block.
+The nearest fluid block of a type listed in this interaction's `States` map will result in the one of the player's
+currently-held items being converted to the fluid's related item state.  If the `States` map indicates a durability
+for the new item state, then the converted item will use that durability. If the item is already in the fluid's related
+item state, then this interaction will fail if the player's held item is already at maximum durability (unless the
+`States` map indicates a durability value greater than the item's maximum, in which case the interaction will succeed
+but the item will not change).  Otherwise, the durability listed for the fluid in the `States` map will be added to the
+item's current durability.
+
+If the interaction has not failed by this point, the fluid block in the world may be transformed to a different type if one is listed
+in the `States` map.
+
+If any part of this process does not proceed for any reason (for instance, if the player is not holding an item),
+then this interaction will fail.
+
+**RefillContainer Fields**
+
+| Field Name | Type                                                       | Required? | Notes                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| ---------- | ---------------------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| States     | `Map`<br />(Key Type: `String`, Value Type: `RefillState`) | **Yes**   | A map from item state names to `RefillState` objects, which contain information such as acceptable fluid block types, durability increases, and what fluid type to convert the targeted fluid block to after refill, if any. If the player targets a fluid block that matches one of the fluid types in the `RefillState`, the item will be converted to the keyed item state and the `RefillState` will be used to decide what happens next. |
+
+**RefillState Fields**
+
+| Field Name     | Type                                  | Required? | Notes                                                                                                                                                                                                                                                                                                                           |
+| -------------- | ------------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| AllowedFluids  | `Array`<br />(Element Type: `String`) | **Yes**   | If any of these fluids are targeted by the player, the player's held item will be converted to the keyed item state and `Durability` and `TransformFluid` will be used.                                                                                                                                                         |
+| Durability     | `Double`<br />(Default: -1.0)         | **No**    | If the player's held item changes item states, this value is the new item's durability, unless it is negative, in which case the item will begin at full durability. If the player's held item is already in the item state, and the item is not already at full durability, this value will be added to the item's durability. |
+| TransformFluid | `String`                              | **No**    | If provided, this field is a fluid id that the targeted fluid block should be transformed to if the player's held item is successfully updated.                                                                                                                                                                                 |
+
+## Entities
+
+### DamageEntity
+
+This interaction does not inherit from SimpleInteraction, but adds its own Next and Failed fields that
+work similarly.
+
+This interaction will cause the User entity to damage the Target entity.  It has the capability to apply different
+damage based on the direction of the attack or what body part was targeted by the User entity, with each possibility
+providing different damage calculations, effects, and Next interaction. If multiple entires match the attack, `TargetedDamage`
+(body part damage) takes highest priority, then the first matching `AngledDamage` in the list, then the default
+damage in the base interaction fields.  It is possible for elements of these different damage priorities to be taken peacemeal if higher-priority
+damage fields do not overwrite lower-priority damage fields. For instance,
+damage calculation could be taken from `TargetedDamage`, the damage effects could be taken from the first matching
+`AngledDamage`, and the Next interaction coming from the default damage field.
+
+If all damage dealt by this interaction is cancelled, then this interaction will fail, and the `Failed` interaction
+will be executed next in the chain. If any damage dealt by this interaction is blocked, then this interaction will
+succeed, but the `Blocked` interaction wil lbe executed next in the chain. Otherwise, the highest-precedent matching
+`Next` interaction that you provide will be executed.  For instance, if you provide `Next` interactions for all
+`TargetedDamage` and `AngledDamage` entries, and one in the interaction's `Next` field, then a headshot could result
+in a unique `Next` interaction being executed, even if there is a matching `AngledDamage` entry. However, if you leave
+the `Next` interaction out of your `TargetedDamage` entries, a special `Next` interaction for backstabs could be
+executed.  Otherwise, the `Next` field in the root of the interaction will be executed instead.
+
+DamageEntity has an unusual relationship with `RunTime`. This interaction always ends immediately after its first tick,
+regardless of the status of `RunTime` or `WaitForAnimationToFinish`.  However, if damage dealt by this interaction is
+calculated as `DamageCalculatorType` `Dps`, then the `RunTime` will be used to determine the precise amount of damage to
+deal. If `RunTime` is 0, then no damage will be dealt.
+
+**DamageEntity Fields**
+
+| Field Name       | Type                                                          | Required?                                                                                                                    | Notes                                                                                                                                                                                                                                                                                                                                                                         |
+| ---------------- | ------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| DamageCalculator | `DamageCalculator`                                            | **No**                                                                                                                       | If provided, describes the damage amounts and types to apply to the Target entity.                                                                                                                                                                                                                                                                                            |
+| DamageEffects    | `DamageEffects`                                               | **No**                                                                                                                       | If provided, describes particles, sounds, knockback, etc. to apply to the target entity on damage.                                                                                                                                                                                                                                                                            |
+| Next             | `Asset`<br />(Asset Type: `Interaction`)                      | **No**  After this interaction has finished, "Next" will be executed if damage was dealt to the target and none was blocked. |                                                                                                                                                                                                                                                                                                                                                                               |
+| AngledDamage     | `Array`<br />(Element Type: `AngledDamage`)                   | **No**                                                                                                                       | If provided, allows alternative `DamageCalculator`, `DamageEffects`, and `Next` entries for attacks that approach the target from certain angles.                                                                                                                                                                                                                             |
+| TargetedDamage   | `Map`<br />(Key Type: `String`, Value Type: `TargetedDamage`) | **Yes**                                                                                                                      | This field must be provided, but is not required to have any entries.  This is a map from body part names to `TargetedDamage` values. Hypixel only uses one body part name: `Head`, and it is not clear whether there are others.  If provided, allows alternative `DamageCalculator`, `DamageEffects`, and `Next` entries for attacks that damage specific enemy body parts. |
+| EntityStatsOnHit | `Array`<br />(Element Type: `EntityStatOnHit`)                | **No**                                                                                                                       | If provided, allows this attack to reduce enemy stats other than health.  Each individual damage application dealt by the same ability will apply stat reductions, at diminishing returns. All damage dealt in interaction chains forked by a Selector interaction will share the number of hits across all targets.                                                          |
+| Failed           | `Asset`<br />(Asset Type: `Interaction`)                      | **No**                                                                                                                       | After this interaction has finished, "Failed" will be executed if no damage hits were applied to the player, or if all damage hits were cancelled.                                                                                                                                                                                                                            |
+| Blocked          | `Asset`<br />(Asset Type: `Interaction`)                      | **No**                                                                                                                       | After this interaction has finished, "Blocked" will be executed if any damage hits were blocked by the target.                                                                                                                                                                                                                                                                |
+
+**DamageCalculator Fields**
+
+| Field Name                | Type                                                      | Required? | Notes                                                                                                                                                                                                                                                 |
+| ------------------------- | --------------------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Type                      | `DamageCalculatorType`<br />(Default: Absolute)           | **No**    | Whether the damage being applied is `Absolute` or \`Dps'.                                                                                                                                                                                             |
+| Class                     | `DamageClass`<br />(Default: Unknown)                     | **No**    | The type of attack producing the damage. Some weapon systems apply equipment modifiers based on this value.                                                                                                                                           |
+| BaseDamage                | `Map`<br />(Key Type: `DamageCause`, Value Type: `Float`) | **No**    | A set of DamageCauses and how much base damage is dealt for each.                                                                                                                                                                                     |
+| SequentialModifierStep    | `Float`<br />(Default: 0.0)                               | **No**    | Value between 0.0-1.0. Each additional hit from a single ability will have its damage reduced by this much as a percentage. All damage dealt in interaction chains forked by a Selector interaction will share the number of hits across all targets. |
+| SequentialModifierMinimum | `Float`<br />(Default: 0.0)                               | **No**    | Value between 0.0-1.0. `SequentialModifierStep` cannot reduce damage below this percentage regardless of the number of hits.                                                                                                                          |
+| RandomPercentageModifier  | `Float`<br />(Default: 0.0)                               | **No**    | A random value between +/- this amount multiplied by the base damage will be added to the base damage.                                                                                                                                                |
+
+**DamageEffects Fields**
+
+| Field Name             | Type                                         | Required? | Notes                                                                                   |
+| ---------------------- | -------------------------------------------- | --------- | --------------------------------------------------------------------------------------- |
+| ModelParticles         | `Array`<br />(Element Type: `ModelParticle`) | **No**    | Particle systems to trigger in the first-person view.                                   |
+| WorldParticles         | `Array`<br />(Element Type: `WorldParticle`) | **No**    | Particle systems to trigger in the third-person view.                                   |
+| LocalSoundEventId      | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | 2D sound to play locally to the attacking entity if they are a player.                  |
+| WorldSoundEventId      | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | Sound to play in the world at the Target entity's location.                             |
+| PlayerSoundEventId     | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | 2D sound to play locally to the Target entity if they are a player.                     |
+| ViewDistance           | `Double`<br />(Default: 75.0)                | **No**    | Distance at which these effects should play for other players.                          |
+| Knockback              | `Knockback`                                  | **No**    | The properties of the knockback that will be applied.                                   |
+| CameraEffect           | `Asset`<br />(Asset Type: `CameraEffect`)    | **No**    | CameraEffect to briefly apply locally to the Target entity if they are a player.        |
+| StaminaDrainMultiplier | `Float`<br />(Default: 1.0)                  | **No**    | This multiplier is applied to the stamina cost incurred by the target blocking, if any. |
+
+**AngledDamage Fields**
+
+| Field Name       | Type                                     | Required? | Notes                                                                                                                                                                                                     |
+| ---------------- | ---------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| AngleDistance    | `Float`<br />(Default: 0)                | **No**    | The width in degrees of the matching arc around the Target entity. If the attack against the Target originates from within the arc, then the properties below will be applied to the attack, if provided. |
+| Angle            | `Float`<br />(Default: 0.0)              | **No**    | The angle in degrees around the Target entity at which the matching arc is centered.                                                                                                                      |
+| DamageCalculator | `DamageCalculator`                       | **No**    | If provided and the attack against the Target entity originates from within the provided arc, this DamageCalculator will override the interaction's `DamageCalculator` field.                             |
+| DamageEffects    | `DamageEffects`                          | **No**    | If provided and the attack against the Target entity originates from within the provided arc, this DamageEffects will override the interaction's `DamageEffects` field.                                   |
+| Next             | `Asset`<br />(Asset Type: `Interaction`) | **No**    | If provided and the attack against the Target entity originates from within the provided arc, this Interaction will override the interaction's `Next` field.                                              |
+
+**TargetedDamage Fields**
+
+| Field Name       | Type                                     | Required? | Notes                                                                                                                                                                                            |
+| ---------------- | ---------------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| DamageCalculator | `DamageCalculator`                       | **No**    | If provided and this TargetedDamage was matched, this DamageCalculator will override the interaction's `DamageCalculator` field and the `DamageCalculator` field of any matching `AngledDamage`. |
+| DamageEffects    | `DamageEffects`                          | **No**    | If provided and this TargetedDamage was matched, this DamageEffects will override the interaction's `DamageEffects` field and the `DamageEffects` field of any matching `AngledDamage`.          |
+| Next             | `Asset`<br />(Asset Type: `Interaction`) | **No**    | If provided and this TargetedDamage was matched, this Interaction will override the interaction's `Next` field and the `Next` field of any matching `AngledDamage`.                              |
+
+**EntityStatOnHit Fields**
+
+| Field Name                  | Type                                                                       | Required? | Notes                                                                                                                                                                                                                                                                                        |
+| --------------------------- | -------------------------------------------------------------------------- | --------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| EntityStatId                | `Asset`<br />(AssetType: `EntityStatType`)                                 | **Yes**   | Which entity stat to affect.                                                                                                                                                                                                                                                                 |
+| Amount                      | `Float`<br />(Default: 0.0)                                                | **No**    | How much of the stat to apply for each damage application. Use negative numbers to reduce stats.                                                                                                                                                                                             |
+| MultipliersPerEntitiesHit   | `Array`<br />(Element Type: `Float`, Default: `[1.0, 0.6, 0.4, 0.2, 0.1]`) | **No**    | The diminishing returns curve to be applied for multiple damage applications by the same ability. Each hit's stat impact will be multiplied by the next value in the list.  If there are more hits than array elements, subsequent hits will be multiplied by `MultiplierPerExtraEntityHit`. |
+| MultiplierPerExtraEntityHit | `Float`<br />(Default: 0.05)                                               | **No**    | If an ability carries out more damage applications than there are elements in the `MultipliersPerEntitiesHit` array, then subsequent stat values will be multiplied by this number.                                                                                                          |
+
+**Knockback Fields**
+
+| Field Name     | Type                                       | Required? | Notes                                                                                                                      |
+| -------------- | ------------------------------------------ | --------- | -------------------------------------------------------------------------------------------------------------------------- |
+| Type           | `String`                                   | **No**    | If provided, specifies a type of knockback to use. Each Target type may come with additional fields.                       |
+| Force          | `Double`<br />(Default: 0.0)               | **No**    | The amount of force to apply to the Owner entity.                                                                          |
+| Duration       | `Double`<br />(Default: 0.0)               | **No**    | If 0.0, apply the force as a single impulse.  If more, continuously apply the force over a period of time.                 |
+| VelocityType   | `ChangeVelocityType`<br />(Default: `Add`) | **No**    | How to apply the force, either adding it to the entity's current velocity, or setting the velocity to the knockback force. |
+| VelocityConfig | `VelocityConfig`                           | **No**    | Characteristics of friction as the Owner entity is thrown by this knockback.                                               |
+
+**Knockback Type: Force**
+
+Apply the calculated knockback force along the provided direction.
+
+| Field Name | Type                         | Required? | Notes                                                                                |
+| ---------- | ---------------------------- | --------- | ------------------------------------------------------------------------------------ |
+| Direction  | `Vector3`<br />(Default: Up) | **No**    | Which direction the entity should be flung, relative to the direction of the attack. |
+
+**Knockback Type: Point**
+
+Apply the calculated knockback force laterally along the XZ plane, plus provided Y velocity.
+
+| Field Name | Type                        | Required? | Notes                                                                                                   |
+| ---------- | --------------------------- | --------- | ------------------------------------------------------------------------------------------------------- |
+| OffsetX    | `Integer`<br />(Default: 0) | **No**    | Offset the source position of the knockback left or right perpendicular to the direction of the attack. |
+| OffsetZ    | `Integer`<br />(Default: 0) | **No**    | Offset the source position of the knockback, forward or backward along the directon of the attack.      |
+| RotateY    | `Integer`<br />(Default: 0) | **No**    | Rotate the knockback direction around the Y axis, where 0 is the default attack direction.              |
+| VelocityY  | `Float`<br />(Default: 0.0) | **No**    | Add vertical velocity to the knockback force after the direction and force has been calculated.         |
+
+**Knockback Type: Directional**
+
+Apply the calculated knockback force along the attack direction, removing any vertical component and replacing it with a provided Y velocity.
+
+| Field Name | Type                      | Required? | Notes                                                                                                                                            |
+| ---------- | ------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------ |
+| RelativeX  | `Float`<br />(Default: 0) | **No**    | Apply additional force left or right perpendicular to the direction of the attack. The additional force is multiplied by the knockback strength. |
+| RelativeZ  | `Float`<br />(Default: 0) | **No**    | Apply additional force forward or backward along the attack direction. The additional force is multiplied by the knockback strength.             |
+| VelocityY  | `Float`<br />(Default: 0) | **No**    | Replace the vertical velocity of the knockback with this value.  This value is not multiplied by knockback strength.                             |
+
+**VelocityConfig Fields**
+
+| Field Name          | Type                                              | Required? | Notes                                                                                                                                                                                           |
+| ------------------- | ------------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| GroundResistance    | `Float`<br />(Default: 0.82)                      | **No**    | The minimum amount of friction applied when the entity is in contact with the ground.  1.0 = no friction, 0.0 = total friction                                                                  |
+| GroundResistanceMax | `Float`<br />(Default: 0.0)                       | **No**    | The maximum amount of friction applied when the entity is in contact with the ground.  1.0 = no friction, 0.0 = total friction                                                                  |
+| AirResistance       | `Float`<br />(Default: 0.96)                      | **No**    | The minimum amount of friction applied when the entity is in the air. 1.0 = no friction, 0.0 = total friction                                                                                   |
+| AirResistanceMax    | `Float`<br />(Default: 0.0)                       | **No**    | The maximum amount of friction applied when the entity is in the air. 1.0 = no friction, 0.0 = total friction                                                                                   |
+| Threshold           | `Float`<br />(Default: 1.0)                       | **No**    | The speed at which the maximum amount of friction will be applied to the entity. The amount of friction applied will increase from minimum to maximum as the entity moves from 0 to this speed. |
+| Style               | `VelocityThresholdStyle`<br />(Default: `Linear`) | **No**    | The curve that friction follows as the entity's speed increases toward the `Threshold`.                                                                                                         |
+
+**DamageCalculatorType Values**
+
+- `Absolute`
+- `Dps`
+
+**DamageClass Values**
+
+- `Unknown`
+- `Light`
+- `Charged`
+- `Signature`
+
+**ChangeVelocityType Values**
+
+- `Add`
+- `Set`
+
+**VelocityThresholdStyle Values**
+
+- `Linear`
+- `Exp`
+
+### LaunchProjectile
+
+This is just a worse version of Projectile and is slated to be removed.  Use Projectile.
+
+### Projectile
+
+This interaction will spawn a new projectile at the User entity's eye position that will travel in its look direction.
+
+| Field Name | Type                                          | Required? | Notes                                                  |
+| ---------- | --------------------------------------------- | --------- | ------------------------------------------------------ |
+| Config     | `Asset`<br />(Asset Type: `ProjectileConfig`) | **No**    | Configuration describing the projectile to be spawned. |
+
+### RemoveEntity
+
+Despawns the specified entity from the world. This interaction will have no effect if the specified entity is a player. This
+interaction has no special failure conditions.
+
+| Field Name | Type                                     | Required? | Notes                  |
+| ---------- | ---------------------------------------- | --------- | ---------------------- |
+| Entity     | `InteractionTarget`<br />(Default: User) | **No**    | The entity to despawn. |
+
+**InteractionTarget Values**
+
+- `User` - The user of this interaction chain. The entity whose actions caused this interaction chain to be executed. This is usually the same as the Owner.
+- `Owner` - The owner of this interaction chain. The entity upon whom this interaction chain is executing.
+- `Target` - The entity target of this interaction chain, if any.  This value is mutable (and can therefore come from many places) but most commonly, it is an entity the User was targeting when this interaction chain began executing.
+
+### SendMessage
+
+This interaction sends a message to the Owner entity if that entity can receive messages.  Otherwise, the message
+is written to the server logs.  If the entity is a player, the message will appear in the player's chat window.
+
+\*\*SendMessage
+
+| Field Name | Type     | Required? | Notes                                                                                                                 |
+| ---------- | -------- | --------- | --------------------------------------------------------------------------------------------------------------------- |
+| Message    | `String` | **No**    | A text message to be sent to the Owner entity.  If this field is not provided, `Key` is used instead.                 |
+| Key        | `String` | **No**    | A translation key for a message to be sent to the Owner entity. If `Message` is provided, then this field is ignored. |
+
+### UseEntity
+
+This interaction is not in use by Hypixel and has some unusual qualities that mean it probably won't do what you want it
+to.  Do not use it.
+
+This interaction will retrieve the entity currently targeted by the client (NOT the interaction chain's current Target
+entity) and execute that entity's RootInteraction for this interaction chain's current interaction type. The
+RootInteraction will be executed as part of this current interaction chain. None of the properties of this interaction
+chain will be modified.
+
+This interaction will fail if the client is not currently targeting an entity, or if no interaction for the current
+interaction type exists on the entity.
+
+## Stats
+
+Hytale's resource system has been written about fairly extensively.  You can use these interactions to modify stats in
+response to actions or use stats as a cost for abilities.
+
+### ChangeStat
+
+This interaction applies a set of raw stat changes to the User entity. It has no special failure conditions.
+
+| Field Name    | Type                                                         | Required? | Notes                                                                                                                                                                                                                      |
+| ------------- | ------------------------------------------------------------ | --------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| StatModifiers | `Map`<br />(Key Type: `EntityStatType`, Value Type: `Float`) | **Yes**   | A set of stats to modify and what value to apply to them.                                                                                                                                                                  |
+| ValueType     | `ValueType`<br />(Default: Absolute)                         | **No**    | Whether the values in the `StatModifiers` map represent flat values to apply to the stat total, or percentages (0.0-100.0). Percentage values are percentage of the difference between the maximum and minimum stat value. |
+| Behaviour     | `ChangeStatBehavior`<br />(Default: Add)                     | **No**    | Whether the values in the `StatModifiers` map represent deltas to add into the User entity's current stat values, or fixed values to set the entity's stats to.                                                            |
+
+**ValueType Values**
+
+- `Absolute`
+- `Percent`
+
+**ChangeStatBehaviour Values**
+
+- `Add`
+- `Set`
+
+### ChangeStatWithModifier
+
+This interaction is like ChangeStat, except an armor stat modifier can be chosen which will apply bonuses and penalties
+to a stat from the User entity's equipped armor before it is applied.
+
+| Field Name            | Type                                                         | Required? | Notes                                                                                                                                                                                                                      |
+| --------------------- | ------------------------------------------------------------ | --------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| StatModifiers         | `Map`<br />(Key Type: `EntityStatType`, Value Type: `Float`) | **Yes**   | A set of stats to modify and what value to apply to them.                                                                                                                                                                  |
+| ValueType             | `ValueType`<br />(Default: Absolute)                         | **No**    | Whether the values in the `StatModifiers` map represent flat values to apply to the stat total, or percentages (0.0-100.0). Percentage values are percentage of the difference between the maximum and minimum stat value. |
+| Behaviour             | `ChangeStatBehavior`<br />(Default: Add)                     | **No**    | Whether the values in the `StatModifiers` map represent deltas to add into the User entity's current stat values, or fixed values to set the entity's stats to.                                                            |
+| InteractionModifierId | `InteractionModifierId`                                      | **Yes**   | The armor interaction modifier to apply bonuses and penalties for.                                                                                                                                                         |
+
+**ValueType Values**
+
+- `Absolute`
+- `Percent`
+
+**ChangeStatBehaviour Values**
+
+- `Add`
+- `Set`
+
+**InteractionModifierId Values**
+
+- `Dodge`
+
+### StatsCondition
+
+This interaction will fail if the User entity cannot afford the specified stats costs, or if it does not have the
+requested stats.
+
+| Field Name | Type                                                         | Required? | Notes                                                                                                                                                                                    |
+| ---------- | ------------------------------------------------------------ | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Costs      | `Map`<br />(Key Type:` EntityStatType`, Value Type: `Float`) | **Yes**   | A set of costs that the User entity needs to be able to afford for this interaction to succeed.                                                                                          |
+| ValueType  | `ValueType`<br />(Default: Absolute)                         | **No**    | Whether the values in the `Costs` map represetn flat values or percentages (0.0-100.0).  Percentage values are percentage of the difference between the maximum and minimum value.       |
+| LessThan   | `Boolean`<br />(Default: false)                              | **No**    | If true, this interaction will fail unless the User entity's current stat values are at or **below** the specified levels.  If false, they must be at or **above** the specified levels. |
+| Lenient    | `Boolean`<br />(Default: false)                              | **No**    | If true and `LessThan` is true, and a player's minimum stat value is below zero, then the player can afford a stat cost if the current value of a stat if above 0.                       |
+
+**ValueType Values**
+
+- `Absolute`
+- `Percent`
+
+### StatsConditionWithModifier
+
+This interaction is like StatsCondition, except an armor stat modifier can be chosen which will apply bonuses and penalties
+to a stat's cost from the User entity's equipped armor before it is compared.
+
+| Field Name            | Type                                                         | Required? | Notes                                                                                                                                                                                    |
+| --------------------- | ------------------------------------------------------------ | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Costs                 | `Map`<br />(Key Type:` EntityStatType`, Value Type: `Float`) | **Yes**   | A set of costs that the User entity needs to be able to afford for this interaction to succeed.                                                                                          |
+| ValueType             | `ValueType`<br />(Default: Absolute)                         | **No**    | Whether the values in the `Costs` map represetn flat values or percentages (0.0-100.0).  Percentage values are percentage of the difference between the maximum and minimum value.       |
+| LessThan              | `Boolean`<br />(Default: false)                              | **No**    | If true, this interaction will fail unless the User entity's current stat values are at or **below** the specified levels.  If false, they must be at or **above** the specified levels. |
+| Lenient               | `Boolean`<br />(Default: false)                              | **No**    | If true and `LessThan` is true, and a player's minimum stat value is below zero, then the player can afford a stat cost if the current value of a stat if above 0.                       |
+| InteractionModifierId | `InteractionModifierId`                                      | **Yes**   | The armor interaction modifier to apply bonuses and penalties for.                                                                                                                       |
+
+**ValueType Values**
+
+- `Absolute`
+- `Percent`
+
+**InteractionModifierId Values**
+
+- `Dodge`
+
+## EntityEffects
+
+EntityEffects are buff or debuff effects that can be applied to a LivingEntity.  These can have a variety of effects from
+movement speed changes to periodic damage.
+
+### EffectCondition
+
+This interaction will fail if the specified entity's EntityEffects do not match the provided conditions.
+
+**EffectCondition Fields**
+
+| Field Name      | Type                                             | Required? | Notes                                                                                                                                                                                                             |
+| --------------- | ------------------------------------------------ | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Entity          | `InteractionTarget`<br />(Default: User)         | **Yes**   | The entity to examine for EntityEffects. This field can indicate the Owner, User, or Target of this interaction chain.                                                                                            |
+| Match           | `Match`<br />(Default: All)                      | **No**    | If `All`, then this interaction will fail if any EntityEffect in the `EntityEffectIds` is not on the specified entity. If `None`, then this interaction will fail if any EntityEffect IS on the specified entity. |
+| EntityEffectIds | `AssetArray`<br />(Element Type: `EntityEffect`) | **Yes**   | The set of EntityEffects to check against the specified entity and `Match`.                                                                                                                                       |
+
+**InteractionTarget Values**
+
+- `User` - The user of this interaction chain. The entity whose actions caused this interaction chain to be executed. This is usually the same as the Owner.
+- `Owner` - The owner of this interaction chain. The entity upon whom this interaction chain is executing.
+- `Target` - The entity target of this interaction chain, if any.  This value is mutable (and can therefore come from many places) but most commonly, it is an entity the User was targeting when this interaction chain began executing.
+
+**Match Values**
+
+- `All` - All EntityEffects must be on the specified entity for this interaction to succeed.
+- `None` - None of the EntityEffects must be on the specified entity for this interaction to succeed.
+
+### ApplyEffect
+
+This interaction will apply the specified EntityEffect to the specified Entity.  It has no special failure conditions.
+
+**ApplyEffect Fields**
+
+| Field Name | Type                                      | Required? | Notes                                                                                                                  |
+| ---------- | ----------------------------------------- | --------- | ---------------------------------------------------------------------------------------------------------------------- |
+| Entity     | `InteractionTarget`<br />(Default: User)  | **Yes**   | The entity to apply the EntityEffect to. This field can indicate the Owner, User, or Target of this interaction chain. |
+| EffectId   | `Asset`<br />(Asset Type: `EntityEffect`) | **Yes**   | The effect to apply.                                                                                                   |
+
+**InteractionTarget Values**
+
+- `User` - The user of this interaction chain. The entity whose actions caused this interaction chain to be executed. This is usually the same as the Owner.
+- `Owner` - The owner of this interaction chain. The entity upon whom this interaction chain is executing.
+- `Target` - The entity target of this interaction chain, if any.  This value is mutable (and can therefore come from many places) but most commonly, it is an entity the User was targeting when this interaction chain began executing.
+
+### ClearEntityEffect
+
+This interaction will remove the specified EntityEffect from the specified Entity. It has no special failure conditions.
+It will not fail if the Entity does not have the EntityEffect.
+
+**ClearEntityEffect Fields**
+
+| Field Name | Type                                      | Required? | Notes                                                                                                                     |
+| ---------- | ----------------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------- |
+| Entity     | `InteractionTarget`<br />(Default: User)  | **Yes**   | The entity to remove the EntityEffect from. This field can indicate the Owner, User, or Target of this interaction chain. |
+| EffectId   | `Asset`<br />(Asset Type: `EntityEffect`) | **Yes**   | The effect to remove.                                                                                                     |
+
+**InteractionTarget Values**
+
+- `User` - The user of this interaction chain. The entity whose actions caused this interaction chain to be executed. This is usually the same as the Owner.
+- `Owner` - The owner of this interaction chain. The entity upon whom this interaction chain is executing.
+- `Target` - The entity target of this interaction chain, if any.  This value is mutable (and can therefore come from many places) but most commonly, it is an entity the User was targeting when this interaction chain began executing.
+
+## Farming
+
+These are interaction types built to support the in-game farming system in Hytale. They are mostly block-related interactions
+with a few exceptions.
+
+### ChangeFarmingStage
+
+If the target block is a farming block, this interaction will attempt to modify the current farming stage in one of
+three ways.  The interaction can optionally specify which StageSet to use for the new stage. If it is not specified,
+the current StageSet will be used. If any part of the the process of changing the growth stage fails, this interaction
+will fail, with the one exception that attempting to set the stage to the crop's existing stage will have no effect but
+still succeed.
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                                                                                                                                                                          |
+| ---------------- | ------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction.                                                                                                                                              |
+| StageSet         | `String`                        | **No**    | If provided, set the block's current stage to one in the provided StageSet. Otherwise, use the crop's current StageSet.                                                                                                                                                        |
+| Increase         | `Integer`                       | **No**    | If provided, increase the current stage by the specified amount. If the specified stage does not exist, the block will be set to the closest extant stage.                                                                                                                     |
+| Decrease         | `Integer`                       | **No**    | If provided and `Increase` is not provided, decrease the current stage by the specified amount. If the specified stage does not exist, the block will be set to the closest extant stage.                                                                                      |
+| Stage            | `Integer`<br />(Default: -1)    | **No**    | If provided and `Increase`/`Decrease` are not provided, set the current stage to the specified stage. If this value is less than 0, set the current stage to the final growth stage. If the specified stage does not exist, the block will be set to the closest extant stage. |
+
+### FertilizeSoil
+
+If the target block is unfertilized tilled soil or a farming block on top of unfertilized tilled soil, fertilizes the soil.
+The interaction will fail otherwise.
+
+**FertilizeSoil Fields**
+
+| Field Name       | Type                                  | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false)       | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+| RefreshModifiers | `Array`<br />(Element Type: `String`) | **No**    | Does nothing.                                                                                                                     |
+
+### HarvestCrop
+
+This interaction will attempt to execute the harvest action on the current block target and add the crop's drops to the User entity's
+inventory.  The block will either be destroyed or set to its post-harvest growth stage, depending on the farming
+configuration of the block.  This will happen (and the player will receive the full harvest drops) regardless of the
+block's current growth stage. This interaction has no special failure conditions, even if the block target isn't a
+farming block or gathering isn't permitted in the current world, but nothing will occur in those cases.
+
+**HarvestCrop Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+
+### UseWateringCan
+
+If the target block is tilled soil or a farming block on top of tilled soil, waters the soil for the specified duration.
+The interaction will fail otherwise.
+
+**UseWateringCan Fields**
+
+| Field Name       | Type                                  | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false)       | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+| Duration         | `Integer`<br />(Default: 0)           | **No**    | The duration in seconds to water the soil for.                                                                                    |
+| RefreshModifiers | `Array`<br />(Element Type: `String`) | **No**    | Does nothing.                                                                                                                     |
diff --git a/content/docs/pl-PL/contributing/pr-guidelines.mdx b/content/docs/pl-PL/contributing/pr-guidelines.mdx
index 7a251032..c226da04 100644
--- a/content/docs/pl-PL/contributing/pr-guidelines.mdx
+++ b/content/docs/pl-PL/contributing/pr-guidelines.mdx
@@ -19,6 +19,8 @@ To ensure a smooth and efficient review process, both contributors and reviewers
 4. **Code Quality**
    - Ensure your code follows the project's coding standards and best practices.
    - Include comments where necessary to explain complex logic.
+   - Always test your changes locally before submitting the PR to catch any issues early.
+   - Format your code using `bun format` to maintain consistency across the codebase.
 5. **Testing**
    - Test your changes thoroughly before submitting the PR.
    - If applicable, include unit tests or integration tests to verify your changes.
diff --git a/content/docs/pl-PL/contributing/translate.mdx b/content/docs/pl-PL/contributing/translate.mdx
new file mode 100644
index 00000000..c62ffdde
--- /dev/null
+++ b/content/docs/pl-PL/contributing/translate.mdx
@@ -0,0 +1,74 @@
+---
+title: Translate
+description: How to translate HytaleModding to your language
+---
+
+# Translating HytaleModding
+
+HytaleModding is translated with the help of the community using **Crowdin**. If you want to help translate or improve existing translations, this is the right place.
+
+## Steps to Translate
+
+All translations are managed **via Crowdin**.
+
+1. Visit [our Crowdin project](https://crowdin.com/project/hytalemodding) and log in if required.
+2. Click on your language.
+3. Click on the file/article you wish to translate. We recommend starting with Official Documentation, and then Server Plugin Documentation.
+4. Start translating!
+5. Approved translations will appear on the website.
+
+### Video Guide
+
+<iframe src="https://www.youtube.com/embed/NHiG1rDRgks" allowFullScreen />
+
+## How to discuss
+
+You can always report issues or discuss specific topics directly on Crowdin, but we recommend using Discord instead of the Crowdin comment system to keep everything organized in one place.
+
+1. Join [our Discord](https://discord.gg/hytalemodding)
+2. Open `#translations` channel. Here you can discuss or ask questions that are not related to a specific language.
+3. If you want to join a thread, you are required to run `/translator <your-language>` command here. The bot will add you to the thread for your language.
+
+## Translation Guidelines
+
+- You need to be confident in what you are translating. You should be able to read the text you just translated and understand the meaning of it very easily.
+- It should use the simplest form of language possible. Use English words if the translation is unknown to the majority in your country.
+- Use your imagination, trust yourself. Feel free to change any context as you wish as long as it can still get the same point across and is understandable.
+- These guidelines are more important than language-specific guidelines, but less important than Hytale terminology and rules.
+
+## What not to translate
+
+We request you all to not translate these specific sections of the website:
+
+### Callout types
+
+Callouts are the boxes that contain important information. We request you to not translate the types as they only work in English.
+
+**Example:**
+
+```mdx
+<Callout type="warning" title="Translate this title!">
+Translate the text inside the callout!
+</Callout>
+```
+
+In this example, please don't translate the word warning, the rest you can translate.
+
+### Icons
+
+Icon names must not be translated.
+They are technical identifiers mapped directly to existing icons. Translating them will break the icon rendering.
+
+```mdx
+icon: Globe
+```
+
+---
+
+{/* 
+For translators who will edit this page:
+
+- You are required to translate the Guidelines as they change.
+- General guidelines should be translated but not edited.
+- Learn how to use Markdown from writing_guides.mdx
+*/}
diff --git a/content/docs/pl-PL/established-information/server/content-categories/art-assets.mdx b/content/docs/pl-PL/established-information/server/content-categories/art-assets.mdx
index 39c2ed37..1e926874 100644
--- a/content/docs/pl-PL/established-information/server/content-categories/art-assets.mdx
+++ b/content/docs/pl-PL/established-information/server/content-categories/art-assets.mdx
@@ -14,7 +14,7 @@ Hytale provides comprehensive support for 3D modeling and texture art creation,
 Hytale uses **Blockbench** as the primary tool for 3D modeling and animation:
 
 * **Official support**: Used for "creating Hytale models, textures, and animations"
-* **Special plugin**: Hytale will have a dedicated Blockbench plugin, to be released ASAP
+* **Special plugin**: Hytale has a dedicated [Blockbench Plugin](https://www.blockbench.net/plugins/hytale_plugin).
 * **Direct compatibility**: The plugin allows creators to "create Hytale-compatible models, textures, and animations directly in Blockbench"
 * **Replaces legacy tools**: Fully replaces the old Hytale Model Maker to better support established creative workflows in the community
 * **Safety features**: Only allows you to add things compatible with the engine, so no need to worry about breaking anything
diff --git a/content/docs/pl-PL/guides/ecs/block-components.mdx b/content/docs/pl-PL/guides/ecs/block-components.mdx
new file mode 100644
index 00000000..ca68b38a
--- /dev/null
+++ b/content/docs/pl-PL/guides/ecs/block-components.mdx
@@ -0,0 +1,247 @@
+---
+title: Block Components
+description: Learn how to use the block components.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+  - name: oskarscot
+    link: https://oskar.scot
+---
+
+# Overview
+
+In this guide, you'll learn how to use block components to create a ticking block.
+
+<Callout>
+  For a more complete reference, you may also want to review FarmingSystems.Ticking, as much of the underlying logic is based on its implementation.
+</Callout>
+
+## Steps
+
+### 1. ExampleBlock - holds block behavior
+
+```java
+public class ExampleBlock implements Component<ChunkStore> {
+
+    public static final BuilderCodec CODEC = BuilderCodec.builder(ExampleBlock.class, ExampleBlock::new).build();
+
+    // Components usually require a copy constructor as well but since we don't actually hold any data in this component this is not neccessary
+    public ExampleBlock() { }
+
+    public static ComponentType getComponentType() {
+        return ExamplePlugin.get().getExampleBlockComponentType();
+    }
+
+    @Nullable
+    public Component<ChunkStore> clone() {
+        return new ExampleBlock();
+    }
+}
+```
+
+ExampleBlock is a custom component that stores the behavior and data for your ticking block. Here, it simply places an Ice Block at x + 1 relative to its current position when it ticks.
+
+---
+
+### 2. ExampleInitializer - marks blocks as ticking when placed
+
+```java
+public class ExampleInitializer extends RefSystem {
+
+    @Override
+    public void onEntityAdded(@Nonnull Ref ref, @Nonnull AddReason reason, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+        BlockModule.BlockStateInfo info = (BlockModule.BlockStateInfo) commandBuffer.getComponent(ref, BlockModule.BlockStateInfo.getComponentType());
+        if (info == null) return;
+
+        ExampleBlock generator = (ExampleBlock) commandBuffer.getComponent(ref, ExamplePlugin.get().getExampleBlockComponentType());
+        if (generator != null) {
+            int x = ChunkUtil.xFromBlockInColumn(info.getIndex());
+            int y = ChunkUtil.yFromBlockInColumn(info.getIndex());
+            int z = ChunkUtil.zFromBlockInColumn(info.getIndex());
+
+            WorldChunk worldChunk = (WorldChunk) commandBuffer.getComponent(info.getChunkRef(), WorldChunk.getComponentType());
+            if (worldChunk != null) {
+				worldChunk.setTicking(x, y, z, true);
+            }
+        }
+    }
+
+    @Override
+    public void onEntityRemove(@Nonnull Ref ref, @Nonnull RemoveReason reason, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+    }
+
+    @Override
+    public Query getQuery() {
+        return Query.and(BlockModule.BlockStateInfo.getComponentType(), ExamplePlugin.get().getExampleBlockComponentType());
+    }
+}
+```
+
+ExampleInitializer is a RefSystem that reacts when block entities with the ExampleBlock component are added or removed. This is crucial for marking blocks as ticking when they're first placed.
+
+**Key Points:**
+
+- Tells the game that this block should tick, allowing `ExampleSystem` to process it.
+
+```java
+worldChunk.setTicking(x, y, z, true);
+```
+
+---
+
+### 3. ExampleSystem - handles ticking
+
+```java
+public class ExampleSystem extends EntityTickingSystem {
+
+    public void tick(float dt, int index, @Nonnull ArchetypeChunk archetypeChunk, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+        BlockSection blocks = (BlockSection) archetypeChunk.getComponent(index, BlockSection.getComponentType());
+
+        assert blocks != null;
+
+        if (blocks.getTickingBlocksCountCopy() != 0) {
+            ChunkSection section = (ChunkSection) archetypeChunk.getComponent(index, ChunkSection.getComponentType());
+
+            assert section != null;
+
+            BlockComponentChunk blockComponentChunk = (BlockComponentChunk) commandBuffer.getComponent(section.getChunkColumnReference(), BlockComponentChunk.getComponentType());
+
+            assert blockComponentChunk != null;
+
+            blocks.forEachTicking(blockComponentChunk, commandBuffer, section.getY(), (blockComponentChunk1, commandBuffer1, localX, localY, localZ, blockId) -> {
+                Ref<ChunkStore> blockRef = blockComponentChunk.getEntityReference(ChunkUtil.indexBlockInColumn(localX, localY, localZ));
+                if (blockRef == null) {
+                    return BlockTickStrategy.IGNORED;
+                } else {
+                    ExampleBlock exampleBlock = (ExampleBlock) commandBuffer1.getComponent(blockRef, ExampleBlock.getComponentType());
+                    if (exampleBlock != null) {
+                        WorldChunk worldChunk = (WorldChunk) commandBuffer.getComponent(section.getChunkColumnReference(), WorldChunk.getComponentType());
+                        World world = worldChunk.getWorld();
+
+                        int globalX = localX + (worldChunk.getX() * 32);
+                        int globalZ = localZ + (worldChunk.getZ() * 32);
+
+                        // We need to execute setBlock on the world thread as you cannot call store functions from a system
+                        // This is because of the architecture of the server, depending on your needs you can also use the CommandBuffer
+                        world.execute(() -> {
+                            world.setBlock(globalX + 1, localY, globalZ, "Rock_Ice");
+                        });
+
+                        return BlockTickStrategy.CONTINUE;
+
+                    } else {
+                        return BlockTickStrategy.IGNORED;
+                    }
+                }
+            });
+        }
+    }
+
+    @Nullable
+    public Query getQuery() {
+        return Query.and(BlockSection.getComponentType(), ChunkSection.getComponentType());;
+    }
+}
+```
+
+ExampleSystem is an EntityTickingSystem that runs every tick to execute the logic for all ticking blocks with the ExampleBlock component.
+
+**Key Points:**
+
+- **Get the block component**
+
+```java
+ExampleBlock exampleBlock = (ExampleBlock) commandBuffer.getComponent(blockRef, ExampleBlock.getComponentType());
+```
+
+- **Convert local chunk coordinates to world coordinates**
+
+```java
+int globalX = localX + (worldChunk.getX() * 32);
+int globalZ = localZ + (worldChunk.getZ() * 32);
+```
+
+- **Run the block logic**
+
+```java
+exampleBlock.runBlockAction(globalX, localY, globalZ, worldChunk.getWorld());
+```
+
+- **Keep the block ticking in the next tick**
+
+```java
+return BlockTickStrategy.CONTINUE;
+```
+
+---
+
+### 4. ExamplePlugin - registers components and systems
+
+```java
+public class ExamplePlugin extends JavaPlugin {
+    protected static ExamplePlugin instance;
+    private static final HytaleLogger LOGGER = HytaleLogger.forEnclosingClass();
+    private ComponentType exampleBlockComponentType;
+
+    public static ExamplePlugin get() {
+        return instance;
+    }
+
+    public ExamplePlugin(@Nonnull JavaPluginInit init) {
+        super(init);
+        LOGGER.atInfo().log("Hello from " + this.getName() + " version " + this.getManifest().getVersion().toString());
+    }
+
+    @Override
+    protected void setup() {
+        instance = this;
+        LOGGER.atInfo().log("Setting up plugin " + this.getName());
+        this.exampleBlockComponentType = this.getChunkStoreRegistry().registerComponent(ExampleBlock.class, "ExampleBlock", ExampleBlock.CODEC);
+    }
+	
+	@Override
+	protected void start() {
+		this.getChunkStoreRegistry().registerSystem(new ExampleSystem());
+		this.getChunkStoreRegistry().registerSystem(new ExampleInitializer());
+	}
+
+    public ComponentType getExampleBlockComponentType() {
+        return this.exampleBlockComponentType;
+    }
+}
+```
+
+---
+
+### 5. Configure In-Game
+
+![block-component-1](/assets/guides/block-component-1.png)
+
+![block-component-2](/assets/guides/block-component-2.png)
+
+With this logic, the block will now continuously place an Ice Block at the coordinates x + 1 relative to its current position every time it ticks.
+
+---
+
+## Common Issues
+
+### NullPointerException on Startup
+
+**Error message:**
+
+```java
+java.lang.NullPointerException: Cannot invoke "com.hypixel.hytale.component.query.Query.validateRegistry(com.hypixel.hytale.component.ComponentRegistry)" because "query" is null
+```
+
+**Cause:**
+This error occurs when your module is loaded **before** the required Hytale modules.
+
+**Fix:**
+Add `EntityModule` and `BlockModule` as dependencies in your `manifest.json` to ensure proper load order.
+
+```json
+"Dependencies": {
+  "Hytale:EntityModule": "*",
+  "Hytale:BlockModule": "*"
+}
+```
diff --git a/content/docs/pl-PL/guides/ecs/hytale-ecs-theory.mdx b/content/docs/pl-PL/guides/ecs/hytale-ecs-theory.mdx
index 20c3a94d..52d8b1f5 100644
--- a/content/docs/pl-PL/guides/ecs/hytale-ecs-theory.mdx
+++ b/content/docs/pl-PL/guides/ecs/hytale-ecs-theory.mdx
@@ -29,7 +29,7 @@ for now this is the basic understanding for the `ChunkStore`. You can use it to
 
 ## Holder
 
-A Holder is essentially a blueprint for an entity. Before an entity exists in the Store (and thus in the world), is exists as a `Holder`. It collects and holds all the necessary components (data). You can compare it analogous to shopping cart. You grab all components you need and once you have everything, check out at the store which will take your cart and create a valid entity ID and hand you back a receipt (a Ref).
+A Holder is essentially a blueprint for an entity. Before an entity exists in the Store (and thus in the world), it exists as a `Holder`. It collects and holds all the necessary components (data). You can compare it analogous to shopping cart. You grab all components you need and once you have everything, check out at the store which will take your cart and create a valid entity ID and hand you back a receipt (a Ref).
 
 Let's take a look at an example: initializing players. In `Universe`, the `addPlayer` method demonstrates it perfectly.
 When a player connects, we don't immediately throw them into the ECS. We first construct their data in a Holder.
@@ -167,7 +167,7 @@ MyComponent comp = commandBuffer.getComponent(ref, componentType);
 
 Codecs handle serialization and deserialization of components. Hytale uses them to save and load entity data to and from disk as well as sending component data over the network. When creating a custom component, you must also create a corresponding Codec.
 
-There are mutliple Codec types already implemented in the default Codec Interface:
+There are multiple Codec types already implemented in the default Codec Interface:
 
 - Codec.STRING
 - Codec.BOOLEAN
@@ -215,7 +215,7 @@ This might seem tedious at first but it ensures that your component can be corre
   KeyedCodec<Integer> exampleInt = new KeyedCodec<Integer>("ExampleIntIdForCodec", Codec.INTEGER);
   ```
 
-- **Setter Function**: This is a lambda function that takes an instance of your component and returns the value of the field you want to serialize. For example, if you have a field called `myCustomField` in your custom component, your getter function would look like this:
+- **Setter Function**: This is a lambda function that takes an instance of your component + the value to set and sets the field value on the component. For example, if you have a field called `myCustomField` in your custom component, your setter function would look like this:
   ```java
   (data, value) -> data.myCustomField = value
   ```
@@ -276,7 +276,7 @@ public class PoisonComponent implements Component<EntityStore> {
 
 You can also add validators to your Codec fields to ensure that the data being serialized/deserialized meets certain criteria. For example, if you want to ensure that the `damagePerTick` field is always non-negative or the poison name is never null, you can add a validator like this:
 
-````java
+```java
 .append(
     new KeyedCodec<Float>("DamagePerTick", Codec.FLOAT),
     (data, value) -> data.damagePerTick = value,
@@ -292,14 +292,15 @@ You can also add validators to your Codec fields to ensure that the data being s
 )
 .addValidator(Validators.nonNull())
 .add()
+```
 
 ### Complex Codec Examples
 
-If you want to have a map inside your component, you can use the MapCodec class to build a KeyedCoded for it. Here's an example of how to create a Codec for a Map field:
+If you want to have a map inside your component, you can use the MapCodec class to build a KeyedCodec for it. Here's an example of how to create a Codec for a Map field:
 
 ```java
 var damagePerTick = new KeyedCodec<>("DamagePerTick", new MapCodec<>(Codec.FLOAT, HashMap<String, Float>::new));
-````
+```
 
 <Callout type="info">
   This also works with custom Objects as long as you have a Codec defined for the Object type.
diff --git a/content/docs/pl-PL/guides/java-basics/00-introduction.mdx b/content/docs/pl-PL/guides/java-basics/00-introduction.mdx
index a03ad638..b0130d74 100644
--- a/content/docs/pl-PL/guides/java-basics/00-introduction.mdx
+++ b/content/docs/pl-PL/guides/java-basics/00-introduction.mdx
@@ -7,7 +7,7 @@ Welcome to your journey into Java Programming! This guide is designed to introdu
 
 ## What is Java?
 
-Java is a powerful, object-oriented programming language created in 1995. It's one of the most popular programming languages in the world and is used for everything from mobile apps to enterprise software. Most importantly for us, it's the language Hytale uses for it's servers & modding API.
+Java is a powerful, object-oriented programming language created in 1995. It's one of the most popular programming languages in the world and is used for everything from mobile apps to enterprise software. Most importantly for us, it's the language Hytale uses for its servers & modding API.
 
 ## What You'll Learn
 
diff --git a/content/docs/pl-PL/guides/java-basics/02-operators.mdx b/content/docs/pl-PL/guides/java-basics/02-operators.mdx
index a132b1c0..18634665 100644
--- a/content/docs/pl-PL/guides/java-basics/02-operators.mdx
+++ b/content/docs/pl-PL/guides/java-basics/02-operators.mdx
@@ -119,7 +119,7 @@ String greetingWithName = "Hello, " + name + "!"; // "Hello, Alice!"
 
 ## Operator Precedence
 
-Operator Precendence means which operator gets evaluated first in an line of code. Think of it like BODMAS/PEMDAS in math!
+Operator Precedence means which operator gets evaluated first in an line of code. Think of it like BODMAS/PEMDAS in math!
 
 ```java
 int result = 10 + 5 * 2; // result is 20, not 30
diff --git a/content/docs/pl-PL/guides/java-basics/03-control-flow-if.mdx b/content/docs/pl-PL/guides/java-basics/03-control-flow-if.mdx
index b9d6c479..af2d1c22 100644
--- a/content/docs/pl-PL/guides/java-basics/03-control-flow-if.mdx
+++ b/content/docs/pl-PL/guides/java-basics/03-control-flow-if.mdx
@@ -7,7 +7,7 @@ Programs need to make decisions. If statements let your code choose different pa
 
 ## Basic If Statement
 
-The simplest form checks one condition;
+The simplest form checks one condition:
 
 ```java
 int health = 20;
diff --git a/content/docs/pl-PL/guides/java-basics/08-access-modifiers.mdx b/content/docs/pl-PL/guides/java-basics/08-access-modifiers.mdx
index af560932..da2bf33b 100644
--- a/content/docs/pl-PL/guides/java-basics/08-access-modifiers.mdx
+++ b/content/docs/pl-PL/guides/java-basics/08-access-modifiers.mdx
@@ -484,7 +484,7 @@ class Data {
     // Static member:
     // cannot access to non-static variables
     public static void bar() {
-        x = 100; // Error: non-static variable x cannot be renference from a static context
+        x = 100; // Error: non-static variable x cannot be referenced from a static context
         y = 100; // OK
     }
 }
@@ -504,7 +504,7 @@ Data.x = 1000; // Error: cannot access instanced variables in a static context
 
 ### Static Fields
 
-A static field represents a data member owned by the class type rather then the object. Static fields are also stored in a specific memory location that's been shared between all the object instances that are created.
+A static field represents a data member owned by the class type rather than the object. Static fields are also stored in a specific memory location that's been shared between all the object instances that are created.
 
 It is declared as following:
 
diff --git a/content/docs/pl-PL/guides/plugin/animated-block-textures.mdx b/content/docs/pl-PL/guides/plugin/animated-block-textures.mdx
new file mode 100644
index 00000000..42bfa51f
--- /dev/null
+++ b/content/docs/pl-PL/guides/plugin/animated-block-textures.mdx
@@ -0,0 +1,101 @@
+---
+title: Animated Block Textures
+description: Learn how to attach a .blockyanim to a block
+authors:
+  - name: Burkino
+---
+
+import { File, Folder, Files } from 'fumadocs-ui/components/files';
+
+So, you want to make your blocks feel more alive through animations, do you?\
+Now for the most part this is the exact same as [Creating custom blocks](./creating-block).
+![blue fire gif](/assets/guides/blue_fire.gif)
+
+## Prerequisites
+
+This is NOT a guide on animating or texturing or even using BlockBench, why? Because I don't know how to do that.\
+The only thing we will be doing is taking the fire texture, changing the color, and applying it to our new fire block.
+
+## Setup
+
+To start, you're obviously going to want to grab the `Common/VFX/Fire/Fire.png` file. How you do it is up to you, in the Asset Editor you'll need to switch to the Common tab.\
+I'll assume you know how colorize or change the hue of an image, so go ahead and do that now and save it as `Blue_Fire.png`.
+
+The other assets used in this guide are `Common/VFX/Fire/Fire.blockymodel` and `Common/Blocks/Animations/Fire/Fire_Burn.blockyanim` (both renamed to `Blue_Fire`) but since we won't be changing them it's probably fine to leave them. I will reference the `Blue_Fire` versions as a way to point out what should be custom assets.\
+I will also duplicate `Server/Item/Item/Deco/Deco_Fire.json` and call it `Deco_Blue_Fire.json`.
+
+## Applying the changes
+
+The `Deco_Blue_Fire` block is actually just a particle emitter, however we will not be using particles, so lets start by removing them in `Block > Particles`.\
+Next we want to set the Block Model (called `CustomModel` in JSON) to `VFX/Blue_Fire/Blue_Fire.blockymodel` and Block Model Textures (`CustomModelTexture` in JSON) to
+
+```json
+[
+    {
+        "Texture": "VFX/Blue_Fire/Blue_Fire.png",
+        "Weight": 1
+    }
+]
+```
+
+Finally, we will apply the .blockyanim to our model, this is done through the Block Model Animation property (`CustomModelAnimation` in JSON) and the value should be `Blocks/Animations/Blue_Fire/Blue_Fire_Burn.blockyanim`.
+
+## Final Code
+
+With that your new blue fire should be done. Here is the minimal JSON for our blue fire.\
+There is an additional `Looping` and `RequiresAlphaBlending` property that I have not gone over, however I hope it is self-explanatory.
+
+```json
+{
+  "BlockType": {
+    "DrawType": "Model",
+    "CustomModel": "VFX/Blue_Fire/Blue_Fire.blockymodel",
+    "CustomModelAnimation": "Blocks/Animations/Blue_Fire/Blue_Fire_Burn.blockyanim",
+    "CustomModelTexture": [
+      {
+        "Texture": "VFX/Blue_Fire/Blue_Fire.png",
+        "Weight": 1
+      }
+    ],
+    "Looping": true,
+    "RequiresAlphaBlending": false
+  },
+  "PlayerAnimationsId": "Block"
+}
+```
+
+<Files>
+  <Folder name="resources" defaultOpen>
+    <Folder name="Server" defaultOpen>
+      <Folder name="Item" defaultOpen>
+        <Folder name="Items" defaultOpen>
+          <Folder name="Deco" defaultOpen>
+            <File name="Deco_Blue_Fire.json" />
+          </Folder>
+        </Folder>
+      </Folder>
+    </Folder>
+
+    <Folder name="Common" defaultOpen>
+      <Folder name="Blocks" defaultOpen>
+        <Folder name="Animations" defaultOpen>
+          <Folder name="Blue_Fire" defaultOpen>
+            <File name="Blue_Fire_Burn.blockyanim" />
+          </Folder>
+        </Folder>
+      </Folder>
+
+      <Folder name="VFX" defaultOpen>
+        <Folder name="Blue_Fire" defaultOpen>
+          <File name="Blue_Fire.blockymodel" />
+
+          <File name="Blue_Fire.png" />
+        </Folder>
+      </Folder>
+    </Folder>
+  </Folder>
+</Files>
+
+## Next steps
+
+Now that you know how to attach an animation to a block, try adding it to a block state.
diff --git a/content/docs/pl-PL/guides/plugin/build-and-test.mdx b/content/docs/pl-PL/guides/plugin/build-and-test.mdx
index 0e7fe7eb..f37534c3 100644
--- a/content/docs/pl-PL/guides/plugin/build-and-test.mdx
+++ b/content/docs/pl-PL/guides/plugin/build-and-test.mdx
@@ -9,18 +9,18 @@ If you followed along with the [Setting Up Your Development Environment](./setti
 
 ## Building Your Mod
 
-In our case, we've **Maven** as the build system. Maven is a powerful build automation tool that manages dependencies, compiles your code, and packages everything into a distributable JAR file.
+In our case, we've **Gradle** as the build system. Gradle is a powerful build automation tool that manages dependencies, compiles your code, and packages everything into a distributable JAR file.
 
-### Understanding Maven
+### Understanding Gradle
 
-Maven uses a `pom.xml` file (Project Object Model) to define your project's configuration, dependencies, and build settings. You can learn more about Maven at the [official Apache Maven website](https://maven.apache.org/).
+Gradle can use a `build.gradle.kts` file (Kotlin DSL) to define your project's configuration, dependencies, and build settings. You can learn more about Gradle at the [official Gradle website](https://gradle.org/).
 
-### Building with Maven
+### Building with Gradle
 
 To build your mod, open a terminal in your project directory and run:
 
 ```bash
-mvn package
+./gradlew build
 ```
 
 This command will:
@@ -29,16 +29,35 @@ This command will:
 2. Run any tests (if present)
 3. Package everything into a JAR file
 
+<Callout type="info">
+  If you are using the plugin template from the [Setting Up Your Development Environment](./setting-up-env) guide, then the build script is already set up for you. It includes paths to your Hytale game library and handles the packaging of your mod, managing hytale dependencies and manifest changes.
+
+  If you have a different path to your Hytale installation, you may receive the following error:
+
+  ```bash
+  FAILURE: Build failed with an exception.
+
+  * What went wrong:
+  Failed to find Hytale at the expected location. Please make sure you have installed the game. The expected location can be changed using the hytale.home_path property. Currently looking in 'C:\Path\To\Hytale'
+  ```
+
+  You can change the path by adding a property to your `gradle.properties` file (if it doesn't exist, create it in the root of your project):
+
+  ```properties
+  hytale.home_path=C:\Correct\Path\To\Hytale
+  ```
+</Callout>
+
 ### Build Output
 
-Once the build completes successfully, your mod will be located in the `target` directory and named:
+Once the build completes successfully, your mod will be located in the `build/libs` directory and named:
 
 ```
-ExamplePlugin-1.0-SNAPSHOT.jar
+ExamplePlugin-1.0.jar
 ```
 
 <Callout type="info">
-  The exact name may vary depending on what you configured in your `pom.xml` file. Check the `artifactId` and `version` fields to see what your JAR will be named.
+  The exact name may vary depending on what you configured in your `build.gradle.kts` and `settings.gradle.kts` file. Check the `rootProject.name` and `version` fields to see what your JAR will be named.
 </Callout>
 
 ## Testing Your Mod
@@ -49,11 +68,11 @@ Now that you've built your mod, it's time to test it in Hytale!
 
 First, you need to find Hytale's mods directory:
 
-1. Press **Win + R** on your keyboard
-2. Type `%appdata%` and press Enter
-3. Navigate to: `Hytale\UserData\Mods`
+1. Go to your Hytale installation directory (The default location is usually in your AppData folder)
+   > On Windows, you can access it by clicking `windows + R` and typing `%appdata%`.
+2. Navigate to: `/UserData/Mods`
 
-The full path should look like:
+The default path would look like:
 
 ```
 C:\Users\YourUsername\AppData\Roaming\Hytale\UserData\Mods
@@ -65,7 +84,7 @@ C:\Users\YourUsername\AppData\Roaming\Hytale\UserData\Mods
 
 ### 2. Copy Your Mod
 
-Copy the `ExamplePlugin-1.0-SNAPSHOT.jar` file from your project's `target` directory into the `Mods` folder you just located.
+Copy the `ExamplePlugin-1.0.jar` file from your project's `build/libs` directory into the `Mods` folder you just located.
 
 ### 3. Launch Hytale and Verify
 
@@ -84,7 +103,7 @@ If your mod doesn't appear in the mods list:
 - Make sure the JAR file is in the correct `Mods` folder
 - Check that your `manifest.json` file is properly configured
 - Look for any error messages in the Hytale logs
-- Verify that you're using the correct version of Java and Maven
+- Verify that you're using the correct version of Java and Gradle
 
 ## Next Steps
 
diff --git a/content/docs/pl-PL/guides/plugin/creating-commands.mdx b/content/docs/pl-PL/guides/plugin/creating-commands.mdx
index d33597f3..08572f16 100644
--- a/content/docs/pl-PL/guides/plugin/creating-commands.mdx
+++ b/content/docs/pl-PL/guides/plugin/creating-commands.mdx
@@ -8,6 +8,8 @@ authors:
     url: https://oskar.scot
   - name: jacobwojoski
     url: https://github.com/jacobwojoski
+  - name: Marcel-TO
+    url: https://marcel-to.net
 ---
 
 In this guide, you will learn how to create custom commands for your Hytale mod.
@@ -36,7 +38,7 @@ The most basic command is an `AbstractAsyncCommand`. It has very minimal data av
   `AbstractAsyncCommand` runs on its own background thread. This means its execute is not tied to any world instance and because of this it can not edit any **Stores** or **Refs** without getting the desired world first. To access this data any of the other command types would be preferred and are likely what you will want to use instead.
 </Callout>
 
-The main purpose for a command like this would be for something that can happen everywhere and is not tied to a specific world. For example a `serverRules` command to tell the user thats running the command in chat what the servers rules are nomatter what world they are in.
+The main purpose for a command like this would be for something that can happen everywhere and is not tied to a specific world. For example a `serverRules` command to tell the user that's running the command in chat what the server's rules are no matter what world they are in.
 
 ```java
 // Command that can be run that lists the server rules in chat to the player
@@ -49,7 +51,7 @@ public class ServerRulesCommand extends AbstractAsyncCommand {
     }
 
     // Run the command
-    // conetext - info about who ran the command. Server console?, Some player?
+    // context - info about who ran the command. Server console?, Some player?
     @Override
     protected CompletableFuture<Void> executeAsync(@Nonnull CommandContext context) {
         context.sendMessage(Message.raw("The only rule is there are no rules."));
@@ -134,7 +136,7 @@ Uses a Ray to see what the player is looking at and tries to run the command on
 
 ## Adding Arguments
 
-Arguments are additional fields that the user can input when running a command. The different types of arguments along with small snipits and a large example can be seen below.
+Arguments are additional fields that the user can input when running a command. The different types of arguments along with small snippets and a large example can be seen below.
 
 ### Command Argument Types
 
@@ -163,14 +165,14 @@ this.messageArg = this.withOptionalArg("message", "Message to print while healin
 
 ### Default Arguments
 
-Adding a default argument has two additional arguemnt for the default value and default value description. You need to use `withDefaultArg` method.
+Adding a default argument has two additional argument for the default value and default value description. You need to use `withDefaultArg` method.
 
 ```java
 // args <Command String> <Description> <Default Value> <Desc of default value>
 this.healthArg = this.withDefaultArg("health", "Amount to heal player", ArgTypes.FLOAT, (float)100, "Desc of Default: 100");
 ```
 
-### Flag Arguemnts
+### Flag Arguments
 
 Similar as above but the flags return is either true if it exists or false if it does not. You need to use `withFlagArg` method.
 
@@ -181,20 +183,13 @@ this.debugArg = this.withFlagArg("debug", "Add debug logs");
 
 ### ArgTypes
 
-The following ArgTypes are available (only lists common types):
-
-- `ArgTypes.STRING`
-- `ArgTypes.INTEGER`
-- `ArgTypes.BOOLEAN`
-- `ArgTypes.FLOAT`
-- `ArgTypes.DOUBLE`
-- `ArgTypes.UUID`
+You can find all the available argument types on the [ArgTypes](../../argtypes) page.
 
 ### Example Command Arg Types
 
-Shows all Command arguemnt types with different various input types.
+Shows all Command argument types with different various input types.
 
-**NOTE:** When getting the value of an argument during execute you need to pass the context with `someArg.get(commandContext)`. Where `commandContext` is the first variable in the execute funtion.
+**NOTE:** When getting the value of an argument during execute you need to pass the context with `someArg.get(commandContext)`. Where `commandContext` is the first variable in the execute function.
 
 ```java
 // Example usage: /healplayer --health 50 --message "Feels Good" --debug
@@ -204,7 +199,7 @@ public class HealPlayerCommand extends AbstractTargetPlayerCommand {
     private final FlagArg debugArg;
 
     public HealPlayerCommand() {
-        super("healplayer", "Healing a player for an <input> ammount of HP (default: 100)");
+        super("healplayer", "Healing a player for an <input> amount of HP (default: 100)");
 
         // Abstract TargetPlayerCommand passes the player that ran the command by default and implements
         // the use of `--player <value>` to specify someone else
@@ -213,10 +208,10 @@ public class HealPlayerCommand extends AbstractTargetPlayerCommand {
         this.healthArg = this.withDefaultArg("health", "Amount to heal player", ArgTypes.FLOAT, (float)100, "Desc of Default: 100");
 
         // Or you could do the following making the health value required instead of with a default.
-        //    You would need to change the decleration to RequiredArg<Float>
+        //    You would need to change the declaration to RequiredArg<Float>
         // this.healthArg = this.withRequiredArg("health", "Amount to heal player", ArgTypes.FLOAT);
 
-        // Optional args reguare the user the input `--<key> <value>` so the following would require `--message "Good Luck"`
+// Optional args require the user the input `--<key> <value>` so the following would require `--message "Good Luck"`
         this.messageArg = this.withOptionalArg("message", "Message to print while healing", ArgTypes.STRING);
 
         // No type needed due to being a bool
@@ -230,7 +225,7 @@ public class HealPlayerCommand extends AbstractTargetPlayerCommand {
             commandContext.sendMessage(Message.raw("We are debugging"));
         }
 
-        // Health is stored in a generic stat map to allowing mods/future contect to easily add more stats if desired.
+        // Health is stored in a generic stat map to allowing mods/future content to easily add more stats if desired.
         EntityStatMap stats = store.getComponent(ref, EntityStatMap.getComponentType());
         int healthIdx = DefaultEntityStatTypes.getHealth();
         EntityStatValue health = stats.get(healthIdx);
@@ -252,7 +247,7 @@ public class HealPlayerCommand extends AbstractTargetPlayerCommand {
 
 ## Argument Validators
 
-Argument validators are a way to check the command before the command gets executed. They are added with the `addValidator` method on an argument when calling `withXxxArg`. They provide a nice output to the user when an input value is invalid.
+Argument validators are a way to check the command before the command gets executed. They are added with the `addValidator` method on an argument when calling `withXxxArg`. They provide a nice output to the user when an input value is invalid. There are some common validators provided in the `Validators` class such as `greaterThan`, `lessThan`, and `or`, `max`, `range`, etc.
 
 ```java
 ...
@@ -260,18 +255,59 @@ Argument validators are a way to check the command before the command gets execu
     OptionalArg<Integer> healAmount = withOptionalArg("amount", "Heal Amount", ArgTypes.INTEGER)
         .addValidator(Validators.greaterThan(0))
         .addValidator(Validators.lessThan(1000));
-
-    // Custom check example
-    OptionalArg<Integer> healAmount = withOptionalArg("amount", "Heal Amount", ArgTypes.INTEGER)
-            .addValidator( value -> {
-                if (value != null && value <= 0) {
-                    return ValidationResult.error("ammount argument must be a positive number");
-                }
-                return ValidationResult.success();
-            });
 ...
 ```
 
+### Custom Validators
+
+You can also create custom validators by implementing the `com.hypixel.hytale.codec.validation.Validator` interface. The interfaces forces you to implement the `accept` and `updateSchema` method. The `accept` method takes in the argument value and validates it. If the validation fails, you can use the `fail` method of the `com.hypixel.hytale.codec.validation.ValidationResults` class to return an error message.
+The `updateSchema` method is used to update the schema of the command argument. This is used for commands that have dynamic schemas based on the input value. For example, if you have a command that takes in a player name as an argument, you can use the `updateSchema` method to update the schema to include a list of online players for validation.
+
+Here is an example of a custom validator that checks if a string value is equal to a banned word. In this example, the banned word is "badword". If the input value is "badword", the validator will fail and return an error message.
+
+```java
+import com.hypixel.hytale.codec.schema.SchemaContext;
+import com.hypixel.hytale.codec.schema.config.Schema;
+import com.hypixel.hytale.codec.validation.ValidationResults;
+import com.hypixel.hytale.codec.validation.Validator;
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+
+public class MyCustomValidator implements Validator<String> {
+    @Nonnull
+    private final String value;
+
+    public MyCustomValidator(@Nonnull String value) {
+        this.value = value;
+    }
+
+    @Override
+    public void accept(@Nullable String input, @Nonnull ValidationResults results) {
+        if (this.value.equalsIgnoreCase(input)) {
+            results.fail("The given role has been banned.");
+        }
+    }
+
+    @Override
+    public void updateSchema(SchemaContext context, @Nonnull Schema target) {
+        // This method can be used to update the schema of the command argument. This is useful for commands that have dynamic schemas based on the input value. For example, if you have a command that takes in a player name as an argument, you can use the `updateSchema` method to update the schema to include a list of online players for validation.
+        throw new UnsupportedOperationException("Not implemented yet.");
+    }
+}
+```
+
+After the custom validator is created, you can add it to an argument like the following example. In this example, we add the `MyCustomValidator` to a string argument called "role". If the user inputs "badword" as the role, the command will fail and return the error message defined in the `MyCustomValidator`.
+
+```java
+    ...
+    // Custom validator example
+    String bannedRole = "badword";
+
+    OptionalArg<String> roleArg = withOptionalArg("role", "Role to assign", ArgTypes.STRING)
+        .addValidator(new MyCustomValidator(bannedRole));
+    ...
+```
+
 ---
 
 ## Permissions
@@ -312,7 +348,7 @@ This allows the server to control who has access to specific commands. You add t
 
 If you want variants of the same command without doing argument parsing you can instead use `addUsageVariant(new OtherCommandClass())` in the original commands constructor.
 
-The only difference is in the `OtherCommandClass()` constrcutor you don't pass the command name to the super class.
+The only difference is in the `OtherCommandClass()` constructor you don't pass the command name to the super class.
 
 <Callout type="info">
   You can also use `addAliases("some_alias", "some_other_alias")` as a way to add shorthand or other ways to write the same command.
@@ -387,7 +423,7 @@ public class AdminCommand extends AbstractCommandCollection {
     public AdminCommand () {
         super("admin", "Admin commands");
         addSubCommand(new UserCommandCollection());
-        addSybCommand(new ServerCommandCollection);
+        addSubCommand(new ServerCommandCollection);
     }
 }
 ```
@@ -417,5 +453,5 @@ public class MyPlugin extends JavaPlugin {
 
 ## Video Link
 
-_Special Thanks to [TroubleDev](https://www.youtube.com/@TroubleDEV) for his excelent video guide on all of these features._
+_Special Thanks to [TroubleDev](https://www.youtube.com/@TroubleDEV) for his excellent video guide on all of these features._
 _Video Link: [TroubleDev - Hytale's Command API Explained](https://www.youtube.com/watch?v=KnmhG9MDMgo)_
diff --git a/content/docs/pl-PL/guides/plugin/creating-events.mdx b/content/docs/pl-PL/guides/plugin/creating-events.mdx
index 95863990..d3f0925d 100644
--- a/content/docs/pl-PL/guides/plugin/creating-events.mdx
+++ b/content/docs/pl-PL/guides/plugin/creating-events.mdx
@@ -1,6 +1,6 @@
 ---
-title: Creating Events
-description: Learn how to create custom events for your Hytale mod.
+title: Creating Events Listeners
+description: Learn how to create event listeners for your Hytale mod.
 authors:
   - name: Neil Revin
     url: https://itsneil.dev
@@ -10,7 +10,7 @@ authors:
 
 ## Event Class
 
-You can import a Event class and create a function with the Event as a argument. [Click here](../../server/events) to look at all available events.
+You can import an Event class and create a function with the Event as an argument. [Click here](../../server/events) to look at all available events.
 
 Example plugin when a player is ready (joins a server):
 
diff --git a/content/docs/pl-PL/guides/plugin/item-registry.mdx b/content/docs/pl-PL/guides/plugin/item-registry.mdx
new file mode 100644
index 00000000..9a0fd53a
--- /dev/null
+++ b/content/docs/pl-PL/guides/plugin/item-registry.mdx
@@ -0,0 +1,95 @@
+---
+title: Working with the Item Registry
+description: Learn how to access and query the game's item registry to list all items, check if items exist, and retrieve item properties.
+authors:
+  - name: Denis
+---
+
+In this guide, you'll learn how to work with Hytale's Item Registry system. This is useful when you need to programmatically list all available items, validate item IDs, or retrieve item properties at runtime.
+
+## Prerequisites
+
+Before diving in, you should be familiar with:
+
+- [Setting up your development environment](./setting-up-env)
+- [Creating commands](./creating-commands) (optional, for testing)
+
+## Required Imports
+
+To work with the Item Registry, you'll need the following imports:
+
+```java
+import com.hypixel.hytale.assetstore.map.DefaultAssetMap;
+import com.hypixel.hytale.server.core.asset.type.item.config.Item;
+```
+
+## Getting the Item Registry
+
+The Item Registry is accessed through the `Item.getAssetMap()` method, which returns a `DefaultAssetMap<String, Item>` containing all registered items in the game:
+
+```java
+DefaultAssetMap<String, Item> itemMap = Item.getAssetMap();
+```
+
+## Listing All Items
+
+To iterate through all items in the registry, you can get the underlying map and loop through its entries:
+
+```java
+DefaultAssetMap<String, Item> itemMap = Item.getAssetMap();
+var map = itemMap.getAssetMap();
+
+for (var entry : map.entrySet()) {
+    String itemId = String.valueOf(entry.getKey());
+    Item item = entry.getValue();
+    
+    // Do something with the item
+    LOGGER.atInfo().log("Item ID: " + itemId);
+}
+```
+
+You can also get the total count of registered items:
+
+```java
+int totalItems = map.size();
+```
+
+## Checking if an Item Exists
+
+To check if a specific item exists in the registry, use `getAsset()` and verify the result:
+
+```java
+public boolean itemExists(String itemId) {
+    var assetMap = Item.getAssetMap();
+    if (assetMap != null) {
+        Item item = assetMap.getAsset(itemId);
+        return item != null && item != Item.UNKNOWN;
+    }
+    return false;
+}
+```
+
+<Callout type="info">
+  The `Item.UNKNOWN` constant represents an invalid or unrecognized item. Always check for both `null` and `Item.UNKNOWN` when validating items.
+</Callout>
+
+## Accessing Item Properties
+
+Once you have an `Item` instance, you can access various properties:
+
+```java
+var assetMap = Item.getAssetMap();
+Item item = assetMap.getAsset("Soil_Grass");
+
+if (item != null && item != Item.UNKNOWN) {
+    String id = item.getId(); // Soil_Grass
+    int maxStack = item.getMaxStack(); // 100
+    boolean isBlock = item.hasBlockType(); // true
+    boolean isConsumable = item.isConsumable(); // false
+}
+```
+
+## Related Guides
+
+- [Inventory Management](./inventory-management) - Learn how to add and remove items from player inventories
+- [Create Custom Item and Interaction](./item-interaction) - Learn how to create your own custom items
diff --git a/content/docs/pl-PL/guides/plugin/permission-management.mdx b/content/docs/pl-PL/guides/plugin/permission-management.mdx
index 6b7cfd46..55f06101 100644
--- a/content/docs/pl-PL/guides/plugin/permission-management.mdx
+++ b/content/docs/pl-PL/guides/plugin/permission-management.mdx
@@ -10,132 +10,569 @@ authors:
     link: https://discord.com/users/292656109939064833
   - name: Ivan
     link: https://discord.com/users/505770451218333717
+  - name: ZenithDevHQ
+    link: https://github.com/ZenithDevHQ
 ---
 
-In this guide, you'll learn how to manage permission nodes and groups in your Hytale plugin.
+In this guide, you'll learn how to manage permission nodes and groups in your Hytale plugin. Permissions control what actions players can perform on your server, from basic commands to advanced administrative functions.
 
-## The `PermissionsModule` class
+## What Are Permissions?
 
-The `PermissionsModule` class is responsible for managing permission nodes and groups in your plugin. It provides methods to check, grant and revoke permissions and groups for players. It allows the following operations
+Permissions are string identifiers that control access to features and commands. When a player tries to perform an action (like using a command), the server checks if they have the required permission.
 
-- Add permissions to user
-- Remove permissions from user
-- Add permissions to group (this also creates the group if it doesn't exist)
-- Remove permissions from group
-- Add user to group
-- Remove user from group
-- List all groups for a user
-- Check if a user has a permission (it checks both user and group permissions for the given player UUID)
+**Example permission nodes:**
 
-With this class you cannot:
+- `hytale.command.gamemode` - Permission to use the gamemode command
+- `hytale.editor.brush.use` - Permission to use brush tools
+- `myplugin.teleport.home` - A custom permission for your plugin
 
-- List all defined groups
-- Remove a group
+Permissions follow a hierarchical naming pattern: `namespace.category.action`
 
-### Adding Permission Nodes
+## Key Concepts
 
-You need a `Set<String>` containing all the permission nodes you want to add, these are added on top of the already existing permission nodes the user may have, it is not a replacement.
+Before diving into code, let's understand the core concepts:
+
+| Concept             | Description                                                                |
+| ------------------- | -------------------------------------------------------------------------- |
+| **Permission Node** | A string like `myplugin.feature.use` that represents a specific permission |
+| **Group**           | A named collection of permissions (e.g., "Admin", "VIP", "Default")        |
+| **Provider**        | The backend that stores and retrieves permissions                          |
+| **Wildcard**        | A pattern like `*` or `myplugin.*` that matches multiple permissions       |
+
+### How Permissions Are Checked
+
+When checking if a player has a permission, Hytale follows this order:
+
+1. **User's direct permissions** - Permissions granted directly to the player
+2. **Group permissions** - Permissions from groups the player belongs to
+3. **Virtual groups** - Game-mode-based permissions (e.g., Creative mode grants builder tools)
+4. **Default value** - Falls back to `false` if no match found
+
+<Callout type="info">
+  The first definitive match wins. If a player has a permission granted at the user level, group permissions won't override it.
+</Callout>
+
+---
+
+## The `PermissionsModule` Class
+
+The `PermissionsModule` class is the central hub for managing permissions. Access it using the singleton pattern:
 
 ```java
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.addUserPermission(playerUUID, permissions);
 ```
 
-### Removing Permission Nodes
+### Available Operations
+
+The module supports these operations:
+
+| Operation                     | Method                                          |
+| ----------------------------- | ----------------------------------------------- |
+| Add permissions to user       | `addUserPermission(uuid, permissions)`          |
+| Remove permissions from user  | `removeUserPermission(uuid, permissions)`       |
+| Add permissions to group      | `addGroupPermission(groupName, permissions)`    |
+| Remove permissions from group | `removeGroupPermission(groupName, permissions)` |
+| Add user to group             | `addUserToGroup(uuid, groupName)`               |
+| Remove user from group        | `removeUserFromGroup(uuid, groupName)`          |
+| Get user's groups             | `getGroupsForUser(uuid)`                        |
+| Check permission              | `hasPermission(uuid, permissionNode)`           |
+
+<Callout type="warning">
+  The module does **not** support:
+
+  - Listing all defined groups
+  - Deleting a group entirely
+
+  Groups are implicitly created when you first add permissions to them.
+</Callout>
+
+---
 
-Same as above, we just use the `removeUserPermission` method instead to remove permission nodes.
+## Checking Permissions
+
+The most common operation is checking if a player has a permission.
+
+### Basic Permission Check
+
+```java
+// Returns true if player has the permission, false otherwise
+boolean canUse = PermissionsModule.get().hasPermission(playerUUID, "myplugin.feature.use");
+
+if (canUse) {
+    // Player has permission, allow the action
+} else {
+    // Player lacks permission, deny or show error
+}
+```
+
+### Permission Check with Default Value
+
+You can specify what to return when no permission is explicitly set:
+
+```java
+// Returns true by default if no explicit permission is found
+boolean canUse = PermissionsModule.get().hasPermission(playerUUID, "myplugin.feature.use", true);
+```
+
+This is useful for features that should be enabled by default but can be revoked.
+
+### Using PermissionHolder Interface
+
+Players and command senders implement `PermissionHolder`, allowing direct checks:
+
+```java
+// In a command or event handler where you have access to the player
+if (player.hasPermission("myplugin.admin.manage")) {
+    // Player has admin permission
+}
+```
+
+---
+
+## Managing User Permissions
+
+### Adding Permissions to a User
+
+Permissions are additive - new permissions are added on top of existing ones, not replaced.
+
+```java
+PermissionsModule perms = PermissionsModule.get();
+
+// Add a single permission
+perms.addUserPermission(playerUUID, Set.of("myplugin.vip.chat"));
+
+// Add multiple permissions at once
+Set<String> newPerms = Set.of(
+    "myplugin.vip.chat",
+    "myplugin.vip.fly",
+    "myplugin.vip.kit"
+);
+perms.addUserPermission(playerUUID, newPerms);
+```
+
+### Removing Permissions from a User
 
 ```java
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.removeUserPermission(playerUUID, permissions);
+
+// Remove specific permissions
+Set<String> toRemove = Set.of("myplugin.vip.fly");
+perms.removeUserPermission(playerUUID, toRemove);
 ```
 
-### Add permissions to group
+---
+
+## Managing Groups
+
+Groups let you assign a collection of permissions to multiple players. This is more manageable than assigning permissions individually.
+
+### Adding Permissions to a Group
+
+If the group doesn't exist, it will be created automatically.
 
 ```java
-String groupName = "testGroup";
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.addGroupPermission(groupName, permissions);
+
+// Create/update the "VIP" group with permissions
+Set<String> vipPerms = Set.of(
+    "myplugin.vip.chat",
+    "myplugin.vip.fly",
+    "myplugin.vip.kit"
+);
+perms.addGroupPermission("VIP", vipPerms);
 ```
 
-### Remove permissions from group
+### Removing Permissions from a Group
 
 ```java
-String groupName = "testGroup";
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.removeGroupPermission(groupName, permissions);
+
+// Remove specific permissions from the group
+Set<String> toRemove = Set.of("myplugin.vip.fly");
+perms.removeGroupPermission("VIP", toRemove);
 ```
 
-### Add user to group
+### Adding a User to a Group
 
 ```java
-String groupName = "testGroup";
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.addUserToGroup(playerUUID, groupName);
+
+// Add player to the VIP group - they now have all VIP permissions
+perms.addUserToGroup(playerUUID, "VIP");
 ```
 
-### Remove user from group
+### Removing a User from a Group
 
 ```java
-String groupName = "testGroup";
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.removeUserFromGroup(playerUUID, groupName);
+
+// Remove player from VIP group
+perms.removeUserFromGroup(playerUUID, "VIP");
 ```
 
-### List all groups for a user
+### Getting a User's Groups
 
 ```java
 PermissionsModule perms = PermissionsModule.get();
-perms.getGroupsForUser(playerUUID);
+
+// Get all groups the player belongs to
+Set<String> groups = perms.getGroupsForUser(playerUUID);
+
+for (String group : groups) {
+    System.out.println("Player is in group: " + group);
+}
 ```
 
-### Check Permission Nodes
+---
+
+## Built-in Groups
+
+Hytale includes two default groups:
+
+| Group     | Default Permissions   | Purpose                           |
+| --------- | --------------------- | --------------------------------- |
+| `OP`      | `*` (all permissions) | Server operators with full access |
+| `Default` | None                  | Base group for all players        |
+
+Players without any explicit group assignment are automatically part of the `Default` group.
 
-To check if a player has a specific permission node, you can use the `hasPermission` method.
+---
+
+## Wildcards
+
+Wildcards let you grant or deny multiple permissions with a single pattern.
+
+### Wildcard Patterns
+
+| Pattern             | Meaning                                          |
+| ------------------- | ------------------------------------------------ |
+| `*`                 | Grants **all** permissions                       |
+| `myplugin.*`        | Grants all permissions starting with `myplugin.` |
+| `-*`                | Denies **all** permissions                       |
+| `-myplugin.admin.*` | Denies all admin permissions in your plugin      |
+
+### Example: Admin Group with Wildcards
 
 ```java
-boolean hasPermission = PermissionsModule.hasPermission(playerUUID, "permission.node");
+// Grant all permissions to admins
+perms.addGroupPermission("Admin", Set.of("*"));
+
+// Grant all plugin permissions to moderators
+perms.addGroupPermission("Moderator", Set.of("myplugin.*"));
+
+// Grant all permissions except admin commands
+perms.addGroupPermission("Helper", Set.of(
+    "*",
+    "-myplugin.admin.*"  // Deny admin permissions
+));
 ```
 
-## Additional: Defining your own provider for permissions and groups
+<Callout type="warning">
+  Negation permissions (starting with `-`) take precedence at each level. Use them carefully to avoid accidentally blocking permissions.
+</Callout>
+
+---
+
+## Built-in Permission Nodes
+
+Hytale provides constants for common permissions in the `HytalePermissions` class:
+
+### Command Permissions
+
+```java
+// Generate permission for a command
+String perm = HytalePermissions.fromCommand("gamemode");
+// Result: "hytale.command.gamemode"
+
+// Generate permission for a subcommand
+String perm = HytalePermissions.fromCommand("gamemode", "creative");
+// Result: "hytale.command.gamemode.creative"
+```
+
+### Common Permission Nodes
+
+| Permission                    | Description                  |
+| ----------------------------- | ---------------------------- |
+| `hytale.command.op.add`       | Add players to OP group      |
+| `hytale.command.op.remove`    | Remove players from OP group |
+| `hytale.editor.brush.use`     | Use brush tools              |
+| `hytale.editor.prefab.use`    | Use prefabs                  |
+| `hytale.editor.selection.use` | Use selection tools          |
+| `hytale.editor.history`       | Undo/redo operations         |
+| `hytale.camera.flycam`        | Use fly camera mode          |
+
+---
+
+## Listening to Permission Events
+
+You can react to permission changes using Hytale's event system.
+
+### Available Events
+
+| Event                                            | Triggered When                   |
+| ------------------------------------------------ | -------------------------------- |
+| `PlayerPermissionChangeEvent.PermissionsAdded`   | Permissions added to a user      |
+| `PlayerPermissionChangeEvent.PermissionsRemoved` | Permissions removed from a user  |
+| `PlayerGroupEvent.Added`                         | User added to a group            |
+| `PlayerGroupEvent.Removed`                       | User removed from a group        |
+| `GroupPermissionChangeEvent.Added`               | Permissions added to a group     |
+| `GroupPermissionChangeEvent.Removed`             | Permissions removed from a group |
 
-The PermissionsModule also enables us to define our own PermissionProvider's, this can be useful for:
+### Example: Reacting to Permission Changes
 
-- Cross server permission systems
-- Implementing features missing in the `HytalePermissionsProvider` like permission expiry
+```java
+public class PermissionListener {
+
+    public static void onPermissionsAdded(PlayerPermissionChangeEvent.PermissionsAdded event) {
+        UUID playerUUID = event.getPlayerUuid();
+        Set<String> added = event.getAddedPermissions();
+
+        System.out.println("Permissions added to " + playerUUID + ": " + added);
 
-To implement our PermissionProvider, first we need to define a provider class that implements PermissionProvider:
+        // Maybe notify the player or update cached data
+    }
+
+    public static void onGroupAdded(PlayerGroupEvent.Added event) {
+        UUID playerUUID = event.getPlayerUuid();
+        String groupName = event.getGroupName();
+
+        System.out.println("Player " + playerUUID + " joined group: " + groupName);
+    }
+}
+```
+
+### Registering the Events
 
 ```java
-public class DatabasePermissionProvider implements PermissionProvider
+public class MyPlugin extends JavaPlugin {
+
+    @Override
+    public void setup() {
+        EventRegistry events = this.getEventRegistry();
+
+        events.registerGlobal(
+            PlayerPermissionChangeEvent.PermissionsAdded.class,
+            PermissionListener::onPermissionsAdded
+        );
+
+        events.registerGlobal(
+            PlayerGroupEvent.Added.class,
+            PermissionListener::onGroupAdded
+        );
+    }
+}
 ```
 
-Then we just implement the required methods using a database implementation.
+---
+
+## Creating a Custom Permission Provider
+
+For advanced use cases, you can create your own permission provider. This is useful for:
+
+- Database-backed permissions (MySQL, MongoDB, etc.)
+- Cross-server permission synchronization
+- Custom features like permission expiry or contexts
+
+### Implementing PermissionProvider
+
+```java
+public class DatabasePermissionProvider implements PermissionProvider {
+
+    @Nonnull
+    @Override
+    public String getName() {
+        return "DatabasePermissionProvider";
+    }
+
+    // User permission methods
+    @Override
+    public void addUserPermissions(@Nonnull UUID uuid, @Nonnull Set<String> permissions) {
+        // Save to your database
+    }
+
+    @Override
+    public void removeUserPermissions(@Nonnull UUID uuid, @Nonnull Set<String> permissions) {
+        // Remove from your database
+    }
+
+    @Override
+    public Set<String> getUserPermissions(@Nonnull UUID uuid) {
+        // Query your database
+        return Set.of();
+    }
+
+    // Group permission methods
+    @Override
+    public void addGroupPermissions(@Nonnull String group, @Nonnull Set<String> permissions) {
+        // Save to your database
+    }
+
+    @Override
+    public void removeGroupPermissions(@Nonnull String group, @Nonnull Set<String> permissions) {
+        // Remove from your database
+    }
+
+    @Override
+    public Set<String> getGroupPermissions(@Nonnull String group) {
+        // Query your database
+        return Set.of();
+    }
+
+    // User-group membership methods
+    @Override
+    public void addUserToGroup(@Nonnull UUID uuid, @Nonnull String group) {
+        // Save to your database
+    }
+
+    @Override
+    public void removeUserFromGroup(@Nonnull UUID uuid, @Nonnull String group) {
+        // Remove from your database
+    }
+
+    @Override
+    public Set<String> getGroupsForUser(@Nonnull UUID uuid) {
+        // Query your database
+        return Set.of("Default");
+    }
+}
+```
 
 <Callout type="warning">
-  Hytale will try to use the first available permissions provider to add/remove gamemode groups (i.e. `Creative`, `Adventure`).
+  Hytale automatically assigns players to game-mode groups (like `Creative` or `Adventure`) using the first available provider.
+
+  If your provider throws an error when the group doesn't exist, the player will be disconnected! Always handle missing groups gracefully.
+</Callout>
+
+### Registering Your Provider
 
-  If your provider throws an error (for instance, if the group does not exist) when the server is preparing the player, the player will be disconnected.
+```java
+public class MyPlugin extends JavaPlugin {
+
+    @Override
+    public void setup() {
+        // Add your provider alongside the default one
+        PermissionsModule.get().addProvider(new DatabasePermissionProvider());
+    }
+}
+```
+
+The `PermissionsModule` aggregates permissions from all registered providers. This means:
+
+- Permission checks query all providers
+- Write operations (add/remove) use the **first** provider
+
+### Replacing the Default Provider
+
+If you want full control, you can remove the default provider:
+
+```java
+public class MyPlugin extends JavaPlugin {
+
+    @Override
+    public void setup() {
+        PermissionsModule perms = PermissionsModule.get();
+
+        // Remove the default provider FIRST
+        perms.removeProvider(perms.getFirstPermissionProvider());
+
+        // Then add your provider
+        perms.addProvider(new DatabasePermissionProvider());
+    }
+}
+```
+
+<Callout type="info">
+  When you remove the default provider, the `/op self` command will stop working since it checks for provider tampering.
 </Callout>
 
-We can then register the provider using the built-in permission module:
+---
+
+## Best Practices
+
+### Permission Naming Conventions
+
+Follow the pattern: `namespace.category.action`
 
 ```java
-PermissionsModule.get().addProvider(new DatabasePermissionProvider());
+// Good - clear hierarchy
+"myplugin.admin.ban"
+"myplugin.user.teleport.home"
+"myplugin.vip.chat.color"
+
+// Bad - unclear structure
+"myplugin_ban"
+"teleport"
+"vipChatColor"
 ```
 
-Please note that the `HytalePermissionsProvider` will still be enabled alongside your provider.
-The `PermissionsModule` will aggregate groups and permissions from all available providers.
+### Use Constants for Permissions
 
-If you want to disable the default `HytalePermissionsProvider`, you can use:
+Define your permissions as constants to avoid typos:
 
 ```java
-// put this **before** you add your provider
-PermissionsModule.get().removeProvider(PermissionsModule.get().getFirstPermissionProvider());
+public final class MyPermissions {
+    public static final String ADMIN_BAN = "myplugin.admin.ban";
+    public static final String ADMIN_KICK = "myplugin.admin.kick";
+    public static final String USER_HOME = "myplugin.user.home";
+    public static final String VIP_FLY = "myplugin.vip.fly";
+}
+
+// Usage
+if (player.hasPermission(MyPermissions.ADMIN_BAN)) {
+    // ...
+}
 ```
+
+### Don't Over-Permission
+
+Only create permissions for actions that genuinely need access control. Not everything needs a permission check.
+
+### Thread Safety
+
+If you create a custom provider, ensure it's thread-safe. Permission checks can occur from multiple threads simultaneously. Use `ReadWriteLock` or `ConcurrentHashMap` for your data structures.
+
+---
+
+## In-Game Commands
+
+Hytale provides built-in commands for managing permissions:
+
+### `/op` Command
+
+| Command               | Description                                                        |
+| --------------------- | ------------------------------------------------------------------ |
+| `/op self`            | Toggle your own OP status (singleplayer or with `--allow-op` flag) |
+| `/op add <player>`    | Add a player to the OP group                                       |
+| `/op remove <player>` | Remove a player from the OP group                                  |
+
+### `/perm` Command
+
+Use `/perm --help` in-game for full usage. Common operations:
+
+| Command                                  | Description                   |
+| ---------------------------------------- | ----------------------------- |
+| `/perm user list <uuid>`                 | List user's permissions       |
+| `/perm user add <uuid> <perm>`           | Add permission to user        |
+| `/perm user remove <uuid> <perm>`        | Remove permission from user   |
+| `/perm user group list <uuid>`           | List user's groups            |
+| `/perm user group add <uuid> <group>`    | Add user to group             |
+| `/perm user group remove <uuid> <group>` | Remove user from group        |
+| `/perm group list <group>`               | List group's permissions      |
+| `/perm group add <group> <perm>`         | Add permission to group       |
+| `/perm group remove <group> <perm>`      | Remove permission from group  |
+| `/perm test <perm>`                      | Test if you have a permission |
+
+---
+
+## Summary
+
+You've learned how to:
+
+- **Check permissions** using `PermissionsModule.hasPermission()`
+- **Manage user permissions** with `addUserPermission()` and `removeUserPermission()`
+- **Work with groups** using `addGroupPermission()`, `addUserToGroup()`, etc.
+- **Use wildcards** like `*` and `myplugin.*` for bulk permissions
+- **Listen to events** for permission changes
+- **Create custom providers** for database-backed permissions
+
+For more advanced permission systems with features like inheritance, expiry, and contexts, we're looking into expanding this guide with advanced permission management techniques in the future.
diff --git a/content/docs/pl-PL/guides/plugin/setting-up-env.mdx b/content/docs/pl-PL/guides/plugin/setting-up-env.mdx
index d2718098..5be5e9e0 100644
--- a/content/docs/pl-PL/guides/plugin/setting-up-env.mdx
+++ b/content/docs/pl-PL/guides/plugin/setting-up-env.mdx
@@ -4,6 +4,10 @@ description: Learn how to set up your development environment for modding Hytale
 authors:
   - name: Neil Revin
     link: https://itsneil.dev
+  - name: Marcel-TO
+    url: https://marcel-to.net
+  - name: Ádám Liszkai
+    link: https://adaliszk.dev
 ---
 
 This guide will walk you through setting up a complete development environment for Hytale modding, including all necessary tools and dependencies.
@@ -19,24 +23,73 @@ Before we begin, make sure you have:
 
 ## Required Software
 
-### 1. Java Development Kit (JDK)
+### Integrated Development Environment (IDE)
 
+We recommend IntelliJ IDEA Community Edition for Hytale modding. If you use IntelliJ IDEA, **almost everything is built-in**. You can clone a template, open a new project, and start working right away!
+
+1. Download from [JetBrains website](https://www.jetbrains.com/idea/download/)
+2. Install with default settings
+3. Launch and complete the initial setup wizard
+
+When opening a project, wait for indexing to finish, then start coding.
+Now, IDEA may say "No JDK configured" at the top of the source file you have.
+In that case, you can click Download JDK and choose JetBrains JDK 25.
+
+<Callout type="success">
+  If IDEA opened the project without errors, your environment is ready.
+</Callout>
+
+More details by [JetBrains](https://www.jetbrains.com/help/idea/2026.1/run-for-the-first-time.html)
+help page, where we recommend that you also check the
+[SDK configuration](https://www.jetbrains.com/help/idea/2026.1/sdk.html) guide.
+
+<Callout type="info">
+  We recommened following
+  [TheNullicorn's](https://gist.github.com/TheNullicorn/90a619796c40f20ae1fcf13094c1a57d) guide to ensure
+  you are using the correct `Nonnull` in your projects.
+</Callout>
+
+#### What the IDE Does for You
+
+When opened in IntelliJ IDEA, the project automatically:
+
+- Detects and configures Gradle or Maven
+- Downloads all dependencies
+- Sets up project structure and classpaths
+- Configures run/build tasks
+
+You do **not** need to manually install or configure Maven or Gradle if you stay inside the IDE.
+
+Skip to the [Setting Up Your Workspace](#setting-up-your-workspace).
+
+### Manual Setup: Java Development Kit (JDK)
+
+For any other setup, you will need to install and configure your system to have and load Java.
 Hytale modding requires Java 25 or later. We recommend using OpenJDK.
 
-#### Windows
+#### Windows via Installer
 
 1. Download OpenJDK 25 from [Adoptium](https://adoptium.net/)
 2. Run the installer with default settings
+   - Optionally enable feature `Set or Override JAVA_HOME variable` to resolve version related build issues with your project.
 3. Verify installation by opening Command Prompt and running:
 
+#### Windows via Scoop
+
+1. Install Scoop via PowerShell using [scoop.sh](https://scoop.sh/)
+2. Install OpenJDK 25:
+
 ```bash
-java -version
+scoop bucket add java
+scoop install java/openjdk25
 ```
 
 #### macOS
 
+1. Install Brew via Terminal using [brew.sh](https://brew.sh)
+2. Install JDK via Homebrew:
+
 ```bash
-# Using Homebrew
 brew install openjdk@25
 ```
 
@@ -51,22 +104,41 @@ brew install openjdk@25
 
 #### Linux (Ubuntu/Debian)
 
+1. Install JDK via the built-in package repository:
+
 ```bash
 sudo apt update
 sudo apt install openjdk-25-jdk
 ```
 
-### 2. Integrated Development Environment (IDE)
+### Verify installation:
 
-We recommend IntelliJ IDEA Community Edition for Hytale modding.
+Run the following command to see what version of Java you have:
 
-1. Download from [JetBrains website](https://www.jetbrains.com/idea/download/)
-2. Install with default settings
-3. Launch and complete the initial setup wizard
+```bash
+java -version
+```
+
+### Java Build Tool (Optional)
+
+We recommend using a Gradle Wrapper for managing dependencies and building your Hytale plugins. It provides benefits by eliminating the need for a system-wide Gradle installation and ensuring consistent Gradle versions across different environments. (Alternatively you can use Maven, but this guide focuses on Gradle since it is the default for our plugin template.)
+
+The plugin template in the following sections includes a Gradle Wrapper, so you can skip this step if you plan to use the template.
+
+#### Choosing Gradle (if not using the template)
+
+If you prefer to install Gradle manually, follow these steps:
 
-### 3) Java Build Tool
+1. Visit the official website: https://gradle.org/releases/
+2. Download the newest gradle binary: `gradle-9.3.1-bin.zip` (Binary zip archive)
+3. Unzip it
+4. Add the `gradle-9.3.1/bin/` folder to your PATH
+
+You can now try the command `gradle -version` to verify Gradle is installed correctly. Make sure to do this in a fresh new terminal instead of one you had opened from before!
+
+#### Choosing Maven (if not using the template)
 
-We recommend using Apache Maven for managing dependencies and building your Hytale plugins. (Alternatively you can use Gradle, but this guide focuses on Maven.)
+If you prefer to use Maven instead of Gradle, follow these steps to install Maven:
 
 1. Visit the official website: https://maven.apache.org/download.cgi
 2. Download this file: `apache-maven-3.9.12-bin.zip` (Binary zip archive)
@@ -89,22 +161,61 @@ cd MyFirstMod
 
 If you don't have Git installed, you can download the ZIP file from the repository page and extract it to a folder named `MyFirstMod`.
 
-### 2. Open Plugin in your IDEA
+### 2. Open Plugin in your IDE
 
-1. Open IntelliJ IDEA
+1. Open Your IDE (e.g., IntelliJ IDEA)
 2. Click "Open" and navigate to your `MyFirstMod` directory
-3. IntelliJ will automatically detect it as a Maven project
+3. Most IDEs like IntelliJ will automatically detect it as a Gradle project
 4. Wait for the project to index and dependencies to download
 
-<Callout type="info">
-  We recommened following [this](https://gist.github.com/TheNullicorn/90a619796c40f20ae1fcf13094c1a57d) guide to ensure you are using the correct `Nonnull` in your projects.
-</Callout>
+## Alternate Approach: Hytale Dependency
+
+If you prefer to set up your project from scratch without using the template and importing the hytale dependencies manually, ensure your build configuration includes the Hytale repositories and dependencies:
+
+For Gradle, add the following to your `build.gradle.kts`:
+
+```kotlin
+repositories {
+    mavenCentral()
+    maven {
+        name = "hytale"
+        url = uri("https://maven.hytale.com/release") // Or "hytale-pre-release" for pre-release versions
+    }
+}
+dependencies {
+    // + here means the latest version, but you can hard-wire any known version!
+    implementation("com.hypixel.hytale:Server:+")
+}
+```
+
+For Maven, add the following to your `pom.xml`:
+
+```xml
+<project>
+    <repositories>
+        <repository>
+            <id>hytale-release</id> <!-- Or "hytale-pre-release" for pre-release versions -->
+            <url>https://maven.hytale.com/release</url> <!-- Or "https://maven.hytale.com/pre-release" -->
+        </repository>
+    </repositories>
+
+    <dependencies>
+        <dependency>
+            <groupId>com.hypixel.hytale</groupId>
+            <artifactId>Server</artifactId>
+            <!-- Replace with latest version, Hytale provides jars for the last five releases -->
+            <version>LATEST_VERSION_HERE</version>
+            <scope>provided</scope>
+        </dependency>
+    </dependencies>
+</project>
+```
 
 ## Next Steps
 
 Now that you have your development environment set up with the plugin template:
 
-1. **Customize the template** - Edit the `pom.xml` and `manifest.json` file to change your mod's name and details
+1. **Customize the template** - Edit the `settings.gradle.kts`, `build.gradle.kts` and `manifest.json` file to change your mod's name and details
 2. **Explore the code structure** - Familiarize yourself with the template's organization
 3. **Start modding** - Begin writing your first Hytale plugin!
 
diff --git a/content/docs/pl-PL/guides/plugin/spawning-entities.mdx b/content/docs/pl-PL/guides/plugin/spawning-entities.mdx
index e12c0aea..15be2fb3 100644
--- a/content/docs/pl-PL/guides/plugin/spawning-entities.mdx
+++ b/content/docs/pl-PL/guides/plugin/spawning-entities.mdx
@@ -36,7 +36,7 @@ Store<EntityStore> store = world.getEntityStore().getStore();
 
 ## Creating Entities
 
-Once you have the `EntityStore` instance, you can start to create a entity and give it components. Entities are just instances of `Holder<EntityStore>` with several components attached to them.
+Once you have the `EntityStore` instance, you can start to create an entity and give it components. Entities are just instances of `Holder<EntityStore>` with several components attached to them.
 
 <Callout type="warning">
   To interact with the `World` instance, some methods require you to run the code inside the world's execution context.
@@ -118,3 +118,48 @@ Finally, we can add the entity to the world by calling the `addEntity` method on
 ```java
 store.addEntity(holder, AddReason.SPAWN);
 ```
+
+## Making the entity persist
+
+Hytale automatically saves all entities, but the `NetworkId` component (required for players to be able to see the entity) needs to be manually added every time the entity is loaded.
+
+### Using a system
+
+If you have a component that is unique to your entities, this can be done by creating and registering a custom system as follows:
+
+```java
+public class AddNetworkIdToMyEntitySystem extends HolderSystem<EntityStore> {
+    private final ComponentType<EntityStore, MyEntityComponent> myEntityComponentType = MyEntityComponent.getComponentType();
+    private final ComponentType<EntityStore, NetworkId> networkIdComponentType = NetworkId.getComponentType();
+    private final Query<EntityStore> query = Query.and(this.myEntityComponentType, Query.not(this.networkIdComponentType));
+
+    @Override
+    public void onEntityAdd(@NotNull Holder<EntityStore> holder, @NotNull AddReason reason, @NotNull Store<EntityStore> store) {
+        if (!holder.getArchetype().contains(NetworkId.getComponentType())) {
+            holder.addComponent(NetworkId.getComponentType(), new NetworkId(store.getExternalData().takeNextNetworkId()));
+        }
+    }
+
+    @Override
+    public void onEntityRemoved(@NotNull Holder<EntityStore> holder, @NotNull RemoveReason reason, @NotNull Store<EntityStore> store) {}
+
+    @Override
+    public @Nullable Query<EntityStore> getQuery() {
+        return query;
+    }
+}
+```
+
+In your plugin's `setup()` function
+
+```java
+this.getEntityStoreRegistry().registerSystem(new AddNetworkIdToMyEntitySystem())
+```
+
+### Using PropComponent
+
+Alternatively you can add `PropComponent` to your entity. Hytale adds `PropComponent` to entities spawned with the Entity Tool, and such entities automatically get `NetworkId` and `PrefabCopyableComponent` (which makes the entity work with prefabs).
+
+<Callout type="warning">
+  There is no guarantee, that Hytale will not add some other behavior to this component in the future, which may break your entity, so be careful if you decide to rely on it.
+</Callout>
diff --git a/content/docs/pl-PL/guides/plugin/store-persistent-data.mdx b/content/docs/pl-PL/guides/plugin/store-persistent-data.mdx
new file mode 100644
index 00000000..1071dff3
--- /dev/null
+++ b/content/docs/pl-PL/guides/plugin/store-persistent-data.mdx
@@ -0,0 +1,171 @@
+---
+title: Storing Persistent Data on the Player
+description: Learn how to save and load persistent data using Components
+authors:
+  - name: Neil Revin
+    url: https://itsneil.dev/
+  - name: ArcticDev
+    url: https://github.com/ArcticRaven
+  - name: oskarscot
+    url: https://oskar.scot
+  - name: JammingEng
+    url: https://github.com/JammingEnd
+---
+
+Here is how to store persistent data using a custom component on a Player.
+
+## Build your Component Class
+
+Creating a custom component class leverages the Component system made with the ECS architecture in mind. For more information on Components, check out the [ECS Guide](../ecs/hytale-ecs-theory#components).
+
+Start by creating your custom component class. This will be extremely similar to how regular components are created, however we'll setup a custom Codec so the server can translate this data to BSON, or the server's internal json encoder.
+
+<Callout type="info">
+  Each variable you want to store in your component must have its own Codec field defined in the BuilderCodec.
+  For more information on how to create custom Codecs, check out the [ECS Codec Guide](../ecs/hytale-ecs-theory#codec).
+</Callout>
+
+```java
+public class YourPlayerData implements Component<EntityStore> {
+
+    // define some vars!
+    private int someInteger;
+    private String someString;
+    private Map<String, String> someMap;
+
+    public static final BuilderCodec<YourPlayerData> CODEC =
+            BuilderCodec.builder(YourPlayerData.class, YourPlayerData::new)
+            .append(new KeyedCodec<>("SomeInteger", Codec.INTEGER),
+                    (data, value) -> data.someInteger = value, // setter
+                    data -> data.someInteger) // getter
+            .addValidator(Validators.nonNull())
+            .add()
+            .append(new KeyedCodec<>("SomeString", Codec.STRING),
+                    (data, value) -> data.someString = value, // setter
+                    data -> data.someString) // getter
+            .add()
+            .append(new KeyedCodec<>("SomeMap",
+                            new MapCodec<>(Codec.STRING, HashMap::new, false)),
+                    (data, value) -> data.someMap = value, // setter
+                    data -> data.someMap) // getter
+            .add()
+            .build();
+
+
+
+    // Getters and Setters are for the purpose of this example omitted.
+
+    // constructor
+    public YourPlayerData() {
+        this.someInteger = 0;
+        this.someString = "";
+        this.someMap = new HashMap<>();
+    }
+
+    // copy constructor for cloning
+    public YourPlayerData(YourPlayerData clone) {
+        this.someInteger = clone.someInteger;
+        this.someString = clone.someString;
+        this.someMap = clone.someMap;
+    }
+
+    @Nonnull
+    @Override
+    public Component<EntityStore> clone() {
+        return new YourPlayerData(this);
+    }
+}
+```
+
+## Register your Component
+
+Inside your main class's `setup()` method, register your new Component.
+
+```java
+public class YourPlugin extends JavaPlugin {
+
+    private ComponentType<EntityStore, YourPlayerData> yourPlayerDataComponent;
+
+    public YourPlugin(@Nonnull JavaPluginInit init) {
+        super(init);
+    }
+
+    @Override
+    protected void setup(){
+        this.yourPlayerDataComponent = this.getEntityStoreRegistry().registerComponent(
+            YourPlayerData.class,
+            "YourPlayerDataComponent",
+            YourPlayerData.CODEC
+        );
+    }
+
+    public ComponentType<EntityStore, YourPlayerData> getYourPlayerDataComponent() {
+        return this.yourPlayerDataComponent;
+    }
+}
+```
+
+## Using your Component
+
+To use your newly created component, you can add the Component to a player using the `addComponent` method, although this only adds it temporarily, meaning when the player/entity leaves the world, the component is removed. You can use `putComponent` to ensure the component persists between sessions.
+
+```java
+// You will need the Ref and Store to apply components
+private void someEntryMethod(@Nonnull Ref<EntityStore> ref, @Nonnull Store<EntityStore> store)
+{
+       // Any entity will work, for now we will use the player
+      Player player = (Player) store.getComponent(ref, Player.getComponentType());
+
+      // since we're using putComponent, it could be useful to check if it already exists on the player in case we want to update it
+     if(store.getComponent(ref, YourPlugin.instance().getYourPlayerDataComponent()) != null)
+     {
+          // here we implement logic that updates the component
+         var comp = store.getComponent(ref, YourPlugin.instance().getYourPlayerDataComponent())
+         // declare public fields or methods in the component class
+         comp.SomeString = "An Updated Field";
+     } else {
+          // Here we put the component
+          var myCustomComp = new CustomComponent();
+          // declare public fields or methods in the component class
+          myCustomComp.SomeString = "Edited String";
+
+          // putComponent allows you to insert declared objects
+          store.putComponent(ref, YourPlugin.instance().getYourPlayerDataComponent(), myCustomComp);
+     }
+}
+```
+
+## Using your Data
+
+Your component will be stored within the `Store<EntityStore>` when added to the player. In the provided example,
+we'll fetch this data off the player using the `ensureAndGetComponent()` method, which will add the component to
+the player if it does not exist with the default values.
+
+```java
+public class IncompleteCustomCommand extends AbstractPlayerCommand {
+
+    public IncompleteCustomCommand() {
+        super("nope", "don't use this command");
+    }
+
+    @Override
+    protected void execute(
+        @NonNullDecl CommandContext commandContext,
+        @NonNullDecl Store<EntityStore> store,
+        @NonNullDecl Ref<EntityStore> ref,
+        @NonNullDecl PlayerRef playerRef,
+        @NonNullDecl World world
+    ) {
+        YourPlayerData customData = store.ensureAndGetComponent(ref, YourPlugin.instance().getYourPlayerDataComponent());
+        // ensureAndGetComponent adds the component to the ref, with the default values defined inside your component.
+ 		// use your data
+    }
+}
+```
+
+And that's it! Your data will now be saved and loaded automatically with the player.
+
+Using custom components to store persistent data on players is a powerful way to maintain state across sessions.
+By following the steps outlined above, you can easily create, register, and utilize your own data structures within the Hytale ECS framework.
+This approach ensures that your data is seamlessly integrated with the game's existing systems.
+For more information about Hytale's Entity Component System visit the [Hytale ECS Theory](https://hytalemodding.dev/en/docs/guides/ecs/hytale-ecs-theory) guide.
diff --git a/content/docs/pl-PL/guides/plugin/teleporting-players.mdx b/content/docs/pl-PL/guides/plugin/teleporting-players.mdx
index 57cee77f..32ce0435 100644
--- a/content/docs/pl-PL/guides/plugin/teleporting-players.mdx
+++ b/content/docs/pl-PL/guides/plugin/teleporting-players.mdx
@@ -1,26 +1,32 @@
 ---
 title: Teleporting the player
 description: Learn how to teleport the player.
+authors:
+  - name: oskarscot
+    url: https://oskar.scot
 ---
 
-To teleport players in Hytale, you will need to get a `World` object so we can safely run the teleport on the world thread. The world thread manages all entity updates, so modifying entities off-thread can crash the server or cause inconsistent state.
-Next, we get the entity store and make a `Teleport` object.
-We add a `Teleport` component to the player’s entity reference in the entity store. This triggers the teleportation logic for that player.
+Teleporting players in Hytale works by simply attaching a `Teleport` component to a player with the desired world and transform.
+You can only trigger teleports from a world where the player is currently present.
+Teleport itself is a component but it also provides factory methods to configure the Teleport. Just as with any entity component, an EntityStore and a Ref to the EntityStore is required
+
+We can create a simple teleport utility like this:
 
 ```java
-public static void teleportPlayer(Player player, int x, int y, int z) {
-        World world = player.getWorld();
-        if (world == null) return;
-        world.execute(() -> {
-            if (player.getReference() == null) return;
-            Store<EntityStore> store = player.getReference().getStore();
-            Teleport teleport = Teleport.createForPlayer(world,
-                new Vector3d(x ,y, z), // Target position
-                new Vector3f(0, 0, 0)  // Target rotation (pitch, yaw, roll)
-            );
+public static void teleportPlayer(Ref<EntityStore> ref, Store<EntityStore> store, World targetWorld, double x, double y, double z) {                                                                                       
+    Transform transform = new Transform(x, y, z);                                                                                                                           
+    Teleport teleport = Teleport.createForPlayer(targetWorld, transform);                                                                                                   
+    store.addComponent(ref, Teleport.getComponentType(), teleport);                                                                                                         
+}  
+```
 
-            store.addComponent(player.getReference(), Teleport.getComponentType(), teleport);
-        });
+A `Transform` is a representation of a position Vector3d and rotation Vector3f which works in the following way:
 
-}
+```java
+Transform transform = new Transform(
+    new Vector3d(x, y, z),      // Position
+    new Rotation(yaw, pitch, 0) // Rotation, last value seems to always be 0
+);
+Teleport teleport = Teleport.createForPlayer(targetWorld, transform);
+store.addComponent(ref, Teleport.getComponentType(), teleport);
 ```
diff --git a/content/docs/pl-PL/guides/plugin/tracking-mod-analytics-with-hstats.mdx b/content/docs/pl-PL/guides/plugin/tracking-mod-analytics-with-hstats.mdx
new file mode 100644
index 00000000..45c022e0
--- /dev/null
+++ b/content/docs/pl-PL/guides/plugin/tracking-mod-analytics-with-hstats.mdx
@@ -0,0 +1,65 @@
+---
+title: Tracking Mod Analytics with HStats
+description: Learn how you can track Analytics for your Hytale Mod for Free using hstats.dev
+authors:
+  - name: Al3x
+    url: https://hstats.dev
+---
+
+In this guide, you will learn how to integrate HStats into your Plugin/Mod which will allow you to track how many Servers are using it along with other stats.
+
+<Callout type="info">
+  HStats is a third-party tool and is not affiliated with HytaleModding or Hypixel Studios
+</Callout>
+
+# Step 1: Register your Mod to HStats
+
+Before you touch any code, you will need to add your mod to the HStats website which will give you a UUID for your mod.
+
+- Create or Login to an Account on https://hstats.dev
+- Navigate to the dashboard page (https://hstats.dev/dashboard)
+- On the left, type in your mod's name and click "Add Mod"
+- Keep note of the UUID generated for later.
+
+# Step 2: Add the HStats Class to Your Project
+
+To keep things simple, HStats uses a single Java class file that handles everything for you.
+
+- Download / Copy the File from the GitHub page (https://github.com/hstats-dev/HStatsExamplePlugin/blob/main/src/main/java/com/al3x/HStats.java)
+- Paste into your Project. You should now have a HStats.java file somewhere in your projects directory.
+- Update the package name from com.al3x to whatever fits your project.
+
+# Step 3: Initialize HStats in your code
+
+You only need to add one line of code to your mod's setup method in your main class to start tracking.
+
+`new HStats("YOUR-MOD-UUID", "1.0.0");`
+
+Replace `YOUR-MOD-UUID` with the Mod UUID we made note of earlier and change the `1.0.0` version to whatever version your mod is currently on.
+
+Your setup method should now look something like this:
+
+```java
+@Override
+protected void setup() {
+  super.setup();
+  new HStats("c34a2b2a-afd8-4d6a-821e-7a63e12c5ea6", "1.0.0");
+}
+```
+
+# Extras
+
+Your done! Your mod should now be listed under the Mods page (https://hstats.dev/mods) as well as under your dashboard.
+
+Servers using your mod should now post updates about every minute to HStats which you can view in the Dashboard.
+
+### Embeds
+
+HStats allows you to generate an Embed Card that you can place on your CurseForge or GitHub page. This is useful for server owners to be able to see how many other servers are using your mod.
+
+- In your dashboard, scroll down to the Embed Card section.
+- Customize the appearance (Light/Dark mode, layout, etc).
+- Copy the generated URL to display your "Active Servers" and "Players Online" live on your mod's description page
+
+Heres an example of what they look like:
+![HStats Example](https://api.hstats.dev/api/embed/d52fa672-6966-47b2-b501-1a11bddebac3/card.svg?theme=light\&layout=compact\&size=md\&show_id=true\&dark=false)
diff --git a/content/docs/pl-PL/guides/plugin/world-gen.mdx b/content/docs/pl-PL/guides/plugin/world-gen.mdx
index 4c23b0c9..7b193ffd 100644
--- a/content/docs/pl-PL/guides/plugin/world-gen.mdx
+++ b/content/docs/pl-PL/guides/plugin/world-gen.mdx
@@ -100,7 +100,7 @@ Biome biome = biomeGen.generateBiomeAt(zoneResult, seed, x, z);
 
 ### Zone & Cave Integration
 
-Each zone defines it's own cave patterns:
+Each zone defines its own cave patterns:
 
 ```java
 Zone zone = /* ... */;
diff --git a/content/docs/pl-PL/guides/prefabs.mdx b/content/docs/pl-PL/guides/prefabs.mdx
index 08404b30..b1a55109 100644
--- a/content/docs/pl-PL/guides/prefabs.mdx
+++ b/content/docs/pl-PL/guides/prefabs.mdx
@@ -14,7 +14,7 @@ Prefabs are Hytale's way of creating reusable structures.
 There are a few fundamental concepts to understand about prefabs:
 
 - Users interact with prefabs via a prefab editing world.
-- Prefabs the physical structures in the game world, and are saved as JSON files.
+- Prefabs are the physical structures in the game world, and are saved as JSON files.
 
 ## How to Create a Prefab
 
diff --git a/content/docs/pl-PL/official-documentation/custom-ui/common-styling.mdx b/content/docs/pl-PL/official-documentation/custom-ui/common-styling.mdx
new file mode 100644
index 00000000..c36e3e3a
--- /dev/null
+++ b/content/docs/pl-PL/official-documentation/custom-ui/common-styling.mdx
@@ -0,0 +1,50 @@
+---
+title: Common Styling
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# Common Styling
+
+## Common UI Styling Library
+
+This document describes the shared UI components and styles defined in `Common.ui`.
+
+---
+
+### Styles
+
+We are providing some styles that can be re-used in any custom UI that, provide a cohesive UI experience with the core game UI. These styles are available in the `Common.ui` file.
+
+You can find a list of all the styles defined with live examples by running the `/ui-gallery` command ingame.
+
+<Callout type="warning">
+  This command is not available yet, but will be in a future patch.
+</Callout>
+
+![Gallery](/assets/official-documentation/ui/gallery.png)
+
+### Importing
+
+To use these styles in your UI file:
+
+```
+$Common = "Common.ui";
+
+// Then reference styles and components:
+$Common.@TextButton { @Text = "My Button"; }
+$Common.@Container { ... }
+```
+
+<Callout type="info">
+  The `Common.ui` file is at `Common/UI/Custom/Common.ui` within the Hytale pack. If your custom ui document is in a subfolder of `Common/UI/Custom/`, reference it via relative path traversal:
+
+  ```
+  $Common = "../Common.ui";
+  ```
+
+  You can find more info about paths [here](markup#path).
+</Callout>
diff --git a/content/docs/pl-PL/official-documentation/custom-ui/index.mdx b/content/docs/pl-PL/official-documentation/custom-ui/index.mdx
new file mode 100644
index 00000000..f94c4e88
--- /dev/null
+++ b/content/docs/pl-PL/official-documentation/custom-ui/index.mdx
@@ -0,0 +1,125 @@
+---
+title: Custom UI
+icon: LayoutDashboard
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# Custom UI
+
+## What is Custom UI?
+
+Custom UI is Hytale's framework for creating **custom user interfaces** controlled by the game server. Unlike the built-in Client UI (which is part of the game client and cannot be modified), Server UI allows you to create interactive screens and HUD overlays through Java plugins and asset packs.
+
+As a modder, Custom UI gives you the power to:
+
+- **Create custom interactive pages** - Shop interfaces, quest dialogs, server settings menus, admin panels
+- **Add custom HUD overlays** - Quest trackers, status displays, custom health bars, server information
+- **Design with markup** - Use `.ui` files to define reusable UI templates
+- **Handle user interactions** - Respond to button clicks, form submissions, and other events
+- **Localize your UI** - Support multiple languages using the game's translation system
+
+## How Custom UI Fits Into Hytale's UI
+
+Hytale's user interface is divided into two main categories:
+
+### Client UI (Not Moddable)
+
+Built-in interfaces controlled by the C# game client:
+
+- Main menu and settings
+- Character creation
+- Built-in HUD (health, hotbar, chat)
+- Inventory and crafting screens
+- Development tools
+
+**You cannot modify these** - they are part of the core game client.
+
+### In-Game UI (Moddable via Server)
+
+Server-controlled interfaces that you can create and customize:
+
+#### Custom Pages
+
+Full-screen interactive overlays that appear during gameplay:
+
+- Can be dismissed by the player (ESC key)
+- Capture all input (keyboard and mouse)
+- Support loading states while waiting for server responses
+- Perfect for: shops, dialogs, menus, configuration screens
+
+#### Custom HUDs
+
+Persistent overlay elements drawn on top of the game world:
+
+- Display-only (no user interaction)
+- Always visible during gameplay
+- Lightweight and non-intrusive
+- Perfect for: quest objectives, status indicators, server info panels
+
+## Architecture Overview
+
+Server UI uses a **command-based architecture**:
+
+```
+┌─────────────────────┐         ┌──────────────────────┐
+│   Java Server       │         │    C# Client         │
+│   (Your Plugin)     │         │    (Game)            │
+├─────────────────────┤         ├──────────────────────┤
+│                     │         │                      │
+│ InteractiveCustomUI │         │   CustomPage or      │
+│ Page                │         │   CustomHud          │
+│   ↓ build()         ├────────→│     ↓ Apply          │
+│ UICommandBuilder    │         │   Element Tree       │
+│   - append()        │         │     ↓ Layout         │
+│   - set()           │         │   Rendered UI        │
+│   - clear()         │         │                      │
+│                     │         │                      │
+│ ↓ handleDataEvent() │← Events │   User Interaction   │
+│   Process input     │         │   (click, type, etc) │
+│   sendUpdate()      │         │                      │
+└─────────────────────┘         └──────────────────────┘
+```
+
+**The flow:**
+
+1. Your Java code builds UI using `UICommandBuilder`
+2. Commands are sent to the client as data
+3. Client parses `.ui` markup files and creates visual elements
+4. User interacts with the UI
+5. Events are sent back to your Java code
+6. You process events and send updates back
+
+## Key Principles
+
+### Declarative, Not Imperative
+
+You don't create UI objects directly. Instead, you send **commands** that describe what you want:
+
+- "Append this button template to that container"
+- "Set this label's text to 'Hello World'"
+- "Clear all children from this list"
+
+### Asset-Driven
+
+UI structure is defined in `.ui` markup files (assets), not hardcoded in Java. This enables:
+
+- Designers to modify layouts without touching code
+- Reusable UI components
+- Consistent visual language
+
+### Event-Driven
+
+User interactions trigger events that flow back to your server code. You register event bindings and handle them in `handleDataEvent()`.
+
+### Selector-Based
+
+You target specific UI elements using **selectors:**
+
+- `#MyButton` - Element with ID "MyButton"
+- `#List[0]` - First child of element "List"
+- `#List[0] #Title` - Element with ID "Title" in the first child of element "List"
+- `#Label.TextColor` - The TextColor property of element "Label"
diff --git a/content/docs/pl-PL/official-documentation/custom-ui/layout.mdx b/content/docs/pl-PL/official-documentation/custom-ui/layout.mdx
new file mode 100644
index 00000000..0a24ca09
--- /dev/null
+++ b/content/docs/pl-PL/official-documentation/custom-ui/layout.mdx
@@ -0,0 +1,492 @@
+---
+title: Layout
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# Layout
+
+The layout system determines how UI elements are positioned and sized on screen. Understanding layout is crucial for creating well-structured, responsive interfaces.
+
+## Layout Fundamentals
+
+Every UI element has:
+
+- **Container Rectangle** - The space allocated by the parent
+- **Anchor** - How the element positions/sizes itself within the container
+- **Padding** - Inner spacing that affects child layout
+- **LayoutMode** - How the element arranges its children (if it's a container)
+
+```
+┌─────────────────────────────────────┐
+│  Container Rectangle (from parent)  │
+│  ┌───────────────────────────────┐  │
+│  │  Anchored Rectangle           │  │
+│  │  ┌─────────────────────────┐  │  │
+│  │  │ Padding                 │  │  │
+│  │  │  ┌───────────────────┐  │  │  │
+│  │  │  │  Content Area     │  │  │  │
+│  │  │  └───────────────────┘  │  │  │
+│  │  └─────────────────────────┘  │  │
+│  └───────────────────────────────┘  │
+└─────────────────────────────────────┘
+```
+
+## Anchor
+
+`Anchor` controls how an element positions and sizes itself within its container rectangle.
+
+### Fixed Size
+
+```
+Button {
+    Anchor: (Width: 200, Height: 40);
+}
+```
+
+Creates a 200×40 pixel button.
+
+### Positioning
+
+```
+Label {
+    Anchor: (Top: 10, Left: 20, Width: 100, Height: 30);
+}
+```
+
+- **Top**: 10 pixels from container's top edge
+- **Left**: 20 pixels from container's left edge
+- **Width**: 100 pixels wide
+- **Height**: 30 pixels tall
+
+### Anchoring to Edges
+
+```
+Button {
+    Anchor: (Bottom: 10, Right: 10, Width: 100, Height: 30);
+}
+```
+
+Anchors the button to the bottom-right corner, 10 pixels from each edge.
+
+### Stretching
+
+```
+Group {
+    Anchor: (Top: 0, Bottom: 0, Left: 0, Right: 0);
+}
+```
+
+Stretches to fill the entire container (all edges at 0 pixels).
+
+**Shorthand:**
+
+```
+Group {
+    Anchor: (Full: 0);
+}
+```
+
+### Mixed Anchoring
+
+```
+Panel {
+    Anchor: (Top: 10, Bottom: 10, Left: 20, Width: 300);
+}
+```
+
+- Fixed width of 300 pixels
+- Stretches vertically between top and bottom edges
+- 10 pixels from top and bottom
+- 20 pixels from left
+
+## Padding
+
+`Padding` creates inner spacing, affecting where children are positioned.
+
+### Uniform Padding
+
+```
+Group {
+    Padding: (Full: 20);
+}
+```
+
+20 pixels of padding on all sides.
+
+### Directional Padding
+
+```
+Group {
+    Padding: (Top: 10, Bottom: 20, Left: 15, Right: 15);
+}
+```
+
+Different padding per edge.
+
+### Shorthand
+
+```
+// Horizontal and vertical
+Group {
+    Padding: (Horizontal: 20, Vertical: 10);
+}
+
+// Equivalent to:
+// Top: 10, Bottom: 10, Left: 20, Right: 20
+```
+
+### Effect on Children
+
+```
+Group {
+    Anchor: (Width: 200, Height: 100);
+    Padding: (Full: 10);
+
+    Label {
+        Anchor: (Full: 0);
+    }
+}
+```
+
+The label fills the group, but there's a 10-pixel gap on all sides due to padding.
+
+```
+┌──────────────────────┐
+│ Group (200×100)      │
+│  ┌────────────────┐  │
+│  │ Label          │  │ ← 10px padding all around
+│  │                │  │
+│  └────────────────┘  │
+└──────────────────────┘
+```
+
+## LayoutMode
+
+`LayoutMode` determines how a container arranges its children.
+
+### Top (Vertical Stack)
+
+```
+Group {
+    LayoutMode: Top;
+
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+}
+```
+
+Children stack vertically from top to bottom:
+
+```
+┌──────────┐
+│ Button 1 │
+├──────────┤
+│ Button 2 │
+├──────────┤
+│ Button 3 │
+└──────────┘
+
+
+```
+
+Each child's `Anchor.Bottom` adds spacing between elements:
+
+```
+Button { Anchor: (Height: 30, Bottom: 10); }  // 10px gap after this button
+```
+
+### Bottom (Vertical Stack)
+
+```
+Group {
+    LayoutMode: Bottom;
+
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+}
+```
+
+Children stack vertically from top to bottom but aligned to the bottom edge of the parent:
+
+```
+
+
+
+┌──────────┐
+│ Button 1 │
+├──────────┤
+│ Button 2 │
+├──────────┤
+│ Button 3 │
+└──────────┘
+```
+
+### Left (Horizontal Stack)
+
+```
+Group {
+    LayoutMode: Left;
+
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+}
+```
+
+Children arrange horizontally from left to right:
+
+```
+┌────────┬────────┬────────┐
+│ Button │ Button │ Button │
+│   1    │   2    │   3    │
+└────────┴────────┴────────┘
+```
+
+Use `Anchor.Right` for spacing between elements.
+
+### Right (Horizontal Stack)
+
+```
+Group {
+    LayoutMode: Right;
+
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+}
+```
+
+Children arrange horizontally from left to right but aligned to the right side of the parent:
+
+```
+                                                                 ┌────────┬────────┬────────┐
+                                                                 │ Button │ Button │ Button │
+                                                                 │   1    │   2    │   3    │
+                                                                 └────────┴────────┴────────┘
+```
+
+### Center
+
+```
+Group {
+    LayoutMode: Center;
+
+    Group #Dialog {
+        Anchor: (Width: 400, Height: 300);
+    }
+}
+```
+
+Centers the children horizontally.
+
+### Middle
+
+```
+Group {
+    LayoutMode: Middle;
+
+    Group #Dialog {
+        Anchor: (Width: 400, Height: 300);
+    }
+}
+```
+
+Centers the children vertically.
+
+### CenterMiddle (Horizontal Stack, Fully Centered)
+
+```
+Group {
+    LayoutMode: CenterMiddle;
+
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+}
+```
+
+Children stack horizontally from left to right, centered both horizontally and vertically within the parent:
+
+```
+┌────────────────────────────────────────────┐
+│                                            │
+│                                            │
+│         ┌──────┐ ┌──────┐ ┌──────┐         │
+│         │  B1  │ │  B2  │ │  B3  │         │
+│         └──────┘ └──────┘ └──────┘         │
+│                                            │
+│                                            │
+└────────────────────────────────────────────┘
+```
+
+---
+
+### MiddleCenter (Vertical Stack, Fully Centered)
+
+```
+Group {
+    LayoutMode: MiddleCenter;
+
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+}
+```
+
+Children stack vertically from top to bottom, centered both horizontally and vertically within the parent:
+
+```
+┌────────────────────────────────────────────┐
+│                                            │
+│              ┌──────────┐                  │
+│              │ Button 1 │                  │
+│              ├──────────┤                  │
+│              │ Button 2 │                  │
+│              ├──────────┤                  │
+│              │ Button 3 │                  │
+│              └──────────┘                  │
+│                                            │
+└────────────────────────────────────────────┘
+```
+
+---
+
+### Full
+
+```
+Group {
+    LayoutMode: Full;
+
+    Label {
+        Anchor: (Top: 20, Left: 20, Width: 100, Height: 30);
+    }
+}
+```
+
+Children use absolute positioning via their `Anchor` properties.
+
+### TopScrolling
+
+```
+Group {
+    LayoutMode: TopScrolling;
+    ScrollbarStyle: $Common.@DefaultScrollbar;
+
+    // ... many children
+}
+```
+
+Like `Top`, but adds a scrollbar if content exceeds container height.
+
+Or use `BottomScrolling` for bottom-aligned content.
+
+### LeftScrolling
+
+```
+Group {
+    LayoutMode: LeftScrolling;
+    ScrollbarStyle: $Common.@DefaultScrollbar;
+
+    // ... many children
+}
+```
+
+Like `Left`, but adds a scrollbar for horizontal scrolling.
+
+Or use `RightScrolling` for right-aligned content.
+
+### LeftCenterWrap (Wrapping Horizontal Stack, Horizontally Centered)
+
+```
+Group {
+    LayoutMode: LeftCenterWrap;
+
+    Button { Anchor: (Width: 80, Height: 30); }
+    Button { Anchor: (Width: 80, Height: 30); }
+    Button { Anchor: (Width: 80, Height: 30); }
+    Button { Anchor: (Width: 80, Height: 30); }
+    Button { Anchor: (Width: 80, Height: 30); }
+}
+```
+
+Children flow left to right. When there's no more horizontal space, they wrap to the next row. Each row is horizontally centered within the parent:
+
+```
+┌────────────────────────────────────────────┐
+│                                            │
+│       ┌──────┐ ┌──────┐ ┌──────┐           │
+│       │  B1  │ │  B2  │ │  B3  │           │
+│       └──────┘ └──────┘ └──────┘           │
+│            ┌──────┐ ┌──────┐               │
+│            │  B4  │ │  B5  │               │
+│            └──────┘ └──────┘               │
+│                                            │
+└────────────────────────────────────────────┘
+```
+
+## FlexWeight
+
+`FlexWeight` distributes remaining space among children.
+
+```
+Group {
+    LayoutMode: Left;
+    Anchor: (Width: 400);
+
+    Button {
+        Anchor: (Width: 100);
+    }
+
+    Group {
+        FlexWeight: 1;  // Takes all remaining space
+    }
+
+    Button {
+        Anchor: (Width: 100);
+    }
+}
+```
+
+Result:
+
+- First button: 100px
+- Middle group: 200px (400 - 100 - 100 = 200)
+- Last button: 100px
+
+### Multiple FlexWeights
+
+```
+Group {
+    LayoutMode: Left;
+    Anchor: (Width: 600);
+
+    Group { FlexWeight: 1; }
+    Group { FlexWeight: 2; }
+    Group { FlexWeight: 1; }
+}
+```
+
+Remaining space (600px) is split:
+
+- First group: 600 × (1/4) = 150px
+- Second group: 600 × (2/4) = 300px
+- Third group: 600 × (1/4) = 150px
+
+## Visibility
+
+```
+Button #HiddenButton {
+    Visible: false;
+}
+```
+
+**Effect:**
+
+- Element and its children are not displayed
+- Element is **not included in layout** (doesn't take up space)
diff --git a/content/docs/pl-PL/official-documentation/custom-ui/markup.mdx b/content/docs/pl-PL/official-documentation/custom-ui/markup.mdx
new file mode 100644
index 00000000..564110ed
--- /dev/null
+++ b/content/docs/pl-PL/official-documentation/custom-ui/markup.mdx
@@ -0,0 +1,226 @@
+---
+title: Markup
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# Markup
+
+## Markup
+
+An element is the basic building block of a user interface. There are various types of elements with different properties, which are documented below.
+
+Here's what the syntax looks like:
+
+```
+// Basic declaration of an element
+// with its Anchor property set to attach on all sides of its parent
+// with 10 pixels of margin
+Group { Anchor: (Left: 10, Top: 10, Right: 10, Bottom: 10); }
+
+Group { Anchor: (Full: 10); } // More concise version
+
+// Declaration of a Label with a name
+// (can be used to access the element from game code)
+Label #MyLabel {
+  Style: LabelStyle(FontSize: 16); // or just Style: (FontSize: 16), type can be inferred.
+  Text: "Hi! I am text.";
+}
+
+// Declaration of a Group containing 2 children
+// You can use FlexWeight to distribute any left-over space after explicit widths/heights have been subtracted
+Group {
+  LayoutMode: Left;
+  Label { Text: "Child 1"; FlexWeight: 2; }
+  Label { Text: "Child 2"; FlexWeight: 1; }
+}
+```
+
+### Documents
+
+A UI document (_.ui_ file) contains trees of elements. There can be multiple root elements.
+
+### Named Expressions
+
+Named expressions can be declared at any level of a document (including at the root) and will be scoped to that subtree, though they need to be declared at the top of the block.
+
+```
+// Example of named expressions, declared and used with @ prefix
+@Title = "Hytale";
+@ExtraSpacing = 5;
+
+Label {
+  Text: @Title;
+  Style: (LetterSpacing: 2 + @ExtraSpacing);
+}
+```
+
+You can use the spread operator `...` to reuse a named expression while overriding some of its fields:
+
+```
+@MyBaseStyle = LabelStyle(FontSize: 24, LetterSpacing: 2);
+
+Label {
+  Style: (...@MyBaseStyle, FontSize: 36);
+}
+```
+
+You can even layer multiple named expressions like so:
+
+```
+@TitleStyle = LabelStyle(FontSize: 24, HorizontalAlignment: Center);
+@SpacedTextStyle = LabelStyle(LetterSpacing: 2);
+
+Label {
+  Style: (...@BigTextStyle, ...@SpacedTextStyle);
+}
+```
+
+#### Document references
+
+A document can reference another document and access its named expressions.
+
+```
+// Document references are defined with $ prefix
+$Common = "../Common.ui";
+
+TextButton {
+  Style: $Common.@DefaultButtonStyle;
+}
+```
+
+### Templates
+
+You can declare a reusable bit of interface as a named expression and then instantiate it as many times as you want in the tree while customizing it.
+
+You can override local named expressions as well as insert additional children at any point in the template tree. However, local named expressions must be defined at the very top of the block, before properties and child elements.
+
+```
+// This is the template
+@Row = Group {
+  Anchor: (Height: 50);
+  Label #Label { Anchor: (Left: 0, Width: 100); Text: @LabelText; }
+  Group #Content { Anchor: (Left: 100); }
+};
+
+// Here we'll be using it twice in the document tree
+Group #Rows {
+  LayoutMode: TopScrolling;
+
+  @Row #MyFirstRow {
+    @LabelText = "First row";
+    #Content { TextInput {} }
+  }
+
+  @Row #MySecondRow {
+    @LabelText = "Second row";
+  }
+}
+```
+
+### Property Types
+
+#### Basic Types
+
+- **Boolean**
+  - `Visible: false;`
+  - `Visible: true;`
+- **Int**
+  - `Height: 20;`
+- **Float, Double, Decimal**
+  - `Min: 0.2;`
+- **String**
+  - `Text: "Hi!";`
+- **Char**
+  - `PasswordChar: "*";`
+  - _Note: The syntax is the same as a string, however a value of this type cannot contain more than one character!_
+- **Color**
+  - `Background: #ffffff;`&#x20;
+- **Objects**
+  - `Style: (Background: #ffffff)`
+- **Array**&#x20;
+  - `TextSpans: [(Text: "Hi", IsBold: true)]`
+
+#### Translations
+
+Translation keys can be referenced anywhere in markup where you can provide a string, and they are then converted to a string when an element gets instantiated.
+
+**Example:**
+
+```
+Label {
+  Text: %ui.general.cancel;
+}
+```
+
+#### Colors
+
+A color literal can be written as follows:
+
+- `#rrggbb`: 6-digit hexadecimal representation for red, green, blue (fully opaque)
+- `#rrggbb(a.a)`: 6-digit hexadecimal representation for red, green, blue with alpha between 0 and 1
+- `#rrggbbaa`: 8-digit hexadecimal representation for red, green, blue and alpha
+
+```
+Group {
+  Background: #000000(0.3);
+}
+```
+
+<Callout>
+  The `#rrggbb(a.a)` format is prefered over the `#rrggbbaa` format for
+  readability reasons.
+</Callout>
+
+#### Font Name
+
+Font names can be referenced directly by their string ID. Internally this is using a custom type called `UIFontName`, however strings will be converted automatically to this type in markup.
+
+```
+Label {
+  Text: "Hi";
+  Style: (FontName: "Secondary");
+}
+```
+
+**Available Font Names**
+
+- _Default_ - This is the default font that is used for most text and is always used unless a different option has been specified
+- _Secondary_ - This font is mostly used for headlines or elements that are supposed to stick out
+- _Mono_ - This is only used for development; For things such as profiling or error overlays.
+
+#### Path
+
+We can reference other UI assets with the `UIPath` type. Similar to `UIFontName`_,_ Strings are automatically converted to a `UIPath`. Paths are always relative to the file where they have been declared in. Looking up _MyButton.png_ in _Menu/MyAwesomeMenu.ui_ will result in _Menu/MyButton.png_. If you want to reference a file that is in a parent folder you can go back one directory by writing two dots (_../MyButton.png_).
+
+The markup syntax of a `UIPath` is the same as a String. (e.g. `Path: "Test.png"`)
+
+Here are some more examples:
+
+| UIPath             | .ui File                              | Resulting Path    |
+| ------------------ | ------------------------------------- | ----------------- |
+| MyButton.png       | Menu/MyAwesomeMenu.ui                 | Menu/MyButton.png |
+| ../MyButton.png    | Menu/MyAwesomeMenu.ui                 | MyButton.png      |
+| ../../MyButton.png | Menu/Popup/Templates/MyAwesomeMenu.ui | Menu/MyButton.png |
+
+#### Objects
+
+Objects contain a set of properties. In this example we are assigning an Anchor object to the _Anchor_ property:
+
+```
+Group {
+  Anchor: (
+   Height: 10,
+   Width: 20
+ );
+}
+```
+
+You can find all objects that can be used in markup [here](type-documentation#elements).
+
+## Visual Studio Code Extension
+
+There is an official extension for Visual Studio Code which adds syntax highlighting for .ui files. You can find it [here](https://marketplace.visualstudio.com/items?itemName=HypixelStudiosCanadaInc.vscode-hytaleui).
diff --git a/content/docs/pl-PL/official-documentation/custom-ui/type-documentation/index.mdx b/content/docs/pl-PL/official-documentation/custom-ui/type-documentation/index.mdx
new file mode 100644
index 00000000..69cea406
--- /dev/null
+++ b/content/docs/pl-PL/official-documentation/custom-ui/type-documentation/index.mdx
@@ -0,0 +1,127 @@
+---
+title: Type Documentation
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# Type Documentation
+
+This is a generated list of UI elements accessible by markup. More information about the User Interface framework can be found in the main documentation.
+
+## Elements
+
+- [ActionButton](type-documentation/elements/actionbutton)
+- [AssetImage](type-documentation/elements/assetimage)
+- [BackButton](type-documentation/elements/backbutton)
+- [BlockSelector](type-documentation/elements/blockselector)
+- [Button](type-documentation/elements/button)
+- [CharacterPreviewComponent](type-documentation/elements/characterpreviewcomponent)
+- [CheckBox](type-documentation/elements/checkbox)
+- [CheckBoxContainer](type-documentation/elements/checkboxcontainer)
+- [CircularProgressBar](type-documentation/elements/circularprogressbar)
+- [CodeEditor](type-documentation/elements/codeeditor)
+- [ColorOptionGrid](type-documentation/elements/coloroptiongrid)
+- [ColorPicker](type-documentation/lements/colorpicker)
+- [ColorPickerDropdownBox](type-documentation/elements/colorpickerdropdownbox)
+- [CompactTextField](type-documentation/elements/compacttextfield)
+- [DropdownBox](type-documentation/elements/dropdownbox)
+- [DropdownEntry](type-documentation/elements/dropdownentry)
+- [DynamicPane](type-documentation/elements/dynamicpane)
+- [DynamicPaneContainer](type-documentation/elements/dynamicpanecontainer)
+- [FloatSlider](type-documentation/elements/floatslider)
+- [FloatSliderNumberField](type-documentation/elements/floatslidernumberfield)
+- [Group](type-documentation/elements/group)
+- [HotkeyLabel](type-documentation/elements/hotkeylabel)
+- [ItemGrid](type-documentation/elements/itemgrid)
+- [ItemIcon](type-documentation/elements/itemicon)
+- [ItemPreviewComponent](type-documentation/elements/itempreviewcomponent)
+- [ItemSlot](type-documentation/elements/itemslot)
+- [ItemSlotButton](type-documentation/elements/itemslotbutton)
+- [Label](type-documentation/elements/label)
+- [LabeledCheckBox](type-documentation/elements/labeledcheckbox)
+- [MenuItem](type-documentation/elements/menuitem)
+- [MultilineTextField](type-documentation/elements/multilinetextfield)
+- [NumberField](type-documentation/elements/numberfield)
+- [Panel](type-documentation/elements/panel)
+- [ProgressBar](type-documentation/elements/progressbar)
+- [ReorderableList](type-documentation/elements/reorderablelist)
+- [ReorderableListGrip](type-documentation/elements/reorderablelistgrip)
+- [SceneBlur](type-documentation/elements/sceneblur)
+- [Slider](type-documentation/elements/slider)
+- [SliderNumberField](type-documentation/elements/slidernumberfield)
+- [Sprite](type-documentation/elements/sprite)
+- [TabButton](type-documentation/elements/tabbutton)
+- [TabNavigation](type-documentation/elements/tabnavigation)
+- [TextButton](type-documentation/elements/textbutton)
+- [TextField](type-documentation/elements/textfield)
+- [TimerLabel](type-documentation/elements/timerlabel)
+- [ToggleButton](type-documentation/elements/togglebutton)
+
+## Property Types
+
+- [Anchor](type-documentation/property-types/anchor)
+- [BlockSelectorStyle](type-documentation/property-types/blockselectorstyle)
+- [ButtonSounds](type-documentation/property-types/buttonsounds)
+- [ButtonStyle](type-documentation/property-types/buttonstyle)
+- [ButtonStyleState](type-documentation/property-types/buttonstylestate)
+- [CheckBoxStyle](type-documentation/property-types/checkboxstyle)
+- [CheckBoxStyleState](type-documentation/property-types/checkboxstylestate)
+- [ClientItemStack](type-documentation/property-types/clientitemstack)
+- [ColorOptionGridStyle](type-documentation/property-types/coloroptiongridstyle)
+- [ColorPickerDropdownBoxStateBackground](type-documentation/property-types/colorpickerdropdownboxstatebackground)
+- [ColorPickerDropdownBoxStyle](type-documentation/property-types/colorpickerdropdownboxstyle)
+- [ColorPickerStyle](type-documentation/property-types/colorpickerstyle)
+- [DropdownBoxSearchInputStyle](type-documentation/property-types/dropdownboxsearchinputstyle)
+- [DropdownBoxSounds](type-documentation/property-types/dropdownboxsounds)
+- [DropdownBoxStyle](type-documentation/property-types/dropdownboxstyle)
+- [InputFieldButtonStyle](type-documentation/property-types/inputfieldbuttonstyle)
+- [InputFieldDecorationStyle](type-documentation/property-types/inputfielddecorationstyle)
+- [InputFieldDecorationStyleState](type-documentation/property-types/inputfielddecorationstylestate)
+- [InputFieldIcon](type-documentation/property-types/inputfieldicon)
+- [InputFieldStyle](type-documentation/property-types/inputfieldstyle)
+- [ItemGridSlot](type-documentation/property-types/itemgridslot)
+- [ItemGridStyle](type-documentation/property-types/itemgridstyle)
+- [LabeledCheckBoxStyle](type-documentation/property-types/labeledcheckboxstyle)
+- [LabeledCheckBoxStyleState](type-documentation/property-types/labeledcheckboxstylestate)
+- [LabelSpan](type-documentation/property-types/labelspan)
+- [LabelStyle](type-documentation/property-types/labelstyle)
+- [NumberFieldFormat](type-documentation/property-types/numberfieldformat)
+- [Padding](type-documentation/property-types/padding)
+- [PatchStyle](type-documentation/property-types/patchstyle)
+- [PopupStyle](type-documentation/property-types/popupstyle)
+- [ScrollbarStyle](type-documentation/property-types/scrollbarstyle)
+- [SliderStyle](type-documentation/property-types/sliderstyle)
+- [SoundStyle](type-documentation/property-types/soundstyle)
+- [SpriteFrame](type-documentation/property-types/spriteframe)
+- [SubMenuItemStyle](type-documentation/property-types/submenuitemstyle)
+- [SubMenuItemStyleState](type-documentation/property-types/submenuitemstylestate)
+- [Tab](type-documentation/property-types/tab)
+- [TabNavigationStyle](type-documentation/property-types/tabnavigationstyle)
+- [TabStyle](type-documentation/property-types/tabstyle)
+- [TabStyleState](type-documentation/property-types/tabstylestate)
+- [TextButtonStyle](type-documentation/property-types/textbuttonstyle)
+- [TextButtonStyleState](type-documentation/property-types/textbuttonstylestate)
+- [TextTooltipStyle](type-documentation/property-types/texttooltipstyle)
+- [ToggleButtonStyle](type-documentation/property-types/togglebuttonstyle)
+- [ToggleButtonStyleState](type-documentation/property-types/togglebuttonstylestate)
+
+## Enums
+
+- [ActionButtonAlignment](type-documentation/enums/actionbuttonalignment)
+- [CodeEditorLanguage](type-documentation/enums/codeeditorlanguage)
+- [ColorFormat](type-documentation/enums/colorformat)
+- [DropdownBoxAlign](type-documentation/enums/dropdownboxalign)
+- [InputFieldButtonSide](type-documentation/enums/inputfieldbuttonside)
+- [InputFieldIconSide](type-documentation/enums/inputfieldiconside)
+- [ItemGridInfoDisplayMode](type-documentation/enums/itemgridinfodisplaymode)
+- [LabelAlignment](type-documentation/enums/labelalignment)
+- [LayoutMode](type-documentation/enums/layoutmode)
+- [MouseWheelScrollBehaviourType](type-documentation/enums/mousewheelscrollbehaviourtype)
+- [ProgressBarAlignment](type-documentation/enums/progressbaralignment)
+- [ProgressBarDirection](type-documentation/enums/progressbardirection)
+- [ResizeType](type-documentation/enums/resizetype)
+- [TimerDirection](type-documentation/enums/timerdirection)
+- [TooltipAlignment](type-documentation/enums/tooltipalignment)
diff --git a/content/docs/pl-PL/official-documentation/npc/2-getting-started-with-templates.mdx b/content/docs/pl-PL/official-documentation/npc/2-getting-started-with-templates.mdx
index 91081ca1..99d078e0 100644
--- a/content/docs/pl-PL/official-documentation/npc/2-getting-started-with-templates.mdx
+++ b/content/docs/pl-PL/official-documentation/npc/2-getting-started-with-templates.mdx
@@ -9,7 +9,7 @@ authors:
 
 There are no hard and fast rules for making a start on a template. I like to duplicate **BlankTemplate** and start from there because it already provides the basic structure of the file.
 
-This leaves me with the following template (`Template_Goblin_Ogre.json`): (note: the file could be looking different in the current version of the game)
+This leaves me with the following template (`Template_Goblin_Ogre.json`): (**note: the file could be looking different in the current version of the game**)
 
 ```json
 {
@@ -33,7 +33,7 @@ This leaves me with the following template (`Template_Goblin_Ogre.json`): (note:
     }
   },
   "Appearance": { "Compute": "Appearance" },
-  "DropList": { "Compute": "Droplist" },
+  "DropList": { "Compute": "DropList" },
   "MaxHealth": { "Compute": "MaxHealth" },
   "MotionControllerList": [
     {
@@ -65,10 +65,10 @@ And the following variant (`Goblin_Ogre.json`) next to the template. There's a t
   "Type": "Variant",
   "Reference": "Template_Goblin_Ogre",
   "Modify": {
-    "Appearance": "Goblin_Ogre",
+    "Appearance": "Goblin",
     "MaxHealth": 124
   }
 }
 ```
 
-Our artists have defined the `Goblin_Ogre` appearance already so I'm going to use that.
+Our artists have not yet finished animations for the `Goblin_Ogre`, for that sake of the tutorial I am going to use appearance `Goblin`, because it offers a more complete set of animations that we will need.
diff --git a/content/docs/pl-PL/official-documentation/worldgen/pack-tutorial/asset-packs.mdx b/content/docs/pl-PL/official-documentation/worldgen/pack-tutorial/asset-packs.mdx
index 38809fad..dcf1f3b9 100644
--- a/content/docs/pl-PL/official-documentation/worldgen/pack-tutorial/asset-packs.mdx
+++ b/content/docs/pl-PL/official-documentation/worldgen/pack-tutorial/asset-packs.mdx
@@ -9,13 +9,13 @@ authors:
 
 <OfficialDocumentationNotice />
 
-# How to modify Hytale
+# How to modify Hytale?
 
-## What's an Asset Pack
+## What's an Asset Pack?
 
-Hytales gameplay is driven by assets in the game that can be modified by creators. Asset Packs are our solution to let you override or add features to the base game with your own work. These can in the form of zip files of folders, which contain a custom set of assets. This is not the only way for a creator to change Hytale but this is the most accessible form.;
+Hytales gameplay is driven by assets in the game that can be modified by creators. Asset Packs are our solution to let you override or add features to the base game with your own work. These can be the form of zip files of folders, which contain a custom set of assets. This is not the only way for a creator to change Hytale but this is the most accessible form.;
 
-### How do I make an Asset Pack
+### How do I make an Asset Pack?
 
 <video controls className="my-6 aspect-video w-full rounded-lg border">
   <source src="https://cdn.internal.hytalemodding.dev/guides/official/how-to-asset-pack.mp4" type="video/mp4" />
@@ -48,7 +48,7 @@ An asset pack is typically a zip or folder, with a `manifest.json` inside. This
 }
 ```
 
-### Where are they stored
+### Where are they stored?
 
 Asset Packs are stored with other mods in the Mods folder.
 
@@ -76,7 +76,7 @@ C:\Users\<user>\AppData\Roaming\Hytale\UserData\Saves\New World 5\mods
 
 When you have Asset Packs or Mods installed, these will appear in the New World menu under the Options menu.;
 
-### How do I change an existing asset
+### How do I change an existing asset?
 
 <video controls className="my-6 aspect-video w-full rounded-lg border">
   <source src="https://cdn.internal.hytalemodding.dev/guides/official/how-to-asset.mp4" type="video/mp4" />
diff --git a/content/docs/pl-PL/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx b/content/docs/pl-PL/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx
index 44528376..24e628b5 100644
--- a/content/docs/pl-PL/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx
+++ b/content/docs/pl-PL/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx
@@ -106,7 +106,7 @@ If a BaseHeight is provided, the TopY and BottomY values are relative to the Bas
 
 Applies a Material Provider slot on a set of horizontal stripes of blocks of varying thickness and position. Below is an example image of basalt stripes into a stone cliff.
 
-{/* ![](https://540086904-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F7KAmBkOg6d13nZCkf9ku%2Fuploads%2FbcxO9LpArn8gPCaBwFg5%2Funknown.png?alt=media&token=1c72b67a-8253-4d03-8c64-1ad5f6830050) */}
+![Example of basalt stripes](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/basalt-stripes-example.png)
 
 #### Parameters:
 
diff --git a/content/docs/pl-PL/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx b/content/docs/pl-PL/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx
index 5e34acd4..a4418473 100644
--- a/content/docs/pl-PL/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx
+++ b/content/docs/pl-PL/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx
@@ -294,7 +294,7 @@ Combines all the positions into a single Positioins field.
 
 ---
 
-### SimpleHoritontal
+### SimpleHorizontal
 
 Keeps only the positions that are within the provided range.
 
diff --git a/content/docs/pl-PL/official-documentation/worldgen/worldgen-tutorial/README.mdx b/content/docs/pl-PL/official-documentation/worldgen/worldgen-tutorial/README.mdx
new file mode 100644
index 00000000..5f66d245
--- /dev/null
+++ b/content/docs/pl-PL/official-documentation/worldgen/worldgen-tutorial/README.mdx
@@ -0,0 +1,166 @@
+---
+title: How to edit and create Biomes
+description: Explores where world generation assets can be found and how to edit them.
+---
+
+### Where are the Assets
+
+World generation assets are kept in the HytaleGenerator directory within the assets.
+
+```
+/Server/HytaleGenerator/
+```
+
+<div className="flex flex-row rounded-lg border p-4">
+  <div className="flex-1/2 border-r pr-4">
+    ```
+    /Biomes
+    ```
+
+    Biome assets, with content configurations.
+  </div>
+
+  <div className="flex-1/2 pl-4">
+    ```
+    /WorldStructure
+    ```
+
+    Generator files that define which biomes spawn together.
+  </div>
+</div>
+
+<div className="flex flex-row rounded-lg border p-4">
+  <div className="flex-1/2 border-r pr-4">
+    ```
+    /Density
+    ```
+
+    Density assets that can be referenced by any other assets.
+  </div>
+
+  <div className="flex-1/2 pl-4">
+    ```
+    /Assignments
+    ```
+
+    Prop assets that can be referenced by any Biome assets.
+  </div>
+</div>
+
+***
+
+An example of this structure can be found bellow, packed in an asset pack with the instance configuration.
+
+[https://drive.google.com/file/d/1sIz_CluANIIe3n8vNiOi-4PQdeqCO0qY/view?usp=drive_link](https://drive.google.com/file/d/1sIz_CluANIIe3n8vNiOi-4PQdeqCO0qY/view?usp=drive_link)
+
+<Callout>
+  Ensure you place your asset pack in the correct directory, under Mods.
+</Callout>
+
+### How to visit our worlds
+
+https://drive.google.com/file/d/1BJurxyj-taE-PXWm04bk7Dl6X7ZHTH92/view?usp=sharing
+
+#### Requirements
+
+- You must be an **Operator** in the world.
+  - To do this, run <mark style="color:$danger;">`/op self`</mark>
+- You must be in **Creative mode**.
+  - Press the <mark style="color:$danger;">`O`</mark> key, O for Orange.&#x20;
+
+The generation assets define a set of generators but on their own you cannot visit these. Currently you require an Instance with a generator that will allow you to visit your work.
+
+```
+/Server/Instances/
+```
+
+Instances are separate worlds that players can join using the `/instances` command. Each instance has an `Instance.bson` configuration asset that specifies which generator to use, among other worldly settings.
+
+```json
+{
+  "WorldGen": {
+    "Type": "HytaleGenerator",
+    "WorldStructure": "Basic",
+    "playerSpawn" : {
+      "X" : 123,
+      "Y" : 480,
+      "Z" : 10000,
+      "Pitch" : 0,
+      "Yaw" : 0,
+      "Roll" : 0
+    }
+  }
+}
+```
+
+<Callout>
+  You can create custom instances for different world structures and biomes as you need them.
+</Callout>
+
+### How to edit Biomes
+
+<video>
+  <source src="https://cdn.internal.hytalemodding.dev/guides/official/How-to-edit-Biomes.mp4" type="video/mp4" />
+</video>
+
+We currently use the Hytale Node Editor when editing world generation assets. This can be accessed while in-game from the Content Creation menu when pressing B. The node editor is then found under the asset editor dropdown on the upper left.&#x20;
+
+![Node Editor 1](/assets/official-documentation/worldgen/worldgen-tutorial/biomes/node-editor-1.png)
+
+Once you have the Hytale Node Editor open, through the file menu you can open Biomes by navigating to the Biomes directory and selecting one from your pack.&#x20;
+
+```
+/Server/HytaleGenerator/Biomes/
+```
+
+### Biome Asset Structure
+
+Every Biome has a root Biome node, this node splits into 5 structures. This is covered briefly but more information on each field can be found on the World Generation Concepts page.
+
+![Node Editor 2](/assets/official-documentation/worldgen/worldgen-tutorial/biomes/node-editor-2.png)
+
+<Callout>
+  Each biome is for the most part self contained, meaning it has control over what appears with the biome. The only exception to this are Base Heights.
+</Callout>
+
+<Tabs>
+  <Tab value="Terrain">
+    Mathematical function nodes that calculate the physical shape of the Biome's terrain.
+  </Tab>
+
+  <Tab value="Materials">
+    Logical nodes that determine what materials (blocks) make up a Biome's terrain.
+  </Tab>
+
+  <Tab value="Props">
+    Function nodes that add objects like prefabs and decorations to the terrain.
+  </Tab>
+
+  <Tab value="Environments">
+    Logical nodes that determine the environment asset at a given coordinate within the biome. This asset determines things like weather, NPC spawns, and sounds.
+  </Tab>
+
+  <Tab value="Tints">
+    Logical function nodes that determine a colour code that can be used by certain blocks in the world. Typically this will be grasses and soils.
+  </Tab>
+</Tabs>
+
+### How to preview your work
+
+[https://drive.google.com/file/d/1mNcHn9LhFnWDF0DzWFH6_YllmKAUvUry/view?t=6](https://drive.google.com/file/d/1mNcHn9LhFnWDF0DzWFH6_YllmKAUvUry/view?t=6)
+
+Once you are in an Instance world with the Hytale Generator active you will only be able to see your work by generating new chunks. There are a few ways to do this.
+
+The viewport command selects an area around the Player that will live reload as you make changes to the generator.&#x20;
+
+```
+/viewport --radius 5 
+```
+
+You can also create a new world to show your changes.&#x20;
+
+```
+/instances spawn <instance> 
+```
+
+The last option is to simply fly south, new chunks will generate with the changes made.
diff --git a/content/docs/pl-PL/quick-start.mdx b/content/docs/pl-PL/quick-start.mdx
index 653644f4..249d803a 100644
--- a/content/docs/pl-PL/quick-start.mdx
+++ b/content/docs/pl-PL/quick-start.mdx
@@ -9,3 +9,8 @@ Welcome to the Hytale modding documentation! Here you'll find everything you nee
 * [Setting up your dev environment](./guides/plugin/setting-up-env)
 * [Entity Component System (ECS)](./guides/ecs/entity-component-system)
 * [Publishing your mod](./publishing)
+
+### Useful Links
+
+* [Kaupenjoe's Modding Videos](https://www.youtube.com/@ModdingByKaupenjoe)
+* [TroubleDEV's Modding Videos](https://www.youtube.com/@TroubleDEV)
diff --git a/content/docs/pl-PL/server/argtypes.mdx b/content/docs/pl-PL/server/argtypes.mdx
new file mode 100644
index 00000000..e54a442e
--- /dev/null
+++ b/content/docs/pl-PL/server/argtypes.mdx
@@ -0,0 +1,61 @@
+---
+title: ArgTypes
+description: Available ArgTypes
+icon: List
+full: true
+authors:
+  - name: Valeena
+---
+
+| Name                        | Target Class                           | Description                                                                                                                               |   |
+| :-------------------------- | :------------------------------------- | :---------------------------------------------------------------------------------------------------------------------------------------- | - |
+| Boolean                     | java.lang.Boolean                      | A 'true' or 'false' input                                                                                                                 |   |
+| Integer                     | java.lang.Integer                      | A whole number                                                                                                                            |   |
+| String                      | java.lang.String                       | Words, text, numbers, letters. To input more than one word at a time, you may need to wrap it with double quotes (`"my fancy sentence"`). |   |
+| Float                       | java.lang.Float                        | A floating-pointer number                                                                                                                 |   |
+| Double                      | java.lang.Double                       | A decimal number                                                                                                                          |   |
+| UUID                        | java.util.UUID                         | A UUID (Universally Unique IDentifier)                                                                                                    |   |
+| Player_UUID                 | java.util.UUID                         | A UUID or an online player username                                                                                                       |   |
+| Game_Profile_Lookup_Async   | ProfileServiceClient.PublicGameProfile | A player UUID or username. If not found locally, performs a remote lookup via the Profile Service.                                        |   |
+| Relative_Double_Coord       | Coord                                  | An x, y, or z coordinate as a decimal, optionally relative by specifying a tilde (~) in front of the number                               |   |
+| Relative_Int_Coord          | IntCoord                               | An x, y, or z coordinate as a whole number, optionally relative by specifying a tilde (~) in front of the number                          |   |
+| Relative_Integer            | RelativeInteger                        | A tilde to mark an integer relative to a base                                                                                             |   |
+| Relative_Float              | RelativeFloat                          | A tilde to mark a float relative to a base                                                                                                |   |
+| Player_Ref                  | PlayerRef                              | A UUID or an online player's username                                                                                                     |   |
+| World                       | World                                  | A world folder name                                                                                                                       |   |
+| Model_Asset                 | ModelAsset                             | A reference to an Asset of type Model                                                                                                     |   |
+| Weather_Asset               | Weather                                | A reference to an Asset of type Weather                                                                                                   |   |
+| Interaction_Asset           | Interaction                            | A reference to an Asset of type Interaction                                                                                               |   |
+| Root_Interaction_Asset      | RootInteraction                        | A reference to an Asset of type Root Interaction                                                                                          |   |
+| Effect_Asset                | EntityEffect                           | A refernece to an Asset of type EntityEffect                                                                                              |   |
+| Environment_Asset           | Environment                            | A reference to an Asset of type Environment                                                                                               |   |
+| Item_Asset                  | Item                                   | A reference to an Asset of type Item                                                                                                      |   |
+| Block_Type_Asset            | BlockType                              | A reference to an Asset of type BlockType                                                                                                 |   |
+| Particle_System             | ParticleSystem                         | A reference to an Asset of type ParticleSystem                                                                                            |   |
+| Hitbox_Collision_Config     | HitboxCollisionConfig                  | A reference to an Asset of type HitboxCollisionConfig                                                                                     |   |
+| Repulsion_Config            | RepulsionConfig                        | A reference to an Asset of type RepulsionConfig                                                                                           |   |
+| Sound_Event_Asset           | SoundEvent                             | A reference to an Asset of type SoundEvent                                                                                                |   |
+| Ambiance_Fx_Asset           | AmbianceFX                             | A reference to an Asset of type AmbianceFX                                                                                                |   |
+| Sound_Category              | SoundCategory                          | A sound category (sfx, music, ambient, ui)                                                                                                |   |
+| Entity_ID                   | `ArgWrapper<EntityWrappedArg, UUID>`   | A UUID representing an entity id                                                                                                          |   |
+| Integer_Comparison_Operator | IntegerComparisonOperator              | A mathematical sign for integer comparison                                                                                                |   |
+| Integer_Operation           | IntegerOperation                       | A mathematical sign for performing an operation                                                                                           |   |
+| Int_Range                   | `Pair<Integer, Integer>`               | Two integers representing a minimum and maximum of a range                                                                                |   |
+| Relative_Int_Range          | RelativeIntRange                       | Two integers representing a minimum and maximum of a range                                                                                |   |
+| Vector2I                    | Vector2i                               | Two integers, generally corresponding to x/z axis                                                                                         |   |
+| Vector3I                    | Vector3i                               | Three integers, generally corresponding to x/y/z axis                                                                                     |   |
+| Relative_Vector3I           | RelativeVector3i                       | Three optionally relative integers, generally corresponding to x/y/z axis                                                                 |   |
+| Relative_Block_Position     | RelativeIntPosition                    | A position with three integer coordinates, representing a block's location in world space.                                                |   |
+| Relative_Position           | Relative                               | A position with three decimal coordinates, representing a location in world space.                                                        |   |
+| Relative_Chunk_Position     | RealtiveChunkPosition                  | A position with two integer coordinates (x, z), representing a chunk's location.                                                          |   |
+| Rotation                    | Vector3f                               | A rotation with three coordinates, representing the pitch, yaw, and roll respectively                                                     |   |
+| Block_Type_Key              | String                                 | A block type                                                                                                                              |   |
+| Block_ID                    | Integer                                | A block type, converted to an int id                                                                                                      |   |
+| Color                       | Integer                                | A color value in hex format, hex integer, or decimal integer                                                                              |   |
+| Weighted_Block_Type         | `Pair<Integer, String>`                | A weight corresponding to a blocktype                                                                                                     |   |
+| Weighted_Block_Entry        | String                                 | A block with optional weight prefix                                                                                                       |   |
+| Block_Pattern               | BlockPattern                           | A list of blocks with optional weights                                                                                                    |   |
+| Individual_Block_Mask       | BlockMask                              | Create a block mask using symbols and block names                                                                                         |   |
+| Block_Mask                  | BlockMask                              | A tick rate value (e.g., 30tps, 33ms, or 30)                                                                                              |   |
+| Tick_Rate                   | Integer                                | A list of block masks that combine together                                                                                               |   |
+| Game_Mode                   | GameMode                               | GameMode                                                                                                                                  |   |
diff --git a/content/docs/pl-PL/server/interaction-reference.mdx b/content/docs/pl-PL/server/interaction-reference.mdx
new file mode 100644
index 00000000..6c0d01b3
--- /dev/null
+++ b/content/docs/pl-PL/server/interaction-reference.mdx
@@ -0,0 +1,1586 @@
+---
+title: Interactions
+description: A list of most Interaction types provided by Hypixel, along with the meaning of their fields, and how they fit together.
+icon: List
+authors:
+  - name: Stephen Baynham
+    url: https://github.com/cannibalvox
+---
+
+### The Interaction Base Type
+
+All interactions of every type below are inherited from Interaction and have these fields.
+
+**Interaction Fields**
+
+| Field Name                | Type                                                                 | Required? | Notes                                                                                                                                                                                                                       |
+| ------------------------- | -------------------------------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| ViewDistance              | `Double`<br />(Default: 96.0)                                        | **No**    | Distance in blocks at which other players can see the effects from this interaction.                                                                                                                                        |
+| Effects                   | `InteractionEffects`                                                 | **No**    | Sound, animations, and particle effects that should trigger when this interaction begins executing.                                                                                                                         |
+| HorizontalSpeedMultiplier | `Float`<br />(Default: 1.0)                                          | **No**    | Multiplier applied to the User entity's movement speed while this interaction is executing                                                                                                                                  |
+| RunTime                   | `Float`                                                              | **No**    | If provided, this interaction will continue executing for at least this long before the interaction chain moves onto the next interaction.                                                                                  |
+| CancelOnItemChange        | `Boolean`<br />(Default: true)                                       | **No**    | If true, this interaction will be cancelled if the User entity's held item changes during execution. This can happen either due to the selected hotbar slot changing or the contents of the item's inventory slot changing. |
+| Rules                     | `InteractionRules`                                                   | **Yes**   | If provided, adds additional limitations and cancellation conditions to this interaction.                                                                                                                                   |
+| Settings                  | `Map`<br />(Key Type: `GameMode`, Value Type: `InteractionSettings`) | **No**    | If provided, adds additional per-GameMode settings to the interaction.                                                                                                                                                      |
+| Camera                    | `InteractionCameraSettings`                                          | **No**    | Arrays of camera motion keyframes for cutscenes and reveals.                                                                                                                                                                |
+
+**GameMode Values**
+
+- `Creative`: The game is currently in Creative Mode
+- `Adventure`: The game is currently in Adventure Mode
+
+**InteractionEffects Fields**
+
+| Field Name               | Type                                              | Required? | Notes                                                                                                                                                 |
+| ------------------------ | ------------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Particles                | `Array`<br />(Element Type: `ModelParticle`)      | **No**    | Particle systems to activate when this interaction begins if the player is in third-person mode.                                                      |
+| FirstPersonParticles     | `Array`<br />(Element Type: `ModelParticle`)      | **No**    | Particle systems to activate when this interaction begins if the player is in first-person mode.                                                      |
+| WorldSoundEventId        | `Asset`<br />(Asset Type: `SoundEvent`)           | **No**    | A sound to play in the world at the User entity's location when this interaction begins.<br />**The SoundEvent must be single-channel (mono) sound.** |
+| LocalSoundEventId        | `Asset`<br />(Asset Type: `SoundEvent`)           | **No**    | A 2D sound to play for the User entity when this interaction begins. Ignored if the User entity is not a player.                                      |
+| Trails                   | `Array`<br />(Element Type: `ModelTrail`)         | **No**    | Trail effects to activate on the User entity when this interaction begins.                                                                            |
+| WaitForAnimationToFinish | `Boolean`<br />(Default: false)                   | **No**    | If true, this interaction will continue executing for at least the length of any animations in this InteractionEffects object.                        |
+| ItemPlayerAnimationsId   | `Asset`<br />(Asset Type: `ItemPlayerAnimations`) | **No**    | If provided, the User entity will use this ItemPlayerAnimations set while this interaction is executing.                                              |
+| ItemAnimationId          | `String`                                          | **No**    | Id of an animation to trigger when this interaction begins executing.<br />**This animation id is not validated on server start.**                    |
+| ClearAnimationOnFinish   | `Boolean`<br />(Default: false)                   | **No**    | If true, animations triggered by this interaction will be halted when the interaction completes.                                                      |
+| ClearSoundEventOnFinish  | `Boolean`<br />(Default: false)                   | **No**    | If true, sounds triggered by this interaction will be halted when the interaction completes.                                                          |
+| CameraEffect             | `Asset`<br />(Asset Type: `CameraEffect` )        | **No**    | If provided, the CameraEffect will be applied while this interaction is executing.                                                                    |
+| MovementEffects          | `MovementEffects`                                 | **No**    | If provided, apply the movement effects to the User entity while this interaction is executing.                                                       |
+| StartDelay               | `Float`<br />(Default: 0.0f)                      | **No**    | The interaction will wait this many seconds before triggering the effects in this object.                                                             |
+
+**InteractionRules Fields**
+
+| Field Name          | Type                                                                                                | Required? | Notes                                                                                                                                                                                                                                     |
+| ------------------- | --------------------------------------------------------------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| BlockedBy           | `Array`<br />(Element Type: `InteractionType`)<br />(Default: Based on the chain's InteractionType) | **No**    | If provided, this RootInteraction cannot be executed while interaction chains of the provided types are executing.<br />**This field only functions for rules attached to a RootInteraction. It has no effect on an Interaction.**        |
+| Blocking            | `Array`<br />(Element Type: `InteractionType`)                                                      | **No**    | If provided, interaction chains with the specified InteractionTypes cannot be executed while this interaction is executing.                                                                                                               |
+| InterruptedBy       | `Array`<br />(Element Type: `InteractionType`)                                                      | **No**    | If provided, interaction chains with the specified InteractionTypes will cancel this interaction chain when they execute.<br />**This field only functions for rules attached to a RootInteraction. It has no effect on an Interaction.** |
+| Interrupting        | `Array`<br />(Element Type: `InteractionType`)                                                      | **No**    | If provided, interaction chains with the specified InteractionTypes will be canceled when this interaction begins.                                                                                                                        |
+| BlockedByBypass     | `String`                                                                                            | **No**    | If provided, this RootInteraction cannot be blocked by interaction chains whose RootInteraction has this value as an asset tag.                                                                                                           |
+| BlockingBypass      | `String`                                                                                            | **No**    | If provided, this interaction will not block RootInteractions that have the this value as an asset tag.                                                                                                                                   |
+| InterruptedByBypass | `String`                                                                                            | **No**    | If provided, this RootInteraction cannot be canceled by RootInteractions that have this value as an asset tag.                                                                                                                            |
+| InterruptingBypass  | `String`                                                                                            | **No**    | If provided, this interaction will not cancel interaction chains whose RootInteraction has this value as an asset tag.                                                                                                                    |
+
+**InteractionType Values**
+
+- `Primary`
+- `Secondary`
+- `Ability1`
+- `Ability2`
+- `Ability3`
+- `Use`
+- `Pick`
+- `Pickup`
+- `CollisionEnter`
+- `CollisionLeave`
+- `Collision`
+- `EntityStatEffect`
+- `SwapTo`
+- `SwapFrom`
+- `Death`
+- `Wielding`
+- `ProjectileSpawn`
+- `ProjectileHit`
+- `ProjectileMiss`
+- `ProjectileBounce`
+- `Held`
+- `HeldOffhand`
+- `Equipped`
+- `Dodge`
+- `GameModeSwap`
+
+**InteractionSettings Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                        |
+| ---------------- | ------------------------------- | --------- | -------------------------------------------------------------------------------------------- |
+| AllowSkipOnClick | `Boolean`<br />(Default: false) | **No**    | If true, the user will be able to skip this interaction by clicking shortly after it starts. |
+
+**InteractionCameraSettings Fields**
+
+| Field Name  | Type                                             | Required? | Notes                                                                                                                                                           |
+| ----------- | ------------------------------------------------ | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| FirstPerson | `Array`<br />(Element Type: `InteractionCamera`) | **No**    | A list of camera keyframes to be played if the player is in first-person.<br />**The time of each keyframe must be after the keyframe before it in the array.** |
+| ThirdPerson | `Array`<br />(Element Type: `InteractionCamera`) | **No**    | A list of camera keyframes to be played if the player is in third-person.<br />**The time of each keyframe must be after the keyframe before it in the array.** |
+
+**InteractionCamera Fields**
+
+| Field Name | Type                         | Required? | Notes                                                                                                                                       |
+| ---------- | ---------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------- |
+| Time       | `Float`<br />(Default: 0.1f) | **No**    | How long after the interaction begins executing that the camera should arrive at this keyframe.<br />**Cannot be less than or equal to 0.** |
+| Position   | `Vector3`                    | **Yes**   | Where the camera should be located when it arrives at this keyframe.                                                                        |
+| Rotation   | `Direction`                  | **Yes**   | Where the camera should be pointing when it arrives at this keyframe.                                                                       |
+
+### SimpleInteraction
+
+Most interaction types below are inherited from SimpleInteraction and have these
+fields.  If a type does not have these fields, the documentation will mention it.
+
+The purpose of SimpleInteraction is to facilitate Interaction chaining by taking different paths
+based on whether the Interaction succeeded or failed.  The circumstances under which
+a given Interaction fails are generally type-specific (and described in the documentation
+below), but all interactions will be marked failed if they are cancelled via one of the
+many, many mechanisms for doing so.
+
+It is valid to create an interaction asset of type "Simple", which can be valuable when you want to use the
+interaction fields with no additional functionality.
+
+**SimpleInteraction Fields**
+
+| Field Name | Type                                     | Required? | Notes                                                                                          |
+| ---------- | ---------------------------------------- | --------- | ---------------------------------------------------------------------------------------------- |
+| Next       | `Asset`<br />(Asset Type: `Interaction`) | **No**    | After this Interaction has finished, "Next" will be executed if this Interaction did not fail. |
+| Failed     | `Asset`<br />(Asset Type: `Interaction`) | **No**    | After this Interaction has finished, "Failed" will be executed if this Interaction failed.     |
+
+## Flow Control
+
+These are interaction types used to control the flow of an interaction chain and allow interactions
+to be composed into more complex behaviors.  These interaction types generally do not pertain to
+the game and instead pertain to the interaction system itself.
+
+### Condition
+
+This interaction will fail if one of the fields is provided but does not match the current state.
+
+**Condition Fields**
+
+| Field Name       | Type       | Required? | Notes                                                                                                                                                                                    |
+| ---------------- | ---------- | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| RequiredGameMode | `GameMode` | **No**    | If provided, the interaction will fail if the current GameMode does not match the provided value.                                                                                        |
+| Jumping          | `Boolean`  | **No**    | If provided, the interaction will fail if the player's Jumping state does not match the provided value. (i.e. if True, the player must be jumping, if False, the player must not be)     |
+| Swimming         | `Boolean`  | **No**    | If provided, the interaction will fail if the player's Swimming state does not match the provided value. (i.e. if True, the player must be swimming, if False, the player must not be)   |
+| Crouching        | `Boolean`  | **No**    | If provided, the interaction will fail if the player's Crouching state does not match the provided value. (i.e. if True, the player must be crouching, if False, the player must not be) |
+| Running          | `Boolean`  | **No**    | If provided, the interaction will fail if the player's Running state does not match the provided value. (i.e. if True, the player must be running, if False, the player must not be)     |
+| Flying           | `Boolean`  | **No**    | If provided, the interaction will fail if the player's Flying state does not match the provided value. (i.e. if True, the player must be flying, if False, the player must not be)       |
+
+**GameMode Values**
+
+- `Creative`: The game is currently in Creative Mode
+- `Adventure`: The game is currently in Adventure Mode
+
+### FirstClick
+
+This interaction does not inherit from SimpleInteraction and therefore has no Next or Failed fields.
+
+This interaction has two fields that each contain a reference to an Interaction: Click and Hold.  If the root interaction
+of the chain was initiated by a client button/key press (or simulated NPC input) and the input was a tap, then
+the Click interaction is run. if it was a longer press, then the Hold interaction is run.
+
+As a minor implementation detail, this interaction is internally marked as failed when the Hold path is followed.
+This generally shouldn't matter.  If the interaction was not initiated by a key press at all, the Click path will be followed,
+but it seems risky to rely on that behavior.
+
+**FirstClick Fields**
+
+| Field Name | Type                                     | Required? | Notes                                                                                                                                                    |
+| ---------- | ---------------------------------------- | --------- | -------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Click      | `Asset`<br />(Asset Type: `Interaction`) | **No**    | If provided and the root interaction of the chain was initiated by button/key press, this interaction is executed next if the press was a quick tap.     |
+| Hold       | `Asset`<br />(Asset Type: `Interaction`) | **No**    | If provided and the root interaction of the chain was initiated by a button/key press, this interaction is executed next if the press was a longer hold. |
+
+### Interrupt
+
+This interaction can be used to cancel one or more running interaction chains on an entity and **all forked interaction
+chains those chains have spawned that are still currently running**.  All interaction chains canceled in this manner will be marked as
+Failed, which may have additional implications if the canceled chains are themselves forked from
+other chains that are still running.
+
+**Interrupt Fields**
+
+| Field Name     | Type                                           | Required? | Notes                                                                                                                                                                                               |
+| -------------- | ---------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Entity         | `InteractionTarget`<br />(Default: User)       | **Yes**   | The entity that is the owner of the target interaction chains.  This field can indicate the Owner, User, or Target of this interaction chain.                                                       |
+| InterruptTypes | `Array`<br />(Element Type: `InteractionType`) | **No**    | A set of InteractionTypes that are to be interrupted. Only interactions of these types are affected. If null, all types will be interrupted.<br />**(Note: An empty set will interrupt NO TYPES.)** |
+| RequiredTag    | `String`                                       | **No**    | An asset tag that, if provided, the RootInteraction of the interaction chain must have in order to be canceled.                                                                                     |
+| ExcludedTag    | `String`                                       | **No**    | An asset tag that, if provided, the RootInteraction of the interaction chain must not have in order to be canceled.                                                                                 |
+
+**InteractionTarget Values**
+
+- `User` - The user of this interaction chain. The entity whose actions caused this interaction chain to be executed. This is usually the same as the Owner.
+- `Owner` - The owner of this interaction chain. The entity upon whom this interaction chain is executing.
+- `Target` - The entity target of this interaction chain, if any.  This value is mutable (and can therefore come from many places) but most commonly, it is an entity the User was targeting when this interaction chain began executing.
+
+**InteractionType Values**
+
+- `Primary`
+- `Secondary`
+- `Ability1`
+- `Ability2`
+- `Ability3`
+- `Use`
+- `Pick`
+- `Pickup`
+- `CollisionEnter`
+- `CollisionLeave`
+- `Collision`
+- `EntityStatEffect`
+- `SwapTo`
+- `SwapFrom`
+- `Death`
+- `Wielding`
+- `ProjectileSpawn`
+- `ProjectileHit`
+- `ProjectileMiss`
+- `ProjectileBounce`
+- `Held`
+- `HeldOffhand`
+- `Equipped`
+- `Dodge`
+- `GameModeSwap`
+
+### Parallel
+
+This interaction does not inherit from SimpleInteraction and therefore has no Next or Failed fields.
+
+This interaction has a field `Interactions` that is an array of RootInteraction assets. The list must contain at least
+two RootInteractions.  This interaction will fork all of its children except for the first into their
+own interaction chains and immediately complete. After this interaction completes, this interaction chain will
+execute the first RootInteraction in the `Interactions` list.
+
+This interaction does not have any failure conditions and is indifferent to the fate of the forked interaction chains.
+
+**Parallel Fields**
+
+| Field Name   | Type                                                | Required? | Notes                                                         |
+| ------------ | --------------------------------------------------- | --------- | ------------------------------------------------------------- |
+| Interactions | `AssetArray`<br />(Element Type: `RootInteraction`) | **Yes**   | An array of RootInteractions that will be forked or executed. |
+
+### Repeat
+
+This interaction has a field `ForkInteractions` that is an asset of type RootInteraction. This interaction will fork that
+RootInteraction into its own interaction chain and then wait for it to complete. If the RootInteraction fails, this
+interaction will complete immediately and be marked failed. Otherwise, the RootInteraction will be forked and run again,
+up to a specified total number of times.
+
+**Repeat Fields**
+
+| Field Name       | Type                                                                                   | Required? | Notes                                                                                                                                                                                                              |
+| ---------------- | -------------------------------------------------------------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| ForkInteractions | `Asset`<br />(Asset Type: `RootInteraction`)                                           | **Yes**   | A RootInteraction that will be forked.                                                                                                                                                                             |
+| Repeat           | `Integer`<br />(Default: 1)<br />**Must be -1 or a positive integer. 0 is not valid.** | **No**    | The total number of times to fork ForkInteractions. If -1 is provided, ForkInteractions will continue being forked and executed indefinitely, until this interaction is cancelled or until ForkInteractions fails. |
+
+### Replace
+
+This interaction does not inherit from SimpleInteraction and therefore has no Next or Failed fields.
+
+This interaction uses the InteractionVars system that is avaiable for items. InteractionVars are RootInteractions that
+can be attached to an Item asset with a name.
+
+This interaction specifies a var name, and if this interaction chain was executed through
+an item and that item has an InteractionVar of the same name, then this interaction will immediately execute
+the RootInteraction on the var.  Otherwise, it will execute the default RootInteraction specified in this interaction.
+If no default is specified, then this interaction will be marked as failed.
+
+**Replace Fields**
+
+| Field Name   | Type                                         | Required? | Notes                                                                                                                                                                                                           |
+| ------------ | -------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Var          | `String`                                     | **Yes**   | The name of the InteractionVar to execute.                                                                                                                                                                      |
+| DefaultValue | `Asset`<br />(Asset Type: `RootInteraction`) | **No**    | The RootInteraction to execute if the owning item does not have an InteractionVar by the specified name. If not provided, the interaction will be marked as failed instead.                                     |
+| DefaultOk    | `Boolean`<br />(Default: false)              | **No**    | If false, then an angry message will be printed to the server logs if the owning item does not have an InteractionVar by the specified name.  The functioning of this interaction will be otherwise unaffected. |
+
+### RunRootInteraction
+
+This interaction immediately executes the provided RootInteraction as part of this interaction chain. This interaction
+does not have any failure conditions.
+
+**RunRootInteraction Fields**
+
+| Field Name      | Type                                         | Required? | Notes                           |
+| --------------- | -------------------------------------------- | --------- | ------------------------------- |
+| RootInteraction | `Asset`<br />(Asset Type: `RootInteraction`) | **Yes**   | The RootInteraction to execute. |
+
+### Selector
+
+This interaction will execute a Selector to find entities and/or blocks (depending on the Selector) and fork off an
+interaction chain for each located entity or block. This interaction will not wait for those interaction chains
+to complete and is indifferent to their fate. The forked interaction chains will use the located entity/block as
+their target entity/target block. Each entity or block will only fork one interaction chain over the life of this
+interaction.  The Selector is guaranteed to run once for each execution of this interaction, but some Selectors
+are intended to be run over a period of time and sweep across an area to locate targets. In order to use those Selectors
+properly, you will need to extend the execution time of this interaction using `RunTime` or `WaitForAnimationToFinish`.
+The Selector will be executed repeatedly over the lifetime of the interaction.
+
+If the Selector is configured to locate entities, you can add additional sets of entity matching rules. If a located entity
+matches one of the rules, the matching RootInteraction will be forked instead of the standard `HitEntity` RootInteraction.
+
+Entities located by the Selector will be ignored if they do not have a NetworkId, if they are dead, or if they are invulnerable.
+The only exception to this rule is that players in Creative Mode that are marked to receive hits will not be ignored.
+
+This interaction's failure conditions are configurable via the `FailOn` field. You can configure this interaction to never
+fail, to fail if the Selector does not locate any blocks before this interaction finishes executing, to fail if the
+Selector does not locate any entities before this interaction finishes executing, or to fail in either case.
+
+**Selector Fields**
+
+| Field Name     | Type                                         | Required? | Notes                                                                                                                                                                                                                                     |
+| -------------- | -------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Selector       | `Selector`                                   | **Yes**   | The Selector is executed at least once and may be executed repeatedly to locate blocks and/or entities in an area.                                                                                                                        |
+| HitEntity      | `Asset`<br />(Asset Type: `RootInteraction`) | **No**    | If included and the `Selector` locates an entity that does not match any `HitEntityRules`, this RootInteraction will be forked into a new interaction chain with the located entity as the target entity.                                 |
+| HitEntityRules | `Array`<br />(Element Type: `HitEntity`)     | **No**    | If included, these rules will be matched against any entity located by the `Selector`. If an entity matches a set of rules, the RootInteraction associated with the rules will be forked instead of the standard `HitEntity` interaction. |
+| HitBlock       | `Asset`<br />(Asset Type: `RootInteraction`) | **No**    | If included and the `Selector` locates a block, this RootInteraction will be forked into a new interaction chain with the located block as the block target.                                                                              |
+| FailOn         | `FailOnType`<br />(Default: `Neither`)       | **No**    | Defines under what circumstances this interaction will fail.  It can be marked to fail when it completes without locating any blocks, it can be marked to fail when it completes without locating any entities, both, or neither.         |
+| IgnoreOwner    | `Boolean`<br />(Default: true)               | **No**    | If true, the Selector will not locate the User entity of this interaction.                                                                                                                                                                |
+
+**HitEntity Fields**
+
+| Field Name | Type                                         | Required? | Notes                                                                                                 |
+| ---------- | -------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------- |
+| Matchers   | `Array`<br />(Element Type: `EntityMatcher`) | **Yes**   | A set of rules that an entity must match. An entity must successful match all rules to be considered. |
+| Next       | `Asset`<br />(Asset Type: `RootInteraction`) | **Yes**   | The RootInteraction to fork if an entity matches all rules.                                           |
+
+**EntityMatcher Fields**
+
+| Field Name | Type                            | Required? | Notes                                                                                                     |
+| ---------- | ------------------------------- | --------- | --------------------------------------------------------------------------------------------------------- |
+| Type       | `String`                        | **Yes**   | If provided, specifies a type of EntityMatcher to use. Each matcher type may come with additional fields. |
+| Invert     | `Boolean`<br />(Default: false) | **No**    | If true, an entity must fail this rule for it to be marked as succeeded.                                  |
+
+**EntityMatcher Type: Player**
+
+This EntityMatcher will succesfully match the entity only if they are a player.
+
+**EntityMatcher Type: Vulnerable**
+
+This Entitymatcher will successfully match the entity only if they are not marked as invulnerable.
+
+**FailOnType Values**
+
+- `Neither`
+- `Entity`
+- `Block`
+- `Either`
+
+### Serial
+
+This interaction does not inherit from SimpleInteraction and therefore has no Next or Failed fields.
+
+This interaction has a field `Interactions` which is a list of Interaction assets. This interaction immediately
+completes and the interaction chain continues by executing the interactions in the list one at a time. This
+interaction does not have any failure conditions.
+
+**Serial Fields**
+
+| Field Name   | Type                                            | Required? | Notes                                      |
+| ------------ | ----------------------------------------------- | --------- | ------------------------------------------ |
+| Interactions | `AssetArray`<br />(Element Type: `Interaction`) | **Yes**   | An array of Interaction assets to execute. |
+
+## Cooldowns
+
+RootInteractions interface with a complex cooldown system that can be used for a variety of purposes. Aside from simply
+adding an important aspect of resource management to your game design, cooldowns can be used to ensure that click-activated
+interaction chains don't repeatedly spam if the player holds down the input.
+
+By default, every RootInteraction has a cooldown timer that is keyed to the RootInteraction name, and by default, it
+will launch a cooldown of 0.35 seconds when activated by client input.  Otherwise, no cooldown will be activated.  However,
+by configuring your RootInteraction, you can change the key for the cooldown (so that multiple RootInteractions can share
+a single cooldown), set the cooldown timer to whatever you like, and configure multiple charges that can build up over time
+to allow the entity to activate the RootInteraction multiple times before being forced to pause.
+
+One important concept to keep in mind is the difference between **cooldown** and **charge time**.  The cooldown, if any,
+is activated each time a RootInteraction triggers, even if the player has more available charges. If the RootInteraction
+is configured to use charges, then they will gradually build up over time. In order for a RootInteraction to be activated,
+the cooldown (if any) must be expired, and the RootInteraction must have at least one charge (if it has been
+configured to use charges).
+
+Bear in mind that the entire Cooldown configuration is shared between different RootInteractions with the same cooldown id.
+If you activate an ability with 5 charges and a short cooldown and then another ability with a much longer cooldown and no
+charges, the second ability will use the cooldown properties of the first ability until/unless the first ability finishes
+charging and is cleared from the system.  You should generally only have multiple RootInteractions share a cooldown id
+if they have the same configuration.
+
+The interactions below interact with the cooldown system to allow you to manipulate cooldowns via the interaction system. By
+using these interactions, you can have several interaction chains with different cooldown configurations share cooldowns
+that are checked and activated as part of the interaction chain itself, or have some components of an interaction change
+use a second cooldown separate from the main one.
+
+### CooldownCondition
+
+**CooldownCondition Fields**
+
+This interaction will fail if the specified cooldown id is on cooldown for the User entity.  This interaction will only
+function for players- the interaction will always succeed for NPCs.  In order for this interaction to succeed, the
+cooldown, if any, must have expired and at least one charge, if any, must have filled.
+
+| Field Name | Type     | Required? | Notes                     |
+| ---------- | -------- | --------- | ------------------------- |
+| Id         | `String` | **Yes**   | The cooldown id to check. |
+
+### IncrementCooldown
+
+**IncrementCooldown Fields**
+
+This interaction will modify a cooldown that is currently active on the User entity, allowing charges and remaining
+cooldown to be modified.
+Despite its name, this interaction can be used to reduce a cooldown as well as increase it. If the cooldown is not
+currently active, this interaction will have no effect. The interaction has no special failure conditions.
+
+| Field Name        | Type                        | Required? | Notes                                                                                                                                                                                                                                                                                     |
+| ----------------- | --------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Id                | `String`                    | **No**    | If provided, the cooldown id of the cooldown to be manipulated. If not provided, the cooldown id of the current chain's RootInteraction will be used.                                                                                                                                     |
+| Time              | `Float`<br />(Default: 0.0) | **No**    | The amount to increase the remaining cooldown by. Can be negative. The remaining cooldown time will not be reduced below zero or increased above the maximum cooldown time.                                                                                                               |
+| ChargeTime        | `Float`<br />(Default: 0.0) | **No**    | The amount to increase the remaining time until the next charge is filled by. Can be negative. The remaining charge time cannot be reduced below zero or increased above the maximum cooldown time. **This will not work on abilities that have a maximum of 1 charge, for some reason.** |
+| Charge            | `Integer`<br />(Default: 0) | **No**    | The amount to increase the number of charges by. Can be negative. The number of charges cannot be reduced below 0 or increased above the maximum.                                                                                                                                         |
+| InterruptRecharge | `Boolean`(Default: false)   | **No**    | If true and `Charge` is not 0, will reset the remaining time to the next charge to the maximum value after changing the charge count.                                                                                                                                                     |
+
+### ResetCooldown
+
+This interaction will trigger a cooldown on the User entity with a specified configuration. The charges will be refilled
+but the cooldown will be immediately triggered.  The mechanisms for deciding on the configuration are a little bit complicated.
+You may specify a cooldown configuration via the `Cooldown` field. If you do not include an `Id` field, then the
+interaction chain's RootInteraction will be used for any field not specified in the configuration. If there is an active
+cooldown under the specified `Id` (or under the RootInteraction's cooldown id if none is specified) then the fields
+from that active cooldown will overwrite data in the RootInteraction's cooldown, but not data in your `Cooldown` field.
+
+**ResetCooldown Fields**
+
+| Field Name | Type                  | Required? | Notes                                                        |
+| ---------- | --------------------- | --------- | ------------------------------------------------------------ |
+| Cooldown   | `InteractionCooldown` | **No**    | A cooldown configuration to use for the new, reset cooldown. |
+
+**InteractionCooldown Fields**
+
+| Field Name        | Type                                 | Required? | Notes                                                                                                                                                                                                 |
+| ----------------- | ------------------------------------ | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Id                | `String`                             | **No**    | The cooldown id to use for this cooldown. If not provided, the RootInteraction's cooldown id will be used, if any.                                                                                    |
+| Cooldown          | `Float`<br />(Default: 0.0)          | **No**    | The duration of the cooldown, in seconds.                                                                                                                                                             |
+| Charges           | `Array`<br />(Element Type: `Float`) | **No**    | If provided, a list of how many charges this cooldown can build, and how long each charge takes to build, in seconds.                                                                                 |
+| InterruptRecharge | `Boolean`<br />(Default: false)      | **No**    | If true, the charge time will be reset when the number of charges changes.                                                                                                                            |
+| ClickBypass       | `Boolean`<br />(Default: false)      | **No**    | If true, RootInteractions keyed to this cooldown can still be activated when it is on cooldown provided that the RootInteraction was triggered by a distinct key or mouse button press on the client. |
+
+### TriggerCooldown
+
+This interaction is similar to ResetCooldown, except instead of refilling the cooldown's charges, one charge will be deducted
+as normal.
+
+**TriggerCooldown Fields**
+
+| Field Name | Type                  | Required? | Notes                                                        |
+| ---------- | --------------------- | --------- | ------------------------------------------------------------ |
+| Cooldown   | `InteractionCooldown` | **No**    | A cooldown configuration to use for the new, reset cooldown. |
+
+**InteractionCooldown Fields**
+
+| Field Name        | Type                                 | Required? | Notes                                                                                                                                                                                                 |
+| ----------------- | ------------------------------------ | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Id                | `String`                             | **No**    | The cooldown id to use for this cooldown. If not provided, the RootInteraction's cooldown id will be used, if any.                                                                                    |
+| Cooldown          | `Float`<br />(Default: 0.0)          | **No**    | The duration of the cooldown, in seconds.                                                                                                                                                             |
+| Charges           | `Array`<br />(Element Type: `Float`) | **No**    | If provided, a list of how many charges this cooldown can build, and how long each charge takes to build, in seconds.                                                                                 |
+| InterruptRecharge | `Boolean`<br />(Default: false)      | **No**    | If true, the charge time will be reset when the number of charges changes.                                                                                                                            |
+| ClickBypass       | `Boolean`<br />(Default: false)      | **No**    | If true, RootInteractions keyed to this cooldown can still be activated when it is on cooldown provided that the RootInteraction was triggered by a distinct key or mouse button press on the client. |
+
+## Combo Chains
+
+Hytale additionally comes with a rich "combo chaining" system, which allows several inputs in a row to result in different
+attacks and special moves.  Rather than being attached to the RootInteraction like the cooldown system, these are
+primarily driven by the `Chaining` interaction.
+
+### Chaining
+
+This interaction does not inherit from SimpleInteraction and therefore has no Failed field. Its Next field works differently
+from most interaction types.
+
+Chaining is a type of flow control interaction- each time a Chaining interaction with the same `ChainId` is called, a single
+interaction in the `Next` list is chosen and the others are ignored. The first time the `ChainId` is used, the first
+interaction in the list is chosen, the next time the second, etc. Once the end of the list is reached, the first
+interaction will be chosen again.
+
+Bear in mind: the progress through the Next list is based on the **ChainId**, not the interaction!  That means that two
+different Chaining interactions can share a single combo chain. You could have a pair of daggers that attacks with
+the left when the left mouse button is clicked and with the right when the right mouse button is clicked.  You could give
+both interaction chains a Chaining interaction with the same `ChainId` and three `Next` entries that do a light-light-heavy
+combo.  Each specific hit would occur with either the left or the right knife based on which button you clicked, but
+the combo would be otherwise identical regardless of which you chose.
+
+The Chaining interaction also has a concept called "flags".  It is possible to attach named flags to a `ChainId` by using
+the ChainFlag interaction.  Then, you specify the flag name in Chaining's `Flags` field. If a Flag is active when the
+Chaining interaction is run, the Flag's interaction will be run instead of the appropriate interaction in `Next`.
+Bear in mind: the entity's progress through the `Next` list still advances, the resulting `Next` interaction is just not
+run.  Only one flag can be active at a time.
+
+Lastly, it is possible to cancel the entity's progress through the combo chain and reset them to the first interaction in
+the list. This can be done with the CancelChain interaction, but it will also happen automatically if the player does
+not trigger an interaction with the ChainId for the specified ChainingAllowance.  When either of these happen, all flags will be
+canceled as well.
+
+All of these effects are triggered on the User entity only. Non-players can use the chaining system, but Flags do not currently
+work for non-players.  This interaction has no special failure conditions.
+
+**Chaining Fields**
+
+| Field Name        | Type                                                       | Required? | Notes                                                                                                                                                                                                                       |
+| ----------------- | ---------------------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| ChainId           | `String`                                                   | **No**    | If provided, acts as a key that multiple Chaining interactions can use to share combo chain progress and flags. If not provided, a unique ChainId will be generated for this interaction.                                   |
+| ChainingAllowance | `Double`<br />(Default: 0.0)                               | **No**    | If, at the time this interaction is triggered, it has been this long in seconds since the last time a Chaining interaction with the same ChainId was executed, all state for this ChainId will be cleared before execution. |
+| Next              | `AssetArray`<br />(Element Type: `Interaction`)            | **Yes**   | A list of interactions to cycle between each time this interaction is run.                                                                                                                                                  |
+| Flags             | `Map`<br />(Key Type: `String`, Value Type: `Interaction`) | **No**    | A map of flag names to interactions to run if the flag is active when this interaction executes.                                                                                                                            |
+
+### CancelChain
+
+This interaction resets all progress and flag data on the User entity for the provided `ChainId`.  The next time a Chaining
+interaction is called for the provided `ChainId`, it will begin at the first interaction in the `Next` list. This
+interaction has no special failure conditions.
+
+**CancelChain Fields**
+
+| Field Name | Type     | Required? | Notes                                 |
+| ---------- | -------- | --------- | ------------------------------------- |
+| ChainId    | `String` | **Yes**   | A ChainId whose data should be reset. |
+
+### ChainFlag
+
+This interaction activates a flag on the User entity for the provided `ChainId`, which can be used to change behavior the
+next time a Chaining interaction with this `ChainId` is run. This will overwrite any flag that has
+already been raised. This interaction will have no effect for non-players. This interaction has no special failure
+conditions.
+
+| Field Name | Type     | Required? | Notes                                        |
+| ---------- | -------- | --------- | -------------------------------------------- |
+| ChainId    | `String` | **Yes**   | A ChainId on whom the flag should be raised. |
+| Flag       | `String` | **Yes**   | The name of the flag to raise.               |
+
+## Charging
+
+A unique flow-control interaction that is frequently used is the Charging interaction.  It is a flow-control interaction
+that delays while the input button used to trigger the interaction chain is held.  When it is released (or the interaction
+is forced to end), the interaction chain can continue with a different interaction based on how long the input was held
+for.
+
+These interactions are all related by either being the Charging interaction, or other interaction types that inherit the
+Charging interaction's behavior.
+
+### Charging
+
+This interaction does not inherit from SimpleInteraction and therefore its Next field works different from most interactions.
+This interaction adds its own Failed field which works the same way that SimpleInteraction's does.
+
+This interaction only works properly when its interaction chain was triggered by a client key or button press (or
+NPC-simulated equivalent). This interaction will continue executing for as long as the key or button press is held (with
+some exceptions, covered below) by the User entity.  Like other interactions, it has a `Next` field indicating which interaction to execute
+after this one, but the field is a map from `Float` values to `Interaction` assets. When this interaction ends, either
+due to the input being released or the charge duration completing, this interaction will determine the largest `Float` key that is less
+than the amount of time in seconds that the interaction was executing for.  The Interaction mapped to that key will be
+executed next.
+
+The interaction includes some cancellation conditions that are specific to this interaction. For instance, the interaction
+has a `CancelOnOtherClick` field that matches the field on RootInteraction. If it is active on this interaction but not
+the RootInteraction, then clicking while charging will cancel this interaction (and execute the `Failed` interaction rather
+than any of the `Next` interactions) but otherwise continue the interaction chain.
+
+Another valuable feature Charging has is the `Forks` field.  For input-triggered interactions that are triggered while the
+Charging interaction is executing, you can add an entry for the relevant InteractionType to this field and instead of
+triggering the usual interaction chain based on held item, targeted block, etc. the RootInteraction specified in the
+`Forks` field will be triggered.  This can unlock rich attack modes and behaviors. For instance, having a shield bash attack
+triggered off left click while blocking, or a special attack that triggers when both mouse buttons are pressed at the
+same time.
+
+There are two modes of operation for the Charging interaction. One is to have the ability charge for as long
+as the input is held and only end execution when the entity releases the input.  Bows in the main Hytale game work
+that way.  That is accomplished by setting `AllowIndefiniteHold` to true.  Another mode of operation is to have the
+interaction complete execution when the execution time has surpassed the largest key value in the `Next` field and
+immediately begin executing the Interaction mapped to that key.  Food in the main Hytale game work like this.  It
+is accomplished by setting `AllowIndefiniteHold` to false.
+
+One pitfall to be careful of when setting `AllowIndefiniteHold` to false is the way it interacts with cooldowns.\
+Normally, input-initiated interaction chains start a 0.35s cooldown on the triggered RootInteraction that prevents
+holding the mouse button from immediately spamming a new interaction when the first one completes.  However, if the
+duration of a Charging interaction is longer than 0.35s, then the cooldown will have already completed when the
+interaction chain finishes, which will often result in a new execution beginning immediately before the player can
+stop pressing the mouse button.  One solution for this problem is to add a `Simple` interaction to the end of your
+interaction chain with a `RunTime` of 0.35s to simulate the cooldown.  Alternatively, you can add a longer cooldown
+(the maximum duration of your Charging interaction plus 0.35s) to the RootInteraction. However, the longer cooldown is
+not always desirable, as the interaction may have ended prematurely, resulting in an unusually long lockout between
+executions.
+
+**Charging Fields**
+
+| Field Name                         | Type                                                                    | Required? | Notes                                                                                                                                                                                                                                                                                                                                                                                       |
+| ---------------------------------- | ----------------------------------------------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| FailOnDamage                       | `Boolean`<br />(Default: false)                                         | **No**    | If true, this interaction will fail and end immediately if the User entity takes any damage while it is executing.                                                                                                                                                                                                                                                                          |
+| CancelOnOtherClick                 | `Boolean`<br />(Default: true)                                          | **No**    | If true, this interaction will fail and end immediately if the User entity sends another button or key press while it is executing.                                                                                                                                                                                                                                                         |
+| Forks                              | `Map`<br />(Key Type: `InteractionType`, Value Type: `RootInteraction`) | **No**    | A map of InteractionType to RootInteraction. If entity input triggers the InteractionType while this interaction is executing, the mapped RootInteraction will be forked into its own interaction chain. This will happen instead of the usual handling for that InteractionType.  This fork will occur even if `CancelOnOtherClick` is set to true.                                        |
+| Failed                             | `Asset`<br />(Asset Type: `Interaction`)                                | **No**    | After this Interaction has finished, "Failed" will be executed if this Interaction failed.                                                                                                                                                                                                                                                                                                  |
+| AllowIndefiniteHold                | `Boolean`<br />(Default: false)                                         | **No**    | If true, this interaction will continue executing for as long as the User entity continues to hold the input. If false, execution will end as soon as the execution time in seconds reaches the largest key value in the `Next` map.                                                                                                                                                        |
+| DisplayProgress                    | `Boolean`<br />(Default: true)                                          | **No**    | If true, players executing this interaction will see a progress bar will be displayed below their cursor indicating how close to reaching the highest key value in `Next` they are.                                                                                                                                                                                                         |
+| Next                               | `Map`<br />(Key Type: `Float`, Value Type: `Interaction`)               | **No**    | A map from `Float` to `Interaction`.  When this interaction successfully finishes executing (either because the input was released or because the maximum duration was reached), this interaction will find the `Float` value with the largest duration in seconds that is less than the amount of time this interaction executed for. That key's mapped Interaction will then be executed. |
+| MouseSensitivityAdjustmentTarget   | `Float`<br />(Default: 1.0)                                             | **No**    | While charging, this mouse sensitivity multiplier will gradually be applied.                                                                                                                                                                                                                                                                                                                |
+| MouseSensitivityAdjustmentDuration | `Float`<br />(Default: 1.0)                                             | **No**    | Duration in seconds. After this many seconds, `MouseSensitivityAdjustmentTarget` will be fully applied to the mouse sensitivity.                                                                                                                                                                                                                                                            |
+| Delay                              | `ChargingDelay`                                                         | **No**    | Settings that allow charging progress to be pushed back when the User entity takes damage.                                                                                                                                                                                                                                                                                                  |
+
+**ChargingDelay Fields**
+
+| Field Name    | Type                        | Required? | Notes                                                                                                                                                                                                                                                                     |
+| ------------- | --------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| MinHealth     | `Float`<br />(Default: 0.0) | **No**    | Damage taken as a percentage of entity health (0.0-1.0). If a hit deals less than this much damage, no pushback will be applied.  If a hit deals exactly this much damage, `MinDelay` seconds worth of pushback will be applied.                                          |
+| MaxHealth     | `Float`<br />(Default: 0.0) | **No**    | Damage taken as a percentage of entity health (0.0-1.0). If a hit deals at least this much damage, `MaxDelay` seconds worth of pushback will be applied.                                                                                                                  |
+| MinDelay      | `Float`<br />(Default: 0)   | **No**    | The amount of pushback, in seconds, to apply if the entity takes a hit that deals `MinHealth` damage. The amount of pushback applied by a hit is a gradiant between `MinDelay` and `MaxDelay` based on the amount of damage between `MinHealth` and `MaxHealth`.          |
+| MaxDelay      | `Float`<br />(Default: 0)   | **No**    | The amount of pushback, in seconds, to apply if the entity takes a hit that deals at least `MaxHealth` damage. The amount of pushback applied by a hit is a gradiant between `MinDelay` and `MaxDelay` based on the amount of damage between `MinHealth` and `MaxHealth`. |
+| MaxTotalDelay | `Float`<br />(Deault: 0)    | **No**    | The maximum amount of pushback the entity can receive over the course of a single charge, regardless of how many times they are hit.                                                                                                                                      |
+
+**InteractionType Values**
+
+- `Primary`
+- `Secondary`
+- `Ability1`
+- `Ability2`
+- `Ability3`
+- `Use`
+- `Pick`
+- `Pickup`
+- `CollisionEnter`
+- `CollisionLeave`
+- `Collision`
+- `EntityStatEffect`
+- `SwapTo`
+- `SwapFrom`
+- `Death`
+- `Wielding`
+- `ProjectileSpawn`
+- `ProjectileHit`
+- `ProjectileMiss`
+- `ProjectileBounce`
+- `Held`
+- `HeldOffhand`
+- `Equipped`
+- `Dodge`
+- `GameModeSwap`
+
+### Wielding
+
+This interaction is inherited from Charging rather than SimpleInteraction.  However, its `Failed` and `Next` fields function
+identically to SimpleInteraction.  It does not inherit all fields from Charging, so be sure to pay close attention to
+the field list below.
+
+This interaction drives most blocking behavior in the game. While this interaction is executing, attacks made against
+the Owner entity will (conditionally) trigger effects defined in this interaction.  Unlike the Charging interaction,
+this interaction can always execute indefinitely and will only end when it fails or when the input is released.
+
+One option available in Wielding is `AngledWielding`, which allows damage and knockback modifiers to only be applied
+depending on the direction the attack against the Owner entity is coming from.  The AngledWielding type has a
+field `Angle` which determines which direction the protection points relative to the player (0 is the player's
+front), and `AngleDistance` which determines how wide the cone of protection extends around the player.  Block effects
+from this interaction (such as `BlockedEffects`, `BlockedInteractions`, and `StaminaCost`) will only apply if
+the DamageCause matches `DamageModifiers` OR if the DamageCause matches `AngledWielding.DamageModifiers` and
+the source of the damage matches `Angle` and `AngleDistance`.  It is possible for damage and knockback multipliers
+specified on both this interaction's modifier fields and `AngledWielding`'s modifier fields to stack, if both
+have entries for the same DamageCause.
+
+This interaction will only have an effect on damage taken by one of the DamageCause entries in `DamageModifiers` or
+`AngledWielding.DamageModifiers`.  If a DamageCause is in `DamageModifiers`, then the block effect will be triggered
+and the damage modifier applied regardless of what direction the Owner entity is attacked from.  If a DamageCause is in
+`AngledWielding.DamageModifiers`, then the damage modifier is only applied if the
+
+\*\* Wielding Fields\*\*
+
+| Field Name          | Type                                                                    | Required? | Notes                                                                                                                                                                                                                                                                                                                                                                                                      |
+| ------------------- | ----------------------------------------------------------------------- | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| FailOnDamage        | `Boolean`<br />(Default: false)                                         | **No**    | If true, this interaction will fail and end immediately if the User entity takes any damage while it is executing.                                                                                                                                                                                                                                                                                         |
+| CancelOnOtherClick  | `Boolean`<br />(Default: true)                                          | **No**    | If true, this interaction will fail and end immediately if the User entity sends another button or key press while it is executing.                                                                                                                                                                                                                                                                        |
+| Forks               | `Map`<br />(Key Type: `InteractionType`, Value Type: `RootInteraction`) | **No**    | A map of InteractionType to RootInteraction. If entity input triggers the InteractionType while this interaction is executing, the mapped RootInteraction will be forked into its own interaction chain. This will happen instead of the usual handling for that InteractionType.  This fork will occur even if `CancelOnOtherClick` is set to true (after which this interaction chain will be canceled). |
+| Next                | `Asset`<br />(Asset Type: `Interaction`)                                | **No**    | After this interaction has finished, "Next" will be executed if this interaction did not fail.                                                                                                                                                                                                                                                                                                             |
+| Failed              | `Asset`<br />(Asset Type: `Interaction`)                                | **No**    | After this interaction has finished, "Failed" will be executed if this interaction failed.                                                                                                                                                                                                                                                                                                                 |
+| DamageModifiers     | `Map`<br />(Key Type: `DamageCause`, Value Type: `Float`)               | **No**    | A map from DamageCause to Float, where the Float is multiplied against any damage received from the mapped DamageCause while this interaction is executing.                                                                                                                                                                                                                                                |
+| KnockbackModifiers  | `Map`<br />(Key Type: `DamageCause`, Value Type: `Float`)               | **No**    | A map from DamageCause to Float, where the Float is multiplied against any knockback force received from the mapped DamageCause while this interaction is executing.                                                                                                                                                                                                                                       |
+| AngledWielding      | `AngledWielding`                                                        | **No**    | Configuration to only trigger block effects from certain angles.                                                                                                                                                                                                                                                                                                                                           |
+| StaminaCost         | `StaminaCost`                                                           | **No**    | If the Owner entity receives damage that matches `DamageModifiers` or `AngledWielding` while this interaction is executing, then the entity's stamina will be deducted according to this configuration.                                                                                                                                                                                                    |
+| BlockedEffects      | `DamageEffects`                                                         | **No**    | If the Owner entity receives damage that matches `DamageModifiers` or `AngledWielding` while this interaction is executing, then these effects will be applied to the instance of damage.                                                                                                                                                                                                                  |
+| BlockedInteractions | `Asset`<br />(Asset Type: `RootInteraction`)                            | **No**    | If the Owner entity receives damage that matches `DamageModifiers` or `AngledWielding` while this interaction is executing, then this RootInteraction will be launched as a brand new interaction chain with the Owner entity as both Owner and User, and the attacker as the Target entity.  This new interaction chain is, notably, brand new, **not** forked from the current one.                      |
+
+**AngledWielding Fields**
+
+| Field Name         | Type                                                      | Required? | Notes                                                                                                                                                                                                            |
+| ------------------ | --------------------------------------------------------- | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Angle              | `Float`<br />(Default: 0.0)                               | **No**    | Angle in degrees relative to the Owner entity where the angled protection is centered. 0.0 means pointed towards the front of the Owner entity.                                                                  |
+| AngleDistance      | `Float`<br />(Default: 0.0)                               | **No**    | Angle in degrees indicating how wide the cone of protection is.                                                                                                                                                  |
+| DamageModifiers    | `Map`<br />(Key Type: `DamageCause`, Value Type: `Float`) | **No**    | A map from DamageCause to Float, where the Float is multiplied against any damage received from the mapped DamageCause received from within the cone of protection while this interaction is executing.          |
+| KnockbackModifiers | `Map`<br />(Key Type: `DamageCause`, Value Type: `Float`) | **No**    | A map from DamageCause to Float, where the Float is multiplied against any knockback force received from the mapped DamageCause received from within the cone of protection while this interaction is executing. |
+
+**StaminaCost Fields**
+
+| Field Name | Type                                             | Required? | Notes                                                                                                                                                                                                                                                |
+| ---------- | ------------------------------------------------ | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| CostType   | `CostType`<br />(Default: `MaxHealthPercentage`) | **No**    | How to calculate stamina consumed by blocking from the raw pre-block damage. If `Damage`, then the stamina consumed will be `rawDamage / Value`. If `MaxHealthPercentage`, then the stamina consumed will be `rawDamage / (EntityMaxHealth * Value)` |
+| Value      | `Float`<br />(Default: 0.04)                     | **No**    | The value to use in the `CostType` formula.                                                                                                                                                                                                          |
+
+**DamageEffects Fields**
+
+| Field Name             | Type                                         | Required? | Notes                                                                           |
+| ---------------------- | -------------------------------------------- | --------- | ------------------------------------------------------------------------------- |
+| ModelParticles         | `Array`<br />(Element Type: `ModelParticle`) | **No**    | Particle systems to trigger in the first-person view.                           |
+| WorldParticles         | `Array`<br />(Element Type: `WorldParticle`) | **No**    | Particle systems to trigger in the third-person view.                           |
+| LocalSoundEventId      | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | 2D sound to play locally to the attacking entity if they are a player.          |
+| WorldSoundEventId      | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | Sound to play in the world at the Owner entity's location.                      |
+| PlayerSoundEventId     | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | 2D sound to play locally to the Owner entity if they are a player.              |
+| ViewDistance           | `Double`<br />(Default: 75.0)                | **No**    | Distance at which these effects should play for other players.                  |
+| Knockback              | `Knockback`                                  | **No**    | The properties of the knockback that will be applied.                           |
+| CameraEffect           | `Asset`<br />(Asset Type: `CameraEffect`)    | **No**    | CameraEffect to briefly apply locally to the Owner entity if they are a player. |
+| StaminaDrainMultiplier | `Float`<br />(Default: 1.0)                  | **No**    | This multiplier is applied to the `StaminaCost`, if any.                        |
+
+**Knockback Fields**
+
+| Field Name     | Type                                       | Required? | Notes                                                                                                                      |
+| -------------- | ------------------------------------------ | --------- | -------------------------------------------------------------------------------------------------------------------------- |
+| Type           | `String`                                   | **No**    | If provided, specifies a type of knockback to use. Each knockback type may come with additional fields.                    |
+| Force          | `Double`<br />(Default: 0.0)               | **No**    | The amount of force to apply to the Owner entity.                                                                          |
+| Duration       | `Double`<br />(Default: 0.0)               | **No**    | If 0.0, apply the force as a single impulse.  If more, continuously apply the force over a period of time.                 |
+| VelocityType   | `ChangeVelocityType`<br />(Default: `Add`) | **No**    | How to apply the force, either adding it to the entity's current velocity, or setting the velocity to the knockback force. |
+| VelocityConfig | `VelocityConfig`                           | **No**    | Characteristics of friction as the Owner entity is thrown by this knockback.                                               |
+
+**Knockback Type: Force**
+
+Apply the calculated knockback force along the provided direction.
+
+| Field Name | Type                         | Required? | Notes                                                                                |
+| ---------- | ---------------------------- | --------- | ------------------------------------------------------------------------------------ |
+| Direction  | `Vector3`<br />(Default: Up) | **No**    | Which direction the player should be flung, relative to the direction of the attack. |
+
+**Knockback Type: Point**
+
+Apply the calculated knockback force laterally along the XZ plane, plus provided Y velocity.
+
+| Field Name | Type                        | Required? | Notes                                                                                                   |
+| ---------- | --------------------------- | --------- | ------------------------------------------------------------------------------------------------------- |
+| OffsetX    | `Integer`<br />(Default: 0) | **No**    | Offset the source position of the knockback left or right perpendicular to the direction of the attack. |
+| OffsetZ    | `Integer`<br />(Default: 0) | **No**    | Offset the source position of the knockback, forward or backward along the directon of the attack.      |
+| RotateY    | `Integer`<br />(Default: 0) | **No**    | Rotate the knockback direction around the Y axis, where 0 is the default attack direction.              |
+| VelocityY  | `Float`<br />(Default: 0.0) | **No**    | Add vertical velocity to the knockback force after the direction and force has been calculated.         |
+
+**Knockback Type: Directional**
+
+Apply the calculated knockback force along the attack direction, removing any vertical component and replacing it with a provided Y velocity.
+
+| Field Name | Type                      | Required? | Notes                                                                                                                                            |
+| ---------- | ------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------ |
+| RelativeX  | `Float`<br />(Default: 0) | **No**    | Apply additional force left or right perpendicular to the direction of the attack. The additional force is multiplied by the knockback strength. |
+| RelativeZ  | `Float`<br />(Default: 0) | **No**    | Apply additional force forward or backward along the attack direction. The additional force is multiplied by the knockback strength.             |
+| VelocityY  | `Float`<br />(Default: 0) | **No**    | Replace the vertical velocity of the knockback with this value.  This value is not multiplied by knockback strength.                             |
+
+**VelocityConfig Fields**
+
+| Field Name          | Type                                              | Required? | Notes                                                                                                                                                                                           |
+| ------------------- | ------------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| GroundResistance    | `Float`<br />(Default: 0.82)                      | **No**    | The minimum amount of friction applied when the entity is in contact with the ground.  1.0 = no friction, 0.0 = total friction                                                                  |
+| GroundResistanceMax | `Float`<br />(Default: 0.0)                       | **No**    | The maximum amount of friction applied when the entity is in contact with the ground.  1.0 = no friction, 0.0 = total friction                                                                  |
+| AirResistance       | `Float`<br />(Default: 0.96)                      | **No**    | The minimum amount of friction applied when the entity is in the air. 1.0 = no friction, 0.0 = total friction                                                                                   |
+| AirResistanceMax    | `Float`<br />(Default: 0.0)                       | **No**    | The maximum amount of friction applied when the entity is in the air. 1.0 = no friction, 0.0 = total friction                                                                                   |
+| Threshold           | `Float`<br />(Default: 1.0)                       | **No**    | The speed at which the maximum amount of friction will be applied to the entity. The amount of friction applied will increase from minimum to maximum as the entity moves from 0 to this speed. |
+| Style               | `VelocityThresholdStyle`<br />(Default: `Linear`) | **No**    | The curve that friction follows as the entity's speed increases toward the `Threshold`.                                                                                                         |
+
+**CostType Values**
+
+- `MaxHealthPercentage`
+- `Damage`
+
+**ChangeVelocityType Values**
+
+- `Add`
+- `Set`
+
+**VelocityThresholdStyle Values**
+
+- `Linear`
+- `Exp`
+
+## Blocks
+
+These are interaction types meant to reason about and modify blocks in the world.  The most important concept unique
+to these interactions is the Block Target.  Like the Entity Target, it is mutable and can come from many places.
+However, for interaction chains initiated by the client, the block target will initially be the block that the player's cursor was
+over, if any.
+
+Additionally, for interaction chains initiated by the client, the client will send along which face of the block is targeted,
+which is used by a few block-related interactions.
+It is left up to each interaction type that cares about block faces as to how to handle this behavior for simulated input
+(i.e. NPCs initiating chains that are normally initated by the client).  At the time of this writing, all block-related
+interactions choose the top face where relevant in simulated input.
+
+### BlockCondition
+
+This interaction has a field `Matchers` which specifies certain conditions, such as block type, state, etc.  This
+interaction fails if the current target block does not match all of them.
+
+**BlockCondition Fields**
+
+| Field Name       | Type                                        | Required? | Notes                                                                                                                                                                                                                                                                                                                                   |
+| ---------------- | ------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false)             | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction.                                                                                                                                                                                                       |
+| Matchers         | `Array`<br />(Element Type: `BlockMatcher`) | **Yes**   | A list of conditions that the target block must match or this condition will fail.<br />**Note: This field is technically not required but there is a bug that makes it dangerous to not provide at the time of this writing.**<br />**Note: If no conditions are added to this array, the interaction will fail, counterintuitively.** |
+
+**BlockMatcher Fields**
+
+| Field Name | Type                       | Required? | Notes                                                                          |
+| ---------- | -------------------------- | --------- | ------------------------------------------------------------------------------ |
+| Block      | `BlockIdMatcher`           | **No**    | If provided, requires the block itself match some set of conditions.           |
+| Face       | `BlockFace`                | **No**    | If provided and not 'None', requires a specific block face be targeted.        |
+| StaticFace | `Boolean` (Default: false) | **No**    | If false, the face condition will be adjusted by the block's current rotation. |
+
+**BlockFace Values**
+
+- `Up`
+- `Down`
+- `North`
+- `South`
+- `East`
+- `West`
+- `None`
+
+**BlockIdMatcher Fields**
+
+| Field Name | Type                                   | Required? | Notes                                                                      |
+| ---------- | -------------------------------------- | --------- | -------------------------------------------------------------------------- |
+| Id         | `Asset`<br />(Asset Type: `BlockType`) | **No**    | If provided, the block must match the specified `BlockType`.               |
+| State      | `String`                               | **No**    | If provided, the block's current state must match the provided state name. |
+| Tag        | `String`                               | **No**    | If provided, the block type's asset tags must contain the provided tag.    |
+
+### DestroyCondition
+
+This interaction fails if the current User entity cannot destroy the current target blcok.
+
+**DestroyCondition Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+
+### PlacementCountCondition
+
+This interaction accepts the name of a BlockType that has the TrackedPlacement BlockEntity. The interaction will fail if the number of
+blocks of the provided BlockType in the world do not match the provided condition.
+
+**PlacementCountCondition Fields**
+
+| Field Name | Type                           | Required? | Notes                                                                                                                                                                                                                                                           |
+| ---------- | ------------------------------ | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Block      | `String`                       | **Yes**   | The BlockType to examine. The number of instances of the BlockType in the world will be compared to Value.<br />**Note: The specified BlockType must have the TrackedPlacement BlockEntity. Otherwise, the number of blocks in the world will always be zero.** |
+| Value      | `Integer`<br />(Default: 0)    | **No**    | The value to compare the number of blocks in the world with.                                                                                                                                                                                                    |
+| LessThan   | \`Boolean<br />(Default: true) | **No**    | If true, the interaction will fail if the number of blocks in the world is greater than or equal to Value. If false, the interaction will fail if the number of blocks in the world is less than or equal to Value.                                             |
+
+### BreakBlock
+
+This interaction attempts to break the target block while acting as the User entity. The User entity must be a player. It
+is not guaranteed to work, depending on world settings and the User entity's current state, it may not work.  If it
+fails, it will fail the interaction under some circumstances, but not others.
+
+**Note: In particular, if `Harvest`=false and the player is in Survival mode, the player will simply execute a damage operation
+against the block. Even when the Tool field is specified, the player's currently-held item can impact the results in unintuitive
+ways.**
+
+This interaction will fail if there is no block target, if `Harvest`=true and the
+block is not harvestable, or if the world settings prevent the Harvest/Break operation.
+It will generally not fail otherwise, even if the block was not broken or damaged.
+The block will generally break every time if `Harvest`=true or the player is in
+Creative mode.
+
+**BreakBlock Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                                                                                                                                                                                                  |
+| ---------------- | ------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction.                                                                                                                                                                      |
+| Harvest          | `Boolean` (Default: false)      | **No**    | If true, harvest the block and deposit the drops in the player's inventory. This operation will generally always succeed.  If false, this interaction will effectively perform whatever action would have occurred if the player had left-clicked the block.                                           |
+| Tool             | `String`                        | **No**    | If `Harvest`=true, the player is in Survival mode, and this field is provided, then the break operation will be performed as though with this tool type.<br />**This field mostly doesn't work.  Your held item will be used for most block damage calculations regardless of this field's contents.** |
+| MatchTool        | `Boolean` (Default: false)      | **No**    | If true, `Harvest`=true, the player is in Survival mode, and `Tool` is provided, block breaking will be prevented unless `Tool` is a valid gathering tool for the target block. The interaction will not be failed, even if block breaking is prevented in this manner.                                |
+
+### ChangeBlock
+
+This interaction requires a mapping from one or more current BlockTypes to one or more target BlockTypes.  If the
+target block is one of the key BlockTypes, then it will be changed to the mapped target BlockType.  If the current
+BlockType of the target block does not appear as a key in the Changes field, then this interaction fails.
+
+**ChangeBlock Fields**
+
+| Field Name        | Type                                                        | Required? | Notes                                                                                                                             |
+| ----------------- | ----------------------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget  | `Boolean`<br />(Default: false)                             | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+| Changes           | `Map`<br />(Key Type: `BlockType`, Value Type: `BlockType`) | **No**    | A list of potential block type changes, with each entry having a current and new BlockType id.                                    |
+| WorldSoundEventId | `Asset`<br />(Asset Type: `SoundEvent`)                     | **No**    | If provided, this SoundEvent is played in the world at the position of the block if the block successfully changes.               |
+| RequireNotBroken  | `Boolean`<br />(Default: false)                             | **No**    | If true, this interaction will fail if the player's held item is broken (durability 0), and the block change will not take place. |
+
+### ChangeState
+
+This interaction requires a mapping from one or more current block state names to one or more state names. If the
+target block is in one of the key block states, then it will be changed to the mapped target blocks tate. If the
+current block state of the target block does nto appear as a key in the Changes field, then this interaction fails.
+
+All blocks start out with a null state by default.  This null state can be referenced by the key "default" and the block
+can be returned to that state with the value "default".
+
+**ChangeState Fields**
+
+| Field Name       | Type                                                  | Required? | Notes                                                                                                                                          |
+| ---------------- | ----------------------------------------------------- | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false)                       | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction.              |
+| Changes          | `Map`<br />(Key Type: `String`, Value Type: `String`) | **No**    | A list of potential block state changes, with each entry having a current and new state name.                                                  |
+| UpdateBlockState | `Boolean`<br />(Default: false)                       | **No**    | If true, performs a full refresh of the block's BlockEntity component and notifies nearby players as though a full block type change occurred. |
+
+### CycleBlockGroup
+
+This interaction will attempt to change the target block to the next block type in one of the BlockGroups it belongs to.
+If the block type belongs to multiple BlockGroups, which one is used is effectively arbitrary. The User entity must be
+a player. If the block cannot be changed for any reason (entity not a player, no block target, block does not belong
+to a BlockGroup, etc.). If the block is the only entry in the BlockGroup, this interaction will succeed and the block
+will be considered changed despite nothing happening.  Unlike most other block-changing interactions, this one will
+fail if the world settings prevent players from breaking blocks.
+
+**This interaction always reduces the player's held item's durability by a single 'hit' worth of damage if the block
+changes. There is no way to prevent it. The block type will change and the interaction will succeed even if the player's
+held item is broken, however.**
+
+**CycleBlockGroup Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+
+### DestroyBlock
+
+This interaction destroys the target block without dropping anything.  It will successfully destroy the block if the
+target block exists and this interaction has no failure conditions.
+
+**This interaction has no additional fields.**
+
+### PickBlock
+
+This interaction is effectively equivalent to using the middle mouse button in creative mode. In survival mode, the
+block's item will be moved to the user's current active hotbar slot if it is in the player's inventory.  This
+interaction is performed entirely on the client and cannot be performed by non-players.  It is unclear if this
+interaction has failure conditions.
+
+**PickBlock Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+
+### PlaceBlock
+
+This interaction is effectively identical to a right clicking while holding a block in their hand, with some
+additional options. For one, it can be executed with any LivingEntity as the User entity. For another, it has some
+useful fields.  For the most part, though, it follows the same behaviors and rules as any ordinary block placement
+by a player.
+
+It's not clear under what circumstances this interaction can fail. The server will not fail the interaction under any
+special circumstances (including when there is no target block, or when `BlockTypeToPlace` is not provided and the
+LivingEntity is not holding a block). However, the client is very involved with the function of this interaction and
+its behavior is unknown.
+
+**PlaceBlock Fields**
+
+| Field Name         | Type                                   | Required? | Notes                                                                                                                                                                                                                                                                                                                                                           |
+| ------------------ | -------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| BlockTypeToPlace   | `Asset`<br />(Asset Type: `BlockType`) | **No**    | If provided, the block placed by this interaction will be the specified BlockType. If not provided, the User entity's held item will be used, instead, if it is a block.                                                                                                                                                                                        |
+| RemoveItemInHand   | `Boolean`<br />(Default: True)         | **No**    | If true and the User entity is not a player in Creative mode, the item in the player's hand must match the block being placed and one quantity will be removed for each block placed. If the item does not match, the block cannot be placed.  If false, the player's hand item is ignored entirely.\*\*                                                        |
+| AllowDragPlacement | `Boolean`<br />(Default: True)         | **No**    | If true and the interaction was triggered on the client by a player, then the player can hold the input that was used to activate this interaction chain and move the mouse around in order to execute this interaction repeatedly and place several blocks. The interaction chain will not move onto the next interaction until the player releases the input. |
+
+### RunOnBlockTypes
+
+This interaction retrieves all blocks within a provided radius of the User entity. For each block that matches any of
+the provided BlockSets, a new interaction chain will be forked that uses the matching block as the target block.
+This interaction will continue executing until all forked interaction chains have completed.  The interaction will fail if no
+blocks within the radius match the provided BlockSets or if all of the forked interaction chains fail.
+
+**RunOnBlockTypes Fields**
+
+| Field Name   | Type                                         | Required?        | Notes                                                                                                                                                                                                                                                                                      |
+| ------------ | -------------------------------------------- | ---------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| Range        | `Integer`                                    | **Yes**          | The spherical radius around the User entity to search for blocks. Must be at least 1.                                                                                                                                                                                                      |
+| BlockSets    | `AssetArray`<br />(Element Type: `BlockSet`) | **No**           | A list of BlockSets to match nearby blocks again. Only blocks that match any of the BlockSets will have interaction chains forked for them.                                                                                                                                                |
+| MaxCount     | `Integer`                                    | **Yes**          | The maximum number of blocks that will be located with the search. Further blocks will be ignored. If there are more matching blocks within the radius than this number, the specific set of blocks that will be found is completely arbitrary and may change from execution to execution. |
+| Interactions | `Asset`<br />(Asset Type: `RootInteraction`) | **No, but yes.** | The RootInteraction that will be forked for each matching block.  This interaction will not fail to validate if it is missing, but every execution of this interaction will fail.                                                                                                          |
+
+### UseBlock
+
+If the target block has an interaction for this interaction chain's interaction type, execute it immediately as part of
+this interaction chain. The execution will be wrapped in UseBlockEvent.Pre and UseBlockEvent.Post events, and cancellations
+of the UserBlockEvent.Pre event are respected. The User entity is considered the triggering entity for both events.
+
+If the target block does not have an interaction for this interaction chain's interaction type, this interaction fails.
+
+**This interaction has no additional fields.**
+
+## Items
+
+These are interactions intended to interface with an entity's inventory. There is no concept of an "item target",
+unfortunately, so these generally either interact with the entity's held item or the entity's inventory at a high level.
+
+### AddItem
+
+Adds a specified quantity of a specified item to the User entity's inventory, preferring to add it to the
+entity's hotbar where possible. This interaction will have no effect on User entities that are not LivingEntities.
+This interaction has no failure states.
+
+**Note: This interaction has a bug in its field validators that will cause interactions that reference items declared
+in the same mod to fail validation on startup.  Additionally, this interaction has a bug that will cause it to
+fail and have no effect if the User entity has no block target. Use ModifyInventory instead.**
+
+**AddItem Fields**
+
+| Field Name       | Type                              | Required? | Notes                                                                                                                             |
+| ---------------- | --------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false)   | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+| ItemId           | `Asset`<br />(Asset Type: `Item`) | **Yes**   | The item id of the item to add to the player's inventory.                                                                         |
+| Quantity         | `Integer`<br />(Default: 0)       | **No**    | The quantity of the item to add to the player's inventory.                                                                        |
+
+### CheckUniqueItemUsage
+
+This interaction will check whether it has run once for the User entity with their currently-held item before. If it hasn't,
+it will succeed. If it has, it will fail. It will also fail if the User entity is not a player. The interaction will record
+the item id of the User entity's currently-held item on success, ensuring it cannot be successfully run with that player
+and item id combination again.
+
+**This interaction has no additional fields.**
+
+### ChangeActiveSlot
+
+This interaction does not inherit from SimpleInteraction and therefore has no Next or Failed fields.  The `CancelOnItemChange`
+field is ignored for this interaction and is always treated as false. This interaction will set the User entity's currently-
+active hotbar slot to the specified slot index. If none is specified, the interaction chain's target slot will be used,
+if any. Otherwise, slot 0 will be used.  If a slot is specified and it is already active, then this interaction will
+have no effect, but if no slot is specified and the interaction chain's target slot is already active, the logic in
+the next paragraph will still be executed. This interaction will also have no effect if the User entity is not a
+LivingEntity.
+
+Once the slot has changed, a new SwapTo interaction chain will be forked off for the selected slot.
+If a target slot was specified, then the interaction chain's current target slot will be set to the specified slot, as will
+the forked SwapTo interaction chain. If this interaction chain was initiated by a player swapping an item into or out of
+an occupied active hotbar slot, then the swap will be executed after the slot is changed and before the SwapTo
+interaction is forked. Not running this interaction in the resulting SwapFrom interaction chain is a way for the server
+to cancel players performing these sorts of swap interactions. The default behavior for these swap interactions is that
+the SwapFrom interaction chain will be initiated with the currently-active-slot as the target slot. As a result, the
+target slot will usually not change when this interaction runs, it merely exists as a signal for the server to continue the
+item swap.
+
+**ChangeActiveSlot Fields**
+
+| Field Name | Type      | Required? | Notes                                                                                                                                                                                                     |
+| ---------- | --------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| TargetSlot | `Integer` | **No**    | If not provided, indicates the slot the player's active hotbar slot should be changed to.  Otherwise, the interaction chain's target slot will be used (which is usually the already-active hotbar slot). |
+
+### EquipItem
+
+This interaction will equip the User entity's currently-held item into the appropriate armor slot, if it is armor. The
+interaction will fail if the item is armor but it cannot be equipped for some reason. The interaction will succeed but
+take no action if the User entity cannot equip armor or if the item is not armor.
+
+**This interaction has no additional fields.**
+
+### IncreaseBackpackCapacity
+
+This interaction will increase the User entity's backpack size by the provided amount.  **It will additionally remove one
+quantity from the player's currently-held item. There is no way to prevent this.**  This interaction will have no effect
+if the User entity is not a player.  This interaction has no special failure conditions, even if the User entity
+is not a player, or the player is not currently holding an item.
+
+| Field Name | Type                        | Required? | Notes                                                                                   |
+| ---------- | --------------------------- | --------- | --------------------------------------------------------------------------------------- |
+| Capacity   | `Integer`<br />(Default: 1) | **No**    | The additional backpack capacity to add to the player. **Must be between 1 and 32767.** |
+
+### ModifyInventory
+
+This interaction attempts to perform one or more inventory-modifying actions against the User entity. The User entity must
+be a player. If they are not, no actions will be performed, but the interaction will not fail. Any item removals performed
+by this interaction, either as a result of `ItemToRemove` or `AdjustHeldItemQuantity`, are both atomic (meaning the entire
+quantity must be removed, or none) and required (meaning that the interaction will fail and no further actions taken if
+the removal fails for any reason).  Item additions performed by this interaction, either as a result of `ItemToAdd` or
+`AdjustHeldItemQuantity` will drop excess items on the ground near the player if necesary and continue on.
+
+This interaction first executes the item removal in `ItemToRemove`, if any, then adjusts the held item as specified by
+`AdjustHeldItemQuantity`, if provided, then executes the item addition in `ItemToAdd`, if any, and then finally executes
+the damage/healing of the held item in `AdjustHeldItemDurability`, if provided.
+
+**ModifyDurability Fields**
+
+| Field Name               | Type                            | Required? | Notes                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
+| ------------------------ | ------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| RequiredGameMode         | `GameMode`                      | **No**    | If provided, only execute the inventory-modifying actions if the player is in the provided GameMode. The interaction will not fail if the GameMode doesn't match.                                                                                                                                                                                                                                                                                                                                                                               |
+| ItemToRemove             | `ItemStack`                     | **No**    | If provided, a matching item will be removed in the provided quantity. If there is no matching item in the player inventory in the required quantity, then the interaction will fail and further actions will not be executed.                                                                                                                                                                                                                                                                                                                  |
+| AdjustHeldItemQuantity   | `Integer`<br />(Default: 0)     | **No**    | The player's held item, if any, will have its quantity will be modified by the provided amount- subtracted from if this number is negative or added to if this item is positive.  If the player has no held item, then this field will have no effect regardless of its value and the interaction will NOT fail.  If the player's inventory does not have sufficient quantity of items to support the removal, this interaction will fail and further actions will not be executed. Excess items will be dropped on the ground near the player. |
+| ItemToAdd                | `ItemStack`                     | **No**    | If provided, the ItemStack will be added to the player's inventory. Excess items will be dropped on the ground near the player.                                                                                                                                                                                                                                                                                                                                                                                                                 |
+| AdjustHeldItemDurability | `Double`<br />(Default: 0.0)    | **No**    | The player's held item, if any, will have its durability adjusted by the specified amount.  The durability cannot go below 0 or raise above the item's maximum durability. Invalid durability values in this field will not cause the interaction to fail. Neither will it fail if the player has no held item.                                                                                                                                                                                                                                 |
+| BrokenItem               | `String`                        | **No**    | This field should contain an ItemId, but it is not validated by the server on startup, so be careful.  This field can have the value of "Empty" to specify no item, or an empty hand. If specified and the `AdjustHeldItemDurability` operation reduces the player's held item to 0 durability, the player's held item is changed to this ItemId. If the inventory replacement fails, this interaction will fail.                                                                                                                               |
+| NotifyOnBreak            | `Boolean`<br />(Default: false) | **No**    | If true and the `AdjustHeldItemDurability` operation reduces the player's held item to 0 durability, this interaction will perform the usual audiovisual feedback of a broken tool. It will play the usual tool breaking sound and send the player a text message in chat that their item has broken.                                                                                                                                                                                                                                           |
+| NotifyOnBreakMessage     | `String`                        | **No**    | If provided, and `NotifyOnBreak` is true, when the player is notified of a broken tool by this interaction, the message sent to their chat will instead be the translation key specified by this field. The translation key supports the templating parameter `{itemName}`. See the translation key `server.general.repair.itemBroken_Hoe` for an example.                                                                                                                                                                                      |
+
+**GameMode Values**
+
+- `Creative`: The game is currently in Creative Mode
+- `Adventure`: The game is currently in Adventure Mode
+
+**ItemStack Fields**
+
+| Field Name                   | Type                              | Required? | Notes                                                                                |
+| ---------------------------- | --------------------------------- | --------- | ------------------------------------------------------------------------------------ |
+| Id                           | `Asset`<br />(Asset Type: `Item`) | **Yes**   | The id of the Item asset this stack contains.                                        |
+| Quantity                     | `Integer`<br />(Default: 1)       | **No**    | The number of items in this stack.<br />**Must be greater than 0.**                  |
+| Durability                   | `Double`<br />(Default: 0.0)      | **No**    | The durability of the item stack.<br />**Cannot be negative.**                       |
+| MaxDurability                | `Double`<br />(Default: 0.0)      | **No**    | The maximum durability of the item this stack contains.<br />**Cannot be negative.** |
+| Metadata                     | `Bson Document`                   | **No**    | If provided, applies the bson to the item stack metadata.                            |
+| OverrideDroppedItemAnimation | `Boolean`\*(Default: false)       | **No**    | ???                                                                                  |
+
+### PickupItem
+
+This interaction will attempt to pick up the User entity's current target entity and add it to their inventory. It will
+fail if the User entity is not a player, if they do not have a target entity, or if the target entity is not an item
+located in the world.  It will not fail if the player simply cannot pick up the item.
+
+**This interaction has no additional fields.**
+
+### RefillContainer
+
+This interaction will fail if the User entity is not a player. The interaction will draw a ray from the player's head
+down their look direction until the edge of the player's held item's interaction range or until the first solid block.
+The nearest fluid block of a type listed in this interaction's `States` map will result in the one of the player's
+currently-held items being converted to the fluid's related item state.  If the `States` map indicates a durability
+for the new item state, then the converted item will use that durability. If the item is already in the fluid's related
+item state, then this interaction will fail if the player's held item is already at maximum durability (unless the
+`States` map indicates a durability value greater than the item's maximum, in which case the interaction will succeed
+but the item will not change).  Otherwise, the durability listed for the fluid in the `States` map will be added to the
+item's current durability.
+
+If the interaction has not failed by this point, the fluid block in the world may be transformed to a different type if one is listed
+in the `States` map.
+
+If any part of this process does not proceed for any reason (for instance, if the player is not holding an item),
+then this interaction will fail.
+
+**RefillContainer Fields**
+
+| Field Name | Type                                                       | Required? | Notes                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| ---------- | ---------------------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| States     | `Map`<br />(Key Type: `String`, Value Type: `RefillState`) | **Yes**   | A map from item state names to `RefillState` objects, which contain information such as acceptable fluid block types, durability increases, and what fluid type to convert the targeted fluid block to after refill, if any. If the player targets a fluid block that matches one of the fluid types in the `RefillState`, the item will be converted to the keyed item state and the `RefillState` will be used to decide what happens next. |
+
+**RefillState Fields**
+
+| Field Name     | Type                                  | Required? | Notes                                                                                                                                                                                                                                                                                                                           |
+| -------------- | ------------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| AllowedFluids  | `Array`<br />(Element Type: `String`) | **Yes**   | If any of these fluids are targeted by the player, the player's held item will be converted to the keyed item state and `Durability` and `TransformFluid` will be used.                                                                                                                                                         |
+| Durability     | `Double`<br />(Default: -1.0)         | **No**    | If the player's held item changes item states, this value is the new item's durability, unless it is negative, in which case the item will begin at full durability. If the player's held item is already in the item state, and the item is not already at full durability, this value will be added to the item's durability. |
+| TransformFluid | `String`                              | **No**    | If provided, this field is a fluid id that the targeted fluid block should be transformed to if the player's held item is successfully updated.                                                                                                                                                                                 |
+
+## Entities
+
+### DamageEntity
+
+This interaction does not inherit from SimpleInteraction, but adds its own Next and Failed fields that
+work similarly.
+
+This interaction will cause the User entity to damage the Target entity.  It has the capability to apply different
+damage based on the direction of the attack or what body part was targeted by the User entity, with each possibility
+providing different damage calculations, effects, and Next interaction. If multiple entires match the attack, `TargetedDamage`
+(body part damage) takes highest priority, then the first matching `AngledDamage` in the list, then the default
+damage in the base interaction fields.  It is possible for elements of these different damage priorities to be taken peacemeal if higher-priority
+damage fields do not overwrite lower-priority damage fields. For instance,
+damage calculation could be taken from `TargetedDamage`, the damage effects could be taken from the first matching
+`AngledDamage`, and the Next interaction coming from the default damage field.
+
+If all damage dealt by this interaction is cancelled, then this interaction will fail, and the `Failed` interaction
+will be executed next in the chain. If any damage dealt by this interaction is blocked, then this interaction will
+succeed, but the `Blocked` interaction wil lbe executed next in the chain. Otherwise, the highest-precedent matching
+`Next` interaction that you provide will be executed.  For instance, if you provide `Next` interactions for all
+`TargetedDamage` and `AngledDamage` entries, and one in the interaction's `Next` field, then a headshot could result
+in a unique `Next` interaction being executed, even if there is a matching `AngledDamage` entry. However, if you leave
+the `Next` interaction out of your `TargetedDamage` entries, a special `Next` interaction for backstabs could be
+executed.  Otherwise, the `Next` field in the root of the interaction will be executed instead.
+
+DamageEntity has an unusual relationship with `RunTime`. This interaction always ends immediately after its first tick,
+regardless of the status of `RunTime` or `WaitForAnimationToFinish`.  However, if damage dealt by this interaction is
+calculated as `DamageCalculatorType` `Dps`, then the `RunTime` will be used to determine the precise amount of damage to
+deal. If `RunTime` is 0, then no damage will be dealt.
+
+**DamageEntity Fields**
+
+| Field Name       | Type                                                          | Required?                                                                                                                    | Notes                                                                                                                                                                                                                                                                                                                                                                         |
+| ---------------- | ------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| DamageCalculator | `DamageCalculator`                                            | **No**                                                                                                                       | If provided, describes the damage amounts and types to apply to the Target entity.                                                                                                                                                                                                                                                                                            |
+| DamageEffects    | `DamageEffects`                                               | **No**                                                                                                                       | If provided, describes particles, sounds, knockback, etc. to apply to the target entity on damage.                                                                                                                                                                                                                                                                            |
+| Next             | `Asset`<br />(Asset Type: `Interaction`)                      | **No**  After this interaction has finished, "Next" will be executed if damage was dealt to the target and none was blocked. |                                                                                                                                                                                                                                                                                                                                                                               |
+| AngledDamage     | `Array`<br />(Element Type: `AngledDamage`)                   | **No**                                                                                                                       | If provided, allows alternative `DamageCalculator`, `DamageEffects`, and `Next` entries for attacks that approach the target from certain angles.                                                                                                                                                                                                                             |
+| TargetedDamage   | `Map`<br />(Key Type: `String`, Value Type: `TargetedDamage`) | **Yes**                                                                                                                      | This field must be provided, but is not required to have any entries.  This is a map from body part names to `TargetedDamage` values. Hypixel only uses one body part name: `Head`, and it is not clear whether there are others.  If provided, allows alternative `DamageCalculator`, `DamageEffects`, and `Next` entries for attacks that damage specific enemy body parts. |
+| EntityStatsOnHit | `Array`<br />(Element Type: `EntityStatOnHit`)                | **No**                                                                                                                       | If provided, allows this attack to reduce enemy stats other than health.  Each individual damage application dealt by the same ability will apply stat reductions, at diminishing returns. All damage dealt in interaction chains forked by a Selector interaction will share the number of hits across all targets.                                                          |
+| Failed           | `Asset`<br />(Asset Type: `Interaction`)                      | **No**                                                                                                                       | After this interaction has finished, "Failed" will be executed if no damage hits were applied to the player, or if all damage hits were cancelled.                                                                                                                                                                                                                            |
+| Blocked          | `Asset`<br />(Asset Type: `Interaction`)                      | **No**                                                                                                                       | After this interaction has finished, "Blocked" will be executed if any damage hits were blocked by the target.                                                                                                                                                                                                                                                                |
+
+**DamageCalculator Fields**
+
+| Field Name                | Type                                                      | Required? | Notes                                                                                                                                                                                                                                                 |
+| ------------------------- | --------------------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Type                      | `DamageCalculatorType`<br />(Default: Absolute)           | **No**    | Whether the damage being applied is `Absolute` or \`Dps'.                                                                                                                                                                                             |
+| Class                     | `DamageClass`<br />(Default: Unknown)                     | **No**    | The type of attack producing the damage. Some weapon systems apply equipment modifiers based on this value.                                                                                                                                           |
+| BaseDamage                | `Map`<br />(Key Type: `DamageCause`, Value Type: `Float`) | **No**    | A set of DamageCauses and how much base damage is dealt for each.                                                                                                                                                                                     |
+| SequentialModifierStep    | `Float`<br />(Default: 0.0)                               | **No**    | Value between 0.0-1.0. Each additional hit from a single ability will have its damage reduced by this much as a percentage. All damage dealt in interaction chains forked by a Selector interaction will share the number of hits across all targets. |
+| SequentialModifierMinimum | `Float`<br />(Default: 0.0)                               | **No**    | Value between 0.0-1.0. `SequentialModifierStep` cannot reduce damage below this percentage regardless of the number of hits.                                                                                                                          |
+| RandomPercentageModifier  | `Float`<br />(Default: 0.0)                               | **No**    | A random value between +/- this amount multiplied by the base damage will be added to the base damage.                                                                                                                                                |
+
+**DamageEffects Fields**
+
+| Field Name             | Type                                         | Required? | Notes                                                                                   |
+| ---------------------- | -------------------------------------------- | --------- | --------------------------------------------------------------------------------------- |
+| ModelParticles         | `Array`<br />(Element Type: `ModelParticle`) | **No**    | Particle systems to trigger in the first-person view.                                   |
+| WorldParticles         | `Array`<br />(Element Type: `WorldParticle`) | **No**    | Particle systems to trigger in the third-person view.                                   |
+| LocalSoundEventId      | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | 2D sound to play locally to the attacking entity if they are a player.                  |
+| WorldSoundEventId      | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | Sound to play in the world at the Target entity's location.                             |
+| PlayerSoundEventId     | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | 2D sound to play locally to the Target entity if they are a player.                     |
+| ViewDistance           | `Double`<br />(Default: 75.0)                | **No**    | Distance at which these effects should play for other players.                          |
+| Knockback              | `Knockback`                                  | **No**    | The properties of the knockback that will be applied.                                   |
+| CameraEffect           | `Asset`<br />(Asset Type: `CameraEffect`)    | **No**    | CameraEffect to briefly apply locally to the Target entity if they are a player.        |
+| StaminaDrainMultiplier | `Float`<br />(Default: 1.0)                  | **No**    | This multiplier is applied to the stamina cost incurred by the target blocking, if any. |
+
+**AngledDamage Fields**
+
+| Field Name       | Type                                     | Required? | Notes                                                                                                                                                                                                     |
+| ---------------- | ---------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| AngleDistance    | `Float`<br />(Default: 0)                | **No**    | The width in degrees of the matching arc around the Target entity. If the attack against the Target originates from within the arc, then the properties below will be applied to the attack, if provided. |
+| Angle            | `Float`<br />(Default: 0.0)              | **No**    | The angle in degrees around the Target entity at which the matching arc is centered.                                                                                                                      |
+| DamageCalculator | `DamageCalculator`                       | **No**    | If provided and the attack against the Target entity originates from within the provided arc, this DamageCalculator will override the interaction's `DamageCalculator` field.                             |
+| DamageEffects    | `DamageEffects`                          | **No**    | If provided and the attack against the Target entity originates from within the provided arc, this DamageEffects will override the interaction's `DamageEffects` field.                                   |
+| Next             | `Asset`<br />(Asset Type: `Interaction`) | **No**    | If provided and the attack against the Target entity originates from within the provided arc, this Interaction will override the interaction's `Next` field.                                              |
+
+**TargetedDamage Fields**
+
+| Field Name       | Type                                     | Required? | Notes                                                                                                                                                                                            |
+| ---------------- | ---------------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| DamageCalculator | `DamageCalculator`                       | **No**    | If provided and this TargetedDamage was matched, this DamageCalculator will override the interaction's `DamageCalculator` field and the `DamageCalculator` field of any matching `AngledDamage`. |
+| DamageEffects    | `DamageEffects`                          | **No**    | If provided and this TargetedDamage was matched, this DamageEffects will override the interaction's `DamageEffects` field and the `DamageEffects` field of any matching `AngledDamage`.          |
+| Next             | `Asset`<br />(Asset Type: `Interaction`) | **No**    | If provided and this TargetedDamage was matched, this Interaction will override the interaction's `Next` field and the `Next` field of any matching `AngledDamage`.                              |
+
+**EntityStatOnHit Fields**
+
+| Field Name                  | Type                                                                       | Required? | Notes                                                                                                                                                                                                                                                                                        |
+| --------------------------- | -------------------------------------------------------------------------- | --------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| EntityStatId                | `Asset`<br />(AssetType: `EntityStatType`)                                 | **Yes**   | Which entity stat to affect.                                                                                                                                                                                                                                                                 |
+| Amount                      | `Float`<br />(Default: 0.0)                                                | **No**    | How much of the stat to apply for each damage application. Use negative numbers to reduce stats.                                                                                                                                                                                             |
+| MultipliersPerEntitiesHit   | `Array`<br />(Element Type: `Float`, Default: `[1.0, 0.6, 0.4, 0.2, 0.1]`) | **No**    | The diminishing returns curve to be applied for multiple damage applications by the same ability. Each hit's stat impact will be multiplied by the next value in the list.  If there are more hits than array elements, subsequent hits will be multiplied by `MultiplierPerExtraEntityHit`. |
+| MultiplierPerExtraEntityHit | `Float`<br />(Default: 0.05)                                               | **No**    | If an ability carries out more damage applications than there are elements in the `MultipliersPerEntitiesHit` array, then subsequent stat values will be multiplied by this number.                                                                                                          |
+
+**Knockback Fields**
+
+| Field Name     | Type                                       | Required? | Notes                                                                                                                      |
+| -------------- | ------------------------------------------ | --------- | -------------------------------------------------------------------------------------------------------------------------- |
+| Type           | `String`                                   | **No**    | If provided, specifies a type of knockback to use. Each Target type may come with additional fields.                       |
+| Force          | `Double`<br />(Default: 0.0)               | **No**    | The amount of force to apply to the Owner entity.                                                                          |
+| Duration       | `Double`<br />(Default: 0.0)               | **No**    | If 0.0, apply the force as a single impulse.  If more, continuously apply the force over a period of time.                 |
+| VelocityType   | `ChangeVelocityType`<br />(Default: `Add`) | **No**    | How to apply the force, either adding it to the entity's current velocity, or setting the velocity to the knockback force. |
+| VelocityConfig | `VelocityConfig`                           | **No**    | Characteristics of friction as the Owner entity is thrown by this knockback.                                               |
+
+**Knockback Type: Force**
+
+Apply the calculated knockback force along the provided direction.
+
+| Field Name | Type                         | Required? | Notes                                                                                |
+| ---------- | ---------------------------- | --------- | ------------------------------------------------------------------------------------ |
+| Direction  | `Vector3`<br />(Default: Up) | **No**    | Which direction the entity should be flung, relative to the direction of the attack. |
+
+**Knockback Type: Point**
+
+Apply the calculated knockback force laterally along the XZ plane, plus provided Y velocity.
+
+| Field Name | Type                        | Required? | Notes                                                                                                   |
+| ---------- | --------------------------- | --------- | ------------------------------------------------------------------------------------------------------- |
+| OffsetX    | `Integer`<br />(Default: 0) | **No**    | Offset the source position of the knockback left or right perpendicular to the direction of the attack. |
+| OffsetZ    | `Integer`<br />(Default: 0) | **No**    | Offset the source position of the knockback, forward or backward along the directon of the attack.      |
+| RotateY    | `Integer`<br />(Default: 0) | **No**    | Rotate the knockback direction around the Y axis, where 0 is the default attack direction.              |
+| VelocityY  | `Float`<br />(Default: 0.0) | **No**    | Add vertical velocity to the knockback force after the direction and force has been calculated.         |
+
+**Knockback Type: Directional**
+
+Apply the calculated knockback force along the attack direction, removing any vertical component and replacing it with a provided Y velocity.
+
+| Field Name | Type                      | Required? | Notes                                                                                                                                            |
+| ---------- | ------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------ |
+| RelativeX  | `Float`<br />(Default: 0) | **No**    | Apply additional force left or right perpendicular to the direction of the attack. The additional force is multiplied by the knockback strength. |
+| RelativeZ  | `Float`<br />(Default: 0) | **No**    | Apply additional force forward or backward along the attack direction. The additional force is multiplied by the knockback strength.             |
+| VelocityY  | `Float`<br />(Default: 0) | **No**    | Replace the vertical velocity of the knockback with this value.  This value is not multiplied by knockback strength.                             |
+
+**VelocityConfig Fields**
+
+| Field Name          | Type                                              | Required? | Notes                                                                                                                                                                                           |
+| ------------------- | ------------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| GroundResistance    | `Float`<br />(Default: 0.82)                      | **No**    | The minimum amount of friction applied when the entity is in contact with the ground.  1.0 = no friction, 0.0 = total friction                                                                  |
+| GroundResistanceMax | `Float`<br />(Default: 0.0)                       | **No**    | The maximum amount of friction applied when the entity is in contact with the ground.  1.0 = no friction, 0.0 = total friction                                                                  |
+| AirResistance       | `Float`<br />(Default: 0.96)                      | **No**    | The minimum amount of friction applied when the entity is in the air. 1.0 = no friction, 0.0 = total friction                                                                                   |
+| AirResistanceMax    | `Float`<br />(Default: 0.0)                       | **No**    | The maximum amount of friction applied when the entity is in the air. 1.0 = no friction, 0.0 = total friction                                                                                   |
+| Threshold           | `Float`<br />(Default: 1.0)                       | **No**    | The speed at which the maximum amount of friction will be applied to the entity. The amount of friction applied will increase from minimum to maximum as the entity moves from 0 to this speed. |
+| Style               | `VelocityThresholdStyle`<br />(Default: `Linear`) | **No**    | The curve that friction follows as the entity's speed increases toward the `Threshold`.                                                                                                         |
+
+**DamageCalculatorType Values**
+
+- `Absolute`
+- `Dps`
+
+**DamageClass Values**
+
+- `Unknown`
+- `Light`
+- `Charged`
+- `Signature`
+
+**ChangeVelocityType Values**
+
+- `Add`
+- `Set`
+
+**VelocityThresholdStyle Values**
+
+- `Linear`
+- `Exp`
+
+### LaunchProjectile
+
+This is just a worse version of Projectile and is slated to be removed.  Use Projectile.
+
+### Projectile
+
+This interaction will spawn a new projectile at the User entity's eye position that will travel in its look direction.
+
+| Field Name | Type                                          | Required? | Notes                                                  |
+| ---------- | --------------------------------------------- | --------- | ------------------------------------------------------ |
+| Config     | `Asset`<br />(Asset Type: `ProjectileConfig`) | **No**    | Configuration describing the projectile to be spawned. |
+
+### RemoveEntity
+
+Despawns the specified entity from the world. This interaction will have no effect if the specified entity is a player. This
+interaction has no special failure conditions.
+
+| Field Name | Type                                     | Required? | Notes                  |
+| ---------- | ---------------------------------------- | --------- | ---------------------- |
+| Entity     | `InteractionTarget`<br />(Default: User) | **No**    | The entity to despawn. |
+
+**InteractionTarget Values**
+
+- `User` - The user of this interaction chain. The entity whose actions caused this interaction chain to be executed. This is usually the same as the Owner.
+- `Owner` - The owner of this interaction chain. The entity upon whom this interaction chain is executing.
+- `Target` - The entity target of this interaction chain, if any.  This value is mutable (and can therefore come from many places) but most commonly, it is an entity the User was targeting when this interaction chain began executing.
+
+### SendMessage
+
+This interaction sends a message to the Owner entity if that entity can receive messages.  Otherwise, the message
+is written to the server logs.  If the entity is a player, the message will appear in the player's chat window.
+
+\*\*SendMessage
+
+| Field Name | Type     | Required? | Notes                                                                                                                 |
+| ---------- | -------- | --------- | --------------------------------------------------------------------------------------------------------------------- |
+| Message    | `String` | **No**    | A text message to be sent to the Owner entity.  If this field is not provided, `Key` is used instead.                 |
+| Key        | `String` | **No**    | A translation key for a message to be sent to the Owner entity. If `Message` is provided, then this field is ignored. |
+
+### UseEntity
+
+This interaction is not in use by Hypixel and has some unusual qualities that mean it probably won't do what you want it
+to.  Do not use it.
+
+This interaction will retrieve the entity currently targeted by the client (NOT the interaction chain's current Target
+entity) and execute that entity's RootInteraction for this interaction chain's current interaction type. The
+RootInteraction will be executed as part of this current interaction chain. None of the properties of this interaction
+chain will be modified.
+
+This interaction will fail if the client is not currently targeting an entity, or if no interaction for the current
+interaction type exists on the entity.
+
+## Stats
+
+Hytale's resource system has been written about fairly extensively.  You can use these interactions to modify stats in
+response to actions or use stats as a cost for abilities.
+
+### ChangeStat
+
+This interaction applies a set of raw stat changes to the User entity. It has no special failure conditions.
+
+| Field Name    | Type                                                         | Required? | Notes                                                                                                                                                                                                                      |
+| ------------- | ------------------------------------------------------------ | --------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| StatModifiers | `Map`<br />(Key Type: `EntityStatType`, Value Type: `Float`) | **Yes**   | A set of stats to modify and what value to apply to them.                                                                                                                                                                  |
+| ValueType     | `ValueType`<br />(Default: Absolute)                         | **No**    | Whether the values in the `StatModifiers` map represent flat values to apply to the stat total, or percentages (0.0-100.0). Percentage values are percentage of the difference between the maximum and minimum stat value. |
+| Behaviour     | `ChangeStatBehavior`<br />(Default: Add)                     | **No**    | Whether the values in the `StatModifiers` map represent deltas to add into the User entity's current stat values, or fixed values to set the entity's stats to.                                                            |
+
+**ValueType Values**
+
+- `Absolute`
+- `Percent`
+
+**ChangeStatBehaviour Values**
+
+- `Add`
+- `Set`
+
+### ChangeStatWithModifier
+
+This interaction is like ChangeStat, except an armor stat modifier can be chosen which will apply bonuses and penalties
+to a stat from the User entity's equipped armor before it is applied.
+
+| Field Name            | Type                                                         | Required? | Notes                                                                                                                                                                                                                      |
+| --------------------- | ------------------------------------------------------------ | --------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| StatModifiers         | `Map`<br />(Key Type: `EntityStatType`, Value Type: `Float`) | **Yes**   | A set of stats to modify and what value to apply to them.                                                                                                                                                                  |
+| ValueType             | `ValueType`<br />(Default: Absolute)                         | **No**    | Whether the values in the `StatModifiers` map represent flat values to apply to the stat total, or percentages (0.0-100.0). Percentage values are percentage of the difference between the maximum and minimum stat value. |
+| Behaviour             | `ChangeStatBehavior`<br />(Default: Add)                     | **No**    | Whether the values in the `StatModifiers` map represent deltas to add into the User entity's current stat values, or fixed values to set the entity's stats to.                                                            |
+| InteractionModifierId | `InteractionModifierId`                                      | **Yes**   | The armor interaction modifier to apply bonuses and penalties for.                                                                                                                                                         |
+
+**ValueType Values**
+
+- `Absolute`
+- `Percent`
+
+**ChangeStatBehaviour Values**
+
+- `Add`
+- `Set`
+
+**InteractionModifierId Values**
+
+- `Dodge`
+
+### StatsCondition
+
+This interaction will fail if the User entity cannot afford the specified stats costs, or if it does not have the
+requested stats.
+
+| Field Name | Type                                                         | Required? | Notes                                                                                                                                                                                    |
+| ---------- | ------------------------------------------------------------ | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Costs      | `Map`<br />(Key Type:` EntityStatType`, Value Type: `Float`) | **Yes**   | A set of costs that the User entity needs to be able to afford for this interaction to succeed.                                                                                          |
+| ValueType  | `ValueType`<br />(Default: Absolute)                         | **No**    | Whether the values in the `Costs` map represetn flat values or percentages (0.0-100.0).  Percentage values are percentage of the difference between the maximum and minimum value.       |
+| LessThan   | `Boolean`<br />(Default: false)                              | **No**    | If true, this interaction will fail unless the User entity's current stat values are at or **below** the specified levels.  If false, they must be at or **above** the specified levels. |
+| Lenient    | `Boolean`<br />(Default: false)                              | **No**    | If true and `LessThan` is true, and a player's minimum stat value is below zero, then the player can afford a stat cost if the current value of a stat if above 0.                       |
+
+**ValueType Values**
+
+- `Absolute`
+- `Percent`
+
+### StatsConditionWithModifier
+
+This interaction is like StatsCondition, except an armor stat modifier can be chosen which will apply bonuses and penalties
+to a stat's cost from the User entity's equipped armor before it is compared.
+
+| Field Name            | Type                                                         | Required? | Notes                                                                                                                                                                                    |
+| --------------------- | ------------------------------------------------------------ | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Costs                 | `Map`<br />(Key Type:` EntityStatType`, Value Type: `Float`) | **Yes**   | A set of costs that the User entity needs to be able to afford for this interaction to succeed.                                                                                          |
+| ValueType             | `ValueType`<br />(Default: Absolute)                         | **No**    | Whether the values in the `Costs` map represetn flat values or percentages (0.0-100.0).  Percentage values are percentage of the difference between the maximum and minimum value.       |
+| LessThan              | `Boolean`<br />(Default: false)                              | **No**    | If true, this interaction will fail unless the User entity's current stat values are at or **below** the specified levels.  If false, they must be at or **above** the specified levels. |
+| Lenient               | `Boolean`<br />(Default: false)                              | **No**    | If true and `LessThan` is true, and a player's minimum stat value is below zero, then the player can afford a stat cost if the current value of a stat if above 0.                       |
+| InteractionModifierId | `InteractionModifierId`                                      | **Yes**   | The armor interaction modifier to apply bonuses and penalties for.                                                                                                                       |
+
+**ValueType Values**
+
+- `Absolute`
+- `Percent`
+
+**InteractionModifierId Values**
+
+- `Dodge`
+
+## EntityEffects
+
+EntityEffects are buff or debuff effects that can be applied to a LivingEntity.  These can have a variety of effects from
+movement speed changes to periodic damage.
+
+### EffectCondition
+
+This interaction will fail if the specified entity's EntityEffects do not match the provided conditions.
+
+**EffectCondition Fields**
+
+| Field Name      | Type                                             | Required? | Notes                                                                                                                                                                                                             |
+| --------------- | ------------------------------------------------ | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Entity          | `InteractionTarget`<br />(Default: User)         | **Yes**   | The entity to examine for EntityEffects. This field can indicate the Owner, User, or Target of this interaction chain.                                                                                            |
+| Match           | `Match`<br />(Default: All)                      | **No**    | If `All`, then this interaction will fail if any EntityEffect in the `EntityEffectIds` is not on the specified entity. If `None`, then this interaction will fail if any EntityEffect IS on the specified entity. |
+| EntityEffectIds | `AssetArray`<br />(Element Type: `EntityEffect`) | **Yes**   | The set of EntityEffects to check against the specified entity and `Match`.                                                                                                                                       |
+
+**InteractionTarget Values**
+
+- `User` - The user of this interaction chain. The entity whose actions caused this interaction chain to be executed. This is usually the same as the Owner.
+- `Owner` - The owner of this interaction chain. The entity upon whom this interaction chain is executing.
+- `Target` - The entity target of this interaction chain, if any.  This value is mutable (and can therefore come from many places) but most commonly, it is an entity the User was targeting when this interaction chain began executing.
+
+**Match Values**
+
+- `All` - All EntityEffects must be on the specified entity for this interaction to succeed.
+- `None` - None of the EntityEffects must be on the specified entity for this interaction to succeed.
+
+### ApplyEffect
+
+This interaction will apply the specified EntityEffect to the specified Entity.  It has no special failure conditions.
+
+**ApplyEffect Fields**
+
+| Field Name | Type                                      | Required? | Notes                                                                                                                  |
+| ---------- | ----------------------------------------- | --------- | ---------------------------------------------------------------------------------------------------------------------- |
+| Entity     | `InteractionTarget`<br />(Default: User)  | **Yes**   | The entity to apply the EntityEffect to. This field can indicate the Owner, User, or Target of this interaction chain. |
+| EffectId   | `Asset`<br />(Asset Type: `EntityEffect`) | **Yes**   | The effect to apply.                                                                                                   |
+
+**InteractionTarget Values**
+
+- `User` - The user of this interaction chain. The entity whose actions caused this interaction chain to be executed. This is usually the same as the Owner.
+- `Owner` - The owner of this interaction chain. The entity upon whom this interaction chain is executing.
+- `Target` - The entity target of this interaction chain, if any.  This value is mutable (and can therefore come from many places) but most commonly, it is an entity the User was targeting when this interaction chain began executing.
+
+### ClearEntityEffect
+
+This interaction will remove the specified EntityEffect from the specified Entity. It has no special failure conditions.
+It will not fail if the Entity does not have the EntityEffect.
+
+**ClearEntityEffect Fields**
+
+| Field Name | Type                                      | Required? | Notes                                                                                                                     |
+| ---------- | ----------------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------- |
+| Entity     | `InteractionTarget`<br />(Default: User)  | **Yes**   | The entity to remove the EntityEffect from. This field can indicate the Owner, User, or Target of this interaction chain. |
+| EffectId   | `Asset`<br />(Asset Type: `EntityEffect`) | **Yes**   | The effect to remove.                                                                                                     |
+
+**InteractionTarget Values**
+
+- `User` - The user of this interaction chain. The entity whose actions caused this interaction chain to be executed. This is usually the same as the Owner.
+- `Owner` - The owner of this interaction chain. The entity upon whom this interaction chain is executing.
+- `Target` - The entity target of this interaction chain, if any.  This value is mutable (and can therefore come from many places) but most commonly, it is an entity the User was targeting when this interaction chain began executing.
+
+## Farming
+
+These are interaction types built to support the in-game farming system in Hytale. They are mostly block-related interactions
+with a few exceptions.
+
+### ChangeFarmingStage
+
+If the target block is a farming block, this interaction will attempt to modify the current farming stage in one of
+three ways.  The interaction can optionally specify which StageSet to use for the new stage. If it is not specified,
+the current StageSet will be used. If any part of the the process of changing the growth stage fails, this interaction
+will fail, with the one exception that attempting to set the stage to the crop's existing stage will have no effect but
+still succeed.
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                                                                                                                                                                          |
+| ---------------- | ------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction.                                                                                                                                              |
+| StageSet         | `String`                        | **No**    | If provided, set the block's current stage to one in the provided StageSet. Otherwise, use the crop's current StageSet.                                                                                                                                                        |
+| Increase         | `Integer`                       | **No**    | If provided, increase the current stage by the specified amount. If the specified stage does not exist, the block will be set to the closest extant stage.                                                                                                                     |
+| Decrease         | `Integer`                       | **No**    | If provided and `Increase` is not provided, decrease the current stage by the specified amount. If the specified stage does not exist, the block will be set to the closest extant stage.                                                                                      |
+| Stage            | `Integer`<br />(Default: -1)    | **No**    | If provided and `Increase`/`Decrease` are not provided, set the current stage to the specified stage. If this value is less than 0, set the current stage to the final growth stage. If the specified stage does not exist, the block will be set to the closest extant stage. |
+
+### FertilizeSoil
+
+If the target block is unfertilized tilled soil or a farming block on top of unfertilized tilled soil, fertilizes the soil.
+The interaction will fail otherwise.
+
+**FertilizeSoil Fields**
+
+| Field Name       | Type                                  | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false)       | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+| RefreshModifiers | `Array`<br />(Element Type: `String`) | **No**    | Does nothing.                                                                                                                     |
+
+### HarvestCrop
+
+This interaction will attempt to execute the harvest action on the current block target and add the crop's drops to the User entity's
+inventory.  The block will either be destroyed or set to its post-harvest growth stage, depending on the farming
+configuration of the block.  This will happen (and the player will receive the full harvest drops) regardless of the
+block's current growth stage. This interaction has no special failure conditions, even if the block target isn't a
+farming block or gathering isn't permitted in the current world, but nothing will occur in those cases.
+
+**HarvestCrop Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+
+### UseWateringCan
+
+If the target block is tilled soil or a farming block on top of tilled soil, waters the soil for the specified duration.
+The interaction will fail otherwise.
+
+**UseWateringCan Fields**
+
+| Field Name       | Type                                  | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false)       | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+| Duration         | `Integer`<br />(Default: 0)           | **No**    | The duration in seconds to water the soil for.                                                                                    |
+| RefreshModifiers | `Array`<br />(Element Type: `String`) | **No**    | Does nothing.                                                                                                                     |
diff --git a/content/docs/pt-BR/contributing/pr-guidelines.mdx b/content/docs/pt-BR/contributing/pr-guidelines.mdx
index 6f5625b7..43841d96 100644
--- a/content/docs/pt-BR/contributing/pr-guidelines.mdx
+++ b/content/docs/pt-BR/contributing/pr-guidelines.mdx
@@ -19,6 +19,8 @@ Para garantir um processo de revisão suave e eficiente, tanto os contribuidores
 4. **Qualidade do código**
    - Certifique-se de que seu código siga os padrões e as práticas recomendadas de codificação do projeto;
    - Inclua comentários quando necessário para explicar a lógica complexa.
+   - Sempre teste suas alterações localmente antes de enviar o pull request para capturar quaisquer problemas antecipadamente.
+   - Construa seu código usando `bun format` para manter a consistência em toda a base dele.
 5. **Testando**
    - Teste as suas alterações cuidadosamente antes de enviar o pull request;
    - Se aplicável, inclua testes unitários ou de integração para verificar as suas alterações.
diff --git a/content/docs/pt-BR/contributing/translate.mdx b/content/docs/pt-BR/contributing/translate.mdx
new file mode 100644
index 00000000..c62ffdde
--- /dev/null
+++ b/content/docs/pt-BR/contributing/translate.mdx
@@ -0,0 +1,74 @@
+---
+title: Translate
+description: How to translate HytaleModding to your language
+---
+
+# Translating HytaleModding
+
+HytaleModding is translated with the help of the community using **Crowdin**. If you want to help translate or improve existing translations, this is the right place.
+
+## Steps to Translate
+
+All translations are managed **via Crowdin**.
+
+1. Visit [our Crowdin project](https://crowdin.com/project/hytalemodding) and log in if required.
+2. Click on your language.
+3. Click on the file/article you wish to translate. We recommend starting with Official Documentation, and then Server Plugin Documentation.
+4. Start translating!
+5. Approved translations will appear on the website.
+
+### Video Guide
+
+<iframe src="https://www.youtube.com/embed/NHiG1rDRgks" allowFullScreen />
+
+## How to discuss
+
+You can always report issues or discuss specific topics directly on Crowdin, but we recommend using Discord instead of the Crowdin comment system to keep everything organized in one place.
+
+1. Join [our Discord](https://discord.gg/hytalemodding)
+2. Open `#translations` channel. Here you can discuss or ask questions that are not related to a specific language.
+3. If you want to join a thread, you are required to run `/translator <your-language>` command here. The bot will add you to the thread for your language.
+
+## Translation Guidelines
+
+- You need to be confident in what you are translating. You should be able to read the text you just translated and understand the meaning of it very easily.
+- It should use the simplest form of language possible. Use English words if the translation is unknown to the majority in your country.
+- Use your imagination, trust yourself. Feel free to change any context as you wish as long as it can still get the same point across and is understandable.
+- These guidelines are more important than language-specific guidelines, but less important than Hytale terminology and rules.
+
+## What not to translate
+
+We request you all to not translate these specific sections of the website:
+
+### Callout types
+
+Callouts are the boxes that contain important information. We request you to not translate the types as they only work in English.
+
+**Example:**
+
+```mdx
+<Callout type="warning" title="Translate this title!">
+Translate the text inside the callout!
+</Callout>
+```
+
+In this example, please don't translate the word warning, the rest you can translate.
+
+### Icons
+
+Icon names must not be translated.
+They are technical identifiers mapped directly to existing icons. Translating them will break the icon rendering.
+
+```mdx
+icon: Globe
+```
+
+---
+
+{/* 
+For translators who will edit this page:
+
+- You are required to translate the Guidelines as they change.
+- General guidelines should be translated but not edited.
+- Learn how to use Markdown from writing_guides.mdx
+*/}
diff --git a/content/docs/pt-BR/established-information/gameplay/creative.mdx b/content/docs/pt-BR/established-information/gameplay/creative.mdx
index e9b9fe35..c94773ac 100644
--- a/content/docs/pt-BR/established-information/gameplay/creative.mdx
+++ b/content/docs/pt-BR/established-information/gameplay/creative.mdx
@@ -15,120 +15,120 @@ Observe que os tópicos abaixo não foram nomeados no vídeo demonstrativo das f
 
 ---
 
-### Laser Pointer
+### Ponteiro Laser
 
-Displays a ray from the player's camera in the direction the player is looking.
+Exibe um raio da câmera do jogador na direção em que ele está observando.
 
 #### Configurações
 
-- Duration (Integer Slider): Description unknown as of December 2025.
-- Laser Color (Hex Color Code): Description unknown as of December 2025.
+- Duração (controle deslizante inteiro): descrição desconhecida de dezembro de 2025;
+- Cor do laser (código por cor hexadecimal): descrição desconhecida em dezembro de 2025.
 
-### Sculpt Brush Tool
+### Pincel de Escultura
 
-Allows the user to raise and lower the terrain to more accurately sculpt and blend shapes. Supports most features of the Paint Brush.
+Permite ao usuário aumentar e diminuir o terreno para esculpir e misturar de forma precisa. Suporta a maioria dos recursos do pincel.
 
-### Line Brush Tool
+### Pincel de Linha
 
 Desconhecido até dezembro de 2025.
 
-### Selection Tool
+### Ferramenta de Seleção
 
-Allows the user to select and edit regions of the world by transforming selections of blocks or a prefab via position, rotation, and extrusion.
+Permite ao usuário selecionar e editar regiões do mundo transformando seleções de blocos ou prefab através da posição, rotação e extrusão.
 
 #### Configurações
 
-- Mode (Combo Box: Set, Wall, Fill, Replace): Description unknown as of December 2025.
-- Material (Integer Slider): Description unknown as of December 2025.
-- Weight (Integer Slider): Description unknown as of December 2025.
-- Pitch (Integer): Description unknown as of December 2025.
+- Modo (caixa de combinação: definir, parede, preencher, substituir): descrição desconhecida em dezembro de 2025;
+- Material (controle deslizante inteiro): descrição desconhecida em dezembro de 2025;
+- Peso (barra deslizante inteira): descrição desconhecida em dezembro de 2025;
+- Inclinação (número inteiro): descrição desconhecida em dezembro de 2025.
 
 ### Régua
 
-Allows the user to measure distances between multiple points in 3D space, with support for multiple measurement lines and editing of measured points.
+Permite ao usuário medir as distâncias entre os vários pontos no espaço 3D, com suporte para múltiplas linhas de medição e edição de pontos de medição.
 
-### Layer Brush Tool
+### Pincel de Camada
 
 Desconhecido até dezembro de 2025.
 
-### Paste Tool
+### Ferramenta de Colar
 
-Allows the user to paste a copied selection of blocks or a prefab at the point at which the player is looking. The paste is relative to the selection's anchor point. If the selection is a prefab, the anchor point may be set in the Prefab Editor. It is unknown if the selection's anchor may be set otherwise.
+Permite ao usuário colar uma seleção de blocos copiados ou prefabs no ponto em que o jogador está observando. A colagem é relativa ao ponto de âncora da seleção. Se a seleção é um prefab, o ponto âncora pode ser definido no Editor de Prefabs. Não se sabe se a âncora da seleção pode ser definida de outra forma.
 
-### Flood Brush Tool
+### Pincel de Preenchimento
 
 Desconhecido até dezembro de 2025.
 
-### Paint Brush Tool
+### Pincel de Pintura
 
-Brushes are used to make large changes to the world from far away.
+Os pincéis são usados para realizar grandes alterações no mundo a partir de uma longa distância.
 
 #### Habilidades gerais
 
-- Place Shapes and Prefabs
-- Replace Blocks
-- Create Axis Locks and Masks
+- Colocar formas e prefabs;
+- Substituir blocos;
+- Criar bloqueio de eixos e máscaras.
 
 #### Configurações
 
-- Material
-- Width (Integer Slider): Description unknown as of December 2025.
-- Height (Integer Slider): Description unknown as of December 2025.
-- Shape (Combo Box: Cube, Sphere, Cylinder, Cone, Inverted Cone, Pyramid, Inverted Pyramid, Cuboid Grid): Description unknown as of December 2025.
-- Origin (Combo Box: Center, Bottom, Top): Description unknown as of December 2025.
-- Mirror Axis (Combo Box: None, Unknown other options): Description unknown as of December 2025.
-- Wall Thickness (Integer Slider): Description unknown as of December 2025.
-- Density (Integer Slider): Description unknown as of December 2025.
+- Material;
+- Largura (controle deslizante inteiro): descrição desconhecida em dezembro de 2025;
+- Altura (barra deslizante inteira): descrição desconhecida em dezembro de 2025;
+- Forma (caixa de combinação: cubo, esfera, cilindro, cone, cone invertido, pirâmide, pirâmide invertida, grade cuboide): descrição desconhecida em dezembro de 2025;
+- Origem (caixa de combinação: centro, parte inferior, parte superior): descrição desconhecida em dezembro de 2025;
+- Eixo de espelhamento (caixa de combinação: nenhuma, outras opções desconhecidas): descrição desconhecida em dezembro de 2025;
+- Espessura da parede (barra deslizante inteira): descrição desconhecida em dezembro de 2025;
+- Densidade (Barra deslizante inteira): descrição desconhecida em dezembro de 2025.
 
 #### Predefinições:
 
-- Boulder: Creates a boulder at the point at which the player is looking.
-- Grassy Path: Transforms the terrain into a grass path at the point at which the player is looking.
-- Rubble: Generate rubble at the point at which the player is looking.
-- Tentacle: TBD
-- Lava Cracks: Transforms the terrain into a lava crack at the point at which the player is looking.
-- Hot Springs: TBD
-- Ruins: Generates a ruin at the point at which the player is looking.
-- Ruin Roofs: Generates a ruin with a roof at the point at which the player is looking.
-- Grama: a definir
-- Mountain: Places consecutive chunks of terrain to form a mountain at the point at which the player is looking.
-- Ruins: TBD
+- Pedra: cria uma pedra no ponto para onde o jogador está olhando;
+- Caminho gramado: transforma o terreno em um caminho gramado no ponto em que o jogador está olhando;
+- Detritos: são gerados no ponto para onde o jogador está olhando;
+- Tentáculos: a definir;
+- Fissuras de Lava: transforma o terreno em uma fissura de lava no ponto em que o jogador está olhando;
+- Fontes termais: a definir;
+- Ruínas: gera uma ruína no ponto em que o jogador está olhando;
+- Telhados em Ruína: gera uma ruína com um telhado no ponto em que o jogador está olhando;
+- Grama: a definir;
+- Montanha: coloca blocos consecutivos de terreno para formar uma montanha no ponto em que o jogador está olhando;
+- Ruínas: a definir.
 
 ---
 
-### Entity Grabber Tool
+### Seletora de Entidade
 
 Desconhecido até dezembro de 2025.
 
-### Noise Brush Tool
+### Pincel de Ruído
 
 Desconhecido até dezembro de 2025.
 
-### Scatter Brush Tool
+### Pincel de Dispersão
 
 Desconhecido até dezembro de 2025.
 
-### Extrude Brush Tool
+### Pincel de Extrusão
 
 Desconhecido até dezembro de 2025.
 
-### Prefab Selector Tool
+### Seletor de Prefabs
 
-Allows the user to select a prefab when inside the Prefab Editor. May be used with the copy command.
+Permite ao usuário selecionar um prefab quando estiver no Editor de Prefabs. Pode ser usado com o comando de copiar.
 
-### Smooth Brush Tool
+### Pincel de Suavização
 
 Desconhecido até dezembro de 2025.
 
-### Hitbox Tool
+### Ferramenta de Caixa de Colisão
 
 Desconhecido até dezembro de 2025.
 
-### Set Anchor Tool
+### Ferramenta de Ancoragem
 
-Allows the user to set an anchor point for a prefab when inside the Prefab Editor.
+Permite ao usuário definir um ponto de âncora para um prefab quando estiver no Editor de Prefabs.
 
-### Tint Brush Tool
+### Pincel de Tingimento
 
 Desconhecido até dezembro de 2025.
 
@@ -138,21 +138,21 @@ Desconhecido até dezembro de 2025.
 
 Veja que estas ferramentas estão em desenvolvimento e estão sujeitas a mudanças. **Atualmente, nem todas as configurações e funcionalidades são conhecidas**.
 
-- Tool Reach Distance (Integer Slider): Description unknown as of December 2025.
-- Tool Delay Minimum (Integer Slider): Description unknown as of December 2025.
-- Brush Opacity (Integer Slider): Description unknown as of December 2025.
-- Selection Opacity (Integer Slider): Description unknown as of December 2025.
-- Selection Panel Opacity (Integer Slider): Description unknown as of December 2025.
-- Enable Brush Shape Rendering (Toggle): Description unknown as of December 2025.
-- Display Legend (Toggle): Description unknown as of December 2025.
-- Show Tool Notifications (Toggle): Description unknown as of December 2025.
-- Default Laser Pointer (Hex Color Code): Description unknown as of December 2025.
-- Enable Brush Spacing (Toggle): Description unknown as of December 2025.
-- Spacing Between Br? (Integer Slider): Description unknown as of December 2025.
-- Flight Intertia (Integer Slider): Description unknown as of December 2025.
-- Flight Mode (Combo Box: Hover, Directional): Description unknown as of December 2025.
-- No Clip (Toggle): Description unknown as of December 2025.
-- Air Placement (Toggle): Description unknown as of December 2025.
+- Distância do alcance da ferramenta (barra deslizante inteira): descrição desconhecida em dezembro de 2025;
+- Atraso mínimo da ferramenta (barra deslizante inteira): descrição desconhecida em dezembro de 2025;
+- Opacidade do pincel (barra deslizante inteira): descrição desconhecida em dezembro de 2025;
+- Opacidade da seleção (barra deslizante inteira): descrição desconhecida em dezembro de 2025;
+- Opacidade do painel de seleção (barra deslizante inteira): descrição desconhecida em dezembro de 2025;
+- Ativar renderização da forma do pincel (alternar): descrição desconhecida em dezembro de 2025;
+- Exibir legenda (dlternar): descrição desconhecida em dezembro de 2025;
+- Exibir notificações da ferramenta (alternar): descrição desconhecida em dezembro de 2025;
+- Ponteiro laser padrão (código de cor hexadecimal): descrição desconhecida em dezembro de 2025;
+- Ativar espaçamento entre pinceladas (alternar): descrição desconhecida em dezembro de 2025;
+- Espaçamento entre as pinceladas? (controle deslizante inteiro): descrição desconhecida em dezembro de 2025;
+- Inércia de voo (barra deslizante inteira): descrição desconhecida em dezembro de 2025;
+- Modo de voo (caixa de combinação: pairar, direcional): descrição desconhecida em dezembro de 2025;
+- Sem colisão (alternar): descrição desconhecida em dezembro de 2025;
+- Posicionamento no ar (alternar): descrição desconhecida em dezembro de 2025.
 
 ## Ferramentas de criação de conteúdo
 
@@ -174,28 +174,28 @@ Desconhecido até dezembro de 2025.
 
 As ferramentas a seguir permitem que o usuário edite o mundo atual:
 
-#### Editor de prefab
+#### Editor de Prefabs
 
 Permite que o usuário crie ou edite os prefabs em um espaço separado.
 
 ##### Configurações
 
-- Saved configs (Unknown type; presumably a file)
-- Root Dir (Unknown type; presumably a folder)
-- Prefab Paths or Folders (Unknown type; presumably a list of paths or folders)
-- Recursively Search for Prefabs (Toggle)
-- Spawn Entities and NPCs (Toggle)
-- Desired Y Level to Paste (Integer)
-- Blocks Between Prefabs (Integer)
-- WorldGen Type (Combo Box: Flat, Unknown other options): Description unknown as of December 2025.
-- (Flat WorldGen Only) Num Air Blocks Below Prefabs (Integer): Description unknown as of December 2025.
-- Axis to Paste On (Combo Box: X, Unknown other options): Description unknown as of December 2025.
-- Alignment Method (Combo Box: By Anchor, Unknown other options): Description unknown as of December 2025.
+- Configurações salvas (tipo desconhecido; provavelmente um arquivo);
+- Diretório raiz (tipo desconhecido; provavelmente uma pasta);
+- Caminhos ou pastas de prefab (tipo desconhecido; presumivelmente uma lista de caminhos ou pastas);
+- Pesquisa recursivamente por prefabs (alternar);
+- Gerar entidades e NPCs (alternar);
+- Nível Y desejado para colar (inteiro);
+- Blocos entre prefabs (inteiro);
+- Tipos de gerações de mundo (caixa de combinação: plano, desconhecido, outras opções): descrição desconhecida em dezembro de 2025;
+- (Apenas geração de mundo plano) Número de blocos de ar abaixo dos prefabs (inteiro): descrição desconhecida em dezembro de 2025;
+- Eixo para colar (caixa de combinação: X, outras opções desconhecidas): descrição desconhecida em dezembro de 2025;
+- Método de alinhamento (caixa de combinação: por âncora, outras opções desconhecidas): descrição desconhecida em dezembro de 2025.
 
 #### Lista de prefabs
 
-- Lists all user created prefabs and allows the user to load a prefab into the Paste tool.
-- User can pick from server, assets, or worldgen prefabs.
+- Lista todos os prefabs criados pelo usuário e permite que ele carregue um prefab na Ferramenta de Colar;
+- O usuário pode escolher entre servidor, recursos ou prefabs de geração de mundo.
 
 #### Gerador de NPC
 
@@ -209,7 +209,7 @@ Desconhecido até dezembro de 2025.
 
 - Permite ao jogador alterar seu modelo com uma escala ajustável.
 
-#### Tint Chunk
+#### Tingir chunk
 
 Desconhecido até dezembro de 2025.
 
@@ -233,7 +233,7 @@ O usuário pode adicionar atores para que a sequência os controle.
 - Câmera
 - Entidade
 - Item
-- Jogador
+- Jogador.
 
 ## Comandos
 
diff --git a/content/docs/pt-BR/established-information/server-plugin-insights.mdx b/content/docs/pt-BR/established-information/server-plugin-insights.mdx
index 6c18a9f0..da9fd630 100644
--- a/content/docs/pt-BR/established-information/server-plugin-insights.mdx
+++ b/content/docs/pt-BR/established-information/server-plugin-insights.mdx
@@ -4,33 +4,32 @@ description: Slikey compartilhou algumas informações sobre o código do servid
 ---
 
 <Callout type="info" title="Nota">
-  The following information is based on insights shared by Technical Director Slikey on December 15, 2025 on the Hytale Discord Server. It provides an overview of the server code architecture and plugin capabilities.
+  As informações a seguir baseiam-se em observações compartilhadas pelo Diretor Técnico Slikey, em 15 de dezembro de 2025, no servidor de Discord do Hytale. Ele fornece uma visão geral da arquitetura do código do servidor e das capacidades dos plugins.
 
-  Majority of this document is just straight quotes from Slikey with minimal commentary. It is more over to preserve the information shared rather than reword it.
+  Este documento é composto principalmente por falas do próprio Slikey, com poucas observações adicionais. A ideia é manter o que foi dito em vez de mudar as palavras e o contexto.
 </Callout>
 
 # Código-fonte do servidor
 
-The server will be released as shared source - we will have the source code with no obfuscation and all their comments.
+O servidor será lançado como fonte compartilhada. Teremos acesso ao código-fonte sem qualquer ofuscação e com todos os seus comentários.
 
 ### Licença
 
-The license permits usage for any **hytale related** things, so as long as you don't use the server / source to make your own game or sell their algorithms.
+A licença permite o uso para quaisquer coisas **relacionadas ao Hytale**, desde que você não use o servidor e/ou código-fonte para criar seu próprio jogo ou vender os algoritmos deles.
 
 # Sistema de permissão
 
-After being asked in the Hytale Modding server, Lead Architect Zero has replied:
+Após ser questionado no servidor Hytale Modding, o Arquiteto Chefe Zero respondeu:
 
-It's quite basic, so don't expect much but yes we do have a permissions system built in. It also support implementing your own backend. Ex. if you wanted to store it in a database.
+É bastante básico, por isso não espere muito, mas sim, temos um sistema de permissões integrado. Também suporta a implementação do seu próprio back-end. Ex.: se você quisesse armazená-lo em um banco de dados.
 
 ![Premission Source Snippet](/assets/premission-system.png)
 
 # Implementação da geração de mundo
 
-The following block of text is directly from Lead Architect Zero:
+O bloco de texto a seguir é diretamente do Arquiteto Chefe Zero:
 
-You can totally implement a custom world gen in a plugin super easy. So if you want a totally different config or logic for generating terrain you can add that into a plugin and then configure a world to use that,
-We have some stuff load prefabs and there is existing code in the current world generators that could possibly be reused but no APIs specifically for the details of the generation itself.
+Você pode implementar uma geração de mundo personalizada em um plugin de forma super fácil. Portanto, caso deseje uma lógica de geração de terreno completamente nova, você pode implementá-la via plugin e definir que o mundo a utilize. Já existem sistemas para carregar os prefabs e os códigos nos geradores atuais que podem ser reaproveitados, mas ainda não temos APIs específicas para os detalhes internos da geração.
 
 ```java
 public interface IWorldGenProvider {
@@ -59,35 +58,33 @@ public interface IWorldGen {
 }
 ```
 
-# Server Code Snippets
+# Trechos de código do servidor
 
-Some code snippets from a plugin they made were also shared. The following snippets are directly quoted from Technical Director Slikey:
+Alguns trechos de código de um plugin que eles criaram também foram compartilhados. Os trechos a seguir são citações diretas do diretor técnico Slikey:
 
 ## Plugin BlockSpawner
 
-Alright, I'll drop some code snippets here for a simple plugin called "BlockSpawner" which will turn into a "random" block when put into the world based on the configured rules
+Deixarei aqui alguns trechos de código para um plugin simples chamado “BlockSpawner”. Ele se transformará em um bloco “aleatório” quando colocado no mundo com base nas regras configuradas.
 
-There is more code here in general but it shows the Asset System and the plugin layout. You can see that the asset system defines "Codecs" which are used to serialize and deserialize data. Using these codecs we can generate schemas.
-Let's say you connect to a server and open the asset editor: the server will send those schemas - so every single asset type defined server side, even you own, now become part of the asset editor on the client - no need to do anything, you just get to enjoy the editor UI for making your assets that you defined
+Há mais código nesta aqui, mas ele serve para mostrar como funciona o sistema de recursos e a estrutura do plugin. Perceba que o sistema de recursos define "Codecs" que são usados para serializar e desserializar dados. Ao usá-los, podemos gerar esquemas.
+Digamos que você se conecte a um servidor e abra o editor de assets: o servidor enviará esses esquemas. Portanto, cada tipo de recurso definido no lado do servidor, até mesmo os seus próprios, agora se tornam parte do editor de recursos no cliente. Não é necessário fazer nada, apenas aproveite a interface do editor para criar os recursos que você mesmo definiu.
 
 ![Block Spawner Code 1](/assets/blockspawner-code-1.png)
 ![Block Spawner Code 2](/assets/blockspawner-code-2.png)
 ![Block Spawner Code 3](/assets/blockspawner-code-3.png)
 ![Block Spawner Manifest](/assets/blockspawner-manifest.png)
 
-> i guess this part also shows a bit how we use constants to store some language keys - Slikey
-> (in reference to the image below)
+> Acredito que essa parte também mostra um pouco como usamos as constantes para armazenar algumas chaves de idioma. — Slikey
+> (referente à imagem abaixo)
 
 ![Constants to store Language Keys](/assets/constants.png)
 
-> you can completely customize the chunk storage provider, we for example made one that is just empty where it doesn't load any chunks from disk
-> you could add an MySQLChunkStorageProvider and it could read the data from a database
-> and the same goes for worldgen, you can simply implement this interface to generate a world generator - slikey
+> Você pode personalizar completamente o provedor de armazenamento de chunks. Por exemplo, criamos um que é apenas vazio, onde ele não carrega nenhum chunk do disco. Você poderia adicionar um `MySQLChunkStorageProvider` e ele poderia ler os dados de um banco de dados. O mesmo vale para a geração de mundo, a qual você pode simplesmente implementar esta interface para criar um gerador de mundo.
 
 ![Chunks 1](/assets/chunks-1.png)
 ![Chunks 2](/assets/chunks-2.png)
 ![Chunks 3](/assets/chunks-3.png)
 
-> i mean here are all the weapons defined, you tell me, obviously you will discover limitations but i think there is plenty of room to make changes - this stuff is actually hard though, there is a lot of QoL to have happen here
+> Digo, aqui estão todas as armas definidas, você me diz e obviamente descobrirá limitações, mas acho que há muito espaço para fazer mudanças. Essas coisas são difíceis, na verdade, ainda há muita qualidade de vida para ser implementada aqui.
 
 ![Weapons 1](/assets/weapons-1.png)
diff --git a/content/docs/pt-BR/established-information/server/content-categories/art-assets.mdx b/content/docs/pt-BR/established-information/server/content-categories/art-assets.mdx
index 0ba8ec24..65cfbf14 100644
--- a/content/docs/pt-BR/established-information/server/content-categories/art-assets.mdx
+++ b/content/docs/pt-BR/established-information/server/content-categories/art-assets.mdx
@@ -14,7 +14,7 @@ Hytale oferece grande suporte para modelagem 3D e criação de texturas de artes
 Hytale usa **Blockbench** como a ferramenta principal para modelagem 3D e animação:
 
 * **Suporte Oficial**: Usado para "criar os modelos, texturas, e animações do Hytale"
-* **Plugin Especial**: Hytale terá um plugin do Blockbench dedicado, será lançado o mais rápido possível
+* **Special plugin**: Hytale has a dedicated [Blockbench Plugin](https://www.blockbench.net/plugins/hytale_plugin).
 * **Compatibilidade Direta**: O plugin permite criadores "criar modelos, texturas, e animações compatíveis com o Hytale, diretamente no Blockbench"
 * **Substituição das ferramentas antigas**: Substitui completamente o antigo criador de modelos do Hytale, para ajudar a comunidade com seus fluxos de trabalhos já implantados
 * **Recursos de Segurança**: Permite adicionar somente coisas compatíveis com a engine, não precisa se preocupar se vai crashar nada
diff --git a/content/docs/pt-BR/established-information/server/content-categories/data-assets.mdx b/content/docs/pt-BR/established-information/server/content-categories/data-assets.mdx
index 7eb7a810..8b2a9cc4 100644
--- a/content/docs/pt-BR/established-information/server/content-categories/data-assets.mdx
+++ b/content/docs/pt-BR/established-information/server/content-categories/data-assets.mdx
@@ -54,7 +54,7 @@ Esse equilíbrio entre capacidade e acessibilidade é o cerne da filosofia de mo
 
 Data Assets funcionam perfeitamente com outras ferramentas de desenvolvimento para o Hytale:
 
-* **Programação visual**: pode referenciar e manipular dados específicos nos ativos de dados
+* **Visual Scripting**: pode referenciar e manipular dados específicos nos ativos de dados
 * **Plugins Java**: pode ler e modificar os ativos de dados para comportamentos mais complexos
 * **Editor de ativos**: oferece uma interface única para gerenciar ativos visuais e suas configurações de dados
 
diff --git a/content/docs/pt-BR/established-information/server/content-categories/visual-scripting.mdx b/content/docs/pt-BR/established-information/server/content-categories/visual-scripting.mdx
index 37103c47..3bd580f7 100644
--- a/content/docs/pt-BR/established-information/server/content-categories/visual-scripting.mdx
+++ b/content/docs/pt-BR/established-information/server/content-categories/visual-scripting.mdx
@@ -1,11 +1,11 @@
 ---
-title: Programação visual
-description: Uma introdução baseada nas informações disponíveis sobre o sistema de programação visual do Hytale.
+title: Visual Scripting
+description: Uma introdução baseada nas informações disponíveis sobre o sistema de visual scripting do Hytale.
 ---
 
 # Introdução
 
-O Hytale pretende implementar a Programação Visual como uma ferramenta para expandir o acesso a lógicas complexas e fluxos de controle para um público mais amplo. Esse sistema não estará disponível no lançamento, mas deve chegar em seguida.
+O Hytale pretende implementar a visual scripting como uma ferramenta para expandir o acesso a lógicas complexas e fluxos de controle para um público mais amplo. Esse sistema não estará disponível no lançamento, mas deve chegar em seguida.
 
 ## Visão geral
 
diff --git a/content/docs/pt-BR/guides/ecs/block-components.mdx b/content/docs/pt-BR/guides/ecs/block-components.mdx
new file mode 100644
index 00000000..ca68b38a
--- /dev/null
+++ b/content/docs/pt-BR/guides/ecs/block-components.mdx
@@ -0,0 +1,247 @@
+---
+title: Block Components
+description: Learn how to use the block components.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+  - name: oskarscot
+    link: https://oskar.scot
+---
+
+# Overview
+
+In this guide, you'll learn how to use block components to create a ticking block.
+
+<Callout>
+  For a more complete reference, you may also want to review FarmingSystems.Ticking, as much of the underlying logic is based on its implementation.
+</Callout>
+
+## Steps
+
+### 1. ExampleBlock - holds block behavior
+
+```java
+public class ExampleBlock implements Component<ChunkStore> {
+
+    public static final BuilderCodec CODEC = BuilderCodec.builder(ExampleBlock.class, ExampleBlock::new).build();
+
+    // Components usually require a copy constructor as well but since we don't actually hold any data in this component this is not neccessary
+    public ExampleBlock() { }
+
+    public static ComponentType getComponentType() {
+        return ExamplePlugin.get().getExampleBlockComponentType();
+    }
+
+    @Nullable
+    public Component<ChunkStore> clone() {
+        return new ExampleBlock();
+    }
+}
+```
+
+ExampleBlock is a custom component that stores the behavior and data for your ticking block. Here, it simply places an Ice Block at x + 1 relative to its current position when it ticks.
+
+---
+
+### 2. ExampleInitializer - marks blocks as ticking when placed
+
+```java
+public class ExampleInitializer extends RefSystem {
+
+    @Override
+    public void onEntityAdded(@Nonnull Ref ref, @Nonnull AddReason reason, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+        BlockModule.BlockStateInfo info = (BlockModule.BlockStateInfo) commandBuffer.getComponent(ref, BlockModule.BlockStateInfo.getComponentType());
+        if (info == null) return;
+
+        ExampleBlock generator = (ExampleBlock) commandBuffer.getComponent(ref, ExamplePlugin.get().getExampleBlockComponentType());
+        if (generator != null) {
+            int x = ChunkUtil.xFromBlockInColumn(info.getIndex());
+            int y = ChunkUtil.yFromBlockInColumn(info.getIndex());
+            int z = ChunkUtil.zFromBlockInColumn(info.getIndex());
+
+            WorldChunk worldChunk = (WorldChunk) commandBuffer.getComponent(info.getChunkRef(), WorldChunk.getComponentType());
+            if (worldChunk != null) {
+				worldChunk.setTicking(x, y, z, true);
+            }
+        }
+    }
+
+    @Override
+    public void onEntityRemove(@Nonnull Ref ref, @Nonnull RemoveReason reason, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+    }
+
+    @Override
+    public Query getQuery() {
+        return Query.and(BlockModule.BlockStateInfo.getComponentType(), ExamplePlugin.get().getExampleBlockComponentType());
+    }
+}
+```
+
+ExampleInitializer is a RefSystem that reacts when block entities with the ExampleBlock component are added or removed. This is crucial for marking blocks as ticking when they're first placed.
+
+**Key Points:**
+
+- Tells the game that this block should tick, allowing `ExampleSystem` to process it.
+
+```java
+worldChunk.setTicking(x, y, z, true);
+```
+
+---
+
+### 3. ExampleSystem - handles ticking
+
+```java
+public class ExampleSystem extends EntityTickingSystem {
+
+    public void tick(float dt, int index, @Nonnull ArchetypeChunk archetypeChunk, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+        BlockSection blocks = (BlockSection) archetypeChunk.getComponent(index, BlockSection.getComponentType());
+
+        assert blocks != null;
+
+        if (blocks.getTickingBlocksCountCopy() != 0) {
+            ChunkSection section = (ChunkSection) archetypeChunk.getComponent(index, ChunkSection.getComponentType());
+
+            assert section != null;
+
+            BlockComponentChunk blockComponentChunk = (BlockComponentChunk) commandBuffer.getComponent(section.getChunkColumnReference(), BlockComponentChunk.getComponentType());
+
+            assert blockComponentChunk != null;
+
+            blocks.forEachTicking(blockComponentChunk, commandBuffer, section.getY(), (blockComponentChunk1, commandBuffer1, localX, localY, localZ, blockId) -> {
+                Ref<ChunkStore> blockRef = blockComponentChunk.getEntityReference(ChunkUtil.indexBlockInColumn(localX, localY, localZ));
+                if (blockRef == null) {
+                    return BlockTickStrategy.IGNORED;
+                } else {
+                    ExampleBlock exampleBlock = (ExampleBlock) commandBuffer1.getComponent(blockRef, ExampleBlock.getComponentType());
+                    if (exampleBlock != null) {
+                        WorldChunk worldChunk = (WorldChunk) commandBuffer.getComponent(section.getChunkColumnReference(), WorldChunk.getComponentType());
+                        World world = worldChunk.getWorld();
+
+                        int globalX = localX + (worldChunk.getX() * 32);
+                        int globalZ = localZ + (worldChunk.getZ() * 32);
+
+                        // We need to execute setBlock on the world thread as you cannot call store functions from a system
+                        // This is because of the architecture of the server, depending on your needs you can also use the CommandBuffer
+                        world.execute(() -> {
+                            world.setBlock(globalX + 1, localY, globalZ, "Rock_Ice");
+                        });
+
+                        return BlockTickStrategy.CONTINUE;
+
+                    } else {
+                        return BlockTickStrategy.IGNORED;
+                    }
+                }
+            });
+        }
+    }
+
+    @Nullable
+    public Query getQuery() {
+        return Query.and(BlockSection.getComponentType(), ChunkSection.getComponentType());;
+    }
+}
+```
+
+ExampleSystem is an EntityTickingSystem that runs every tick to execute the logic for all ticking blocks with the ExampleBlock component.
+
+**Key Points:**
+
+- **Get the block component**
+
+```java
+ExampleBlock exampleBlock = (ExampleBlock) commandBuffer.getComponent(blockRef, ExampleBlock.getComponentType());
+```
+
+- **Convert local chunk coordinates to world coordinates**
+
+```java
+int globalX = localX + (worldChunk.getX() * 32);
+int globalZ = localZ + (worldChunk.getZ() * 32);
+```
+
+- **Run the block logic**
+
+```java
+exampleBlock.runBlockAction(globalX, localY, globalZ, worldChunk.getWorld());
+```
+
+- **Keep the block ticking in the next tick**
+
+```java
+return BlockTickStrategy.CONTINUE;
+```
+
+---
+
+### 4. ExamplePlugin - registers components and systems
+
+```java
+public class ExamplePlugin extends JavaPlugin {
+    protected static ExamplePlugin instance;
+    private static final HytaleLogger LOGGER = HytaleLogger.forEnclosingClass();
+    private ComponentType exampleBlockComponentType;
+
+    public static ExamplePlugin get() {
+        return instance;
+    }
+
+    public ExamplePlugin(@Nonnull JavaPluginInit init) {
+        super(init);
+        LOGGER.atInfo().log("Hello from " + this.getName() + " version " + this.getManifest().getVersion().toString());
+    }
+
+    @Override
+    protected void setup() {
+        instance = this;
+        LOGGER.atInfo().log("Setting up plugin " + this.getName());
+        this.exampleBlockComponentType = this.getChunkStoreRegistry().registerComponent(ExampleBlock.class, "ExampleBlock", ExampleBlock.CODEC);
+    }
+	
+	@Override
+	protected void start() {
+		this.getChunkStoreRegistry().registerSystem(new ExampleSystem());
+		this.getChunkStoreRegistry().registerSystem(new ExampleInitializer());
+	}
+
+    public ComponentType getExampleBlockComponentType() {
+        return this.exampleBlockComponentType;
+    }
+}
+```
+
+---
+
+### 5. Configure In-Game
+
+![block-component-1](/assets/guides/block-component-1.png)
+
+![block-component-2](/assets/guides/block-component-2.png)
+
+With this logic, the block will now continuously place an Ice Block at the coordinates x + 1 relative to its current position every time it ticks.
+
+---
+
+## Common Issues
+
+### NullPointerException on Startup
+
+**Error message:**
+
+```java
+java.lang.NullPointerException: Cannot invoke "com.hypixel.hytale.component.query.Query.validateRegistry(com.hypixel.hytale.component.ComponentRegistry)" because "query" is null
+```
+
+**Cause:**
+This error occurs when your module is loaded **before** the required Hytale modules.
+
+**Fix:**
+Add `EntityModule` and `BlockModule` as dependencies in your `manifest.json` to ensure proper load order.
+
+```json
+"Dependencies": {
+  "Hytale:EntityModule": "*",
+  "Hytale:BlockModule": "*"
+}
+```
diff --git a/content/docs/pt-BR/guides/ecs/entity-component-system.mdx b/content/docs/pt-BR/guides/ecs/entity-component-system.mdx
index 391a276d..5c950de4 100644
--- a/content/docs/pt-BR/guides/ecs/entity-component-system.mdx
+++ b/content/docs/pt-BR/guides/ecs/entity-component-system.mdx
@@ -1,6 +1,6 @@
 ---
 title: Entity Component System
-description: A basic introduction into ECS (Entity Component System)
+description: Uma introdução básica ao ECS (Entity Component System)
 ---
 
 <Callout type="warning">
@@ -31,34 +31,34 @@ We can describe composition as "has X" and inheritance as "is X".
 When we inherit a class in Java, we inherit all of its attributes and methods.
 While in composition we can choose for each object what it references and what systems will work on it.
 
-# Entities, Components and Systems
+# Entidades, componentes e sistemas
 
-## Entities
+## Entidades
 
-An Entity is just a unique identifier.
+Uma entidade é apenas um identificador único.
 
 - It contains no data.
 - It contains no logic
 
 Think of entities as nouns that can be described using components
 
-## Components
+## Componentes
 
 Components are just plain data containers.
 
-- They store only data
-- They contain no behavior or logic
-- They describe traits or aspects of an entity
+- Eles armazenam apenas dados;
+- Eles não contêm comportamento nem lógica;
+- Eles descrevem características ou aspectos de uma entidade.
 
-Examples of components:
+Exemplos de componentes:
 
-- A 'Position' component that stores X, Y and Z coordinates
-- A 'Velocity' component that stores the speed along each axis
-- A 'Health' component that stores the current health of the entity
+- Um componente "position" que armazena coordenadas X, Y e Z;
+- Um componente "velocity" que armazena a velocidade ao longo de cada eixo;
+- Um componente "health" que armazena a vida atual da entidade.
 
 Think of components as adjectives that describe an entity
 
-## Systems
+## Sistemas
 
 Systems contains the logic for your game (or in this case, a mod).
 
@@ -66,7 +66,7 @@ Systems contains the logic for your game (or in this case, a mod).
 - It Does not store entity data itself
 - It Applies behavior by reading and modifying component data
 
-For example:
+Por exemplo:
 
 - A "WinConditionSystem" may process every Entity that contains the components "Position" and "Velocity"
 - If an entity reaches the position `(0, 0, 0)`, the system will trigger a "You Won!" message.
diff --git a/content/docs/pt-BR/guides/ecs/hytale-ecs-theory.mdx b/content/docs/pt-BR/guides/ecs/hytale-ecs-theory.mdx
index fc8e636e..36855848 100644
--- a/content/docs/pt-BR/guides/ecs/hytale-ecs-theory.mdx
+++ b/content/docs/pt-BR/guides/ecs/hytale-ecs-theory.mdx
@@ -29,7 +29,7 @@ for now this is the basic understanding for the `ChunkStore`. You can use it to
 
 ## Holder
 
-A Holder is essentially a blueprint for an entity. Before an entity exists in the Store (and thus in the world), is exists as a `Holder`. It collects and holds all the necessary components (data). You can compare it analogous to shopping cart. You grab all components you need and once you have everything, check out at the store which will take your cart and create a valid entity ID and hand you back a receipt (a Ref).
+A Holder is essentially a blueprint for an entity. Before an entity exists in the Store (and thus in the world), it exists as a `Holder`. It collects and holds all the necessary components (data). You can compare it analogous to shopping cart. You grab all components you need and once you have everything, check out at the store which will take your cart and create a valid entity ID and hand you back a receipt (a Ref).
 
 Let's take a look at an example: initializing players. In `Universe`, the `addPlayer` method demonstrates it perfectly.
 When a player connects, we don't immediately throw them into the ECS. We first construct their data in a Holder.
@@ -167,7 +167,7 @@ MyComponent comp = commandBuffer.getComponent(ref, componentType);
 
 Codecs handle serialization and deserialization of components. Hytale uses them to save and load entity data to and from disk as well as sending component data over the network. When creating a custom component, you must also create a corresponding Codec.
 
-There are mutliple Codec types already implemented in the default Codec Interface:
+There are multiple Codec types already implemented in the default Codec Interface:
 
 - Codec.STRING
 - Codec.BOOLEAN
@@ -215,7 +215,7 @@ This might seem tedious at first but it ensures that your component can be corre
   KeyedCodec<Integer> exampleInt = new KeyedCodec<Integer>("ExampleIntIdForCodec", Codec.INTEGER);
   ```
 
-- **Setter Function**: This is a lambda function that takes an instance of your component and returns the value of the field you want to serialize. For example, if you have a field called `myCustomField` in your custom component, your getter function would look like this:
+- **Setter Function**: This is a lambda function that takes an instance of your component + the value to set and sets the field value on the component. For example, if you have a field called `myCustomField` in your custom component, your setter function would look like this:
   ```java
   (data, value) -> data.myCustomField = value
   ```
@@ -276,7 +276,7 @@ public class PoisonComponent implements Component<EntityStore> {
 
 You can also add validators to your Codec fields to ensure that the data being serialized/deserialized meets certain criteria. For example, if you want to ensure that the `damagePerTick` field is always non-negative or the poison name is never null, you can add a validator like this:
 
-````java
+```java
 .append(
     new KeyedCodec<Float>("DamagePerTick", Codec.FLOAT),
     (data, value) -> data.damagePerTick = value,
@@ -292,14 +292,15 @@ You can also add validators to your Codec fields to ensure that the data being s
 )
 .addValidator(Validators.nonNull())
 .add()
+```
 
 ### Complex Codec Examples
 
-If you want to have a map inside your component, you can use the MapCodec class to build a KeyedCoded for it. Here's an example of how to create a Codec for a Map field:
+If you want to have a map inside your component, you can use the MapCodec class to build a KeyedCodec for it. Here's an example of how to create a Codec for a Map field:
 
 ```java
 var damagePerTick = new KeyedCodec<>("DamagePerTick", new MapCodec<>(Codec.FLOAT, HashMap<String, Float>::new));
-````
+```
 
 <Callout type="info">
   This also works with custom Objects as long as you have a Codec defined for the Object type.
diff --git a/content/docs/pt-BR/guides/java-basics/02-operators.mdx b/content/docs/pt-BR/guides/java-basics/02-operators.mdx
index 44c50994..894c5cba 100644
--- a/content/docs/pt-BR/guides/java-basics/02-operators.mdx
+++ b/content/docs/pt-BR/guides/java-basics/02-operators.mdx
@@ -119,7 +119,7 @@ String greetingWithName = "Olá, " + name + "!"; // "Olá, Alice!"
 
 ## Precedência de operador
 
-A Precendência do operador significa qual operador é avaliado primeiro em uma linha de código. Pense nisso como a ordem das operações na matemática: parênteses, expoentes, multiplicação, divisão, adição e subtração!
+Operator Precedence means which operator gets evaluated first in an line of code. Pense nisso como a ordem das operações na matemática: parênteses, expoentes, multiplicação, divisão, adição e subtração!
 
 ```java
 int result = 10 + 5 * 2; // resultado é 20, não 30
diff --git a/content/docs/pt-BR/guides/java-basics/03-control-flow-if.mdx b/content/docs/pt-BR/guides/java-basics/03-control-flow-if.mdx
index 4e725554..271fec3e 100644
--- a/content/docs/pt-BR/guides/java-basics/03-control-flow-if.mdx
+++ b/content/docs/pt-BR/guides/java-basics/03-control-flow-if.mdx
@@ -7,7 +7,7 @@ Os programas precisam tomar decisões. Instruções "se" permitem que seu códig
 
 ## Declaração básica de if
 
-A forma mais simples verifica uma condição;
+The simplest form checks one condition:
 
 ```java
 int saude = 20;
diff --git a/content/docs/pt-BR/guides/java-basics/08-access-modifiers.mdx b/content/docs/pt-BR/guides/java-basics/08-access-modifiers.mdx
index 515ef2e4..cf80ca8a 100644
--- a/content/docs/pt-BR/guides/java-basics/08-access-modifiers.mdx
+++ b/content/docs/pt-BR/guides/java-basics/08-access-modifiers.mdx
@@ -383,7 +383,7 @@ public class ProtectedBlock {
 ## Quando usar `Private` e `Public`
 
 <Callout type="info" title="Regras gerais">
-  **Make it private by default!** Only make things public if they need to be accessed from outside.
+  **Torne-o privado por padrão!** Apenas torne as coisas públicas se elas precisarem ser acessadas pela lado de fora.
 
   **Private:**
 
@@ -399,17 +399,17 @@ public class ProtectedBlock {
 
   ```java
   public class Example {
-      // Private - internal data
+      // Privado — dados internos
       private int internalCounter;
       private String secretKey;
       
-      // Public - part of the interface
+      // Público — parte da interface
       public void doSomething() {
-          // Uses private helper method
+          // Usa um método auxiliar privado
           validateData();
       }
       
-      // Private - internal helper
+      // Auxiliar interno privado
       private void validateData() {
           // ...
       }
@@ -419,7 +419,7 @@ public class ProtectedBlock {
 
 ## A palavra-chave `final`
 
-`final` means a variable can't be changed after it's set:
+A palavra-chave `final` significa que uma variável não pode ser alterada após ser definida:
 
 ```java
 public class Player {
@@ -452,13 +452,13 @@ public class Player {
 
 ### Membros estáticos
 
-A class can define two kinds of members:
+Uma classe pode definir dois tipos de membros:
 
-* **Instance members** — owned by each object (each instance has its own copy).
+* **Membros de instância**: pertencentes a cada objeto (cada instância tem sua própria cópia);
 
-* **Static members** — owned by the class (one shared copy for the entire type).
+* **Membros estáticos**: pertencentes à classe (uma cópia compartilhada do tipo inteiro).
 
-Put simply: instance members belong to objects; static members belong to the class itself and are shared by all objects of that type.
+Simplificando um pouco: os "membros da instância" pertencem a objetos, enquanto os "membros estáticos" pertencem à própria classe e são compartilhados por todos os objetos desse tipo.
 
 #### Declaração
 
@@ -483,27 +483,27 @@ class Data {
     // Static member:
     // cannot access to non-static variables
     public static void bar() {
-        x = 100; // Error: non-static variable x cannot be renference from a static context
+        x = 100; // Error: non-static variable x cannot be referenced from a static context
         y = 100; // OK
     }
 }
 ```
 
-#### Accessing static members
+#### Acessando membros estáticos
 
 ```java
 Data data = new Data();
 data.x = 1000; // OK
 
-data.y = 1000; // OK-ish - not really suggested; it's better to use Data.y
-Data.y = 1000; // OK - best practice
+data.y = 1000; // OK-ish — implementação não recomendada. É preferível realizar a referência via Data.y.
+Data.y = 1000; // OK — boas práticas
 
-Data.x = 1000; // Error: cannot access instanced variables in a static context
+Data.x = 1000; // Erro: não é possível acessar variáveis de instância em um contexto estático
 ```
 
 ### Campos estáticos
 
-A static field represents a data member owned by the class type rather then the object. Static fields are also stored in a specific memory location that's been shared between all the object instances that are created.
+A static field represents a data member owned by the class type rather than the object. Os campos estáticos são armazenados em um local de memória específico, compartilhado entre todas as instâncias de objetos criadas.
 
 É declarado o seguinte:
 
@@ -511,44 +511,44 @@ A static field represents a data member owned by the class type rather then the
 /* (modificador de acesso) (opcional) */ static /* final/volatile (opcional) */ fieldName;
 ```
 
-Let's take the same Data class example and add this constructor:
+Pegaremos o mesmo exemplo da classe `Data` e adicionaremos este construtor:
 
 ```java
 public Data() {
-    y++; // remember that's the same as Data.y++;
+    y++; // lembre-se de que isso é o mesmo que Data.y++;
 }
 ```
 
 ```java
-// Every instance of Data will have a private copy of the instanced member x
-// However it will point to the same location in memory for the member y
+// Cada instância de Data possuirá uma cópia privada do membro de instância x.
+// Entretanto, todas apontarão para a mesma localização de memória em relação ao membro y.
 Data d1 = new Data(); // y = 1001
 d1.x = 5;
 Data d2 = new Data(); // y = 1002
 d2.x = 25;
 Data d3 = new Data(); // y = 1003
-// ... and so on
+// ... e assim por diante
 ```
 
 ### Métodos estáticos
 
-Static methods essentially represent a function member of a certain class type
+Os métodos estáticos representam, essencialmente, um membro funcional vinculado a um determinado tipo de classe.
 
-From the Data class remember the function (instanced method) `foo` and (static method) `bar`
+A partir da classe `Data`, considere o método de instância `foo`e o método estático `bar`.
 
-One can access those methods via:
+Acesse os métodos com:
 
 ```java
 Data d1 = new Data();
 
-d1.foo(); // Instanced method: Accessible ONLY by an object
+d1.foo(); // Método de instância: acessível SOMENTE por um objeto
 
-Data.bar(); // Static method: accessible without an object
+Data.bar(); // Método estático: acessível sem um objeto
 ```
 
 ### Inicializador estático
 
-Use a *static initializer* block to run initialization logic when the class is first loaded:
+Use um bloco de *inicialização estática* para executar a lógica de configuração no momento do carregamento inicial da classe:
 
 ```java
 class OtherData {
diff --git a/content/docs/pt-BR/guides/java-basics/09-string.mdx b/content/docs/pt-BR/guides/java-basics/09-string.mdx
index 1a66122c..251be6cf 100644
--- a/content/docs/pt-BR/guides/java-basics/09-string.mdx
+++ b/content/docs/pt-BR/guides/java-basics/09-string.mdx
@@ -436,8 +436,8 @@ public static int countOccurrences(String text, String target) {
     return count;
 }
 
-// Usage
-int count = countOccurrences("hello hello world", "hello");
+// Modo de uso
+int count = countOccurrences("olá olá mundo", "olá");
 System.out.println(count);  // 2
 ```
 
@@ -449,12 +449,12 @@ public static String reverse(String text) {
     return sb.reverse().toString();
 }
 
-// Usage
-String reversed = reverse("Hello");
-System.out.println(reversed);  // "olleH"
+// Modo de uso
+String reversed = reverse("Olá");
+System.out.println(reversed);  // "álO"
 ```
 
-### Check if Palindrome
+### Verifique se é um palíndromo
 
 ```java
 public static boolean isPalindrome(String text) {
@@ -463,31 +463,31 @@ public static boolean isPalindrome(String text) {
     return cleaned.equals(reversed);
 }
 
-// Usage
-System.out.println(isPalindrome("racecar"));     // true
-System.out.println(isPalindrome("hello"));       // false
+// Modo de uso
+System.out.println(isPalindrome("carrodecorrida"));     // Correto
+System.out.println(isPalindrome("olá"));       // Errado
 ```
 
 ## Exercícios práticos
 
-1. **Username Checker**: Write a method that checks if a username:
-   - Is between 3 and 16 characters
-   - Contains only letters, numbers, and underscores
-   - Doesn't start with a number
-   - Returns true if valid, false otherwise
+1. **Verificador de nome de usuário**: escreva um método que verifique se um nome de usuário:
+   - Deve ter entre 3 e 16 caracteres;
+   - Conter apenas letras, números e sublinhados;
+   - Não pode começar com um número;
+   - Retorna _true_ se for válido e _false_ se não for.
 
-2. **Command Parser**: Parse this command format: `/teleport x y z`
-   - Extract the coordinates
-   - Convert them to integers
-   - Return an array of the three values
+2. **Command `parse`**: realize o `parse` deste formato de comando: `/teleport x y z`:
+   - Extraia as coordenadas;
+   - Converta para números inteiros;
+   - Retorne um array de três valores.
 
-3. **Chat Formatter**: Create a method that formats chat messages:
-   - Input: player name, rank, message
-   - Output: `"[RANK] PlayerName: message"`
-   - If no rank, just show `"PlayerName: message"`
+3. **Formatador de bate-papo**: crie um método que formate as mensagens do bate-papo:
+   - Input: nome do jogador, rank, mensagem;
+   - Output: `"[RANK] nome do jogador: mensagem"`;
+   - Se não houver rank, apenas mostre `"Nome do jogador: mensagem"`.
 
-4. **Word Counter**: Count how many words are in a sentence (words are separated by spaces)
+4. **Contagem de palavras**: contar quantas palavras há em uma frase (as palavras são separadas por espaços).
 
-5. **Title Case**: Convert a string to title case:
-   - Input: `"hello world"`
-   - Output: `"Hello World"`
+5. **Title-case**: converter uma sequência de caracteres para maiúsculas e minúsculas:
+   - Input: `"olá mundo"`;
+   - Output: `"Olá Mundo"`.
diff --git a/content/docs/pt-BR/guides/java-basics/11-hashmaps.mdx b/content/docs/pt-BR/guides/java-basics/11-hashmaps.mdx
index 751708b2..e64568a5 100644
--- a/content/docs/pt-BR/guides/java-basics/11-hashmaps.mdx
+++ b/content/docs/pt-BR/guides/java-basics/11-hashmaps.mdx
@@ -1,5 +1,5 @@
 ---
-title: 11 — HashMap e armazenamento de chaves-Valor
+title: 11 — HashMap e armazenamento de chaves-valor
 description: Aprenda a armazenar e recuperar dados usando pares de chave-valor.
 ---
 
@@ -56,9 +56,9 @@ public class Main {
 ```java
 HashMap<String, Integer> scores = new HashMap<>();
 
-scores.put("Alice", 100);     // Add new entry
+scores.put("Alice", 100);     // Adiciona uma nova entrada
 scores.put("Bob", 150);
-scores.put("Alice", 200);     // Update existing (Alice now 200)
+scores.put("Alice", 200);     // Atualiza a existente (Alice agora tem 200)
 ```
 
 ### Obtendo valores
@@ -68,10 +68,10 @@ HashMap<String, Integer> scores = new HashMap<>();
 scores.put("Alice", 100);
 
 int score = scores.get("Alice");        // 100
-Integer missing = scores.get("Dave");   // null (doesn't exist)
+Integer missing = scores.get("Dave");   // null (inexistente)
 
-// Get with default value
-int score2 = scores.getOrDefault("Dave", 0);  // 0 (returns default)
+// Obtém com o valor padrão
+int score2 = scores.getOrDefault("Dave", 0);  // 0 (retorna o valor padrão)
 ```
 
 ### Verificando chaves/valores
@@ -94,10 +94,10 @@ HashMap<String, Integer> scores = new HashMap<>();
 scores.put("Alice", 100);
 scores.put("Bob", 150);
 
-scores.remove("Alice");           // Remove by key
+scores.remove("Alice");           // Remove por chave
 System.out.println(scores);       // {Bob=150}
 
-scores.clear();                   // Remove everything
+scores.clear();                   // Remove tudo
 System.out.println(scores);       // {}
 ```
 
@@ -108,7 +108,7 @@ HashMap<String, Integer> scores = new HashMap<>();
 scores.put("Alice", 100);
 
 int size = scores.size();         // 1
-boolean empty = scores.isEmpty(); // false
+boolean empty = scores.isEmpty(); // falso
 ```
 
 ## Repetição por HashMaps
@@ -124,7 +124,7 @@ scores.put("Charlie", 75);
 for (String name : scores.keySet()) {
     System.out.println(name);
 }
-// Output: Alice, Bob, Charlie (order may vary)
+// Output: Alice, Bob, Charlie (a ordem pode mudar)
 ```
 
 ### Por valores
@@ -133,7 +133,7 @@ for (String name : scores.keySet()) {
 for (Integer score : scores.values()) {
     System.out.println(score);
 }
-// Output: 100, 150, 75 (order may vary)
+// Output: 100, 150, 75 (a ordem pode mudar)
 ```
 
 ### Por chaves e valores
@@ -144,7 +144,7 @@ for (String name : scores.keySet()) {
     System.out.println(name + ": " + score);
 }
 
-// Or using entrySet (more efficient)
+// Ou usando entrySet (mais eficiente)
 for (var entry : scores.entrySet()) {
     String name = entry.getKey();
     int score = entry.getValue();
@@ -153,7 +153,7 @@ for (var entry : scores.entrySet()) {
 ```
 
 <Callout type="info" title="Ordem do HashMap">
-  HashMap does **not** maintain insertion order! If you need order, use `LinkedHashMap`:
+  Um HashMap **não** mantém a ordem de inserção! Se isso for necessário, use `LinkedHashMap`:
 
   ```java
   import java.util.LinkedHashMap;
@@ -163,11 +163,11 @@ for (var entry : scores.entrySet()) {
   orderedScores.put("Bob", 150);
   orderedScores.put("Charlie", 75);
 
-  // Will print in insertion order
+  // Será impresso na ordem de inserção
   for (String name : orderedScores.keySet()) {
       System.out.println(name);
   }
-  // Output: Alice, Bob, Charlie (guaranteed order)
+  // Output: Alice, Bob, Charlie (ordem garantida)
   ```
 </Callout>
 
@@ -183,12 +183,12 @@ public class PlayerStats {
     
     public PlayerStats() {
         this.stats = new HashMap<>();
-        // Initialize default stats
-        stats.put("health", 100);
+        // Inicializa as estatísticas padrões
+        stats.put("vida", 100);
         stats.put("mana", 50);
-        stats.put("strength", 10);
-        stats.put("defense", 5);
-        stats.put("speed", 8);
+        stats.put("força", 10);
+        stats.put("defesa", 5);
+        stats.put("velocidade", 8);
     }
     
     public int getStat(String statName) {
@@ -205,23 +205,23 @@ public class PlayerStats {
     }
     
     public void displayStats() {
-        System.out.println("=== Player Stats ===");
+        System.out.println("=== Estatísticas do jogador  ===");
         for (var entry : stats.entrySet()) {
             System.out.println(entry.getKey() + ": " + entry.getValue());
         }
     }
 }
 
-// Usage
+// Modo de uso
 public class Main {
     public static void main(String[] args) {
         PlayerStats stats = new PlayerStats();
         stats.displayStats();
         
-        stats.modifyStat("strength", 5);
-        stats.modifyStat("health", -20);
+        stats.modifyStat("força", 5);
+        stats.modifyStat("vida", -20);
         
-        System.out.println("\nAfter modifications:");
+        System.out.println("\nApós alterações:");
         stats.displayStats();
     }
 }
@@ -241,10 +241,10 @@ public class ItemDatabase {
     
     public void addItem(String itemName) {
         HashMap<String, Object> properties = new HashMap<>();
-        properties.put("damage", 0);
-        properties.put("durability", 100);
-        properties.put("rarity", "Common");
-        properties.put("stackable", true);
+        properties.put("dano", 0);
+        properties.put("durabilidade", 100);
+        properties.put("raridade", "Comum");
+        properties.put("empilhável", true);
         
         items.put(itemName, properties);
     }
@@ -264,7 +264,7 @@ public class ItemDatabase {
     
     public void displayItem(String itemName) {
         if (!items.containsKey(itemName)) {
-            System.out.println("Item not found!");
+            System.out.println("item não encontrado!");
             return;
         }
         
@@ -276,16 +276,16 @@ public class ItemDatabase {
     }
 }
 
-// Usage
+// Classe de uso
 public class Main {
     public static void main(String[] args) {
         ItemDatabase db = new ItemDatabase();
         
-        db.addItem("Iron Sword");
-        db.setProperty("Iron Sword", "damage", 15);
-        db.setProperty("Iron Sword", "rarity", "Uncommon");
+        db.addItem("Espada de Ferro");
+        db.setProperty("Espada de Ferro", "dano", 15);
+        db.setProperty("Espada de Ferro", "raridade", "Incomum");
         
-        db.displayItem("Iron Sword");
+        db.displayItem("Espada de Ferro");
     }
 }
 ```
@@ -304,11 +304,11 @@ public class GameConfig {
     }
     
     private void loadDefaults() {
-        settings.put("difficulty", "normal");
-        settings.put("musicVolume", "50");
-        settings.put("sfxVolume", "50");
-        settings.put("renderDistance", "10");
-        settings.put("showFPS", "false");
+        settings.put("Dificuldade", "normal");
+        settings.put("Música", "50");
+        settings.put("Efeitos sonoros", "50");
+        settings.put("Distância de renderização", "10");
+        settings.put("Mostrar FPS", "false");
     }
     
     public String getSetting(String key) {
@@ -317,7 +317,7 @@ public class GameConfig {
     
     public void setSetting(String key, String value) {
         settings.put(key, value);
-        System.out.println("Set " + key + " to " + value);
+        System.out.println("Definir " + key + " para " + value);
     }
     
     public int getIntSetting(String key) {
@@ -334,7 +334,7 @@ public class GameConfig {
     }
     
     public void displaySettings() {
-        System.out.println("=== Game Settings ===");
+        System.out.println("=== Configuração do jogo ===");
         for (var entry : settings.entrySet()) {
             System.out.println(entry.getKey() + " = " + entry.getValue());
         }
@@ -358,25 +358,25 @@ public class Inventory {
     
     public boolean addItem(String itemName, int quantity) {
         if (items.size() >= maxSlots && !items.containsKey(itemName)) {
-            System.out.println("Inventory full!");
+            System.out.println("Inventário cheio!");
             return false;
         }
         
         int current = items.getOrDefault(itemName, 0);
         items.put(itemName, current + quantity);
-        System.out.println("Added " + quantity + "x " + itemName);
+        System.out.println("Adicionado: " + quantity + "x " + itemName);
         return true;
     }
     
     public boolean removeItem(String itemName, int quantity) {
         if (!items.containsKey(itemName)) {
-            System.out.println("Don't have that item!");
+            System.out.println("Não tenho esse item.!");
             return false;
         }
         
         int current = items.get(itemName);
         if (current < quantity) {
-            System.out.println("Not enough " + itemName);
+            System.out.println("Insuficiente: " + itemName);
             return false;
         }
         
@@ -386,7 +386,7 @@ public class Inventory {
             items.put(itemName, current - quantity);
         }
         
-        System.out.println("Removed " + quantity + "x " + itemName);
+        System.out.println("Removido: " + quantity + "x " + itemName);
         return true;
     }
     
@@ -399,9 +399,9 @@ public class Inventory {
     }
     
     public void displayInventory() {
-        System.out.println("\n=== Inventory (" + items.size() + "/" + maxSlots + " slots) ===");
+        System.out.println("\n=== Inventário (" + items.size() + "/" + maxSlots + " espaços) ===");
         if (items.isEmpty()) {
-            System.out.println("Empty");
+            System.out.println("Vazio");
         } else {
             for (var entry : items.entrySet()) {
                 System.out.println(entry.getKey() + " x" + entry.getValue());
@@ -410,18 +410,18 @@ public class Inventory {
     }
 }
 
-// Usage
+// Classe de uso
 public class Main {
     public static void main(String[] args) {
         Inventory inv = new Inventory(10);
         
-        inv.addItem("Wood", 64);
-        inv.addItem("Stone", 32);
-        inv.addItem("Wood", 20);  // Adds to existing
+        inv.addItem("Madeira", 64);
+        inv.addItem("Pedra", 32);
+        inv.addItem("Madeira", 20);  // Adicionado a quantidade existente
         
         inv.displayInventory();
         
-        inv.removeItem("Wood", 50);
+        inv.removeItem("Madeira", 50);
         inv.displayInventory();
     }
 }
@@ -442,7 +442,7 @@ public class CooldownManager {
     public void startCooldown(String ability, long durationMs) {
         long endTime = System.currentTimeMillis() + durationMs;
         cooldowns.put(ability, endTime);
-        System.out.println(ability + " on cooldown for " + (durationMs / 1000) + " seconds");
+        System.out.println(ability + " está em recarga por " + (durationMs / 1000) + " segundo(s)");
     }
     
     public boolean isOnCooldown(String ability) {
@@ -474,11 +474,11 @@ public class CooldownManager {
     public boolean useAbility(String ability, long cooldownSeconds) {
         if (isOnCooldown(ability)) {
             long remaining = getRemainingTime(ability);
-            System.out.println(ability + " is on cooldown (" + remaining + "s remaining)");
+            System.out.println(ability + " está recarregando (Tempo restante: " + remaining + "s)");
             return false;
         }
         
-        System.out.println("Used " + ability + "!");
+        System.out.println(ability + " usada!");
         startCooldown(ability, cooldownSeconds * 1000);
         return true;
     }
@@ -501,11 +501,11 @@ public class Player {
         this.health = 100;
     }
     
-    // Getters and setters...
+    // Obtentores e definidores...
     
     @Override
     public String toString() {
-        return name + " (Lv. " + level + ", HP: " + health + ")";
+        return name + " (Nível " + level + ", Vida: " + health + ")";
     }
 }
 
@@ -513,11 +513,11 @@ public class Main {
     public static void main(String[] args) {
         HashMap<String, Player> players = new HashMap<>();
         
-        players.put("player1", new Player("Alice", 10));
-        players.put("player2", new Player("Bob", 15));
+        players.put("jogador 1", new Player("Alice", 10));
+        players.put("jogador 2", new Player("Bob", 15));
         
-        // Get and use player
-        Player alice = players.get("player1");
+        // Obtém e usa o jogador
+        Player alice = players.get("jogador 1");
         System.out.println(alice);
     }
 }
@@ -525,44 +525,44 @@ public class Main {
 
 ## HashMaps aninhadas
 
-HashMaps can contain other HashMaps:
+Hashmaps podem conter outros HashMaps:
 
 ```java
-// Store multiple properties per player
+// Armazene várias propriedades por jogador
 HashMap<String, HashMap<String, Integer>> playerData = new HashMap<>();
 
-// Add player with stats
+// Adiciona um jogador com estatísticas
 HashMap<String, Integer> aliceStats = new HashMap<>();
-aliceStats.put("level", 10);
-aliceStats.put("health", 100);
+aliceStats.put("nível", 10);
+aliceStats.put("vida", 100);
 aliceStats.put("mana", 50);
 playerData.put("Alice", aliceStats);
 
-// Access nested data
-int aliceLevel = playerData.get("Alice").get("level");
-System.out.println("Alice's level: " + aliceLevel);
+// Acessa os dados inseridos
+int aliceLevel = playerData.get("Alice").get("nível");
+System.out.println("Nível de Alice: " + aliceLevel);
 ```
 
 ## Exercícios práticos
 
-1. **Phone Book**: Create a phone book that stores names and phone numbers. Add methods to:
-   - Add contact
-   - Find number by name
-   - Delete contact
-   - Display all contacts
-
-2. **Grade Manager**: Store student names and grades. Create methods to:
-   - Add student with grade
-   - Update grade
-   - Calculate class average
-   - Find highest grade
-
-3. **Word Counter**: Write a program that counts how many times each word appears in a sentence using a HashMap.
-
-4. **Item Shop**: Create a shop where items have names and prices. Add methods to:
-   - Add item with price
-   - Get item price
-   - Apply discount to all items
-   - Display all items and prices
+1. **Agenda telefônica**: crie uma agenda telefônica que armazena nomes e números de telefone. Adicione métodos para:
+   - Adicionar um contato;
+   - Encontrar um número pelo nome;
+   - Apagar um contato;
+   - Exibir todos os contatos.
+
+2. **Gerenciador de notas**: armazena os nomes e notas dos alunos. Crie métodos para:
+   - Adicionar um aluno com nota;
+   - Atualizar a nota;
+   - Calcular a média da classe;
+   - Encontrar a maior nota.
+
+3. **Contador de palavras**: escreva um programa que conta quantas vezes uma palavra aparece numa frase usando um HashMap.
+
+4. **Loja de itens**: crie uma loja onde os itens têm nomes e preços. Adicione métodos para:
+   - Adicionar um item com preço;
+   - Obter o preço de um item;
+   - Aplicar desconto a todos os itens;
+   - Exibir todos os itens e seus preços.
 
 ---
diff --git a/content/docs/pt-BR/guides/plugin/animated-block-textures.mdx b/content/docs/pt-BR/guides/plugin/animated-block-textures.mdx
new file mode 100644
index 00000000..42bfa51f
--- /dev/null
+++ b/content/docs/pt-BR/guides/plugin/animated-block-textures.mdx
@@ -0,0 +1,101 @@
+---
+title: Animated Block Textures
+description: Learn how to attach a .blockyanim to a block
+authors:
+  - name: Burkino
+---
+
+import { File, Folder, Files } from 'fumadocs-ui/components/files';
+
+So, you want to make your blocks feel more alive through animations, do you?\
+Now for the most part this is the exact same as [Creating custom blocks](./creating-block).
+![blue fire gif](/assets/guides/blue_fire.gif)
+
+## Prerequisites
+
+This is NOT a guide on animating or texturing or even using BlockBench, why? Because I don't know how to do that.\
+The only thing we will be doing is taking the fire texture, changing the color, and applying it to our new fire block.
+
+## Setup
+
+To start, you're obviously going to want to grab the `Common/VFX/Fire/Fire.png` file. How you do it is up to you, in the Asset Editor you'll need to switch to the Common tab.\
+I'll assume you know how colorize or change the hue of an image, so go ahead and do that now and save it as `Blue_Fire.png`.
+
+The other assets used in this guide are `Common/VFX/Fire/Fire.blockymodel` and `Common/Blocks/Animations/Fire/Fire_Burn.blockyanim` (both renamed to `Blue_Fire`) but since we won't be changing them it's probably fine to leave them. I will reference the `Blue_Fire` versions as a way to point out what should be custom assets.\
+I will also duplicate `Server/Item/Item/Deco/Deco_Fire.json` and call it `Deco_Blue_Fire.json`.
+
+## Applying the changes
+
+The `Deco_Blue_Fire` block is actually just a particle emitter, however we will not be using particles, so lets start by removing them in `Block > Particles`.\
+Next we want to set the Block Model (called `CustomModel` in JSON) to `VFX/Blue_Fire/Blue_Fire.blockymodel` and Block Model Textures (`CustomModelTexture` in JSON) to
+
+```json
+[
+    {
+        "Texture": "VFX/Blue_Fire/Blue_Fire.png",
+        "Weight": 1
+    }
+]
+```
+
+Finally, we will apply the .blockyanim to our model, this is done through the Block Model Animation property (`CustomModelAnimation` in JSON) and the value should be `Blocks/Animations/Blue_Fire/Blue_Fire_Burn.blockyanim`.
+
+## Final Code
+
+With that your new blue fire should be done. Here is the minimal JSON for our blue fire.\
+There is an additional `Looping` and `RequiresAlphaBlending` property that I have not gone over, however I hope it is self-explanatory.
+
+```json
+{
+  "BlockType": {
+    "DrawType": "Model",
+    "CustomModel": "VFX/Blue_Fire/Blue_Fire.blockymodel",
+    "CustomModelAnimation": "Blocks/Animations/Blue_Fire/Blue_Fire_Burn.blockyanim",
+    "CustomModelTexture": [
+      {
+        "Texture": "VFX/Blue_Fire/Blue_Fire.png",
+        "Weight": 1
+      }
+    ],
+    "Looping": true,
+    "RequiresAlphaBlending": false
+  },
+  "PlayerAnimationsId": "Block"
+}
+```
+
+<Files>
+  <Folder name="resources" defaultOpen>
+    <Folder name="Server" defaultOpen>
+      <Folder name="Item" defaultOpen>
+        <Folder name="Items" defaultOpen>
+          <Folder name="Deco" defaultOpen>
+            <File name="Deco_Blue_Fire.json" />
+          </Folder>
+        </Folder>
+      </Folder>
+    </Folder>
+
+    <Folder name="Common" defaultOpen>
+      <Folder name="Blocks" defaultOpen>
+        <Folder name="Animations" defaultOpen>
+          <Folder name="Blue_Fire" defaultOpen>
+            <File name="Blue_Fire_Burn.blockyanim" />
+          </Folder>
+        </Folder>
+      </Folder>
+
+      <Folder name="VFX" defaultOpen>
+        <Folder name="Blue_Fire" defaultOpen>
+          <File name="Blue_Fire.blockymodel" />
+
+          <File name="Blue_Fire.png" />
+        </Folder>
+      </Folder>
+    </Folder>
+  </Folder>
+</Files>
+
+## Next steps
+
+Now that you know how to attach an animation to a block, try adding it to a block state.
diff --git a/content/docs/pt-BR/guides/plugin/build-and-test.mdx b/content/docs/pt-BR/guides/plugin/build-and-test.mdx
index 0e7fe7eb..f37534c3 100644
--- a/content/docs/pt-BR/guides/plugin/build-and-test.mdx
+++ b/content/docs/pt-BR/guides/plugin/build-and-test.mdx
@@ -9,18 +9,18 @@ If you followed along with the [Setting Up Your Development Environment](./setti
 
 ## Building Your Mod
 
-In our case, we've **Maven** as the build system. Maven is a powerful build automation tool that manages dependencies, compiles your code, and packages everything into a distributable JAR file.
+In our case, we've **Gradle** as the build system. Gradle is a powerful build automation tool that manages dependencies, compiles your code, and packages everything into a distributable JAR file.
 
-### Understanding Maven
+### Understanding Gradle
 
-Maven uses a `pom.xml` file (Project Object Model) to define your project's configuration, dependencies, and build settings. You can learn more about Maven at the [official Apache Maven website](https://maven.apache.org/).
+Gradle can use a `build.gradle.kts` file (Kotlin DSL) to define your project's configuration, dependencies, and build settings. You can learn more about Gradle at the [official Gradle website](https://gradle.org/).
 
-### Building with Maven
+### Building with Gradle
 
 To build your mod, open a terminal in your project directory and run:
 
 ```bash
-mvn package
+./gradlew build
 ```
 
 This command will:
@@ -29,16 +29,35 @@ This command will:
 2. Run any tests (if present)
 3. Package everything into a JAR file
 
+<Callout type="info">
+  If you are using the plugin template from the [Setting Up Your Development Environment](./setting-up-env) guide, then the build script is already set up for you. It includes paths to your Hytale game library and handles the packaging of your mod, managing hytale dependencies and manifest changes.
+
+  If you have a different path to your Hytale installation, you may receive the following error:
+
+  ```bash
+  FAILURE: Build failed with an exception.
+
+  * What went wrong:
+  Failed to find Hytale at the expected location. Please make sure you have installed the game. The expected location can be changed using the hytale.home_path property. Currently looking in 'C:\Path\To\Hytale'
+  ```
+
+  You can change the path by adding a property to your `gradle.properties` file (if it doesn't exist, create it in the root of your project):
+
+  ```properties
+  hytale.home_path=C:\Correct\Path\To\Hytale
+  ```
+</Callout>
+
 ### Build Output
 
-Once the build completes successfully, your mod will be located in the `target` directory and named:
+Once the build completes successfully, your mod will be located in the `build/libs` directory and named:
 
 ```
-ExamplePlugin-1.0-SNAPSHOT.jar
+ExamplePlugin-1.0.jar
 ```
 
 <Callout type="info">
-  The exact name may vary depending on what you configured in your `pom.xml` file. Check the `artifactId` and `version` fields to see what your JAR will be named.
+  The exact name may vary depending on what you configured in your `build.gradle.kts` and `settings.gradle.kts` file. Check the `rootProject.name` and `version` fields to see what your JAR will be named.
 </Callout>
 
 ## Testing Your Mod
@@ -49,11 +68,11 @@ Now that you've built your mod, it's time to test it in Hytale!
 
 First, you need to find Hytale's mods directory:
 
-1. Press **Win + R** on your keyboard
-2. Type `%appdata%` and press Enter
-3. Navigate to: `Hytale\UserData\Mods`
+1. Go to your Hytale installation directory (The default location is usually in your AppData folder)
+   > On Windows, you can access it by clicking `windows + R` and typing `%appdata%`.
+2. Navigate to: `/UserData/Mods`
 
-The full path should look like:
+The default path would look like:
 
 ```
 C:\Users\YourUsername\AppData\Roaming\Hytale\UserData\Mods
@@ -65,7 +84,7 @@ C:\Users\YourUsername\AppData\Roaming\Hytale\UserData\Mods
 
 ### 2. Copy Your Mod
 
-Copy the `ExamplePlugin-1.0-SNAPSHOT.jar` file from your project's `target` directory into the `Mods` folder you just located.
+Copy the `ExamplePlugin-1.0.jar` file from your project's `build/libs` directory into the `Mods` folder you just located.
 
 ### 3. Launch Hytale and Verify
 
@@ -84,7 +103,7 @@ If your mod doesn't appear in the mods list:
 - Make sure the JAR file is in the correct `Mods` folder
 - Check that your `manifest.json` file is properly configured
 - Look for any error messages in the Hytale logs
-- Verify that you're using the correct version of Java and Maven
+- Verify that you're using the correct version of Java and Gradle
 
 ## Next Steps
 
diff --git a/content/docs/pt-BR/guides/plugin/creating-commands.mdx b/content/docs/pt-BR/guides/plugin/creating-commands.mdx
index 97ce454b..77acbf59 100644
--- a/content/docs/pt-BR/guides/plugin/creating-commands.mdx
+++ b/content/docs/pt-BR/guides/plugin/creating-commands.mdx
@@ -8,6 +8,8 @@ authors:
     url: https://oskar.scot
   - name: jacobwojoski
     url: https://github.com/jacobwojoski
+  - name: Marcel-TO
+    url: https://marcel-to.net
 ---
 
 In this guide, you will learn how to create custom commands for your Hytale mod.
@@ -36,7 +38,7 @@ The most basic command is an `AbstractAsyncCommand`. It has very minimal data av
   `AbstractAsyncCommand` runs on its own background thread. This means its execute is not tied to any world instance and because of this it can not edit any **Stores** or **Refs** without getting the desired world first. To access this data any of the other command types would be preferred and are likely what you will want to use instead.
 </Callout>
 
-The main purpose for a command like this would be for something that can happen everywhere and is not tied to a specific world. For example a `serverRules` command to tell the user thats running the command in chat what the servers rules are nomatter what world they are in.
+The main purpose for a command like this would be for something that can happen everywhere and is not tied to a specific world. For example a `serverRules` command to tell the user that's running the command in chat what the server's rules are no matter what world they are in.
 
 ```java
 // Command that can be run that lists the server rules in chat to the player
@@ -49,7 +51,7 @@ public class ServerRulesCommand extends AbstractAsyncCommand {
     }
 
     // Run the command
-    // conetext - info about who ran the command. Server console?, Some player?
+    // context - info about who ran the command. Server console?, Some player?
     @Override
     protected CompletableFuture<Void> executeAsync(@Nonnull CommandContext context) {
         context.sendMessage(Message.raw("The only rule is there are no rules."));
@@ -134,7 +136,7 @@ Uses a Ray to see what the player is looking at and tries to run the command on
 
 ## Adicionando argumentos
 
-Arguments are additional fields that the user can input when running a command. The different types of arguments along with small snipits and a large example can be seen below.
+Arguments are additional fields that the user can input when running a command. The different types of arguments along with small snippets and a large example can be seen below.
 
 ### Command Argument Types
 
@@ -163,14 +165,14 @@ this.messageArg = this.withOptionalArg("message", "Message to print while healin
 
 ### Default Arguments
 
-Adding a default argument has two additional arguemnt for the default value and default value description. You need to use `withDefaultArg` method.
+Adding a default argument has two additional argument for the default value and default value description. You need to use `withDefaultArg` method.
 
 ```java
 // args <Command String> <Description> <Default Value> <Desc of default value>
 this.healthArg = this.withDefaultArg("health", "Amount to heal player", ArgTypes.FLOAT, (float)100, "Desc of Default: 100");
 ```
 
-### Flag Arguemnts
+### Flag Arguments
 
 Similar as above but the flags return is either true if it exists or false if it does not. You need to use `withFlagArg` method.
 
@@ -181,20 +183,13 @@ this.debugArg = this.withFlagArg("debug", "Add debug logs");
 
 ### ArgTypes
 
-The following ArgTypes are available (only lists common types):
-
-- `ArgTypes.STRING`
-- `ArgTypes.INTEGER`
-- `ArgTypes.BOOLEAN`
-- `ArgTypes.FLOAT`
-- `ArgTypes.DOUBLE`
-- `ArgTypes.UUID`
+You can find all the available argument types on the [ArgTypes](../../argtypes) page.
 
 ### Example Command Arg Types
 
-Shows all Command arguemnt types with different various input types.
+Shows all Command argument types with different various input types.
 
-**NOTE:** When getting the value of an argument during execute you need to pass the context with `someArg.get(commandContext)`. Where `commandContext` is the first variable in the execute funtion.
+**NOTE:** When getting the value of an argument during execute you need to pass the context with `someArg.get(commandContext)`. Where `commandContext` is the first variable in the execute function.
 
 ```java
 // Example usage: /healplayer --health 50 --message "Feels Good" --debug
@@ -204,7 +199,7 @@ public class HealPlayerCommand extends AbstractTargetPlayerCommand {
     private final FlagArg debugArg;
 
     public HealPlayerCommand() {
-        super("healplayer", "Healing a player for an <input> ammount of HP (default: 100)");
+        super("healplayer", "Healing a player for an <input> amount of HP (default: 100)");
 
         // Abstract TargetPlayerCommand passes the player that ran the command by default and implements
         // the use of `--player <value>` to specify someone else
@@ -213,10 +208,10 @@ public class HealPlayerCommand extends AbstractTargetPlayerCommand {
         this.healthArg = this.withDefaultArg("health", "Amount to heal player", ArgTypes.FLOAT, (float)100, "Desc of Default: 100");
 
         // Or you could do the following making the health value required instead of with a default.
-        //    You would need to change the decleration to RequiredArg<Float>
+        //    You would need to change the declaration to RequiredArg<Float>
         // this.healthArg = this.withRequiredArg("health", "Amount to heal player", ArgTypes.FLOAT);
 
-        // Optional args reguare the user the input `--<key> <value>` so the following would require `--message "Good Luck"`
+// Optional args require the user the input `--<key> <value>` so the following would require `--message "Good Luck"`
         this.messageArg = this.withOptionalArg("message", "Message to print while healing", ArgTypes.STRING);
 
         // No type needed due to being a bool
@@ -230,7 +225,7 @@ public class HealPlayerCommand extends AbstractTargetPlayerCommand {
             commandContext.sendMessage(Message.raw("We are debugging"));
         }
 
-        // Health is stored in a generic stat map to allowing mods/future contect to easily add more stats if desired.
+        // Health is stored in a generic stat map to allowing mods/future content to easily add more stats if desired.
         EntityStatMap stats = store.getComponent(ref, EntityStatMap.getComponentType());
         int healthIdx = DefaultEntityStatTypes.getHealth();
         EntityStatValue health = stats.get(healthIdx);
@@ -252,7 +247,7 @@ public class HealPlayerCommand extends AbstractTargetPlayerCommand {
 
 ## Argument Validators
 
-Argument validators are a way to check the command before the command gets executed. They are added with the `addValidator` method on an argument when calling `withXxxArg`. They provide a nice output to the user when an input value is invalid.
+Argument validators are a way to check the command before the command gets executed. They are added with the `addValidator` method on an argument when calling `withXxxArg`. They provide a nice output to the user when an input value is invalid. There are some common validators provided in the `Validators` class such as `greaterThan`, `lessThan`, and `or`, `max`, `range`, etc.
 
 ```java
 ...
@@ -260,18 +255,59 @@ Argument validators are a way to check the command before the command gets execu
     OptionalArg<Integer> healAmount = withOptionalArg("amount", "Heal Amount", ArgTypes.INTEGER)
         .addValidator(Validators.greaterThan(0))
         .addValidator(Validators.lessThan(1000));
-
-    // Custom check example
-    OptionalArg<Integer> healAmount = withOptionalArg("amount", "Heal Amount", ArgTypes.INTEGER)
-            .addValidator( value -> {
-                if (value != null && value <= 0) {
-                    return ValidationResult.error("ammount argument must be a positive number");
-                }
-                return ValidationResult.success();
-            });
 ...
 ```
 
+### Custom Validators
+
+You can also create custom validators by implementing the `com.hypixel.hytale.codec.validation.Validator` interface. The interfaces forces you to implement the `accept` and `updateSchema` method. The `accept` method takes in the argument value and validates it. If the validation fails, you can use the `fail` method of the `com.hypixel.hytale.codec.validation.ValidationResults` class to return an error message.
+The `updateSchema` method is used to update the schema of the command argument. This is used for commands that have dynamic schemas based on the input value. For example, if you have a command that takes in a player name as an argument, you can use the `updateSchema` method to update the schema to include a list of online players for validation.
+
+Here is an example of a custom validator that checks if a string value is equal to a banned word. In this example, the banned word is "badword". If the input value is "badword", the validator will fail and return an error message.
+
+```java
+import com.hypixel.hytale.codec.schema.SchemaContext;
+import com.hypixel.hytale.codec.schema.config.Schema;
+import com.hypixel.hytale.codec.validation.ValidationResults;
+import com.hypixel.hytale.codec.validation.Validator;
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+
+public class MyCustomValidator implements Validator<String> {
+    @Nonnull
+    private final String value;
+
+    public MyCustomValidator(@Nonnull String value) {
+        this.value = value;
+    }
+
+    @Override
+    public void accept(@Nullable String input, @Nonnull ValidationResults results) {
+        if (this.value.equalsIgnoreCase(input)) {
+            results.fail("The given role has been banned.");
+        }
+    }
+
+    @Override
+    public void updateSchema(SchemaContext context, @Nonnull Schema target) {
+        // This method can be used to update the schema of the command argument. This is useful for commands that have dynamic schemas based on the input value. For example, if you have a command that takes in a player name as an argument, you can use the `updateSchema` method to update the schema to include a list of online players for validation.
+        throw new UnsupportedOperationException("Not implemented yet.");
+    }
+}
+```
+
+After the custom validator is created, you can add it to an argument like the following example. In this example, we add the `MyCustomValidator` to a string argument called "role". If the user inputs "badword" as the role, the command will fail and return the error message defined in the `MyCustomValidator`.
+
+```java
+    ...
+    // Custom validator example
+    String bannedRole = "badword";
+
+    OptionalArg<String> roleArg = withOptionalArg("role", "Role to assign", ArgTypes.STRING)
+        .addValidator(new MyCustomValidator(bannedRole));
+    ...
+```
+
 ---
 
 ## Permissions
@@ -312,7 +348,7 @@ This allows the server to control who has access to specific commands. You add t
 
 If you want variants of the same command without doing argument parsing you can instead use `addUsageVariant(new OtherCommandClass())` in the original commands constructor.
 
-The only difference is in the `OtherCommandClass()` constrcutor you don't pass the command name to the super class.
+The only difference is in the `OtherCommandClass()` constructor you don't pass the command name to the super class.
 
 <Callout type="info">
   You can also use `addAliases("some_alias", "some_other_alias")` as a way to add shorthand or other ways to write the same command.
@@ -387,7 +423,7 @@ public class AdminCommand extends AbstractCommandCollection {
     public AdminCommand () {
         super("admin", "Admin commands");
         addSubCommand(new UserCommandCollection());
-        addSybCommand(new ServerCommandCollection);
+        addSubCommand(new ServerCommandCollection);
     }
 }
 ```
@@ -417,5 +453,5 @@ public class MyPlugin extends JavaPlugin {
 
 ## Video Link
 
-_Special Thanks to [TroubleDev](https://www.youtube.com/@TroubleDEV) for his excelent video guide on all of these features._
+_Special Thanks to [TroubleDev](https://www.youtube.com/@TroubleDEV) for his excellent video guide on all of these features._
 _Video Link: [TroubleDev - Hytale's Command API Explained](https://www.youtube.com/watch?v=KnmhG9MDMgo)_
diff --git a/content/docs/pt-BR/guides/plugin/creating-events.mdx b/content/docs/pt-BR/guides/plugin/creating-events.mdx
index 4f8026f8..f68ff024 100644
--- a/content/docs/pt-BR/guides/plugin/creating-events.mdx
+++ b/content/docs/pt-BR/guides/plugin/creating-events.mdx
@@ -1,6 +1,6 @@
 ---
-title: Criando eventos
-description: Aprenda a criar eventos personalizados para o seu mod de Hytale.
+title: Creating Events Listeners
+description: Learn how to create event listeners for your Hytale mod.
 authors:
   - name: Neil Revin
     url: https://itsneil.dev
@@ -10,7 +10,7 @@ authors:
 
 ## Classe de evento
 
-Você pode importar uma classe de evento e criar uma função com o evento como argumento. [Clique aqui](../../server/events) para ver todos os eventos disponíveis.
+You can import an Event class and create a function with the Event as an argument. [Clique aqui](../../server/events) para ver todos os eventos disponíveis.
 
 Exemplo de plugin para quando um jogador estiver pronto (entrar num servidor):
 
diff --git a/content/docs/pt-BR/guides/plugin/item-registry.mdx b/content/docs/pt-BR/guides/plugin/item-registry.mdx
new file mode 100644
index 00000000..9a0fd53a
--- /dev/null
+++ b/content/docs/pt-BR/guides/plugin/item-registry.mdx
@@ -0,0 +1,95 @@
+---
+title: Working with the Item Registry
+description: Learn how to access and query the game's item registry to list all items, check if items exist, and retrieve item properties.
+authors:
+  - name: Denis
+---
+
+In this guide, you'll learn how to work with Hytale's Item Registry system. This is useful when you need to programmatically list all available items, validate item IDs, or retrieve item properties at runtime.
+
+## Prerequisites
+
+Before diving in, you should be familiar with:
+
+- [Setting up your development environment](./setting-up-env)
+- [Creating commands](./creating-commands) (optional, for testing)
+
+## Required Imports
+
+To work with the Item Registry, you'll need the following imports:
+
+```java
+import com.hypixel.hytale.assetstore.map.DefaultAssetMap;
+import com.hypixel.hytale.server.core.asset.type.item.config.Item;
+```
+
+## Getting the Item Registry
+
+The Item Registry is accessed through the `Item.getAssetMap()` method, which returns a `DefaultAssetMap<String, Item>` containing all registered items in the game:
+
+```java
+DefaultAssetMap<String, Item> itemMap = Item.getAssetMap();
+```
+
+## Listing All Items
+
+To iterate through all items in the registry, you can get the underlying map and loop through its entries:
+
+```java
+DefaultAssetMap<String, Item> itemMap = Item.getAssetMap();
+var map = itemMap.getAssetMap();
+
+for (var entry : map.entrySet()) {
+    String itemId = String.valueOf(entry.getKey());
+    Item item = entry.getValue();
+    
+    // Do something with the item
+    LOGGER.atInfo().log("Item ID: " + itemId);
+}
+```
+
+You can also get the total count of registered items:
+
+```java
+int totalItems = map.size();
+```
+
+## Checking if an Item Exists
+
+To check if a specific item exists in the registry, use `getAsset()` and verify the result:
+
+```java
+public boolean itemExists(String itemId) {
+    var assetMap = Item.getAssetMap();
+    if (assetMap != null) {
+        Item item = assetMap.getAsset(itemId);
+        return item != null && item != Item.UNKNOWN;
+    }
+    return false;
+}
+```
+
+<Callout type="info">
+  The `Item.UNKNOWN` constant represents an invalid or unrecognized item. Always check for both `null` and `Item.UNKNOWN` when validating items.
+</Callout>
+
+## Accessing Item Properties
+
+Once you have an `Item` instance, you can access various properties:
+
+```java
+var assetMap = Item.getAssetMap();
+Item item = assetMap.getAsset("Soil_Grass");
+
+if (item != null && item != Item.UNKNOWN) {
+    String id = item.getId(); // Soil_Grass
+    int maxStack = item.getMaxStack(); // 100
+    boolean isBlock = item.hasBlockType(); // true
+    boolean isConsumable = item.isConsumable(); // false
+}
+```
+
+## Related Guides
+
+- [Inventory Management](./inventory-management) - Learn how to add and remove items from player inventories
+- [Create Custom Item and Interaction](./item-interaction) - Learn how to create your own custom items
diff --git a/content/docs/pt-BR/guides/plugin/permission-management.mdx b/content/docs/pt-BR/guides/plugin/permission-management.mdx
index 5647e868..41e36b7a 100644
--- a/content/docs/pt-BR/guides/plugin/permission-management.mdx
+++ b/content/docs/pt-BR/guides/plugin/permission-management.mdx
@@ -10,132 +10,569 @@ authors:
     link: https://discord.com/users/292656109939064833
   - name: Ivan
     link: https://discord.com/users/505770451218333717
+  - name: ZenithDevHQ
+    link: https://github.com/ZenithDevHQ
 ---
 
-In this guide, you'll learn how to manage permission nodes and groups in your Hytale plugin.
+In this guide, you'll learn how to manage permission nodes and groups in your Hytale plugin. Permissions control what actions players can perform on your server, from basic commands to advanced administrative functions.
 
-## The `PermissionsModule` class
+## What Are Permissions?
 
-The `PermissionsModule` class is responsible for managing permission nodes and groups in your plugin. It provides methods to check, grant and revoke permissions and groups for players. It allows the following operations
+Permissions are string identifiers that control access to features and commands. When a player tries to perform an action (like using a command), the server checks if they have the required permission.
 
-- Add permissions to user
-- Remove permissions from user
-- Add permissions to group (this also creates the group if it doesn't exist)
-- Remove permissions from group
-- Add user to group
-- Remove user from group
-- List all groups for a user
-- Check if a user has a permission (it checks both user and group permissions for the given player UUID)
+**Example permission nodes:**
 
-With this class you cannot:
+- `hytale.command.gamemode` - Permission to use the gamemode command
+- `hytale.editor.brush.use` - Permission to use brush tools
+- `myplugin.teleport.home` - A custom permission for your plugin
 
-- List all defined groups
-- Remove a group
+Permissions follow a hierarchical naming pattern: `namespace.category.action`
 
-### Adding Permission Nodes
+## Key Concepts
 
-You need a `Set<String>` containing all the permission nodes you want to add, these are added on top of the already existing permission nodes the user may have, it is not a replacement.
+Before diving into code, let's understand the core concepts:
+
+| Concept             | Description                                                                |
+| ------------------- | -------------------------------------------------------------------------- |
+| **Permission Node** | A string like `myplugin.feature.use` that represents a specific permission |
+| **Group**           | A named collection of permissions (e.g., "Admin", "VIP", "Default")        |
+| **Provider**        | The backend that stores and retrieves permissions                          |
+| **Wildcard**        | A pattern like `*` or `myplugin.*` that matches multiple permissions       |
+
+### How Permissions Are Checked
+
+When checking if a player has a permission, Hytale follows this order:
+
+1. **User's direct permissions** - Permissions granted directly to the player
+2. **Group permissions** - Permissions from groups the player belongs to
+3. **Virtual groups** - Game-mode-based permissions (e.g., Creative mode grants builder tools)
+4. **Default value** - Falls back to `false` if no match found
+
+<Callout type="info">
+  The first definitive match wins. If a player has a permission granted at the user level, group permissions won't override it.
+</Callout>
+
+---
+
+## The `PermissionsModule` Class
+
+The `PermissionsModule` class is the central hub for managing permissions. Access it using the singleton pattern:
 
 ```java
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.addUserPermission(playerUUID, permissions);
 ```
 
-### Removing Permission Nodes
+### Available Operations
+
+The module supports these operations:
+
+| Operation                     | Method                                          |
+| ----------------------------- | ----------------------------------------------- |
+| Add permissions to user       | `addUserPermission(uuid, permissions)`          |
+| Remove permissions from user  | `removeUserPermission(uuid, permissions)`       |
+| Add permissions to group      | `addGroupPermission(groupName, permissions)`    |
+| Remove permissions from group | `removeGroupPermission(groupName, permissions)` |
+| Add user to group             | `addUserToGroup(uuid, groupName)`               |
+| Remove user from group        | `removeUserFromGroup(uuid, groupName)`          |
+| Get user's groups             | `getGroupsForUser(uuid)`                        |
+| Check permission              | `hasPermission(uuid, permissionNode)`           |
+
+<Callout type="warning">
+  The module does **not** support:
+
+  - Listing all defined groups
+  - Deleting a group entirely
+
+  Groups are implicitly created when you first add permissions to them.
+</Callout>
+
+---
 
-Same as above, we just use the `removeUserPermission` method instead to remove permission nodes.
+## Checking Permissions
+
+The most common operation is checking if a player has a permission.
+
+### Basic Permission Check
+
+```java
+// Returns true if player has the permission, false otherwise
+boolean canUse = PermissionsModule.get().hasPermission(playerUUID, "myplugin.feature.use");
+
+if (canUse) {
+    // Player has permission, allow the action
+} else {
+    // Player lacks permission, deny or show error
+}
+```
+
+### Permission Check with Default Value
+
+You can specify what to return when no permission is explicitly set:
+
+```java
+// Returns true by default if no explicit permission is found
+boolean canUse = PermissionsModule.get().hasPermission(playerUUID, "myplugin.feature.use", true);
+```
+
+This is useful for features that should be enabled by default but can be revoked.
+
+### Using PermissionHolder Interface
+
+Players and command senders implement `PermissionHolder`, allowing direct checks:
+
+```java
+// In a command or event handler where you have access to the player
+if (player.hasPermission("myplugin.admin.manage")) {
+    // Player has admin permission
+}
+```
+
+---
+
+## Managing User Permissions
+
+### Adding Permissions to a User
+
+Permissions are additive - new permissions are added on top of existing ones, not replaced.
+
+```java
+PermissionsModule perms = PermissionsModule.get();
+
+// Add a single permission
+perms.addUserPermission(playerUUID, Set.of("myplugin.vip.chat"));
+
+// Add multiple permissions at once
+Set<String> newPerms = Set.of(
+    "myplugin.vip.chat",
+    "myplugin.vip.fly",
+    "myplugin.vip.kit"
+);
+perms.addUserPermission(playerUUID, newPerms);
+```
+
+### Removing Permissions from a User
 
 ```java
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.removeUserPermission(playerUUID, permissions);
+
+// Remove specific permissions
+Set<String> toRemove = Set.of("myplugin.vip.fly");
+perms.removeUserPermission(playerUUID, toRemove);
 ```
 
-### Add permissions to group
+---
+
+## Managing Groups
+
+Groups let you assign a collection of permissions to multiple players. This is more manageable than assigning permissions individually.
+
+### Adding Permissions to a Group
+
+If the group doesn't exist, it will be created automatically.
 
 ```java
-String groupName = "testGroup";
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.addGroupPermission(groupName, permissions);
+
+// Create/update the "VIP" group with permissions
+Set<String> vipPerms = Set.of(
+    "myplugin.vip.chat",
+    "myplugin.vip.fly",
+    "myplugin.vip.kit"
+);
+perms.addGroupPermission("VIP", vipPerms);
 ```
 
-### Remove permissions from group
+### Removing Permissions from a Group
 
 ```java
-String groupName = "testGroup";
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.removeGroupPermission(groupName, permissions);
+
+// Remove specific permissions from the group
+Set<String> toRemove = Set.of("myplugin.vip.fly");
+perms.removeGroupPermission("VIP", toRemove);
 ```
 
-### Add user to group
+### Adding a User to a Group
 
 ```java
-String groupName = "testGroup";
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.addUserToGroup(playerUUID, groupName);
+
+// Add player to the VIP group - they now have all VIP permissions
+perms.addUserToGroup(playerUUID, "VIP");
 ```
 
-### Remove user from group
+### Removing a User from a Group
 
 ```java
-String groupName = "testGroup";
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.removeUserFromGroup(playerUUID, groupName);
+
+// Remove player from VIP group
+perms.removeUserFromGroup(playerUUID, "VIP");
 ```
 
-### List all groups for a user
+### Getting a User's Groups
 
 ```java
 PermissionsModule perms = PermissionsModule.get();
-perms.getGroupsForUser(playerUUID);
+
+// Get all groups the player belongs to
+Set<String> groups = perms.getGroupsForUser(playerUUID);
+
+for (String group : groups) {
+    System.out.println("Player is in group: " + group);
+}
 ```
 
-### Check Permission Nodes
+---
+
+## Built-in Groups
+
+Hytale includes two default groups:
+
+| Group     | Default Permissions   | Purpose                           |
+| --------- | --------------------- | --------------------------------- |
+| `OP`      | `*` (all permissions) | Server operators with full access |
+| `Default` | None                  | Base group for all players        |
+
+Players without any explicit group assignment are automatically part of the `Default` group.
 
-To check if a player has a specific permission node, you can use the `hasPermission` method.
+---
+
+## Wildcards
+
+Wildcards let you grant or deny multiple permissions with a single pattern.
+
+### Wildcard Patterns
+
+| Pattern             | Meaning                                          |
+| ------------------- | ------------------------------------------------ |
+| `*`                 | Grants **all** permissions                       |
+| `myplugin.*`        | Grants all permissions starting with `myplugin.` |
+| `-*`                | Denies **all** permissions                       |
+| `-myplugin.admin.*` | Denies all admin permissions in your plugin      |
+
+### Example: Admin Group with Wildcards
 
 ```java
-boolean hasPermission = PermissionsModule.hasPermission(playerUUID, "permission.node");
+// Grant all permissions to admins
+perms.addGroupPermission("Admin", Set.of("*"));
+
+// Grant all plugin permissions to moderators
+perms.addGroupPermission("Moderator", Set.of("myplugin.*"));
+
+// Grant all permissions except admin commands
+perms.addGroupPermission("Helper", Set.of(
+    "*",
+    "-myplugin.admin.*"  // Deny admin permissions
+));
 ```
 
-## Additional: Defining your own provider for permissions and groups
+<Callout type="warning">
+  Negation permissions (starting with `-`) take precedence at each level. Use them carefully to avoid accidentally blocking permissions.
+</Callout>
+
+---
+
+## Built-in Permission Nodes
+
+Hytale provides constants for common permissions in the `HytalePermissions` class:
+
+### Command Permissions
+
+```java
+// Generate permission for a command
+String perm = HytalePermissions.fromCommand("gamemode");
+// Result: "hytale.command.gamemode"
+
+// Generate permission for a subcommand
+String perm = HytalePermissions.fromCommand("gamemode", "creative");
+// Result: "hytale.command.gamemode.creative"
+```
+
+### Common Permission Nodes
+
+| Permission                    | Description                  |
+| ----------------------------- | ---------------------------- |
+| `hytale.command.op.add`       | Add players to OP group      |
+| `hytale.command.op.remove`    | Remove players from OP group |
+| `hytale.editor.brush.use`     | Use brush tools              |
+| `hytale.editor.prefab.use`    | Use prefabs                  |
+| `hytale.editor.selection.use` | Use selection tools          |
+| `hytale.editor.history`       | Undo/redo operations         |
+| `hytale.camera.flycam`        | Use fly camera mode          |
+
+---
+
+## Listening to Permission Events
+
+You can react to permission changes using Hytale's event system.
+
+### Available Events
+
+| Event                                            | Triggered When                   |
+| ------------------------------------------------ | -------------------------------- |
+| `PlayerPermissionChangeEvent.PermissionsAdded`   | Permissions added to a user      |
+| `PlayerPermissionChangeEvent.PermissionsRemoved` | Permissions removed from a user  |
+| `PlayerGroupEvent.Added`                         | User added to a group            |
+| `PlayerGroupEvent.Removed`                       | User removed from a group        |
+| `GroupPermissionChangeEvent.Added`               | Permissions added to a group     |
+| `GroupPermissionChangeEvent.Removed`             | Permissions removed from a group |
 
-The PermissionsModule also enables us to define our own PermissionProvider's, this can be useful for:
+### Example: Reacting to Permission Changes
 
-- Cross server permission systems
-- Implementing features missing in the `HytalePermissionsProvider` like permission expiry
+```java
+public class PermissionListener {
+
+    public static void onPermissionsAdded(PlayerPermissionChangeEvent.PermissionsAdded event) {
+        UUID playerUUID = event.getPlayerUuid();
+        Set<String> added = event.getAddedPermissions();
+
+        System.out.println("Permissions added to " + playerUUID + ": " + added);
 
-To implement our PermissionProvider, first we need to define a provider class that implements PermissionProvider:
+        // Maybe notify the player or update cached data
+    }
+
+    public static void onGroupAdded(PlayerGroupEvent.Added event) {
+        UUID playerUUID = event.getPlayerUuid();
+        String groupName = event.getGroupName();
+
+        System.out.println("Player " + playerUUID + " joined group: " + groupName);
+    }
+}
+```
+
+### Registering the Events
 
 ```java
-public class DatabasePermissionProvider implements PermissionProvider
+public class MyPlugin extends JavaPlugin {
+
+    @Override
+    public void setup() {
+        EventRegistry events = this.getEventRegistry();
+
+        events.registerGlobal(
+            PlayerPermissionChangeEvent.PermissionsAdded.class,
+            PermissionListener::onPermissionsAdded
+        );
+
+        events.registerGlobal(
+            PlayerGroupEvent.Added.class,
+            PermissionListener::onGroupAdded
+        );
+    }
+}
 ```
 
-Then we just implement the required methods using a database implementation.
+---
+
+## Creating a Custom Permission Provider
+
+For advanced use cases, you can create your own permission provider. This is useful for:
+
+- Database-backed permissions (MySQL, MongoDB, etc.)
+- Cross-server permission synchronization
+- Custom features like permission expiry or contexts
+
+### Implementing PermissionProvider
+
+```java
+public class DatabasePermissionProvider implements PermissionProvider {
+
+    @Nonnull
+    @Override
+    public String getName() {
+        return "DatabasePermissionProvider";
+    }
+
+    // User permission methods
+    @Override
+    public void addUserPermissions(@Nonnull UUID uuid, @Nonnull Set<String> permissions) {
+        // Save to your database
+    }
+
+    @Override
+    public void removeUserPermissions(@Nonnull UUID uuid, @Nonnull Set<String> permissions) {
+        // Remove from your database
+    }
+
+    @Override
+    public Set<String> getUserPermissions(@Nonnull UUID uuid) {
+        // Query your database
+        return Set.of();
+    }
+
+    // Group permission methods
+    @Override
+    public void addGroupPermissions(@Nonnull String group, @Nonnull Set<String> permissions) {
+        // Save to your database
+    }
+
+    @Override
+    public void removeGroupPermissions(@Nonnull String group, @Nonnull Set<String> permissions) {
+        // Remove from your database
+    }
+
+    @Override
+    public Set<String> getGroupPermissions(@Nonnull String group) {
+        // Query your database
+        return Set.of();
+    }
+
+    // User-group membership methods
+    @Override
+    public void addUserToGroup(@Nonnull UUID uuid, @Nonnull String group) {
+        // Save to your database
+    }
+
+    @Override
+    public void removeUserFromGroup(@Nonnull UUID uuid, @Nonnull String group) {
+        // Remove from your database
+    }
+
+    @Override
+    public Set<String> getGroupsForUser(@Nonnull UUID uuid) {
+        // Query your database
+        return Set.of("Default");
+    }
+}
+```
 
 <Callout type="warning">
-  Hytale will try to use the first available permissions provider to add/remove gamemode groups (i.e. `Creative`, `Adventure`).
+  Hytale automatically assigns players to game-mode groups (like `Creative` or `Adventure`) using the first available provider.
+
+  If your provider throws an error when the group doesn't exist, the player will be disconnected! Always handle missing groups gracefully.
+</Callout>
+
+### Registering Your Provider
 
-  If your provider throws an error (for instance, if the group does not exist) when the server is preparing the player, the player will be disconnected.
+```java
+public class MyPlugin extends JavaPlugin {
+
+    @Override
+    public void setup() {
+        // Add your provider alongside the default one
+        PermissionsModule.get().addProvider(new DatabasePermissionProvider());
+    }
+}
+```
+
+The `PermissionsModule` aggregates permissions from all registered providers. This means:
+
+- Permission checks query all providers
+- Write operations (add/remove) use the **first** provider
+
+### Replacing the Default Provider
+
+If you want full control, you can remove the default provider:
+
+```java
+public class MyPlugin extends JavaPlugin {
+
+    @Override
+    public void setup() {
+        PermissionsModule perms = PermissionsModule.get();
+
+        // Remove the default provider FIRST
+        perms.removeProvider(perms.getFirstPermissionProvider());
+
+        // Then add your provider
+        perms.addProvider(new DatabasePermissionProvider());
+    }
+}
+```
+
+<Callout type="info">
+  When you remove the default provider, the `/op self` command will stop working since it checks for provider tampering.
 </Callout>
 
-We can then register the provider using the built-in permission module:
+---
+
+## Best Practices
+
+### Permission Naming Conventions
+
+Follow the pattern: `namespace.category.action`
 
 ```java
-PermissionsModule.get().addProvider(new DatabasePermissionProvider());
+// Good - clear hierarchy
+"myplugin.admin.ban"
+"myplugin.user.teleport.home"
+"myplugin.vip.chat.color"
+
+// Bad - unclear structure
+"myplugin_ban"
+"teleport"
+"vipChatColor"
 ```
 
-Please note that the `HytalePermissionsProvider` will still be enabled alongside your provider.
-The `PermissionsModule` will aggregate groups and permissions from all available providers.
+### Use Constants for Permissions
 
-If you want to disable the default `HytalePermissionsProvider`, you can use:
+Define your permissions as constants to avoid typos:
 
 ```java
-// put this **before** you add your provider
-PermissionsModule.get().removeProvider(PermissionsModule.get().getFirstPermissionProvider());
+public final class MyPermissions {
+    public static final String ADMIN_BAN = "myplugin.admin.ban";
+    public static final String ADMIN_KICK = "myplugin.admin.kick";
+    public static final String USER_HOME = "myplugin.user.home";
+    public static final String VIP_FLY = "myplugin.vip.fly";
+}
+
+// Usage
+if (player.hasPermission(MyPermissions.ADMIN_BAN)) {
+    // ...
+}
 ```
+
+### Don't Over-Permission
+
+Only create permissions for actions that genuinely need access control. Not everything needs a permission check.
+
+### Thread Safety
+
+If you create a custom provider, ensure it's thread-safe. Permission checks can occur from multiple threads simultaneously. Use `ReadWriteLock` or `ConcurrentHashMap` for your data structures.
+
+---
+
+## In-Game Commands
+
+Hytale provides built-in commands for managing permissions:
+
+### `/op` Command
+
+| Command               | Description                                                        |
+| --------------------- | ------------------------------------------------------------------ |
+| `/op self`            | Toggle your own OP status (singleplayer or with `--allow-op` flag) |
+| `/op add <player>`    | Add a player to the OP group                                       |
+| `/op remove <player>` | Remove a player from the OP group                                  |
+
+### `/perm` Command
+
+Use `/perm --help` in-game for full usage. Common operations:
+
+| Command                                  | Description                   |
+| ---------------------------------------- | ----------------------------- |
+| `/perm user list <uuid>`                 | List user's permissions       |
+| `/perm user add <uuid> <perm>`           | Add permission to user        |
+| `/perm user remove <uuid> <perm>`        | Remove permission from user   |
+| `/perm user group list <uuid>`           | List user's groups            |
+| `/perm user group add <uuid> <group>`    | Add user to group             |
+| `/perm user group remove <uuid> <group>` | Remove user from group        |
+| `/perm group list <group>`               | List group's permissions      |
+| `/perm group add <group> <perm>`         | Add permission to group       |
+| `/perm group remove <group> <perm>`      | Remove permission from group  |
+| `/perm test <perm>`                      | Test if you have a permission |
+
+---
+
+## Summary
+
+You've learned how to:
+
+- **Check permissions** using `PermissionsModule.hasPermission()`
+- **Manage user permissions** with `addUserPermission()` and `removeUserPermission()`
+- **Work with groups** using `addGroupPermission()`, `addUserToGroup()`, etc.
+- **Use wildcards** like `*` and `myplugin.*` for bulk permissions
+- **Listen to events** for permission changes
+- **Create custom providers** for database-backed permissions
+
+For more advanced permission systems with features like inheritance, expiry, and contexts, we're looking into expanding this guide with advanced permission management techniques in the future.
diff --git a/content/docs/pt-BR/guides/plugin/setting-up-env.mdx b/content/docs/pt-BR/guides/plugin/setting-up-env.mdx
index d2718098..5be5e9e0 100644
--- a/content/docs/pt-BR/guides/plugin/setting-up-env.mdx
+++ b/content/docs/pt-BR/guides/plugin/setting-up-env.mdx
@@ -4,6 +4,10 @@ description: Learn how to set up your development environment for modding Hytale
 authors:
   - name: Neil Revin
     link: https://itsneil.dev
+  - name: Marcel-TO
+    url: https://marcel-to.net
+  - name: Ádám Liszkai
+    link: https://adaliszk.dev
 ---
 
 This guide will walk you through setting up a complete development environment for Hytale modding, including all necessary tools and dependencies.
@@ -19,24 +23,73 @@ Before we begin, make sure you have:
 
 ## Required Software
 
-### 1. Java Development Kit (JDK)
+### Integrated Development Environment (IDE)
 
+We recommend IntelliJ IDEA Community Edition for Hytale modding. If you use IntelliJ IDEA, **almost everything is built-in**. You can clone a template, open a new project, and start working right away!
+
+1. Download from [JetBrains website](https://www.jetbrains.com/idea/download/)
+2. Install with default settings
+3. Launch and complete the initial setup wizard
+
+When opening a project, wait for indexing to finish, then start coding.
+Now, IDEA may say "No JDK configured" at the top of the source file you have.
+In that case, you can click Download JDK and choose JetBrains JDK 25.
+
+<Callout type="success">
+  If IDEA opened the project without errors, your environment is ready.
+</Callout>
+
+More details by [JetBrains](https://www.jetbrains.com/help/idea/2026.1/run-for-the-first-time.html)
+help page, where we recommend that you also check the
+[SDK configuration](https://www.jetbrains.com/help/idea/2026.1/sdk.html) guide.
+
+<Callout type="info">
+  We recommened following
+  [TheNullicorn's](https://gist.github.com/TheNullicorn/90a619796c40f20ae1fcf13094c1a57d) guide to ensure
+  you are using the correct `Nonnull` in your projects.
+</Callout>
+
+#### What the IDE Does for You
+
+When opened in IntelliJ IDEA, the project automatically:
+
+- Detects and configures Gradle or Maven
+- Downloads all dependencies
+- Sets up project structure and classpaths
+- Configures run/build tasks
+
+You do **not** need to manually install or configure Maven or Gradle if you stay inside the IDE.
+
+Skip to the [Setting Up Your Workspace](#setting-up-your-workspace).
+
+### Manual Setup: Java Development Kit (JDK)
+
+For any other setup, you will need to install and configure your system to have and load Java.
 Hytale modding requires Java 25 or later. We recommend using OpenJDK.
 
-#### Windows
+#### Windows via Installer
 
 1. Download OpenJDK 25 from [Adoptium](https://adoptium.net/)
 2. Run the installer with default settings
+   - Optionally enable feature `Set or Override JAVA_HOME variable` to resolve version related build issues with your project.
 3. Verify installation by opening Command Prompt and running:
 
+#### Windows via Scoop
+
+1. Install Scoop via PowerShell using [scoop.sh](https://scoop.sh/)
+2. Install OpenJDK 25:
+
 ```bash
-java -version
+scoop bucket add java
+scoop install java/openjdk25
 ```
 
 #### macOS
 
+1. Install Brew via Terminal using [brew.sh](https://brew.sh)
+2. Install JDK via Homebrew:
+
 ```bash
-# Using Homebrew
 brew install openjdk@25
 ```
 
@@ -51,22 +104,41 @@ brew install openjdk@25
 
 #### Linux (Ubuntu/Debian)
 
+1. Install JDK via the built-in package repository:
+
 ```bash
 sudo apt update
 sudo apt install openjdk-25-jdk
 ```
 
-### 2. Integrated Development Environment (IDE)
+### Verify installation:
 
-We recommend IntelliJ IDEA Community Edition for Hytale modding.
+Run the following command to see what version of Java you have:
 
-1. Download from [JetBrains website](https://www.jetbrains.com/idea/download/)
-2. Install with default settings
-3. Launch and complete the initial setup wizard
+```bash
+java -version
+```
+
+### Java Build Tool (Optional)
+
+We recommend using a Gradle Wrapper for managing dependencies and building your Hytale plugins. It provides benefits by eliminating the need for a system-wide Gradle installation and ensuring consistent Gradle versions across different environments. (Alternatively you can use Maven, but this guide focuses on Gradle since it is the default for our plugin template.)
+
+The plugin template in the following sections includes a Gradle Wrapper, so you can skip this step if you plan to use the template.
+
+#### Choosing Gradle (if not using the template)
+
+If you prefer to install Gradle manually, follow these steps:
 
-### 3) Java Build Tool
+1. Visit the official website: https://gradle.org/releases/
+2. Download the newest gradle binary: `gradle-9.3.1-bin.zip` (Binary zip archive)
+3. Unzip it
+4. Add the `gradle-9.3.1/bin/` folder to your PATH
+
+You can now try the command `gradle -version` to verify Gradle is installed correctly. Make sure to do this in a fresh new terminal instead of one you had opened from before!
+
+#### Choosing Maven (if not using the template)
 
-We recommend using Apache Maven for managing dependencies and building your Hytale plugins. (Alternatively you can use Gradle, but this guide focuses on Maven.)
+If you prefer to use Maven instead of Gradle, follow these steps to install Maven:
 
 1. Visit the official website: https://maven.apache.org/download.cgi
 2. Download this file: `apache-maven-3.9.12-bin.zip` (Binary zip archive)
@@ -89,22 +161,61 @@ cd MyFirstMod
 
 If you don't have Git installed, you can download the ZIP file from the repository page and extract it to a folder named `MyFirstMod`.
 
-### 2. Open Plugin in your IDEA
+### 2. Open Plugin in your IDE
 
-1. Open IntelliJ IDEA
+1. Open Your IDE (e.g., IntelliJ IDEA)
 2. Click "Open" and navigate to your `MyFirstMod` directory
-3. IntelliJ will automatically detect it as a Maven project
+3. Most IDEs like IntelliJ will automatically detect it as a Gradle project
 4. Wait for the project to index and dependencies to download
 
-<Callout type="info">
-  We recommened following [this](https://gist.github.com/TheNullicorn/90a619796c40f20ae1fcf13094c1a57d) guide to ensure you are using the correct `Nonnull` in your projects.
-</Callout>
+## Alternate Approach: Hytale Dependency
+
+If you prefer to set up your project from scratch without using the template and importing the hytale dependencies manually, ensure your build configuration includes the Hytale repositories and dependencies:
+
+For Gradle, add the following to your `build.gradle.kts`:
+
+```kotlin
+repositories {
+    mavenCentral()
+    maven {
+        name = "hytale"
+        url = uri("https://maven.hytale.com/release") // Or "hytale-pre-release" for pre-release versions
+    }
+}
+dependencies {
+    // + here means the latest version, but you can hard-wire any known version!
+    implementation("com.hypixel.hytale:Server:+")
+}
+```
+
+For Maven, add the following to your `pom.xml`:
+
+```xml
+<project>
+    <repositories>
+        <repository>
+            <id>hytale-release</id> <!-- Or "hytale-pre-release" for pre-release versions -->
+            <url>https://maven.hytale.com/release</url> <!-- Or "https://maven.hytale.com/pre-release" -->
+        </repository>
+    </repositories>
+
+    <dependencies>
+        <dependency>
+            <groupId>com.hypixel.hytale</groupId>
+            <artifactId>Server</artifactId>
+            <!-- Replace with latest version, Hytale provides jars for the last five releases -->
+            <version>LATEST_VERSION_HERE</version>
+            <scope>provided</scope>
+        </dependency>
+    </dependencies>
+</project>
+```
 
 ## Next Steps
 
 Now that you have your development environment set up with the plugin template:
 
-1. **Customize the template** - Edit the `pom.xml` and `manifest.json` file to change your mod's name and details
+1. **Customize the template** - Edit the `settings.gradle.kts`, `build.gradle.kts` and `manifest.json` file to change your mod's name and details
 2. **Explore the code structure** - Familiarize yourself with the template's organization
 3. **Start modding** - Begin writing your first Hytale plugin!
 
diff --git a/content/docs/pt-BR/guides/plugin/spawning-entities.mdx b/content/docs/pt-BR/guides/plugin/spawning-entities.mdx
index e12c0aea..15be2fb3 100644
--- a/content/docs/pt-BR/guides/plugin/spawning-entities.mdx
+++ b/content/docs/pt-BR/guides/plugin/spawning-entities.mdx
@@ -36,7 +36,7 @@ Store<EntityStore> store = world.getEntityStore().getStore();
 
 ## Creating Entities
 
-Once you have the `EntityStore` instance, you can start to create a entity and give it components. Entities are just instances of `Holder<EntityStore>` with several components attached to them.
+Once you have the `EntityStore` instance, you can start to create an entity and give it components. Entities are just instances of `Holder<EntityStore>` with several components attached to them.
 
 <Callout type="warning">
   To interact with the `World` instance, some methods require you to run the code inside the world's execution context.
@@ -118,3 +118,48 @@ Finally, we can add the entity to the world by calling the `addEntity` method on
 ```java
 store.addEntity(holder, AddReason.SPAWN);
 ```
+
+## Making the entity persist
+
+Hytale automatically saves all entities, but the `NetworkId` component (required for players to be able to see the entity) needs to be manually added every time the entity is loaded.
+
+### Using a system
+
+If you have a component that is unique to your entities, this can be done by creating and registering a custom system as follows:
+
+```java
+public class AddNetworkIdToMyEntitySystem extends HolderSystem<EntityStore> {
+    private final ComponentType<EntityStore, MyEntityComponent> myEntityComponentType = MyEntityComponent.getComponentType();
+    private final ComponentType<EntityStore, NetworkId> networkIdComponentType = NetworkId.getComponentType();
+    private final Query<EntityStore> query = Query.and(this.myEntityComponentType, Query.not(this.networkIdComponentType));
+
+    @Override
+    public void onEntityAdd(@NotNull Holder<EntityStore> holder, @NotNull AddReason reason, @NotNull Store<EntityStore> store) {
+        if (!holder.getArchetype().contains(NetworkId.getComponentType())) {
+            holder.addComponent(NetworkId.getComponentType(), new NetworkId(store.getExternalData().takeNextNetworkId()));
+        }
+    }
+
+    @Override
+    public void onEntityRemoved(@NotNull Holder<EntityStore> holder, @NotNull RemoveReason reason, @NotNull Store<EntityStore> store) {}
+
+    @Override
+    public @Nullable Query<EntityStore> getQuery() {
+        return query;
+    }
+}
+```
+
+In your plugin's `setup()` function
+
+```java
+this.getEntityStoreRegistry().registerSystem(new AddNetworkIdToMyEntitySystem())
+```
+
+### Using PropComponent
+
+Alternatively you can add `PropComponent` to your entity. Hytale adds `PropComponent` to entities spawned with the Entity Tool, and such entities automatically get `NetworkId` and `PrefabCopyableComponent` (which makes the entity work with prefabs).
+
+<Callout type="warning">
+  There is no guarantee, that Hytale will not add some other behavior to this component in the future, which may break your entity, so be careful if you decide to rely on it.
+</Callout>
diff --git a/content/docs/pt-BR/guides/plugin/store-persistent-data.mdx b/content/docs/pt-BR/guides/plugin/store-persistent-data.mdx
new file mode 100644
index 00000000..1071dff3
--- /dev/null
+++ b/content/docs/pt-BR/guides/plugin/store-persistent-data.mdx
@@ -0,0 +1,171 @@
+---
+title: Storing Persistent Data on the Player
+description: Learn how to save and load persistent data using Components
+authors:
+  - name: Neil Revin
+    url: https://itsneil.dev/
+  - name: ArcticDev
+    url: https://github.com/ArcticRaven
+  - name: oskarscot
+    url: https://oskar.scot
+  - name: JammingEng
+    url: https://github.com/JammingEnd
+---
+
+Here is how to store persistent data using a custom component on a Player.
+
+## Build your Component Class
+
+Creating a custom component class leverages the Component system made with the ECS architecture in mind. For more information on Components, check out the [ECS Guide](../ecs/hytale-ecs-theory#components).
+
+Start by creating your custom component class. This will be extremely similar to how regular components are created, however we'll setup a custom Codec so the server can translate this data to BSON, or the server's internal json encoder.
+
+<Callout type="info">
+  Each variable you want to store in your component must have its own Codec field defined in the BuilderCodec.
+  For more information on how to create custom Codecs, check out the [ECS Codec Guide](../ecs/hytale-ecs-theory#codec).
+</Callout>
+
+```java
+public class YourPlayerData implements Component<EntityStore> {
+
+    // define some vars!
+    private int someInteger;
+    private String someString;
+    private Map<String, String> someMap;
+
+    public static final BuilderCodec<YourPlayerData> CODEC =
+            BuilderCodec.builder(YourPlayerData.class, YourPlayerData::new)
+            .append(new KeyedCodec<>("SomeInteger", Codec.INTEGER),
+                    (data, value) -> data.someInteger = value, // setter
+                    data -> data.someInteger) // getter
+            .addValidator(Validators.nonNull())
+            .add()
+            .append(new KeyedCodec<>("SomeString", Codec.STRING),
+                    (data, value) -> data.someString = value, // setter
+                    data -> data.someString) // getter
+            .add()
+            .append(new KeyedCodec<>("SomeMap",
+                            new MapCodec<>(Codec.STRING, HashMap::new, false)),
+                    (data, value) -> data.someMap = value, // setter
+                    data -> data.someMap) // getter
+            .add()
+            .build();
+
+
+
+    // Getters and Setters are for the purpose of this example omitted.
+
+    // constructor
+    public YourPlayerData() {
+        this.someInteger = 0;
+        this.someString = "";
+        this.someMap = new HashMap<>();
+    }
+
+    // copy constructor for cloning
+    public YourPlayerData(YourPlayerData clone) {
+        this.someInteger = clone.someInteger;
+        this.someString = clone.someString;
+        this.someMap = clone.someMap;
+    }
+
+    @Nonnull
+    @Override
+    public Component<EntityStore> clone() {
+        return new YourPlayerData(this);
+    }
+}
+```
+
+## Register your Component
+
+Inside your main class's `setup()` method, register your new Component.
+
+```java
+public class YourPlugin extends JavaPlugin {
+
+    private ComponentType<EntityStore, YourPlayerData> yourPlayerDataComponent;
+
+    public YourPlugin(@Nonnull JavaPluginInit init) {
+        super(init);
+    }
+
+    @Override
+    protected void setup(){
+        this.yourPlayerDataComponent = this.getEntityStoreRegistry().registerComponent(
+            YourPlayerData.class,
+            "YourPlayerDataComponent",
+            YourPlayerData.CODEC
+        );
+    }
+
+    public ComponentType<EntityStore, YourPlayerData> getYourPlayerDataComponent() {
+        return this.yourPlayerDataComponent;
+    }
+}
+```
+
+## Using your Component
+
+To use your newly created component, you can add the Component to a player using the `addComponent` method, although this only adds it temporarily, meaning when the player/entity leaves the world, the component is removed. You can use `putComponent` to ensure the component persists between sessions.
+
+```java
+// You will need the Ref and Store to apply components
+private void someEntryMethod(@Nonnull Ref<EntityStore> ref, @Nonnull Store<EntityStore> store)
+{
+       // Any entity will work, for now we will use the player
+      Player player = (Player) store.getComponent(ref, Player.getComponentType());
+
+      // since we're using putComponent, it could be useful to check if it already exists on the player in case we want to update it
+     if(store.getComponent(ref, YourPlugin.instance().getYourPlayerDataComponent()) != null)
+     {
+          // here we implement logic that updates the component
+         var comp = store.getComponent(ref, YourPlugin.instance().getYourPlayerDataComponent())
+         // declare public fields or methods in the component class
+         comp.SomeString = "An Updated Field";
+     } else {
+          // Here we put the component
+          var myCustomComp = new CustomComponent();
+          // declare public fields or methods in the component class
+          myCustomComp.SomeString = "Edited String";
+
+          // putComponent allows you to insert declared objects
+          store.putComponent(ref, YourPlugin.instance().getYourPlayerDataComponent(), myCustomComp);
+     }
+}
+```
+
+## Using your Data
+
+Your component will be stored within the `Store<EntityStore>` when added to the player. In the provided example,
+we'll fetch this data off the player using the `ensureAndGetComponent()` method, which will add the component to
+the player if it does not exist with the default values.
+
+```java
+public class IncompleteCustomCommand extends AbstractPlayerCommand {
+
+    public IncompleteCustomCommand() {
+        super("nope", "don't use this command");
+    }
+
+    @Override
+    protected void execute(
+        @NonNullDecl CommandContext commandContext,
+        @NonNullDecl Store<EntityStore> store,
+        @NonNullDecl Ref<EntityStore> ref,
+        @NonNullDecl PlayerRef playerRef,
+        @NonNullDecl World world
+    ) {
+        YourPlayerData customData = store.ensureAndGetComponent(ref, YourPlugin.instance().getYourPlayerDataComponent());
+        // ensureAndGetComponent adds the component to the ref, with the default values defined inside your component.
+ 		// use your data
+    }
+}
+```
+
+And that's it! Your data will now be saved and loaded automatically with the player.
+
+Using custom components to store persistent data on players is a powerful way to maintain state across sessions.
+By following the steps outlined above, you can easily create, register, and utilize your own data structures within the Hytale ECS framework.
+This approach ensures that your data is seamlessly integrated with the game's existing systems.
+For more information about Hytale's Entity Component System visit the [Hytale ECS Theory](https://hytalemodding.dev/en/docs/guides/ecs/hytale-ecs-theory) guide.
diff --git a/content/docs/pt-BR/guides/plugin/teleporting-players.mdx b/content/docs/pt-BR/guides/plugin/teleporting-players.mdx
index 976f86c2..f312ff73 100644
--- a/content/docs/pt-BR/guides/plugin/teleporting-players.mdx
+++ b/content/docs/pt-BR/guides/plugin/teleporting-players.mdx
@@ -1,26 +1,32 @@
 ---
 title: Teletransportando o jogador
 description: Aprenda a teletransportar o jogador.
+authors:
+  - name: oskarscot
+    url: https://oskar.scot
 ---
 
-To teleport players in Hytale, you will need to get a `World` object so we can safely run the teleport on the world thread. The world thread manages all entity updates, so modifying entities off-thread can crash the server or cause inconsistent state.
-Next, we get the entity store and make a `Teleport` object.
-We add a `Teleport` component to the player’s entity reference in the entity store. This triggers the teleportation logic for that player.
+Teleporting players in Hytale works by simply attaching a `Teleport` component to a player with the desired world and transform.
+You can only trigger teleports from a world where the player is currently present.
+Teleport itself is a component but it also provides factory methods to configure the Teleport. Just as with any entity component, an EntityStore and a Ref to the EntityStore is required
+
+We can create a simple teleport utility like this:
 
 ```java
-public static void teleportPlayer(Player player, int x, int y, int z) {
-        World world = player.getWorld();
-        if (world == null) return;
-        world.execute(() -> {
-            if (player.getReference() == null) return;
-            Store<EntityStore> store = player.getReference().getStore();
-            Teleport teleport = Teleport.createForPlayer(world,
-                new Vector3d(x ,y, z), // Target position
-                new Vector3f(0, 0, 0)  // Target rotation (pitch, yaw, roll)
-            );
+public static void teleportPlayer(Ref<EntityStore> ref, Store<EntityStore> store, World targetWorld, double x, double y, double z) {                                                                                       
+    Transform transform = new Transform(x, y, z);                                                                                                                           
+    Teleport teleport = Teleport.createForPlayer(targetWorld, transform);                                                                                                   
+    store.addComponent(ref, Teleport.getComponentType(), teleport);                                                                                                         
+}  
+```
 
-            store.addComponent(player.getReference(), Teleport.getComponentType(), teleport);
-        });
+A `Transform` is a representation of a position Vector3d and rotation Vector3f which works in the following way:
 
-}
+```java
+Transform transform = new Transform(
+    new Vector3d(x, y, z),      // Position
+    new Rotation(yaw, pitch, 0) // Rotation, last value seems to always be 0
+);
+Teleport teleport = Teleport.createForPlayer(targetWorld, transform);
+store.addComponent(ref, Teleport.getComponentType(), teleport);
 ```
diff --git a/content/docs/pt-BR/guides/plugin/tracking-mod-analytics-with-hstats.mdx b/content/docs/pt-BR/guides/plugin/tracking-mod-analytics-with-hstats.mdx
new file mode 100644
index 00000000..45c022e0
--- /dev/null
+++ b/content/docs/pt-BR/guides/plugin/tracking-mod-analytics-with-hstats.mdx
@@ -0,0 +1,65 @@
+---
+title: Tracking Mod Analytics with HStats
+description: Learn how you can track Analytics for your Hytale Mod for Free using hstats.dev
+authors:
+  - name: Al3x
+    url: https://hstats.dev
+---
+
+In this guide, you will learn how to integrate HStats into your Plugin/Mod which will allow you to track how many Servers are using it along with other stats.
+
+<Callout type="info">
+  HStats is a third-party tool and is not affiliated with HytaleModding or Hypixel Studios
+</Callout>
+
+# Step 1: Register your Mod to HStats
+
+Before you touch any code, you will need to add your mod to the HStats website which will give you a UUID for your mod.
+
+- Create or Login to an Account on https://hstats.dev
+- Navigate to the dashboard page (https://hstats.dev/dashboard)
+- On the left, type in your mod's name and click "Add Mod"
+- Keep note of the UUID generated for later.
+
+# Step 2: Add the HStats Class to Your Project
+
+To keep things simple, HStats uses a single Java class file that handles everything for you.
+
+- Download / Copy the File from the GitHub page (https://github.com/hstats-dev/HStatsExamplePlugin/blob/main/src/main/java/com/al3x/HStats.java)
+- Paste into your Project. You should now have a HStats.java file somewhere in your projects directory.
+- Update the package name from com.al3x to whatever fits your project.
+
+# Step 3: Initialize HStats in your code
+
+You only need to add one line of code to your mod's setup method in your main class to start tracking.
+
+`new HStats("YOUR-MOD-UUID", "1.0.0");`
+
+Replace `YOUR-MOD-UUID` with the Mod UUID we made note of earlier and change the `1.0.0` version to whatever version your mod is currently on.
+
+Your setup method should now look something like this:
+
+```java
+@Override
+protected void setup() {
+  super.setup();
+  new HStats("c34a2b2a-afd8-4d6a-821e-7a63e12c5ea6", "1.0.0");
+}
+```
+
+# Extras
+
+Your done! Your mod should now be listed under the Mods page (https://hstats.dev/mods) as well as under your dashboard.
+
+Servers using your mod should now post updates about every minute to HStats which you can view in the Dashboard.
+
+### Embeds
+
+HStats allows you to generate an Embed Card that you can place on your CurseForge or GitHub page. This is useful for server owners to be able to see how many other servers are using your mod.
+
+- In your dashboard, scroll down to the Embed Card section.
+- Customize the appearance (Light/Dark mode, layout, etc).
+- Copy the generated URL to display your "Active Servers" and "Players Online" live on your mod's description page
+
+Heres an example of what they look like:
+![HStats Example](https://api.hstats.dev/api/embed/d52fa672-6966-47b2-b501-1a11bddebac3/card.svg?theme=light\&layout=compact\&size=md\&show_id=true\&dark=false)
diff --git a/content/docs/pt-BR/guides/plugin/world-gen.mdx b/content/docs/pt-BR/guides/plugin/world-gen.mdx
index 06f436e5..29e3c1df 100644
--- a/content/docs/pt-BR/guides/plugin/world-gen.mdx
+++ b/content/docs/pt-BR/guides/plugin/world-gen.mdx
@@ -100,7 +100,7 @@ Biome biome = biomeGen.generateBiomeAt(zoneResult, seed, x, z);
 
 ### Integração de zona e caverna
 
-Cada zona define seu próprio padrão de caverna:
+Each zone defines its own cave patterns:
 
 ```java
 Zone zone = /* ... */;
diff --git a/content/docs/pt-BR/guides/prefabs.mdx b/content/docs/pt-BR/guides/prefabs.mdx
index f11a04da..4cffa2e2 100644
--- a/content/docs/pt-BR/guides/prefabs.mdx
+++ b/content/docs/pt-BR/guides/prefabs.mdx
@@ -14,7 +14,7 @@ Prefabs are Hytale's way of creating reusable structures.
 There are a few fundamental concepts to understand about prefabs:
 
 - Users interact with prefabs via a prefab editing world.
-- Prefabs the physical structures in the game world, and are saved as JSON files.
+- Prefabs are the physical structures in the game world, and are saved as JSON files.
 
 ## How to Create a Prefab
 
diff --git a/content/docs/pt-BR/official-documentation/custom-ui/common-styling.mdx b/content/docs/pt-BR/official-documentation/custom-ui/common-styling.mdx
new file mode 100644
index 00000000..c36e3e3a
--- /dev/null
+++ b/content/docs/pt-BR/official-documentation/custom-ui/common-styling.mdx
@@ -0,0 +1,50 @@
+---
+title: Common Styling
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# Common Styling
+
+## Common UI Styling Library
+
+This document describes the shared UI components and styles defined in `Common.ui`.
+
+---
+
+### Styles
+
+We are providing some styles that can be re-used in any custom UI that, provide a cohesive UI experience with the core game UI. These styles are available in the `Common.ui` file.
+
+You can find a list of all the styles defined with live examples by running the `/ui-gallery` command ingame.
+
+<Callout type="warning">
+  This command is not available yet, but will be in a future patch.
+</Callout>
+
+![Gallery](/assets/official-documentation/ui/gallery.png)
+
+### Importing
+
+To use these styles in your UI file:
+
+```
+$Common = "Common.ui";
+
+// Then reference styles and components:
+$Common.@TextButton { @Text = "My Button"; }
+$Common.@Container { ... }
+```
+
+<Callout type="info">
+  The `Common.ui` file is at `Common/UI/Custom/Common.ui` within the Hytale pack. If your custom ui document is in a subfolder of `Common/UI/Custom/`, reference it via relative path traversal:
+
+  ```
+  $Common = "../Common.ui";
+  ```
+
+  You can find more info about paths [here](markup#path).
+</Callout>
diff --git a/content/docs/pt-BR/official-documentation/custom-ui/index.mdx b/content/docs/pt-BR/official-documentation/custom-ui/index.mdx
new file mode 100644
index 00000000..f94c4e88
--- /dev/null
+++ b/content/docs/pt-BR/official-documentation/custom-ui/index.mdx
@@ -0,0 +1,125 @@
+---
+title: Custom UI
+icon: LayoutDashboard
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# Custom UI
+
+## What is Custom UI?
+
+Custom UI is Hytale's framework for creating **custom user interfaces** controlled by the game server. Unlike the built-in Client UI (which is part of the game client and cannot be modified), Server UI allows you to create interactive screens and HUD overlays through Java plugins and asset packs.
+
+As a modder, Custom UI gives you the power to:
+
+- **Create custom interactive pages** - Shop interfaces, quest dialogs, server settings menus, admin panels
+- **Add custom HUD overlays** - Quest trackers, status displays, custom health bars, server information
+- **Design with markup** - Use `.ui` files to define reusable UI templates
+- **Handle user interactions** - Respond to button clicks, form submissions, and other events
+- **Localize your UI** - Support multiple languages using the game's translation system
+
+## How Custom UI Fits Into Hytale's UI
+
+Hytale's user interface is divided into two main categories:
+
+### Client UI (Not Moddable)
+
+Built-in interfaces controlled by the C# game client:
+
+- Main menu and settings
+- Character creation
+- Built-in HUD (health, hotbar, chat)
+- Inventory and crafting screens
+- Development tools
+
+**You cannot modify these** - they are part of the core game client.
+
+### In-Game UI (Moddable via Server)
+
+Server-controlled interfaces that you can create and customize:
+
+#### Custom Pages
+
+Full-screen interactive overlays that appear during gameplay:
+
+- Can be dismissed by the player (ESC key)
+- Capture all input (keyboard and mouse)
+- Support loading states while waiting for server responses
+- Perfect for: shops, dialogs, menus, configuration screens
+
+#### Custom HUDs
+
+Persistent overlay elements drawn on top of the game world:
+
+- Display-only (no user interaction)
+- Always visible during gameplay
+- Lightweight and non-intrusive
+- Perfect for: quest objectives, status indicators, server info panels
+
+## Architecture Overview
+
+Server UI uses a **command-based architecture**:
+
+```
+┌─────────────────────┐         ┌──────────────────────┐
+│   Java Server       │         │    C# Client         │
+│   (Your Plugin)     │         │    (Game)            │
+├─────────────────────┤         ├──────────────────────┤
+│                     │         │                      │
+│ InteractiveCustomUI │         │   CustomPage or      │
+│ Page                │         │   CustomHud          │
+│   ↓ build()         ├────────→│     ↓ Apply          │
+│ UICommandBuilder    │         │   Element Tree       │
+│   - append()        │         │     ↓ Layout         │
+│   - set()           │         │   Rendered UI        │
+│   - clear()         │         │                      │
+│                     │         │                      │
+│ ↓ handleDataEvent() │← Events │   User Interaction   │
+│   Process input     │         │   (click, type, etc) │
+│   sendUpdate()      │         │                      │
+└─────────────────────┘         └──────────────────────┘
+```
+
+**The flow:**
+
+1. Your Java code builds UI using `UICommandBuilder`
+2. Commands are sent to the client as data
+3. Client parses `.ui` markup files and creates visual elements
+4. User interacts with the UI
+5. Events are sent back to your Java code
+6. You process events and send updates back
+
+## Key Principles
+
+### Declarative, Not Imperative
+
+You don't create UI objects directly. Instead, you send **commands** that describe what you want:
+
+- "Append this button template to that container"
+- "Set this label's text to 'Hello World'"
+- "Clear all children from this list"
+
+### Asset-Driven
+
+UI structure is defined in `.ui` markup files (assets), not hardcoded in Java. This enables:
+
+- Designers to modify layouts without touching code
+- Reusable UI components
+- Consistent visual language
+
+### Event-Driven
+
+User interactions trigger events that flow back to your server code. You register event bindings and handle them in `handleDataEvent()`.
+
+### Selector-Based
+
+You target specific UI elements using **selectors:**
+
+- `#MyButton` - Element with ID "MyButton"
+- `#List[0]` - First child of element "List"
+- `#List[0] #Title` - Element with ID "Title" in the first child of element "List"
+- `#Label.TextColor` - The TextColor property of element "Label"
diff --git a/content/docs/pt-BR/official-documentation/custom-ui/layout.mdx b/content/docs/pt-BR/official-documentation/custom-ui/layout.mdx
new file mode 100644
index 00000000..0a24ca09
--- /dev/null
+++ b/content/docs/pt-BR/official-documentation/custom-ui/layout.mdx
@@ -0,0 +1,492 @@
+---
+title: Layout
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# Layout
+
+The layout system determines how UI elements are positioned and sized on screen. Understanding layout is crucial for creating well-structured, responsive interfaces.
+
+## Layout Fundamentals
+
+Every UI element has:
+
+- **Container Rectangle** - The space allocated by the parent
+- **Anchor** - How the element positions/sizes itself within the container
+- **Padding** - Inner spacing that affects child layout
+- **LayoutMode** - How the element arranges its children (if it's a container)
+
+```
+┌─────────────────────────────────────┐
+│  Container Rectangle (from parent)  │
+│  ┌───────────────────────────────┐  │
+│  │  Anchored Rectangle           │  │
+│  │  ┌─────────────────────────┐  │  │
+│  │  │ Padding                 │  │  │
+│  │  │  ┌───────────────────┐  │  │  │
+│  │  │  │  Content Area     │  │  │  │
+│  │  │  └───────────────────┘  │  │  │
+│  │  └─────────────────────────┘  │  │
+│  └───────────────────────────────┘  │
+└─────────────────────────────────────┘
+```
+
+## Anchor
+
+`Anchor` controls how an element positions and sizes itself within its container rectangle.
+
+### Fixed Size
+
+```
+Button {
+    Anchor: (Width: 200, Height: 40);
+}
+```
+
+Creates a 200×40 pixel button.
+
+### Positioning
+
+```
+Label {
+    Anchor: (Top: 10, Left: 20, Width: 100, Height: 30);
+}
+```
+
+- **Top**: 10 pixels from container's top edge
+- **Left**: 20 pixels from container's left edge
+- **Width**: 100 pixels wide
+- **Height**: 30 pixels tall
+
+### Anchoring to Edges
+
+```
+Button {
+    Anchor: (Bottom: 10, Right: 10, Width: 100, Height: 30);
+}
+```
+
+Anchors the button to the bottom-right corner, 10 pixels from each edge.
+
+### Stretching
+
+```
+Group {
+    Anchor: (Top: 0, Bottom: 0, Left: 0, Right: 0);
+}
+```
+
+Stretches to fill the entire container (all edges at 0 pixels).
+
+**Shorthand:**
+
+```
+Group {
+    Anchor: (Full: 0);
+}
+```
+
+### Mixed Anchoring
+
+```
+Panel {
+    Anchor: (Top: 10, Bottom: 10, Left: 20, Width: 300);
+}
+```
+
+- Fixed width of 300 pixels
+- Stretches vertically between top and bottom edges
+- 10 pixels from top and bottom
+- 20 pixels from left
+
+## Padding
+
+`Padding` creates inner spacing, affecting where children are positioned.
+
+### Uniform Padding
+
+```
+Group {
+    Padding: (Full: 20);
+}
+```
+
+20 pixels of padding on all sides.
+
+### Directional Padding
+
+```
+Group {
+    Padding: (Top: 10, Bottom: 20, Left: 15, Right: 15);
+}
+```
+
+Different padding per edge.
+
+### Shorthand
+
+```
+// Horizontal and vertical
+Group {
+    Padding: (Horizontal: 20, Vertical: 10);
+}
+
+// Equivalent to:
+// Top: 10, Bottom: 10, Left: 20, Right: 20
+```
+
+### Effect on Children
+
+```
+Group {
+    Anchor: (Width: 200, Height: 100);
+    Padding: (Full: 10);
+
+    Label {
+        Anchor: (Full: 0);
+    }
+}
+```
+
+The label fills the group, but there's a 10-pixel gap on all sides due to padding.
+
+```
+┌──────────────────────┐
+│ Group (200×100)      │
+│  ┌────────────────┐  │
+│  │ Label          │  │ ← 10px padding all around
+│  │                │  │
+│  └────────────────┘  │
+└──────────────────────┘
+```
+
+## LayoutMode
+
+`LayoutMode` determines how a container arranges its children.
+
+### Top (Vertical Stack)
+
+```
+Group {
+    LayoutMode: Top;
+
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+}
+```
+
+Children stack vertically from top to bottom:
+
+```
+┌──────────┐
+│ Button 1 │
+├──────────┤
+│ Button 2 │
+├──────────┤
+│ Button 3 │
+└──────────┘
+
+
+```
+
+Each child's `Anchor.Bottom` adds spacing between elements:
+
+```
+Button { Anchor: (Height: 30, Bottom: 10); }  // 10px gap after this button
+```
+
+### Bottom (Vertical Stack)
+
+```
+Group {
+    LayoutMode: Bottom;
+
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+}
+```
+
+Children stack vertically from top to bottom but aligned to the bottom edge of the parent:
+
+```
+
+
+
+┌──────────┐
+│ Button 1 │
+├──────────┤
+│ Button 2 │
+├──────────┤
+│ Button 3 │
+└──────────┘
+```
+
+### Left (Horizontal Stack)
+
+```
+Group {
+    LayoutMode: Left;
+
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+}
+```
+
+Children arrange horizontally from left to right:
+
+```
+┌────────┬────────┬────────┐
+│ Button │ Button │ Button │
+│   1    │   2    │   3    │
+└────────┴────────┴────────┘
+```
+
+Use `Anchor.Right` for spacing between elements.
+
+### Right (Horizontal Stack)
+
+```
+Group {
+    LayoutMode: Right;
+
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+}
+```
+
+Children arrange horizontally from left to right but aligned to the right side of the parent:
+
+```
+                                                                 ┌────────┬────────┬────────┐
+                                                                 │ Button │ Button │ Button │
+                                                                 │   1    │   2    │   3    │
+                                                                 └────────┴────────┴────────┘
+```
+
+### Center
+
+```
+Group {
+    LayoutMode: Center;
+
+    Group #Dialog {
+        Anchor: (Width: 400, Height: 300);
+    }
+}
+```
+
+Centers the children horizontally.
+
+### Middle
+
+```
+Group {
+    LayoutMode: Middle;
+
+    Group #Dialog {
+        Anchor: (Width: 400, Height: 300);
+    }
+}
+```
+
+Centers the children vertically.
+
+### CenterMiddle (Horizontal Stack, Fully Centered)
+
+```
+Group {
+    LayoutMode: CenterMiddle;
+
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+}
+```
+
+Children stack horizontally from left to right, centered both horizontally and vertically within the parent:
+
+```
+┌────────────────────────────────────────────┐
+│                                            │
+│                                            │
+│         ┌──────┐ ┌──────┐ ┌──────┐         │
+│         │  B1  │ │  B2  │ │  B3  │         │
+│         └──────┘ └──────┘ └──────┘         │
+│                                            │
+│                                            │
+└────────────────────────────────────────────┘
+```
+
+---
+
+### MiddleCenter (Vertical Stack, Fully Centered)
+
+```
+Group {
+    LayoutMode: MiddleCenter;
+
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+}
+```
+
+Children stack vertically from top to bottom, centered both horizontally and vertically within the parent:
+
+```
+┌────────────────────────────────────────────┐
+│                                            │
+│              ┌──────────┐                  │
+│              │ Button 1 │                  │
+│              ├──────────┤                  │
+│              │ Button 2 │                  │
+│              ├──────────┤                  │
+│              │ Button 3 │                  │
+│              └──────────┘                  │
+│                                            │
+└────────────────────────────────────────────┘
+```
+
+---
+
+### Full
+
+```
+Group {
+    LayoutMode: Full;
+
+    Label {
+        Anchor: (Top: 20, Left: 20, Width: 100, Height: 30);
+    }
+}
+```
+
+Children use absolute positioning via their `Anchor` properties.
+
+### TopScrolling
+
+```
+Group {
+    LayoutMode: TopScrolling;
+    ScrollbarStyle: $Common.@DefaultScrollbar;
+
+    // ... many children
+}
+```
+
+Like `Top`, but adds a scrollbar if content exceeds container height.
+
+Or use `BottomScrolling` for bottom-aligned content.
+
+### LeftScrolling
+
+```
+Group {
+    LayoutMode: LeftScrolling;
+    ScrollbarStyle: $Common.@DefaultScrollbar;
+
+    // ... many children
+}
+```
+
+Like `Left`, but adds a scrollbar for horizontal scrolling.
+
+Or use `RightScrolling` for right-aligned content.
+
+### LeftCenterWrap (Wrapping Horizontal Stack, Horizontally Centered)
+
+```
+Group {
+    LayoutMode: LeftCenterWrap;
+
+    Button { Anchor: (Width: 80, Height: 30); }
+    Button { Anchor: (Width: 80, Height: 30); }
+    Button { Anchor: (Width: 80, Height: 30); }
+    Button { Anchor: (Width: 80, Height: 30); }
+    Button { Anchor: (Width: 80, Height: 30); }
+}
+```
+
+Children flow left to right. When there's no more horizontal space, they wrap to the next row. Each row is horizontally centered within the parent:
+
+```
+┌────────────────────────────────────────────┐
+│                                            │
+│       ┌──────┐ ┌──────┐ ┌──────┐           │
+│       │  B1  │ │  B2  │ │  B3  │           │
+│       └──────┘ └──────┘ └──────┘           │
+│            ┌──────┐ ┌──────┐               │
+│            │  B4  │ │  B5  │               │
+│            └──────┘ └──────┘               │
+│                                            │
+└────────────────────────────────────────────┘
+```
+
+## FlexWeight
+
+`FlexWeight` distributes remaining space among children.
+
+```
+Group {
+    LayoutMode: Left;
+    Anchor: (Width: 400);
+
+    Button {
+        Anchor: (Width: 100);
+    }
+
+    Group {
+        FlexWeight: 1;  // Takes all remaining space
+    }
+
+    Button {
+        Anchor: (Width: 100);
+    }
+}
+```
+
+Result:
+
+- First button: 100px
+- Middle group: 200px (400 - 100 - 100 = 200)
+- Last button: 100px
+
+### Multiple FlexWeights
+
+```
+Group {
+    LayoutMode: Left;
+    Anchor: (Width: 600);
+
+    Group { FlexWeight: 1; }
+    Group { FlexWeight: 2; }
+    Group { FlexWeight: 1; }
+}
+```
+
+Remaining space (600px) is split:
+
+- First group: 600 × (1/4) = 150px
+- Second group: 600 × (2/4) = 300px
+- Third group: 600 × (1/4) = 150px
+
+## Visibility
+
+```
+Button #HiddenButton {
+    Visible: false;
+}
+```
+
+**Effect:**
+
+- Element and its children are not displayed
+- Element is **not included in layout** (doesn't take up space)
diff --git a/content/docs/pt-BR/official-documentation/custom-ui/markup.mdx b/content/docs/pt-BR/official-documentation/custom-ui/markup.mdx
new file mode 100644
index 00000000..564110ed
--- /dev/null
+++ b/content/docs/pt-BR/official-documentation/custom-ui/markup.mdx
@@ -0,0 +1,226 @@
+---
+title: Markup
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# Markup
+
+## Markup
+
+An element is the basic building block of a user interface. There are various types of elements with different properties, which are documented below.
+
+Here's what the syntax looks like:
+
+```
+// Basic declaration of an element
+// with its Anchor property set to attach on all sides of its parent
+// with 10 pixels of margin
+Group { Anchor: (Left: 10, Top: 10, Right: 10, Bottom: 10); }
+
+Group { Anchor: (Full: 10); } // More concise version
+
+// Declaration of a Label with a name
+// (can be used to access the element from game code)
+Label #MyLabel {
+  Style: LabelStyle(FontSize: 16); // or just Style: (FontSize: 16), type can be inferred.
+  Text: "Hi! I am text.";
+}
+
+// Declaration of a Group containing 2 children
+// You can use FlexWeight to distribute any left-over space after explicit widths/heights have been subtracted
+Group {
+  LayoutMode: Left;
+  Label { Text: "Child 1"; FlexWeight: 2; }
+  Label { Text: "Child 2"; FlexWeight: 1; }
+}
+```
+
+### Documents
+
+A UI document (_.ui_ file) contains trees of elements. There can be multiple root elements.
+
+### Named Expressions
+
+Named expressions can be declared at any level of a document (including at the root) and will be scoped to that subtree, though they need to be declared at the top of the block.
+
+```
+// Example of named expressions, declared and used with @ prefix
+@Title = "Hytale";
+@ExtraSpacing = 5;
+
+Label {
+  Text: @Title;
+  Style: (LetterSpacing: 2 + @ExtraSpacing);
+}
+```
+
+You can use the spread operator `...` to reuse a named expression while overriding some of its fields:
+
+```
+@MyBaseStyle = LabelStyle(FontSize: 24, LetterSpacing: 2);
+
+Label {
+  Style: (...@MyBaseStyle, FontSize: 36);
+}
+```
+
+You can even layer multiple named expressions like so:
+
+```
+@TitleStyle = LabelStyle(FontSize: 24, HorizontalAlignment: Center);
+@SpacedTextStyle = LabelStyle(LetterSpacing: 2);
+
+Label {
+  Style: (...@BigTextStyle, ...@SpacedTextStyle);
+}
+```
+
+#### Document references
+
+A document can reference another document and access its named expressions.
+
+```
+// Document references are defined with $ prefix
+$Common = "../Common.ui";
+
+TextButton {
+  Style: $Common.@DefaultButtonStyle;
+}
+```
+
+### Templates
+
+You can declare a reusable bit of interface as a named expression and then instantiate it as many times as you want in the tree while customizing it.
+
+You can override local named expressions as well as insert additional children at any point in the template tree. However, local named expressions must be defined at the very top of the block, before properties and child elements.
+
+```
+// This is the template
+@Row = Group {
+  Anchor: (Height: 50);
+  Label #Label { Anchor: (Left: 0, Width: 100); Text: @LabelText; }
+  Group #Content { Anchor: (Left: 100); }
+};
+
+// Here we'll be using it twice in the document tree
+Group #Rows {
+  LayoutMode: TopScrolling;
+
+  @Row #MyFirstRow {
+    @LabelText = "First row";
+    #Content { TextInput {} }
+  }
+
+  @Row #MySecondRow {
+    @LabelText = "Second row";
+  }
+}
+```
+
+### Property Types
+
+#### Basic Types
+
+- **Boolean**
+  - `Visible: false;`
+  - `Visible: true;`
+- **Int**
+  - `Height: 20;`
+- **Float, Double, Decimal**
+  - `Min: 0.2;`
+- **String**
+  - `Text: "Hi!";`
+- **Char**
+  - `PasswordChar: "*";`
+  - _Note: The syntax is the same as a string, however a value of this type cannot contain more than one character!_
+- **Color**
+  - `Background: #ffffff;`&#x20;
+- **Objects**
+  - `Style: (Background: #ffffff)`
+- **Array**&#x20;
+  - `TextSpans: [(Text: "Hi", IsBold: true)]`
+
+#### Translations
+
+Translation keys can be referenced anywhere in markup where you can provide a string, and they are then converted to a string when an element gets instantiated.
+
+**Example:**
+
+```
+Label {
+  Text: %ui.general.cancel;
+}
+```
+
+#### Colors
+
+A color literal can be written as follows:
+
+- `#rrggbb`: 6-digit hexadecimal representation for red, green, blue (fully opaque)
+- `#rrggbb(a.a)`: 6-digit hexadecimal representation for red, green, blue with alpha between 0 and 1
+- `#rrggbbaa`: 8-digit hexadecimal representation for red, green, blue and alpha
+
+```
+Group {
+  Background: #000000(0.3);
+}
+```
+
+<Callout>
+  The `#rrggbb(a.a)` format is prefered over the `#rrggbbaa` format for
+  readability reasons.
+</Callout>
+
+#### Font Name
+
+Font names can be referenced directly by their string ID. Internally this is using a custom type called `UIFontName`, however strings will be converted automatically to this type in markup.
+
+```
+Label {
+  Text: "Hi";
+  Style: (FontName: "Secondary");
+}
+```
+
+**Available Font Names**
+
+- _Default_ - This is the default font that is used for most text and is always used unless a different option has been specified
+- _Secondary_ - This font is mostly used for headlines or elements that are supposed to stick out
+- _Mono_ - This is only used for development; For things such as profiling or error overlays.
+
+#### Path
+
+We can reference other UI assets with the `UIPath` type. Similar to `UIFontName`_,_ Strings are automatically converted to a `UIPath`. Paths are always relative to the file where they have been declared in. Looking up _MyButton.png_ in _Menu/MyAwesomeMenu.ui_ will result in _Menu/MyButton.png_. If you want to reference a file that is in a parent folder you can go back one directory by writing two dots (_../MyButton.png_).
+
+The markup syntax of a `UIPath` is the same as a String. (e.g. `Path: "Test.png"`)
+
+Here are some more examples:
+
+| UIPath             | .ui File                              | Resulting Path    |
+| ------------------ | ------------------------------------- | ----------------- |
+| MyButton.png       | Menu/MyAwesomeMenu.ui                 | Menu/MyButton.png |
+| ../MyButton.png    | Menu/MyAwesomeMenu.ui                 | MyButton.png      |
+| ../../MyButton.png | Menu/Popup/Templates/MyAwesomeMenu.ui | Menu/MyButton.png |
+
+#### Objects
+
+Objects contain a set of properties. In this example we are assigning an Anchor object to the _Anchor_ property:
+
+```
+Group {
+  Anchor: (
+   Height: 10,
+   Width: 20
+ );
+}
+```
+
+You can find all objects that can be used in markup [here](type-documentation#elements).
+
+## Visual Studio Code Extension
+
+There is an official extension for Visual Studio Code which adds syntax highlighting for .ui files. You can find it [here](https://marketplace.visualstudio.com/items?itemName=HypixelStudiosCanadaInc.vscode-hytaleui).
diff --git a/content/docs/pt-BR/official-documentation/custom-ui/type-documentation/index.mdx b/content/docs/pt-BR/official-documentation/custom-ui/type-documentation/index.mdx
new file mode 100644
index 00000000..69cea406
--- /dev/null
+++ b/content/docs/pt-BR/official-documentation/custom-ui/type-documentation/index.mdx
@@ -0,0 +1,127 @@
+---
+title: Type Documentation
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# Type Documentation
+
+This is a generated list of UI elements accessible by markup. More information about the User Interface framework can be found in the main documentation.
+
+## Elements
+
+- [ActionButton](type-documentation/elements/actionbutton)
+- [AssetImage](type-documentation/elements/assetimage)
+- [BackButton](type-documentation/elements/backbutton)
+- [BlockSelector](type-documentation/elements/blockselector)
+- [Button](type-documentation/elements/button)
+- [CharacterPreviewComponent](type-documentation/elements/characterpreviewcomponent)
+- [CheckBox](type-documentation/elements/checkbox)
+- [CheckBoxContainer](type-documentation/elements/checkboxcontainer)
+- [CircularProgressBar](type-documentation/elements/circularprogressbar)
+- [CodeEditor](type-documentation/elements/codeeditor)
+- [ColorOptionGrid](type-documentation/elements/coloroptiongrid)
+- [ColorPicker](type-documentation/lements/colorpicker)
+- [ColorPickerDropdownBox](type-documentation/elements/colorpickerdropdownbox)
+- [CompactTextField](type-documentation/elements/compacttextfield)
+- [DropdownBox](type-documentation/elements/dropdownbox)
+- [DropdownEntry](type-documentation/elements/dropdownentry)
+- [DynamicPane](type-documentation/elements/dynamicpane)
+- [DynamicPaneContainer](type-documentation/elements/dynamicpanecontainer)
+- [FloatSlider](type-documentation/elements/floatslider)
+- [FloatSliderNumberField](type-documentation/elements/floatslidernumberfield)
+- [Group](type-documentation/elements/group)
+- [HotkeyLabel](type-documentation/elements/hotkeylabel)
+- [ItemGrid](type-documentation/elements/itemgrid)
+- [ItemIcon](type-documentation/elements/itemicon)
+- [ItemPreviewComponent](type-documentation/elements/itempreviewcomponent)
+- [ItemSlot](type-documentation/elements/itemslot)
+- [ItemSlotButton](type-documentation/elements/itemslotbutton)
+- [Label](type-documentation/elements/label)
+- [LabeledCheckBox](type-documentation/elements/labeledcheckbox)
+- [MenuItem](type-documentation/elements/menuitem)
+- [MultilineTextField](type-documentation/elements/multilinetextfield)
+- [NumberField](type-documentation/elements/numberfield)
+- [Panel](type-documentation/elements/panel)
+- [ProgressBar](type-documentation/elements/progressbar)
+- [ReorderableList](type-documentation/elements/reorderablelist)
+- [ReorderableListGrip](type-documentation/elements/reorderablelistgrip)
+- [SceneBlur](type-documentation/elements/sceneblur)
+- [Slider](type-documentation/elements/slider)
+- [SliderNumberField](type-documentation/elements/slidernumberfield)
+- [Sprite](type-documentation/elements/sprite)
+- [TabButton](type-documentation/elements/tabbutton)
+- [TabNavigation](type-documentation/elements/tabnavigation)
+- [TextButton](type-documentation/elements/textbutton)
+- [TextField](type-documentation/elements/textfield)
+- [TimerLabel](type-documentation/elements/timerlabel)
+- [ToggleButton](type-documentation/elements/togglebutton)
+
+## Property Types
+
+- [Anchor](type-documentation/property-types/anchor)
+- [BlockSelectorStyle](type-documentation/property-types/blockselectorstyle)
+- [ButtonSounds](type-documentation/property-types/buttonsounds)
+- [ButtonStyle](type-documentation/property-types/buttonstyle)
+- [ButtonStyleState](type-documentation/property-types/buttonstylestate)
+- [CheckBoxStyle](type-documentation/property-types/checkboxstyle)
+- [CheckBoxStyleState](type-documentation/property-types/checkboxstylestate)
+- [ClientItemStack](type-documentation/property-types/clientitemstack)
+- [ColorOptionGridStyle](type-documentation/property-types/coloroptiongridstyle)
+- [ColorPickerDropdownBoxStateBackground](type-documentation/property-types/colorpickerdropdownboxstatebackground)
+- [ColorPickerDropdownBoxStyle](type-documentation/property-types/colorpickerdropdownboxstyle)
+- [ColorPickerStyle](type-documentation/property-types/colorpickerstyle)
+- [DropdownBoxSearchInputStyle](type-documentation/property-types/dropdownboxsearchinputstyle)
+- [DropdownBoxSounds](type-documentation/property-types/dropdownboxsounds)
+- [DropdownBoxStyle](type-documentation/property-types/dropdownboxstyle)
+- [InputFieldButtonStyle](type-documentation/property-types/inputfieldbuttonstyle)
+- [InputFieldDecorationStyle](type-documentation/property-types/inputfielddecorationstyle)
+- [InputFieldDecorationStyleState](type-documentation/property-types/inputfielddecorationstylestate)
+- [InputFieldIcon](type-documentation/property-types/inputfieldicon)
+- [InputFieldStyle](type-documentation/property-types/inputfieldstyle)
+- [ItemGridSlot](type-documentation/property-types/itemgridslot)
+- [ItemGridStyle](type-documentation/property-types/itemgridstyle)
+- [LabeledCheckBoxStyle](type-documentation/property-types/labeledcheckboxstyle)
+- [LabeledCheckBoxStyleState](type-documentation/property-types/labeledcheckboxstylestate)
+- [LabelSpan](type-documentation/property-types/labelspan)
+- [LabelStyle](type-documentation/property-types/labelstyle)
+- [NumberFieldFormat](type-documentation/property-types/numberfieldformat)
+- [Padding](type-documentation/property-types/padding)
+- [PatchStyle](type-documentation/property-types/patchstyle)
+- [PopupStyle](type-documentation/property-types/popupstyle)
+- [ScrollbarStyle](type-documentation/property-types/scrollbarstyle)
+- [SliderStyle](type-documentation/property-types/sliderstyle)
+- [SoundStyle](type-documentation/property-types/soundstyle)
+- [SpriteFrame](type-documentation/property-types/spriteframe)
+- [SubMenuItemStyle](type-documentation/property-types/submenuitemstyle)
+- [SubMenuItemStyleState](type-documentation/property-types/submenuitemstylestate)
+- [Tab](type-documentation/property-types/tab)
+- [TabNavigationStyle](type-documentation/property-types/tabnavigationstyle)
+- [TabStyle](type-documentation/property-types/tabstyle)
+- [TabStyleState](type-documentation/property-types/tabstylestate)
+- [TextButtonStyle](type-documentation/property-types/textbuttonstyle)
+- [TextButtonStyleState](type-documentation/property-types/textbuttonstylestate)
+- [TextTooltipStyle](type-documentation/property-types/texttooltipstyle)
+- [ToggleButtonStyle](type-documentation/property-types/togglebuttonstyle)
+- [ToggleButtonStyleState](type-documentation/property-types/togglebuttonstylestate)
+
+## Enums
+
+- [ActionButtonAlignment](type-documentation/enums/actionbuttonalignment)
+- [CodeEditorLanguage](type-documentation/enums/codeeditorlanguage)
+- [ColorFormat](type-documentation/enums/colorformat)
+- [DropdownBoxAlign](type-documentation/enums/dropdownboxalign)
+- [InputFieldButtonSide](type-documentation/enums/inputfieldbuttonside)
+- [InputFieldIconSide](type-documentation/enums/inputfieldiconside)
+- [ItemGridInfoDisplayMode](type-documentation/enums/itemgridinfodisplaymode)
+- [LabelAlignment](type-documentation/enums/labelalignment)
+- [LayoutMode](type-documentation/enums/layoutmode)
+- [MouseWheelScrollBehaviourType](type-documentation/enums/mousewheelscrollbehaviourtype)
+- [ProgressBarAlignment](type-documentation/enums/progressbaralignment)
+- [ProgressBarDirection](type-documentation/enums/progressbardirection)
+- [ResizeType](type-documentation/enums/resizetype)
+- [TimerDirection](type-documentation/enums/timerdirection)
+- [TooltipAlignment](type-documentation/enums/tooltipalignment)
diff --git a/content/docs/pt-BR/official-documentation/npc/2-getting-started-with-templates.mdx b/content/docs/pt-BR/official-documentation/npc/2-getting-started-with-templates.mdx
index 91081ca1..99d078e0 100644
--- a/content/docs/pt-BR/official-documentation/npc/2-getting-started-with-templates.mdx
+++ b/content/docs/pt-BR/official-documentation/npc/2-getting-started-with-templates.mdx
@@ -9,7 +9,7 @@ authors:
 
 There are no hard and fast rules for making a start on a template. I like to duplicate **BlankTemplate** and start from there because it already provides the basic structure of the file.
 
-This leaves me with the following template (`Template_Goblin_Ogre.json`): (note: the file could be looking different in the current version of the game)
+This leaves me with the following template (`Template_Goblin_Ogre.json`): (**note: the file could be looking different in the current version of the game**)
 
 ```json
 {
@@ -33,7 +33,7 @@ This leaves me with the following template (`Template_Goblin_Ogre.json`): (note:
     }
   },
   "Appearance": { "Compute": "Appearance" },
-  "DropList": { "Compute": "Droplist" },
+  "DropList": { "Compute": "DropList" },
   "MaxHealth": { "Compute": "MaxHealth" },
   "MotionControllerList": [
     {
@@ -65,10 +65,10 @@ And the following variant (`Goblin_Ogre.json`) next to the template. There's a t
   "Type": "Variant",
   "Reference": "Template_Goblin_Ogre",
   "Modify": {
-    "Appearance": "Goblin_Ogre",
+    "Appearance": "Goblin",
     "MaxHealth": 124
   }
 }
 ```
 
-Our artists have defined the `Goblin_Ogre` appearance already so I'm going to use that.
+Our artists have not yet finished animations for the `Goblin_Ogre`, for that sake of the tutorial I am going to use appearance `Goblin`, because it offers a more complete set of animations that we will need.
diff --git a/content/docs/pt-BR/official-documentation/worldgen/pack-tutorial/asset-packs.mdx b/content/docs/pt-BR/official-documentation/worldgen/pack-tutorial/asset-packs.mdx
index 38809fad..dcf1f3b9 100644
--- a/content/docs/pt-BR/official-documentation/worldgen/pack-tutorial/asset-packs.mdx
+++ b/content/docs/pt-BR/official-documentation/worldgen/pack-tutorial/asset-packs.mdx
@@ -9,13 +9,13 @@ authors:
 
 <OfficialDocumentationNotice />
 
-# How to modify Hytale
+# How to modify Hytale?
 
-## What's an Asset Pack
+## What's an Asset Pack?
 
-Hytales gameplay is driven by assets in the game that can be modified by creators. Asset Packs are our solution to let you override or add features to the base game with your own work. These can in the form of zip files of folders, which contain a custom set of assets. This is not the only way for a creator to change Hytale but this is the most accessible form.;
+Hytales gameplay is driven by assets in the game that can be modified by creators. Asset Packs are our solution to let you override or add features to the base game with your own work. These can be the form of zip files of folders, which contain a custom set of assets. This is not the only way for a creator to change Hytale but this is the most accessible form.;
 
-### How do I make an Asset Pack
+### How do I make an Asset Pack?
 
 <video controls className="my-6 aspect-video w-full rounded-lg border">
   <source src="https://cdn.internal.hytalemodding.dev/guides/official/how-to-asset-pack.mp4" type="video/mp4" />
@@ -48,7 +48,7 @@ An asset pack is typically a zip or folder, with a `manifest.json` inside. This
 }
 ```
 
-### Where are they stored
+### Where are they stored?
 
 Asset Packs are stored with other mods in the Mods folder.
 
@@ -76,7 +76,7 @@ C:\Users\<user>\AppData\Roaming\Hytale\UserData\Saves\New World 5\mods
 
 When you have Asset Packs or Mods installed, these will appear in the New World menu under the Options menu.;
 
-### How do I change an existing asset
+### How do I change an existing asset?
 
 <video controls className="my-6 aspect-video w-full rounded-lg border">
   <source src="https://cdn.internal.hytalemodding.dev/guides/official/how-to-asset.mp4" type="video/mp4" />
diff --git a/content/docs/pt-BR/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx b/content/docs/pt-BR/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx
index 44528376..24e628b5 100644
--- a/content/docs/pt-BR/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx
+++ b/content/docs/pt-BR/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx
@@ -106,7 +106,7 @@ If a BaseHeight is provided, the TopY and BottomY values are relative to the Bas
 
 Applies a Material Provider slot on a set of horizontal stripes of blocks of varying thickness and position. Below is an example image of basalt stripes into a stone cliff.
 
-{/* ![](https://540086904-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F7KAmBkOg6d13nZCkf9ku%2Fuploads%2FbcxO9LpArn8gPCaBwFg5%2Funknown.png?alt=media&token=1c72b67a-8253-4d03-8c64-1ad5f6830050) */}
+![Example of basalt stripes](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/basalt-stripes-example.png)
 
 #### Parameters:
 
diff --git a/content/docs/pt-BR/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx b/content/docs/pt-BR/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx
index 5e34acd4..a4418473 100644
--- a/content/docs/pt-BR/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx
+++ b/content/docs/pt-BR/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx
@@ -294,7 +294,7 @@ Combines all the positions into a single Positioins field.
 
 ---
 
-### SimpleHoritontal
+### SimpleHorizontal
 
 Keeps only the positions that are within the provided range.
 
diff --git a/content/docs/pt-BR/official-documentation/worldgen/worldgen-tutorial/README.mdx b/content/docs/pt-BR/official-documentation/worldgen/worldgen-tutorial/README.mdx
new file mode 100644
index 00000000..5f66d245
--- /dev/null
+++ b/content/docs/pt-BR/official-documentation/worldgen/worldgen-tutorial/README.mdx
@@ -0,0 +1,166 @@
+---
+title: How to edit and create Biomes
+description: Explores where world generation assets can be found and how to edit them.
+---
+
+### Where are the Assets
+
+World generation assets are kept in the HytaleGenerator directory within the assets.
+
+```
+/Server/HytaleGenerator/
+```
+
+<div className="flex flex-row rounded-lg border p-4">
+  <div className="flex-1/2 border-r pr-4">
+    ```
+    /Biomes
+    ```
+
+    Biome assets, with content configurations.
+  </div>
+
+  <div className="flex-1/2 pl-4">
+    ```
+    /WorldStructure
+    ```
+
+    Generator files that define which biomes spawn together.
+  </div>
+</div>
+
+<div className="flex flex-row rounded-lg border p-4">
+  <div className="flex-1/2 border-r pr-4">
+    ```
+    /Density
+    ```
+
+    Density assets that can be referenced by any other assets.
+  </div>
+
+  <div className="flex-1/2 pl-4">
+    ```
+    /Assignments
+    ```
+
+    Prop assets that can be referenced by any Biome assets.
+  </div>
+</div>
+
+***
+
+An example of this structure can be found bellow, packed in an asset pack with the instance configuration.
+
+[https://drive.google.com/file/d/1sIz_CluANIIe3n8vNiOi-4PQdeqCO0qY/view?usp=drive_link](https://drive.google.com/file/d/1sIz_CluANIIe3n8vNiOi-4PQdeqCO0qY/view?usp=drive_link)
+
+<Callout>
+  Ensure you place your asset pack in the correct directory, under Mods.
+</Callout>
+
+### How to visit our worlds
+
+https://drive.google.com/file/d/1BJurxyj-taE-PXWm04bk7Dl6X7ZHTH92/view?usp=sharing
+
+#### Requirements
+
+- You must be an **Operator** in the world.
+  - To do this, run <mark style="color:$danger;">`/op self`</mark>
+- You must be in **Creative mode**.
+  - Press the <mark style="color:$danger;">`O`</mark> key, O for Orange.&#x20;
+
+The generation assets define a set of generators but on their own you cannot visit these. Currently you require an Instance with a generator that will allow you to visit your work.
+
+```
+/Server/Instances/
+```
+
+Instances are separate worlds that players can join using the `/instances` command. Each instance has an `Instance.bson` configuration asset that specifies which generator to use, among other worldly settings.
+
+```json
+{
+  "WorldGen": {
+    "Type": "HytaleGenerator",
+    "WorldStructure": "Basic",
+    "playerSpawn" : {
+      "X" : 123,
+      "Y" : 480,
+      "Z" : 10000,
+      "Pitch" : 0,
+      "Yaw" : 0,
+      "Roll" : 0
+    }
+  }
+}
+```
+
+<Callout>
+  You can create custom instances for different world structures and biomes as you need them.
+</Callout>
+
+### How to edit Biomes
+
+<video>
+  <source src="https://cdn.internal.hytalemodding.dev/guides/official/How-to-edit-Biomes.mp4" type="video/mp4" />
+</video>
+
+We currently use the Hytale Node Editor when editing world generation assets. This can be accessed while in-game from the Content Creation menu when pressing B. The node editor is then found under the asset editor dropdown on the upper left.&#x20;
+
+![Node Editor 1](/assets/official-documentation/worldgen/worldgen-tutorial/biomes/node-editor-1.png)
+
+Once you have the Hytale Node Editor open, through the file menu you can open Biomes by navigating to the Biomes directory and selecting one from your pack.&#x20;
+
+```
+/Server/HytaleGenerator/Biomes/
+```
+
+### Biome Asset Structure
+
+Every Biome has a root Biome node, this node splits into 5 structures. This is covered briefly but more information on each field can be found on the World Generation Concepts page.
+
+![Node Editor 2](/assets/official-documentation/worldgen/worldgen-tutorial/biomes/node-editor-2.png)
+
+<Callout>
+  Each biome is for the most part self contained, meaning it has control over what appears with the biome. The only exception to this are Base Heights.
+</Callout>
+
+<Tabs>
+  <Tab value="Terrain">
+    Mathematical function nodes that calculate the physical shape of the Biome's terrain.
+  </Tab>
+
+  <Tab value="Materials">
+    Logical nodes that determine what materials (blocks) make up a Biome's terrain.
+  </Tab>
+
+  <Tab value="Props">
+    Function nodes that add objects like prefabs and decorations to the terrain.
+  </Tab>
+
+  <Tab value="Environments">
+    Logical nodes that determine the environment asset at a given coordinate within the biome. This asset determines things like weather, NPC spawns, and sounds.
+  </Tab>
+
+  <Tab value="Tints">
+    Logical function nodes that determine a colour code that can be used by certain blocks in the world. Typically this will be grasses and soils.
+  </Tab>
+</Tabs>
+
+### How to preview your work
+
+[https://drive.google.com/file/d/1mNcHn9LhFnWDF0DzWFH6_YllmKAUvUry/view?t=6](https://drive.google.com/file/d/1mNcHn9LhFnWDF0DzWFH6_YllmKAUvUry/view?t=6)
+
+Once you are in an Instance world with the Hytale Generator active you will only be able to see your work by generating new chunks. There are a few ways to do this.
+
+The viewport command selects an area around the Player that will live reload as you make changes to the generator.&#x20;
+
+```
+/viewport --radius 5 
+```
+
+You can also create a new world to show your changes.&#x20;
+
+```
+/instances spawn <instance> 
+```
+
+The last option is to simply fly south, new chunks will generate with the changes made.
diff --git a/content/docs/pt-BR/quick-start.mdx b/content/docs/pt-BR/quick-start.mdx
index 20c57afb..a22daeee 100644
--- a/content/docs/pt-BR/quick-start.mdx
+++ b/content/docs/pt-BR/quick-start.mdx
@@ -3,9 +3,14 @@ title: Primeiros passos
 description: Configure um projeto padrão de Hytale.
 ---
 
-Bem-vindo(a) à documentação de criação de mods para o Hytale Esta seção contém o guia completo para o desenvolvimento dos seus próprios mods para o Hytale.
+Bem-vindo(a) à documentação de criação de mods para o Hytale. Esta seção contém o guia completo para o desenvolvimento dos seus próprios mods para o Hytale.
 
 * [Fundamentos do Java](./guides/java-basics/00-introduction)
 * [Configurando seu ambiente de desenvolvimento](./guides/plugin/setting-up-env)
-* [Entity Component System (ECS)](./guides/ecs/entity-component-system)
-* [Publishing your mod](./publishing)
+* [Sistema de componentes de entidade (ECS)](./guides/ecs/entity-component-system)
+* [Publicando seu mod](./publishing)
+
+### Useful Links
+
+* [Kaupenjoe's Modding Videos](https://www.youtube.com/@ModdingByKaupenjoe)
+* [TroubleDEV's Modding Videos](https://www.youtube.com/@TroubleDEV)
diff --git a/content/docs/pt-BR/server/argtypes.mdx b/content/docs/pt-BR/server/argtypes.mdx
new file mode 100644
index 00000000..e54a442e
--- /dev/null
+++ b/content/docs/pt-BR/server/argtypes.mdx
@@ -0,0 +1,61 @@
+---
+title: ArgTypes
+description: Available ArgTypes
+icon: List
+full: true
+authors:
+  - name: Valeena
+---
+
+| Name                        | Target Class                           | Description                                                                                                                               |   |
+| :-------------------------- | :------------------------------------- | :---------------------------------------------------------------------------------------------------------------------------------------- | - |
+| Boolean                     | java.lang.Boolean                      | A 'true' or 'false' input                                                                                                                 |   |
+| Integer                     | java.lang.Integer                      | A whole number                                                                                                                            |   |
+| String                      | java.lang.String                       | Words, text, numbers, letters. To input more than one word at a time, you may need to wrap it with double quotes (`"my fancy sentence"`). |   |
+| Float                       | java.lang.Float                        | A floating-pointer number                                                                                                                 |   |
+| Double                      | java.lang.Double                       | A decimal number                                                                                                                          |   |
+| UUID                        | java.util.UUID                         | A UUID (Universally Unique IDentifier)                                                                                                    |   |
+| Player_UUID                 | java.util.UUID                         | A UUID or an online player username                                                                                                       |   |
+| Game_Profile_Lookup_Async   | ProfileServiceClient.PublicGameProfile | A player UUID or username. If not found locally, performs a remote lookup via the Profile Service.                                        |   |
+| Relative_Double_Coord       | Coord                                  | An x, y, or z coordinate as a decimal, optionally relative by specifying a tilde (~) in front of the number                               |   |
+| Relative_Int_Coord          | IntCoord                               | An x, y, or z coordinate as a whole number, optionally relative by specifying a tilde (~) in front of the number                          |   |
+| Relative_Integer            | RelativeInteger                        | A tilde to mark an integer relative to a base                                                                                             |   |
+| Relative_Float              | RelativeFloat                          | A tilde to mark a float relative to a base                                                                                                |   |
+| Player_Ref                  | PlayerRef                              | A UUID or an online player's username                                                                                                     |   |
+| World                       | World                                  | A world folder name                                                                                                                       |   |
+| Model_Asset                 | ModelAsset                             | A reference to an Asset of type Model                                                                                                     |   |
+| Weather_Asset               | Weather                                | A reference to an Asset of type Weather                                                                                                   |   |
+| Interaction_Asset           | Interaction                            | A reference to an Asset of type Interaction                                                                                               |   |
+| Root_Interaction_Asset      | RootInteraction                        | A reference to an Asset of type Root Interaction                                                                                          |   |
+| Effect_Asset                | EntityEffect                           | A refernece to an Asset of type EntityEffect                                                                                              |   |
+| Environment_Asset           | Environment                            | A reference to an Asset of type Environment                                                                                               |   |
+| Item_Asset                  | Item                                   | A reference to an Asset of type Item                                                                                                      |   |
+| Block_Type_Asset            | BlockType                              | A reference to an Asset of type BlockType                                                                                                 |   |
+| Particle_System             | ParticleSystem                         | A reference to an Asset of type ParticleSystem                                                                                            |   |
+| Hitbox_Collision_Config     | HitboxCollisionConfig                  | A reference to an Asset of type HitboxCollisionConfig                                                                                     |   |
+| Repulsion_Config            | RepulsionConfig                        | A reference to an Asset of type RepulsionConfig                                                                                           |   |
+| Sound_Event_Asset           | SoundEvent                             | A reference to an Asset of type SoundEvent                                                                                                |   |
+| Ambiance_Fx_Asset           | AmbianceFX                             | A reference to an Asset of type AmbianceFX                                                                                                |   |
+| Sound_Category              | SoundCategory                          | A sound category (sfx, music, ambient, ui)                                                                                                |   |
+| Entity_ID                   | `ArgWrapper<EntityWrappedArg, UUID>`   | A UUID representing an entity id                                                                                                          |   |
+| Integer_Comparison_Operator | IntegerComparisonOperator              | A mathematical sign for integer comparison                                                                                                |   |
+| Integer_Operation           | IntegerOperation                       | A mathematical sign for performing an operation                                                                                           |   |
+| Int_Range                   | `Pair<Integer, Integer>`               | Two integers representing a minimum and maximum of a range                                                                                |   |
+| Relative_Int_Range          | RelativeIntRange                       | Two integers representing a minimum and maximum of a range                                                                                |   |
+| Vector2I                    | Vector2i                               | Two integers, generally corresponding to x/z axis                                                                                         |   |
+| Vector3I                    | Vector3i                               | Three integers, generally corresponding to x/y/z axis                                                                                     |   |
+| Relative_Vector3I           | RelativeVector3i                       | Three optionally relative integers, generally corresponding to x/y/z axis                                                                 |   |
+| Relative_Block_Position     | RelativeIntPosition                    | A position with three integer coordinates, representing a block's location in world space.                                                |   |
+| Relative_Position           | Relative                               | A position with three decimal coordinates, representing a location in world space.                                                        |   |
+| Relative_Chunk_Position     | RealtiveChunkPosition                  | A position with two integer coordinates (x, z), representing a chunk's location.                                                          |   |
+| Rotation                    | Vector3f                               | A rotation with three coordinates, representing the pitch, yaw, and roll respectively                                                     |   |
+| Block_Type_Key              | String                                 | A block type                                                                                                                              |   |
+| Block_ID                    | Integer                                | A block type, converted to an int id                                                                                                      |   |
+| Color                       | Integer                                | A color value in hex format, hex integer, or decimal integer                                                                              |   |
+| Weighted_Block_Type         | `Pair<Integer, String>`                | A weight corresponding to a blocktype                                                                                                     |   |
+| Weighted_Block_Entry        | String                                 | A block with optional weight prefix                                                                                                       |   |
+| Block_Pattern               | BlockPattern                           | A list of blocks with optional weights                                                                                                    |   |
+| Individual_Block_Mask       | BlockMask                              | Create a block mask using symbols and block names                                                                                         |   |
+| Block_Mask                  | BlockMask                              | A tick rate value (e.g., 30tps, 33ms, or 30)                                                                                              |   |
+| Tick_Rate                   | Integer                                | A list of block masks that combine together                                                                                               |   |
+| Game_Mode                   | GameMode                               | GameMode                                                                                                                                  |   |
diff --git a/content/docs/pt-BR/server/interaction-reference.mdx b/content/docs/pt-BR/server/interaction-reference.mdx
new file mode 100644
index 00000000..6c0d01b3
--- /dev/null
+++ b/content/docs/pt-BR/server/interaction-reference.mdx
@@ -0,0 +1,1586 @@
+---
+title: Interactions
+description: A list of most Interaction types provided by Hypixel, along with the meaning of their fields, and how they fit together.
+icon: List
+authors:
+  - name: Stephen Baynham
+    url: https://github.com/cannibalvox
+---
+
+### The Interaction Base Type
+
+All interactions of every type below are inherited from Interaction and have these fields.
+
+**Interaction Fields**
+
+| Field Name                | Type                                                                 | Required? | Notes                                                                                                                                                                                                                       |
+| ------------------------- | -------------------------------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| ViewDistance              | `Double`<br />(Default: 96.0)                                        | **No**    | Distance in blocks at which other players can see the effects from this interaction.                                                                                                                                        |
+| Effects                   | `InteractionEffects`                                                 | **No**    | Sound, animations, and particle effects that should trigger when this interaction begins executing.                                                                                                                         |
+| HorizontalSpeedMultiplier | `Float`<br />(Default: 1.0)                                          | **No**    | Multiplier applied to the User entity's movement speed while this interaction is executing                                                                                                                                  |
+| RunTime                   | `Float`                                                              | **No**    | If provided, this interaction will continue executing for at least this long before the interaction chain moves onto the next interaction.                                                                                  |
+| CancelOnItemChange        | `Boolean`<br />(Default: true)                                       | **No**    | If true, this interaction will be cancelled if the User entity's held item changes during execution. This can happen either due to the selected hotbar slot changing or the contents of the item's inventory slot changing. |
+| Rules                     | `InteractionRules`                                                   | **Yes**   | If provided, adds additional limitations and cancellation conditions to this interaction.                                                                                                                                   |
+| Settings                  | `Map`<br />(Key Type: `GameMode`, Value Type: `InteractionSettings`) | **No**    | If provided, adds additional per-GameMode settings to the interaction.                                                                                                                                                      |
+| Camera                    | `InteractionCameraSettings`                                          | **No**    | Arrays of camera motion keyframes for cutscenes and reveals.                                                                                                                                                                |
+
+**GameMode Values**
+
+- `Creative`: The game is currently in Creative Mode
+- `Adventure`: The game is currently in Adventure Mode
+
+**InteractionEffects Fields**
+
+| Field Name               | Type                                              | Required? | Notes                                                                                                                                                 |
+| ------------------------ | ------------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Particles                | `Array`<br />(Element Type: `ModelParticle`)      | **No**    | Particle systems to activate when this interaction begins if the player is in third-person mode.                                                      |
+| FirstPersonParticles     | `Array`<br />(Element Type: `ModelParticle`)      | **No**    | Particle systems to activate when this interaction begins if the player is in first-person mode.                                                      |
+| WorldSoundEventId        | `Asset`<br />(Asset Type: `SoundEvent`)           | **No**    | A sound to play in the world at the User entity's location when this interaction begins.<br />**The SoundEvent must be single-channel (mono) sound.** |
+| LocalSoundEventId        | `Asset`<br />(Asset Type: `SoundEvent`)           | **No**    | A 2D sound to play for the User entity when this interaction begins. Ignored if the User entity is not a player.                                      |
+| Trails                   | `Array`<br />(Element Type: `ModelTrail`)         | **No**    | Trail effects to activate on the User entity when this interaction begins.                                                                            |
+| WaitForAnimationToFinish | `Boolean`<br />(Default: false)                   | **No**    | If true, this interaction will continue executing for at least the length of any animations in this InteractionEffects object.                        |
+| ItemPlayerAnimationsId   | `Asset`<br />(Asset Type: `ItemPlayerAnimations`) | **No**    | If provided, the User entity will use this ItemPlayerAnimations set while this interaction is executing.                                              |
+| ItemAnimationId          | `String`                                          | **No**    | Id of an animation to trigger when this interaction begins executing.<br />**This animation id is not validated on server start.**                    |
+| ClearAnimationOnFinish   | `Boolean`<br />(Default: false)                   | **No**    | If true, animations triggered by this interaction will be halted when the interaction completes.                                                      |
+| ClearSoundEventOnFinish  | `Boolean`<br />(Default: false)                   | **No**    | If true, sounds triggered by this interaction will be halted when the interaction completes.                                                          |
+| CameraEffect             | `Asset`<br />(Asset Type: `CameraEffect` )        | **No**    | If provided, the CameraEffect will be applied while this interaction is executing.                                                                    |
+| MovementEffects          | `MovementEffects`                                 | **No**    | If provided, apply the movement effects to the User entity while this interaction is executing.                                                       |
+| StartDelay               | `Float`<br />(Default: 0.0f)                      | **No**    | The interaction will wait this many seconds before triggering the effects in this object.                                                             |
+
+**InteractionRules Fields**
+
+| Field Name          | Type                                                                                                | Required? | Notes                                                                                                                                                                                                                                     |
+| ------------------- | --------------------------------------------------------------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| BlockedBy           | `Array`<br />(Element Type: `InteractionType`)<br />(Default: Based on the chain's InteractionType) | **No**    | If provided, this RootInteraction cannot be executed while interaction chains of the provided types are executing.<br />**This field only functions for rules attached to a RootInteraction. It has no effect on an Interaction.**        |
+| Blocking            | `Array`<br />(Element Type: `InteractionType`)                                                      | **No**    | If provided, interaction chains with the specified InteractionTypes cannot be executed while this interaction is executing.                                                                                                               |
+| InterruptedBy       | `Array`<br />(Element Type: `InteractionType`)                                                      | **No**    | If provided, interaction chains with the specified InteractionTypes will cancel this interaction chain when they execute.<br />**This field only functions for rules attached to a RootInteraction. It has no effect on an Interaction.** |
+| Interrupting        | `Array`<br />(Element Type: `InteractionType`)                                                      | **No**    | If provided, interaction chains with the specified InteractionTypes will be canceled when this interaction begins.                                                                                                                        |
+| BlockedByBypass     | `String`                                                                                            | **No**    | If provided, this RootInteraction cannot be blocked by interaction chains whose RootInteraction has this value as an asset tag.                                                                                                           |
+| BlockingBypass      | `String`                                                                                            | **No**    | If provided, this interaction will not block RootInteractions that have the this value as an asset tag.                                                                                                                                   |
+| InterruptedByBypass | `String`                                                                                            | **No**    | If provided, this RootInteraction cannot be canceled by RootInteractions that have this value as an asset tag.                                                                                                                            |
+| InterruptingBypass  | `String`                                                                                            | **No**    | If provided, this interaction will not cancel interaction chains whose RootInteraction has this value as an asset tag.                                                                                                                    |
+
+**InteractionType Values**
+
+- `Primary`
+- `Secondary`
+- `Ability1`
+- `Ability2`
+- `Ability3`
+- `Use`
+- `Pick`
+- `Pickup`
+- `CollisionEnter`
+- `CollisionLeave`
+- `Collision`
+- `EntityStatEffect`
+- `SwapTo`
+- `SwapFrom`
+- `Death`
+- `Wielding`
+- `ProjectileSpawn`
+- `ProjectileHit`
+- `ProjectileMiss`
+- `ProjectileBounce`
+- `Held`
+- `HeldOffhand`
+- `Equipped`
+- `Dodge`
+- `GameModeSwap`
+
+**InteractionSettings Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                        |
+| ---------------- | ------------------------------- | --------- | -------------------------------------------------------------------------------------------- |
+| AllowSkipOnClick | `Boolean`<br />(Default: false) | **No**    | If true, the user will be able to skip this interaction by clicking shortly after it starts. |
+
+**InteractionCameraSettings Fields**
+
+| Field Name  | Type                                             | Required? | Notes                                                                                                                                                           |
+| ----------- | ------------------------------------------------ | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| FirstPerson | `Array`<br />(Element Type: `InteractionCamera`) | **No**    | A list of camera keyframes to be played if the player is in first-person.<br />**The time of each keyframe must be after the keyframe before it in the array.** |
+| ThirdPerson | `Array`<br />(Element Type: `InteractionCamera`) | **No**    | A list of camera keyframes to be played if the player is in third-person.<br />**The time of each keyframe must be after the keyframe before it in the array.** |
+
+**InteractionCamera Fields**
+
+| Field Name | Type                         | Required? | Notes                                                                                                                                       |
+| ---------- | ---------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------- |
+| Time       | `Float`<br />(Default: 0.1f) | **No**    | How long after the interaction begins executing that the camera should arrive at this keyframe.<br />**Cannot be less than or equal to 0.** |
+| Position   | `Vector3`                    | **Yes**   | Where the camera should be located when it arrives at this keyframe.                                                                        |
+| Rotation   | `Direction`                  | **Yes**   | Where the camera should be pointing when it arrives at this keyframe.                                                                       |
+
+### SimpleInteraction
+
+Most interaction types below are inherited from SimpleInteraction and have these
+fields.  If a type does not have these fields, the documentation will mention it.
+
+The purpose of SimpleInteraction is to facilitate Interaction chaining by taking different paths
+based on whether the Interaction succeeded or failed.  The circumstances under which
+a given Interaction fails are generally type-specific (and described in the documentation
+below), but all interactions will be marked failed if they are cancelled via one of the
+many, many mechanisms for doing so.
+
+It is valid to create an interaction asset of type "Simple", which can be valuable when you want to use the
+interaction fields with no additional functionality.
+
+**SimpleInteraction Fields**
+
+| Field Name | Type                                     | Required? | Notes                                                                                          |
+| ---------- | ---------------------------------------- | --------- | ---------------------------------------------------------------------------------------------- |
+| Next       | `Asset`<br />(Asset Type: `Interaction`) | **No**    | After this Interaction has finished, "Next" will be executed if this Interaction did not fail. |
+| Failed     | `Asset`<br />(Asset Type: `Interaction`) | **No**    | After this Interaction has finished, "Failed" will be executed if this Interaction failed.     |
+
+## Flow Control
+
+These are interaction types used to control the flow of an interaction chain and allow interactions
+to be composed into more complex behaviors.  These interaction types generally do not pertain to
+the game and instead pertain to the interaction system itself.
+
+### Condition
+
+This interaction will fail if one of the fields is provided but does not match the current state.
+
+**Condition Fields**
+
+| Field Name       | Type       | Required? | Notes                                                                                                                                                                                    |
+| ---------------- | ---------- | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| RequiredGameMode | `GameMode` | **No**    | If provided, the interaction will fail if the current GameMode does not match the provided value.                                                                                        |
+| Jumping          | `Boolean`  | **No**    | If provided, the interaction will fail if the player's Jumping state does not match the provided value. (i.e. if True, the player must be jumping, if False, the player must not be)     |
+| Swimming         | `Boolean`  | **No**    | If provided, the interaction will fail if the player's Swimming state does not match the provided value. (i.e. if True, the player must be swimming, if False, the player must not be)   |
+| Crouching        | `Boolean`  | **No**    | If provided, the interaction will fail if the player's Crouching state does not match the provided value. (i.e. if True, the player must be crouching, if False, the player must not be) |
+| Running          | `Boolean`  | **No**    | If provided, the interaction will fail if the player's Running state does not match the provided value. (i.e. if True, the player must be running, if False, the player must not be)     |
+| Flying           | `Boolean`  | **No**    | If provided, the interaction will fail if the player's Flying state does not match the provided value. (i.e. if True, the player must be flying, if False, the player must not be)       |
+
+**GameMode Values**
+
+- `Creative`: The game is currently in Creative Mode
+- `Adventure`: The game is currently in Adventure Mode
+
+### FirstClick
+
+This interaction does not inherit from SimpleInteraction and therefore has no Next or Failed fields.
+
+This interaction has two fields that each contain a reference to an Interaction: Click and Hold.  If the root interaction
+of the chain was initiated by a client button/key press (or simulated NPC input) and the input was a tap, then
+the Click interaction is run. if it was a longer press, then the Hold interaction is run.
+
+As a minor implementation detail, this interaction is internally marked as failed when the Hold path is followed.
+This generally shouldn't matter.  If the interaction was not initiated by a key press at all, the Click path will be followed,
+but it seems risky to rely on that behavior.
+
+**FirstClick Fields**
+
+| Field Name | Type                                     | Required? | Notes                                                                                                                                                    |
+| ---------- | ---------------------------------------- | --------- | -------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Click      | `Asset`<br />(Asset Type: `Interaction`) | **No**    | If provided and the root interaction of the chain was initiated by button/key press, this interaction is executed next if the press was a quick tap.     |
+| Hold       | `Asset`<br />(Asset Type: `Interaction`) | **No**    | If provided and the root interaction of the chain was initiated by a button/key press, this interaction is executed next if the press was a longer hold. |
+
+### Interrupt
+
+This interaction can be used to cancel one or more running interaction chains on an entity and **all forked interaction
+chains those chains have spawned that are still currently running**.  All interaction chains canceled in this manner will be marked as
+Failed, which may have additional implications if the canceled chains are themselves forked from
+other chains that are still running.
+
+**Interrupt Fields**
+
+| Field Name     | Type                                           | Required? | Notes                                                                                                                                                                                               |
+| -------------- | ---------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Entity         | `InteractionTarget`<br />(Default: User)       | **Yes**   | The entity that is the owner of the target interaction chains.  This field can indicate the Owner, User, or Target of this interaction chain.                                                       |
+| InterruptTypes | `Array`<br />(Element Type: `InteractionType`) | **No**    | A set of InteractionTypes that are to be interrupted. Only interactions of these types are affected. If null, all types will be interrupted.<br />**(Note: An empty set will interrupt NO TYPES.)** |
+| RequiredTag    | `String`                                       | **No**    | An asset tag that, if provided, the RootInteraction of the interaction chain must have in order to be canceled.                                                                                     |
+| ExcludedTag    | `String`                                       | **No**    | An asset tag that, if provided, the RootInteraction of the interaction chain must not have in order to be canceled.                                                                                 |
+
+**InteractionTarget Values**
+
+- `User` - The user of this interaction chain. The entity whose actions caused this interaction chain to be executed. This is usually the same as the Owner.
+- `Owner` - The owner of this interaction chain. The entity upon whom this interaction chain is executing.
+- `Target` - The entity target of this interaction chain, if any.  This value is mutable (and can therefore come from many places) but most commonly, it is an entity the User was targeting when this interaction chain began executing.
+
+**InteractionType Values**
+
+- `Primary`
+- `Secondary`
+- `Ability1`
+- `Ability2`
+- `Ability3`
+- `Use`
+- `Pick`
+- `Pickup`
+- `CollisionEnter`
+- `CollisionLeave`
+- `Collision`
+- `EntityStatEffect`
+- `SwapTo`
+- `SwapFrom`
+- `Death`
+- `Wielding`
+- `ProjectileSpawn`
+- `ProjectileHit`
+- `ProjectileMiss`
+- `ProjectileBounce`
+- `Held`
+- `HeldOffhand`
+- `Equipped`
+- `Dodge`
+- `GameModeSwap`
+
+### Parallel
+
+This interaction does not inherit from SimpleInteraction and therefore has no Next or Failed fields.
+
+This interaction has a field `Interactions` that is an array of RootInteraction assets. The list must contain at least
+two RootInteractions.  This interaction will fork all of its children except for the first into their
+own interaction chains and immediately complete. After this interaction completes, this interaction chain will
+execute the first RootInteraction in the `Interactions` list.
+
+This interaction does not have any failure conditions and is indifferent to the fate of the forked interaction chains.
+
+**Parallel Fields**
+
+| Field Name   | Type                                                | Required? | Notes                                                         |
+| ------------ | --------------------------------------------------- | --------- | ------------------------------------------------------------- |
+| Interactions | `AssetArray`<br />(Element Type: `RootInteraction`) | **Yes**   | An array of RootInteractions that will be forked or executed. |
+
+### Repeat
+
+This interaction has a field `ForkInteractions` that is an asset of type RootInteraction. This interaction will fork that
+RootInteraction into its own interaction chain and then wait for it to complete. If the RootInteraction fails, this
+interaction will complete immediately and be marked failed. Otherwise, the RootInteraction will be forked and run again,
+up to a specified total number of times.
+
+**Repeat Fields**
+
+| Field Name       | Type                                                                                   | Required? | Notes                                                                                                                                                                                                              |
+| ---------------- | -------------------------------------------------------------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| ForkInteractions | `Asset`<br />(Asset Type: `RootInteraction`)                                           | **Yes**   | A RootInteraction that will be forked.                                                                                                                                                                             |
+| Repeat           | `Integer`<br />(Default: 1)<br />**Must be -1 or a positive integer. 0 is not valid.** | **No**    | The total number of times to fork ForkInteractions. If -1 is provided, ForkInteractions will continue being forked and executed indefinitely, until this interaction is cancelled or until ForkInteractions fails. |
+
+### Replace
+
+This interaction does not inherit from SimpleInteraction and therefore has no Next or Failed fields.
+
+This interaction uses the InteractionVars system that is avaiable for items. InteractionVars are RootInteractions that
+can be attached to an Item asset with a name.
+
+This interaction specifies a var name, and if this interaction chain was executed through
+an item and that item has an InteractionVar of the same name, then this interaction will immediately execute
+the RootInteraction on the var.  Otherwise, it will execute the default RootInteraction specified in this interaction.
+If no default is specified, then this interaction will be marked as failed.
+
+**Replace Fields**
+
+| Field Name   | Type                                         | Required? | Notes                                                                                                                                                                                                           |
+| ------------ | -------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Var          | `String`                                     | **Yes**   | The name of the InteractionVar to execute.                                                                                                                                                                      |
+| DefaultValue | `Asset`<br />(Asset Type: `RootInteraction`) | **No**    | The RootInteraction to execute if the owning item does not have an InteractionVar by the specified name. If not provided, the interaction will be marked as failed instead.                                     |
+| DefaultOk    | `Boolean`<br />(Default: false)              | **No**    | If false, then an angry message will be printed to the server logs if the owning item does not have an InteractionVar by the specified name.  The functioning of this interaction will be otherwise unaffected. |
+
+### RunRootInteraction
+
+This interaction immediately executes the provided RootInteraction as part of this interaction chain. This interaction
+does not have any failure conditions.
+
+**RunRootInteraction Fields**
+
+| Field Name      | Type                                         | Required? | Notes                           |
+| --------------- | -------------------------------------------- | --------- | ------------------------------- |
+| RootInteraction | `Asset`<br />(Asset Type: `RootInteraction`) | **Yes**   | The RootInteraction to execute. |
+
+### Selector
+
+This interaction will execute a Selector to find entities and/or blocks (depending on the Selector) and fork off an
+interaction chain for each located entity or block. This interaction will not wait for those interaction chains
+to complete and is indifferent to their fate. The forked interaction chains will use the located entity/block as
+their target entity/target block. Each entity or block will only fork one interaction chain over the life of this
+interaction.  The Selector is guaranteed to run once for each execution of this interaction, but some Selectors
+are intended to be run over a period of time and sweep across an area to locate targets. In order to use those Selectors
+properly, you will need to extend the execution time of this interaction using `RunTime` or `WaitForAnimationToFinish`.
+The Selector will be executed repeatedly over the lifetime of the interaction.
+
+If the Selector is configured to locate entities, you can add additional sets of entity matching rules. If a located entity
+matches one of the rules, the matching RootInteraction will be forked instead of the standard `HitEntity` RootInteraction.
+
+Entities located by the Selector will be ignored if they do not have a NetworkId, if they are dead, or if they are invulnerable.
+The only exception to this rule is that players in Creative Mode that are marked to receive hits will not be ignored.
+
+This interaction's failure conditions are configurable via the `FailOn` field. You can configure this interaction to never
+fail, to fail if the Selector does not locate any blocks before this interaction finishes executing, to fail if the
+Selector does not locate any entities before this interaction finishes executing, or to fail in either case.
+
+**Selector Fields**
+
+| Field Name     | Type                                         | Required? | Notes                                                                                                                                                                                                                                     |
+| -------------- | -------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Selector       | `Selector`                                   | **Yes**   | The Selector is executed at least once and may be executed repeatedly to locate blocks and/or entities in an area.                                                                                                                        |
+| HitEntity      | `Asset`<br />(Asset Type: `RootInteraction`) | **No**    | If included and the `Selector` locates an entity that does not match any `HitEntityRules`, this RootInteraction will be forked into a new interaction chain with the located entity as the target entity.                                 |
+| HitEntityRules | `Array`<br />(Element Type: `HitEntity`)     | **No**    | If included, these rules will be matched against any entity located by the `Selector`. If an entity matches a set of rules, the RootInteraction associated with the rules will be forked instead of the standard `HitEntity` interaction. |
+| HitBlock       | `Asset`<br />(Asset Type: `RootInteraction`) | **No**    | If included and the `Selector` locates a block, this RootInteraction will be forked into a new interaction chain with the located block as the block target.                                                                              |
+| FailOn         | `FailOnType`<br />(Default: `Neither`)       | **No**    | Defines under what circumstances this interaction will fail.  It can be marked to fail when it completes without locating any blocks, it can be marked to fail when it completes without locating any entities, both, or neither.         |
+| IgnoreOwner    | `Boolean`<br />(Default: true)               | **No**    | If true, the Selector will not locate the User entity of this interaction.                                                                                                                                                                |
+
+**HitEntity Fields**
+
+| Field Name | Type                                         | Required? | Notes                                                                                                 |
+| ---------- | -------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------- |
+| Matchers   | `Array`<br />(Element Type: `EntityMatcher`) | **Yes**   | A set of rules that an entity must match. An entity must successful match all rules to be considered. |
+| Next       | `Asset`<br />(Asset Type: `RootInteraction`) | **Yes**   | The RootInteraction to fork if an entity matches all rules.                                           |
+
+**EntityMatcher Fields**
+
+| Field Name | Type                            | Required? | Notes                                                                                                     |
+| ---------- | ------------------------------- | --------- | --------------------------------------------------------------------------------------------------------- |
+| Type       | `String`                        | **Yes**   | If provided, specifies a type of EntityMatcher to use. Each matcher type may come with additional fields. |
+| Invert     | `Boolean`<br />(Default: false) | **No**    | If true, an entity must fail this rule for it to be marked as succeeded.                                  |
+
+**EntityMatcher Type: Player**
+
+This EntityMatcher will succesfully match the entity only if they are a player.
+
+**EntityMatcher Type: Vulnerable**
+
+This Entitymatcher will successfully match the entity only if they are not marked as invulnerable.
+
+**FailOnType Values**
+
+- `Neither`
+- `Entity`
+- `Block`
+- `Either`
+
+### Serial
+
+This interaction does not inherit from SimpleInteraction and therefore has no Next or Failed fields.
+
+This interaction has a field `Interactions` which is a list of Interaction assets. This interaction immediately
+completes and the interaction chain continues by executing the interactions in the list one at a time. This
+interaction does not have any failure conditions.
+
+**Serial Fields**
+
+| Field Name   | Type                                            | Required? | Notes                                      |
+| ------------ | ----------------------------------------------- | --------- | ------------------------------------------ |
+| Interactions | `AssetArray`<br />(Element Type: `Interaction`) | **Yes**   | An array of Interaction assets to execute. |
+
+## Cooldowns
+
+RootInteractions interface with a complex cooldown system that can be used for a variety of purposes. Aside from simply
+adding an important aspect of resource management to your game design, cooldowns can be used to ensure that click-activated
+interaction chains don't repeatedly spam if the player holds down the input.
+
+By default, every RootInteraction has a cooldown timer that is keyed to the RootInteraction name, and by default, it
+will launch a cooldown of 0.35 seconds when activated by client input.  Otherwise, no cooldown will be activated.  However,
+by configuring your RootInteraction, you can change the key for the cooldown (so that multiple RootInteractions can share
+a single cooldown), set the cooldown timer to whatever you like, and configure multiple charges that can build up over time
+to allow the entity to activate the RootInteraction multiple times before being forced to pause.
+
+One important concept to keep in mind is the difference between **cooldown** and **charge time**.  The cooldown, if any,
+is activated each time a RootInteraction triggers, even if the player has more available charges. If the RootInteraction
+is configured to use charges, then they will gradually build up over time. In order for a RootInteraction to be activated,
+the cooldown (if any) must be expired, and the RootInteraction must have at least one charge (if it has been
+configured to use charges).
+
+Bear in mind that the entire Cooldown configuration is shared between different RootInteractions with the same cooldown id.
+If you activate an ability with 5 charges and a short cooldown and then another ability with a much longer cooldown and no
+charges, the second ability will use the cooldown properties of the first ability until/unless the first ability finishes
+charging and is cleared from the system.  You should generally only have multiple RootInteractions share a cooldown id
+if they have the same configuration.
+
+The interactions below interact with the cooldown system to allow you to manipulate cooldowns via the interaction system. By
+using these interactions, you can have several interaction chains with different cooldown configurations share cooldowns
+that are checked and activated as part of the interaction chain itself, or have some components of an interaction change
+use a second cooldown separate from the main one.
+
+### CooldownCondition
+
+**CooldownCondition Fields**
+
+This interaction will fail if the specified cooldown id is on cooldown for the User entity.  This interaction will only
+function for players- the interaction will always succeed for NPCs.  In order for this interaction to succeed, the
+cooldown, if any, must have expired and at least one charge, if any, must have filled.
+
+| Field Name | Type     | Required? | Notes                     |
+| ---------- | -------- | --------- | ------------------------- |
+| Id         | `String` | **Yes**   | The cooldown id to check. |
+
+### IncrementCooldown
+
+**IncrementCooldown Fields**
+
+This interaction will modify a cooldown that is currently active on the User entity, allowing charges and remaining
+cooldown to be modified.
+Despite its name, this interaction can be used to reduce a cooldown as well as increase it. If the cooldown is not
+currently active, this interaction will have no effect. The interaction has no special failure conditions.
+
+| Field Name        | Type                        | Required? | Notes                                                                                                                                                                                                                                                                                     |
+| ----------------- | --------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Id                | `String`                    | **No**    | If provided, the cooldown id of the cooldown to be manipulated. If not provided, the cooldown id of the current chain's RootInteraction will be used.                                                                                                                                     |
+| Time              | `Float`<br />(Default: 0.0) | **No**    | The amount to increase the remaining cooldown by. Can be negative. The remaining cooldown time will not be reduced below zero or increased above the maximum cooldown time.                                                                                                               |
+| ChargeTime        | `Float`<br />(Default: 0.0) | **No**    | The amount to increase the remaining time until the next charge is filled by. Can be negative. The remaining charge time cannot be reduced below zero or increased above the maximum cooldown time. **This will not work on abilities that have a maximum of 1 charge, for some reason.** |
+| Charge            | `Integer`<br />(Default: 0) | **No**    | The amount to increase the number of charges by. Can be negative. The number of charges cannot be reduced below 0 or increased above the maximum.                                                                                                                                         |
+| InterruptRecharge | `Boolean`(Default: false)   | **No**    | If true and `Charge` is not 0, will reset the remaining time to the next charge to the maximum value after changing the charge count.                                                                                                                                                     |
+
+### ResetCooldown
+
+This interaction will trigger a cooldown on the User entity with a specified configuration. The charges will be refilled
+but the cooldown will be immediately triggered.  The mechanisms for deciding on the configuration are a little bit complicated.
+You may specify a cooldown configuration via the `Cooldown` field. If you do not include an `Id` field, then the
+interaction chain's RootInteraction will be used for any field not specified in the configuration. If there is an active
+cooldown under the specified `Id` (or under the RootInteraction's cooldown id if none is specified) then the fields
+from that active cooldown will overwrite data in the RootInteraction's cooldown, but not data in your `Cooldown` field.
+
+**ResetCooldown Fields**
+
+| Field Name | Type                  | Required? | Notes                                                        |
+| ---------- | --------------------- | --------- | ------------------------------------------------------------ |
+| Cooldown   | `InteractionCooldown` | **No**    | A cooldown configuration to use for the new, reset cooldown. |
+
+**InteractionCooldown Fields**
+
+| Field Name        | Type                                 | Required? | Notes                                                                                                                                                                                                 |
+| ----------------- | ------------------------------------ | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Id                | `String`                             | **No**    | The cooldown id to use for this cooldown. If not provided, the RootInteraction's cooldown id will be used, if any.                                                                                    |
+| Cooldown          | `Float`<br />(Default: 0.0)          | **No**    | The duration of the cooldown, in seconds.                                                                                                                                                             |
+| Charges           | `Array`<br />(Element Type: `Float`) | **No**    | If provided, a list of how many charges this cooldown can build, and how long each charge takes to build, in seconds.                                                                                 |
+| InterruptRecharge | `Boolean`<br />(Default: false)      | **No**    | If true, the charge time will be reset when the number of charges changes.                                                                                                                            |
+| ClickBypass       | `Boolean`<br />(Default: false)      | **No**    | If true, RootInteractions keyed to this cooldown can still be activated when it is on cooldown provided that the RootInteraction was triggered by a distinct key or mouse button press on the client. |
+
+### TriggerCooldown
+
+This interaction is similar to ResetCooldown, except instead of refilling the cooldown's charges, one charge will be deducted
+as normal.
+
+**TriggerCooldown Fields**
+
+| Field Name | Type                  | Required? | Notes                                                        |
+| ---------- | --------------------- | --------- | ------------------------------------------------------------ |
+| Cooldown   | `InteractionCooldown` | **No**    | A cooldown configuration to use for the new, reset cooldown. |
+
+**InteractionCooldown Fields**
+
+| Field Name        | Type                                 | Required? | Notes                                                                                                                                                                                                 |
+| ----------------- | ------------------------------------ | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Id                | `String`                             | **No**    | The cooldown id to use for this cooldown. If not provided, the RootInteraction's cooldown id will be used, if any.                                                                                    |
+| Cooldown          | `Float`<br />(Default: 0.0)          | **No**    | The duration of the cooldown, in seconds.                                                                                                                                                             |
+| Charges           | `Array`<br />(Element Type: `Float`) | **No**    | If provided, a list of how many charges this cooldown can build, and how long each charge takes to build, in seconds.                                                                                 |
+| InterruptRecharge | `Boolean`<br />(Default: false)      | **No**    | If true, the charge time will be reset when the number of charges changes.                                                                                                                            |
+| ClickBypass       | `Boolean`<br />(Default: false)      | **No**    | If true, RootInteractions keyed to this cooldown can still be activated when it is on cooldown provided that the RootInteraction was triggered by a distinct key or mouse button press on the client. |
+
+## Combo Chains
+
+Hytale additionally comes with a rich "combo chaining" system, which allows several inputs in a row to result in different
+attacks and special moves.  Rather than being attached to the RootInteraction like the cooldown system, these are
+primarily driven by the `Chaining` interaction.
+
+### Chaining
+
+This interaction does not inherit from SimpleInteraction and therefore has no Failed field. Its Next field works differently
+from most interaction types.
+
+Chaining is a type of flow control interaction- each time a Chaining interaction with the same `ChainId` is called, a single
+interaction in the `Next` list is chosen and the others are ignored. The first time the `ChainId` is used, the first
+interaction in the list is chosen, the next time the second, etc. Once the end of the list is reached, the first
+interaction will be chosen again.
+
+Bear in mind: the progress through the Next list is based on the **ChainId**, not the interaction!  That means that two
+different Chaining interactions can share a single combo chain. You could have a pair of daggers that attacks with
+the left when the left mouse button is clicked and with the right when the right mouse button is clicked.  You could give
+both interaction chains a Chaining interaction with the same `ChainId` and three `Next` entries that do a light-light-heavy
+combo.  Each specific hit would occur with either the left or the right knife based on which button you clicked, but
+the combo would be otherwise identical regardless of which you chose.
+
+The Chaining interaction also has a concept called "flags".  It is possible to attach named flags to a `ChainId` by using
+the ChainFlag interaction.  Then, you specify the flag name in Chaining's `Flags` field. If a Flag is active when the
+Chaining interaction is run, the Flag's interaction will be run instead of the appropriate interaction in `Next`.
+Bear in mind: the entity's progress through the `Next` list still advances, the resulting `Next` interaction is just not
+run.  Only one flag can be active at a time.
+
+Lastly, it is possible to cancel the entity's progress through the combo chain and reset them to the first interaction in
+the list. This can be done with the CancelChain interaction, but it will also happen automatically if the player does
+not trigger an interaction with the ChainId for the specified ChainingAllowance.  When either of these happen, all flags will be
+canceled as well.
+
+All of these effects are triggered on the User entity only. Non-players can use the chaining system, but Flags do not currently
+work for non-players.  This interaction has no special failure conditions.
+
+**Chaining Fields**
+
+| Field Name        | Type                                                       | Required? | Notes                                                                                                                                                                                                                       |
+| ----------------- | ---------------------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| ChainId           | `String`                                                   | **No**    | If provided, acts as a key that multiple Chaining interactions can use to share combo chain progress and flags. If not provided, a unique ChainId will be generated for this interaction.                                   |
+| ChainingAllowance | `Double`<br />(Default: 0.0)                               | **No**    | If, at the time this interaction is triggered, it has been this long in seconds since the last time a Chaining interaction with the same ChainId was executed, all state for this ChainId will be cleared before execution. |
+| Next              | `AssetArray`<br />(Element Type: `Interaction`)            | **Yes**   | A list of interactions to cycle between each time this interaction is run.                                                                                                                                                  |
+| Flags             | `Map`<br />(Key Type: `String`, Value Type: `Interaction`) | **No**    | A map of flag names to interactions to run if the flag is active when this interaction executes.                                                                                                                            |
+
+### CancelChain
+
+This interaction resets all progress and flag data on the User entity for the provided `ChainId`.  The next time a Chaining
+interaction is called for the provided `ChainId`, it will begin at the first interaction in the `Next` list. This
+interaction has no special failure conditions.
+
+**CancelChain Fields**
+
+| Field Name | Type     | Required? | Notes                                 |
+| ---------- | -------- | --------- | ------------------------------------- |
+| ChainId    | `String` | **Yes**   | A ChainId whose data should be reset. |
+
+### ChainFlag
+
+This interaction activates a flag on the User entity for the provided `ChainId`, which can be used to change behavior the
+next time a Chaining interaction with this `ChainId` is run. This will overwrite any flag that has
+already been raised. This interaction will have no effect for non-players. This interaction has no special failure
+conditions.
+
+| Field Name | Type     | Required? | Notes                                        |
+| ---------- | -------- | --------- | -------------------------------------------- |
+| ChainId    | `String` | **Yes**   | A ChainId on whom the flag should be raised. |
+| Flag       | `String` | **Yes**   | The name of the flag to raise.               |
+
+## Charging
+
+A unique flow-control interaction that is frequently used is the Charging interaction.  It is a flow-control interaction
+that delays while the input button used to trigger the interaction chain is held.  When it is released (or the interaction
+is forced to end), the interaction chain can continue with a different interaction based on how long the input was held
+for.
+
+These interactions are all related by either being the Charging interaction, or other interaction types that inherit the
+Charging interaction's behavior.
+
+### Charging
+
+This interaction does not inherit from SimpleInteraction and therefore its Next field works different from most interactions.
+This interaction adds its own Failed field which works the same way that SimpleInteraction's does.
+
+This interaction only works properly when its interaction chain was triggered by a client key or button press (or
+NPC-simulated equivalent). This interaction will continue executing for as long as the key or button press is held (with
+some exceptions, covered below) by the User entity.  Like other interactions, it has a `Next` field indicating which interaction to execute
+after this one, but the field is a map from `Float` values to `Interaction` assets. When this interaction ends, either
+due to the input being released or the charge duration completing, this interaction will determine the largest `Float` key that is less
+than the amount of time in seconds that the interaction was executing for.  The Interaction mapped to that key will be
+executed next.
+
+The interaction includes some cancellation conditions that are specific to this interaction. For instance, the interaction
+has a `CancelOnOtherClick` field that matches the field on RootInteraction. If it is active on this interaction but not
+the RootInteraction, then clicking while charging will cancel this interaction (and execute the `Failed` interaction rather
+than any of the `Next` interactions) but otherwise continue the interaction chain.
+
+Another valuable feature Charging has is the `Forks` field.  For input-triggered interactions that are triggered while the
+Charging interaction is executing, you can add an entry for the relevant InteractionType to this field and instead of
+triggering the usual interaction chain based on held item, targeted block, etc. the RootInteraction specified in the
+`Forks` field will be triggered.  This can unlock rich attack modes and behaviors. For instance, having a shield bash attack
+triggered off left click while blocking, or a special attack that triggers when both mouse buttons are pressed at the
+same time.
+
+There are two modes of operation for the Charging interaction. One is to have the ability charge for as long
+as the input is held and only end execution when the entity releases the input.  Bows in the main Hytale game work
+that way.  That is accomplished by setting `AllowIndefiniteHold` to true.  Another mode of operation is to have the
+interaction complete execution when the execution time has surpassed the largest key value in the `Next` field and
+immediately begin executing the Interaction mapped to that key.  Food in the main Hytale game work like this.  It
+is accomplished by setting `AllowIndefiniteHold` to false.
+
+One pitfall to be careful of when setting `AllowIndefiniteHold` to false is the way it interacts with cooldowns.\
+Normally, input-initiated interaction chains start a 0.35s cooldown on the triggered RootInteraction that prevents
+holding the mouse button from immediately spamming a new interaction when the first one completes.  However, if the
+duration of a Charging interaction is longer than 0.35s, then the cooldown will have already completed when the
+interaction chain finishes, which will often result in a new execution beginning immediately before the player can
+stop pressing the mouse button.  One solution for this problem is to add a `Simple` interaction to the end of your
+interaction chain with a `RunTime` of 0.35s to simulate the cooldown.  Alternatively, you can add a longer cooldown
+(the maximum duration of your Charging interaction plus 0.35s) to the RootInteraction. However, the longer cooldown is
+not always desirable, as the interaction may have ended prematurely, resulting in an unusually long lockout between
+executions.
+
+**Charging Fields**
+
+| Field Name                         | Type                                                                    | Required? | Notes                                                                                                                                                                                                                                                                                                                                                                                       |
+| ---------------------------------- | ----------------------------------------------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| FailOnDamage                       | `Boolean`<br />(Default: false)                                         | **No**    | If true, this interaction will fail and end immediately if the User entity takes any damage while it is executing.                                                                                                                                                                                                                                                                          |
+| CancelOnOtherClick                 | `Boolean`<br />(Default: true)                                          | **No**    | If true, this interaction will fail and end immediately if the User entity sends another button or key press while it is executing.                                                                                                                                                                                                                                                         |
+| Forks                              | `Map`<br />(Key Type: `InteractionType`, Value Type: `RootInteraction`) | **No**    | A map of InteractionType to RootInteraction. If entity input triggers the InteractionType while this interaction is executing, the mapped RootInteraction will be forked into its own interaction chain. This will happen instead of the usual handling for that InteractionType.  This fork will occur even if `CancelOnOtherClick` is set to true.                                        |
+| Failed                             | `Asset`<br />(Asset Type: `Interaction`)                                | **No**    | After this Interaction has finished, "Failed" will be executed if this Interaction failed.                                                                                                                                                                                                                                                                                                  |
+| AllowIndefiniteHold                | `Boolean`<br />(Default: false)                                         | **No**    | If true, this interaction will continue executing for as long as the User entity continues to hold the input. If false, execution will end as soon as the execution time in seconds reaches the largest key value in the `Next` map.                                                                                                                                                        |
+| DisplayProgress                    | `Boolean`<br />(Default: true)                                          | **No**    | If true, players executing this interaction will see a progress bar will be displayed below their cursor indicating how close to reaching the highest key value in `Next` they are.                                                                                                                                                                                                         |
+| Next                               | `Map`<br />(Key Type: `Float`, Value Type: `Interaction`)               | **No**    | A map from `Float` to `Interaction`.  When this interaction successfully finishes executing (either because the input was released or because the maximum duration was reached), this interaction will find the `Float` value with the largest duration in seconds that is less than the amount of time this interaction executed for. That key's mapped Interaction will then be executed. |
+| MouseSensitivityAdjustmentTarget   | `Float`<br />(Default: 1.0)                                             | **No**    | While charging, this mouse sensitivity multiplier will gradually be applied.                                                                                                                                                                                                                                                                                                                |
+| MouseSensitivityAdjustmentDuration | `Float`<br />(Default: 1.0)                                             | **No**    | Duration in seconds. After this many seconds, `MouseSensitivityAdjustmentTarget` will be fully applied to the mouse sensitivity.                                                                                                                                                                                                                                                            |
+| Delay                              | `ChargingDelay`                                                         | **No**    | Settings that allow charging progress to be pushed back when the User entity takes damage.                                                                                                                                                                                                                                                                                                  |
+
+**ChargingDelay Fields**
+
+| Field Name    | Type                        | Required? | Notes                                                                                                                                                                                                                                                                     |
+| ------------- | --------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| MinHealth     | `Float`<br />(Default: 0.0) | **No**    | Damage taken as a percentage of entity health (0.0-1.0). If a hit deals less than this much damage, no pushback will be applied.  If a hit deals exactly this much damage, `MinDelay` seconds worth of pushback will be applied.                                          |
+| MaxHealth     | `Float`<br />(Default: 0.0) | **No**    | Damage taken as a percentage of entity health (0.0-1.0). If a hit deals at least this much damage, `MaxDelay` seconds worth of pushback will be applied.                                                                                                                  |
+| MinDelay      | `Float`<br />(Default: 0)   | **No**    | The amount of pushback, in seconds, to apply if the entity takes a hit that deals `MinHealth` damage. The amount of pushback applied by a hit is a gradiant between `MinDelay` and `MaxDelay` based on the amount of damage between `MinHealth` and `MaxHealth`.          |
+| MaxDelay      | `Float`<br />(Default: 0)   | **No**    | The amount of pushback, in seconds, to apply if the entity takes a hit that deals at least `MaxHealth` damage. The amount of pushback applied by a hit is a gradiant between `MinDelay` and `MaxDelay` based on the amount of damage between `MinHealth` and `MaxHealth`. |
+| MaxTotalDelay | `Float`<br />(Deault: 0)    | **No**    | The maximum amount of pushback the entity can receive over the course of a single charge, regardless of how many times they are hit.                                                                                                                                      |
+
+**InteractionType Values**
+
+- `Primary`
+- `Secondary`
+- `Ability1`
+- `Ability2`
+- `Ability3`
+- `Use`
+- `Pick`
+- `Pickup`
+- `CollisionEnter`
+- `CollisionLeave`
+- `Collision`
+- `EntityStatEffect`
+- `SwapTo`
+- `SwapFrom`
+- `Death`
+- `Wielding`
+- `ProjectileSpawn`
+- `ProjectileHit`
+- `ProjectileMiss`
+- `ProjectileBounce`
+- `Held`
+- `HeldOffhand`
+- `Equipped`
+- `Dodge`
+- `GameModeSwap`
+
+### Wielding
+
+This interaction is inherited from Charging rather than SimpleInteraction.  However, its `Failed` and `Next` fields function
+identically to SimpleInteraction.  It does not inherit all fields from Charging, so be sure to pay close attention to
+the field list below.
+
+This interaction drives most blocking behavior in the game. While this interaction is executing, attacks made against
+the Owner entity will (conditionally) trigger effects defined in this interaction.  Unlike the Charging interaction,
+this interaction can always execute indefinitely and will only end when it fails or when the input is released.
+
+One option available in Wielding is `AngledWielding`, which allows damage and knockback modifiers to only be applied
+depending on the direction the attack against the Owner entity is coming from.  The AngledWielding type has a
+field `Angle` which determines which direction the protection points relative to the player (0 is the player's
+front), and `AngleDistance` which determines how wide the cone of protection extends around the player.  Block effects
+from this interaction (such as `BlockedEffects`, `BlockedInteractions`, and `StaminaCost`) will only apply if
+the DamageCause matches `DamageModifiers` OR if the DamageCause matches `AngledWielding.DamageModifiers` and
+the source of the damage matches `Angle` and `AngleDistance`.  It is possible for damage and knockback multipliers
+specified on both this interaction's modifier fields and `AngledWielding`'s modifier fields to stack, if both
+have entries for the same DamageCause.
+
+This interaction will only have an effect on damage taken by one of the DamageCause entries in `DamageModifiers` or
+`AngledWielding.DamageModifiers`.  If a DamageCause is in `DamageModifiers`, then the block effect will be triggered
+and the damage modifier applied regardless of what direction the Owner entity is attacked from.  If a DamageCause is in
+`AngledWielding.DamageModifiers`, then the damage modifier is only applied if the
+
+\*\* Wielding Fields\*\*
+
+| Field Name          | Type                                                                    | Required? | Notes                                                                                                                                                                                                                                                                                                                                                                                                      |
+| ------------------- | ----------------------------------------------------------------------- | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| FailOnDamage        | `Boolean`<br />(Default: false)                                         | **No**    | If true, this interaction will fail and end immediately if the User entity takes any damage while it is executing.                                                                                                                                                                                                                                                                                         |
+| CancelOnOtherClick  | `Boolean`<br />(Default: true)                                          | **No**    | If true, this interaction will fail and end immediately if the User entity sends another button or key press while it is executing.                                                                                                                                                                                                                                                                        |
+| Forks               | `Map`<br />(Key Type: `InteractionType`, Value Type: `RootInteraction`) | **No**    | A map of InteractionType to RootInteraction. If entity input triggers the InteractionType while this interaction is executing, the mapped RootInteraction will be forked into its own interaction chain. This will happen instead of the usual handling for that InteractionType.  This fork will occur even if `CancelOnOtherClick` is set to true (after which this interaction chain will be canceled). |
+| Next                | `Asset`<br />(Asset Type: `Interaction`)                                | **No**    | After this interaction has finished, "Next" will be executed if this interaction did not fail.                                                                                                                                                                                                                                                                                                             |
+| Failed              | `Asset`<br />(Asset Type: `Interaction`)                                | **No**    | After this interaction has finished, "Failed" will be executed if this interaction failed.                                                                                                                                                                                                                                                                                                                 |
+| DamageModifiers     | `Map`<br />(Key Type: `DamageCause`, Value Type: `Float`)               | **No**    | A map from DamageCause to Float, where the Float is multiplied against any damage received from the mapped DamageCause while this interaction is executing.                                                                                                                                                                                                                                                |
+| KnockbackModifiers  | `Map`<br />(Key Type: `DamageCause`, Value Type: `Float`)               | **No**    | A map from DamageCause to Float, where the Float is multiplied against any knockback force received from the mapped DamageCause while this interaction is executing.                                                                                                                                                                                                                                       |
+| AngledWielding      | `AngledWielding`                                                        | **No**    | Configuration to only trigger block effects from certain angles.                                                                                                                                                                                                                                                                                                                                           |
+| StaminaCost         | `StaminaCost`                                                           | **No**    | If the Owner entity receives damage that matches `DamageModifiers` or `AngledWielding` while this interaction is executing, then the entity's stamina will be deducted according to this configuration.                                                                                                                                                                                                    |
+| BlockedEffects      | `DamageEffects`                                                         | **No**    | If the Owner entity receives damage that matches `DamageModifiers` or `AngledWielding` while this interaction is executing, then these effects will be applied to the instance of damage.                                                                                                                                                                                                                  |
+| BlockedInteractions | `Asset`<br />(Asset Type: `RootInteraction`)                            | **No**    | If the Owner entity receives damage that matches `DamageModifiers` or `AngledWielding` while this interaction is executing, then this RootInteraction will be launched as a brand new interaction chain with the Owner entity as both Owner and User, and the attacker as the Target entity.  This new interaction chain is, notably, brand new, **not** forked from the current one.                      |
+
+**AngledWielding Fields**
+
+| Field Name         | Type                                                      | Required? | Notes                                                                                                                                                                                                            |
+| ------------------ | --------------------------------------------------------- | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Angle              | `Float`<br />(Default: 0.0)                               | **No**    | Angle in degrees relative to the Owner entity where the angled protection is centered. 0.0 means pointed towards the front of the Owner entity.                                                                  |
+| AngleDistance      | `Float`<br />(Default: 0.0)                               | **No**    | Angle in degrees indicating how wide the cone of protection is.                                                                                                                                                  |
+| DamageModifiers    | `Map`<br />(Key Type: `DamageCause`, Value Type: `Float`) | **No**    | A map from DamageCause to Float, where the Float is multiplied against any damage received from the mapped DamageCause received from within the cone of protection while this interaction is executing.          |
+| KnockbackModifiers | `Map`<br />(Key Type: `DamageCause`, Value Type: `Float`) | **No**    | A map from DamageCause to Float, where the Float is multiplied against any knockback force received from the mapped DamageCause received from within the cone of protection while this interaction is executing. |
+
+**StaminaCost Fields**
+
+| Field Name | Type                                             | Required? | Notes                                                                                                                                                                                                                                                |
+| ---------- | ------------------------------------------------ | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| CostType   | `CostType`<br />(Default: `MaxHealthPercentage`) | **No**    | How to calculate stamina consumed by blocking from the raw pre-block damage. If `Damage`, then the stamina consumed will be `rawDamage / Value`. If `MaxHealthPercentage`, then the stamina consumed will be `rawDamage / (EntityMaxHealth * Value)` |
+| Value      | `Float`<br />(Default: 0.04)                     | **No**    | The value to use in the `CostType` formula.                                                                                                                                                                                                          |
+
+**DamageEffects Fields**
+
+| Field Name             | Type                                         | Required? | Notes                                                                           |
+| ---------------------- | -------------------------------------------- | --------- | ------------------------------------------------------------------------------- |
+| ModelParticles         | `Array`<br />(Element Type: `ModelParticle`) | **No**    | Particle systems to trigger in the first-person view.                           |
+| WorldParticles         | `Array`<br />(Element Type: `WorldParticle`) | **No**    | Particle systems to trigger in the third-person view.                           |
+| LocalSoundEventId      | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | 2D sound to play locally to the attacking entity if they are a player.          |
+| WorldSoundEventId      | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | Sound to play in the world at the Owner entity's location.                      |
+| PlayerSoundEventId     | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | 2D sound to play locally to the Owner entity if they are a player.              |
+| ViewDistance           | `Double`<br />(Default: 75.0)                | **No**    | Distance at which these effects should play for other players.                  |
+| Knockback              | `Knockback`                                  | **No**    | The properties of the knockback that will be applied.                           |
+| CameraEffect           | `Asset`<br />(Asset Type: `CameraEffect`)    | **No**    | CameraEffect to briefly apply locally to the Owner entity if they are a player. |
+| StaminaDrainMultiplier | `Float`<br />(Default: 1.0)                  | **No**    | This multiplier is applied to the `StaminaCost`, if any.                        |
+
+**Knockback Fields**
+
+| Field Name     | Type                                       | Required? | Notes                                                                                                                      |
+| -------------- | ------------------------------------------ | --------- | -------------------------------------------------------------------------------------------------------------------------- |
+| Type           | `String`                                   | **No**    | If provided, specifies a type of knockback to use. Each knockback type may come with additional fields.                    |
+| Force          | `Double`<br />(Default: 0.0)               | **No**    | The amount of force to apply to the Owner entity.                                                                          |
+| Duration       | `Double`<br />(Default: 0.0)               | **No**    | If 0.0, apply the force as a single impulse.  If more, continuously apply the force over a period of time.                 |
+| VelocityType   | `ChangeVelocityType`<br />(Default: `Add`) | **No**    | How to apply the force, either adding it to the entity's current velocity, or setting the velocity to the knockback force. |
+| VelocityConfig | `VelocityConfig`                           | **No**    | Characteristics of friction as the Owner entity is thrown by this knockback.                                               |
+
+**Knockback Type: Force**
+
+Apply the calculated knockback force along the provided direction.
+
+| Field Name | Type                         | Required? | Notes                                                                                |
+| ---------- | ---------------------------- | --------- | ------------------------------------------------------------------------------------ |
+| Direction  | `Vector3`<br />(Default: Up) | **No**    | Which direction the player should be flung, relative to the direction of the attack. |
+
+**Knockback Type: Point**
+
+Apply the calculated knockback force laterally along the XZ plane, plus provided Y velocity.
+
+| Field Name | Type                        | Required? | Notes                                                                                                   |
+| ---------- | --------------------------- | --------- | ------------------------------------------------------------------------------------------------------- |
+| OffsetX    | `Integer`<br />(Default: 0) | **No**    | Offset the source position of the knockback left or right perpendicular to the direction of the attack. |
+| OffsetZ    | `Integer`<br />(Default: 0) | **No**    | Offset the source position of the knockback, forward or backward along the directon of the attack.      |
+| RotateY    | `Integer`<br />(Default: 0) | **No**    | Rotate the knockback direction around the Y axis, where 0 is the default attack direction.              |
+| VelocityY  | `Float`<br />(Default: 0.0) | **No**    | Add vertical velocity to the knockback force after the direction and force has been calculated.         |
+
+**Knockback Type: Directional**
+
+Apply the calculated knockback force along the attack direction, removing any vertical component and replacing it with a provided Y velocity.
+
+| Field Name | Type                      | Required? | Notes                                                                                                                                            |
+| ---------- | ------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------ |
+| RelativeX  | `Float`<br />(Default: 0) | **No**    | Apply additional force left or right perpendicular to the direction of the attack. The additional force is multiplied by the knockback strength. |
+| RelativeZ  | `Float`<br />(Default: 0) | **No**    | Apply additional force forward or backward along the attack direction. The additional force is multiplied by the knockback strength.             |
+| VelocityY  | `Float`<br />(Default: 0) | **No**    | Replace the vertical velocity of the knockback with this value.  This value is not multiplied by knockback strength.                             |
+
+**VelocityConfig Fields**
+
+| Field Name          | Type                                              | Required? | Notes                                                                                                                                                                                           |
+| ------------------- | ------------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| GroundResistance    | `Float`<br />(Default: 0.82)                      | **No**    | The minimum amount of friction applied when the entity is in contact with the ground.  1.0 = no friction, 0.0 = total friction                                                                  |
+| GroundResistanceMax | `Float`<br />(Default: 0.0)                       | **No**    | The maximum amount of friction applied when the entity is in contact with the ground.  1.0 = no friction, 0.0 = total friction                                                                  |
+| AirResistance       | `Float`<br />(Default: 0.96)                      | **No**    | The minimum amount of friction applied when the entity is in the air. 1.0 = no friction, 0.0 = total friction                                                                                   |
+| AirResistanceMax    | `Float`<br />(Default: 0.0)                       | **No**    | The maximum amount of friction applied when the entity is in the air. 1.0 = no friction, 0.0 = total friction                                                                                   |
+| Threshold           | `Float`<br />(Default: 1.0)                       | **No**    | The speed at which the maximum amount of friction will be applied to the entity. The amount of friction applied will increase from minimum to maximum as the entity moves from 0 to this speed. |
+| Style               | `VelocityThresholdStyle`<br />(Default: `Linear`) | **No**    | The curve that friction follows as the entity's speed increases toward the `Threshold`.                                                                                                         |
+
+**CostType Values**
+
+- `MaxHealthPercentage`
+- `Damage`
+
+**ChangeVelocityType Values**
+
+- `Add`
+- `Set`
+
+**VelocityThresholdStyle Values**
+
+- `Linear`
+- `Exp`
+
+## Blocks
+
+These are interaction types meant to reason about and modify blocks in the world.  The most important concept unique
+to these interactions is the Block Target.  Like the Entity Target, it is mutable and can come from many places.
+However, for interaction chains initiated by the client, the block target will initially be the block that the player's cursor was
+over, if any.
+
+Additionally, for interaction chains initiated by the client, the client will send along which face of the block is targeted,
+which is used by a few block-related interactions.
+It is left up to each interaction type that cares about block faces as to how to handle this behavior for simulated input
+(i.e. NPCs initiating chains that are normally initated by the client).  At the time of this writing, all block-related
+interactions choose the top face where relevant in simulated input.
+
+### BlockCondition
+
+This interaction has a field `Matchers` which specifies certain conditions, such as block type, state, etc.  This
+interaction fails if the current target block does not match all of them.
+
+**BlockCondition Fields**
+
+| Field Name       | Type                                        | Required? | Notes                                                                                                                                                                                                                                                                                                                                   |
+| ---------------- | ------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false)             | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction.                                                                                                                                                                                                       |
+| Matchers         | `Array`<br />(Element Type: `BlockMatcher`) | **Yes**   | A list of conditions that the target block must match or this condition will fail.<br />**Note: This field is technically not required but there is a bug that makes it dangerous to not provide at the time of this writing.**<br />**Note: If no conditions are added to this array, the interaction will fail, counterintuitively.** |
+
+**BlockMatcher Fields**
+
+| Field Name | Type                       | Required? | Notes                                                                          |
+| ---------- | -------------------------- | --------- | ------------------------------------------------------------------------------ |
+| Block      | `BlockIdMatcher`           | **No**    | If provided, requires the block itself match some set of conditions.           |
+| Face       | `BlockFace`                | **No**    | If provided and not 'None', requires a specific block face be targeted.        |
+| StaticFace | `Boolean` (Default: false) | **No**    | If false, the face condition will be adjusted by the block's current rotation. |
+
+**BlockFace Values**
+
+- `Up`
+- `Down`
+- `North`
+- `South`
+- `East`
+- `West`
+- `None`
+
+**BlockIdMatcher Fields**
+
+| Field Name | Type                                   | Required? | Notes                                                                      |
+| ---------- | -------------------------------------- | --------- | -------------------------------------------------------------------------- |
+| Id         | `Asset`<br />(Asset Type: `BlockType`) | **No**    | If provided, the block must match the specified `BlockType`.               |
+| State      | `String`                               | **No**    | If provided, the block's current state must match the provided state name. |
+| Tag        | `String`                               | **No**    | If provided, the block type's asset tags must contain the provided tag.    |
+
+### DestroyCondition
+
+This interaction fails if the current User entity cannot destroy the current target blcok.
+
+**DestroyCondition Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+
+### PlacementCountCondition
+
+This interaction accepts the name of a BlockType that has the TrackedPlacement BlockEntity. The interaction will fail if the number of
+blocks of the provided BlockType in the world do not match the provided condition.
+
+**PlacementCountCondition Fields**
+
+| Field Name | Type                           | Required? | Notes                                                                                                                                                                                                                                                           |
+| ---------- | ------------------------------ | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Block      | `String`                       | **Yes**   | The BlockType to examine. The number of instances of the BlockType in the world will be compared to Value.<br />**Note: The specified BlockType must have the TrackedPlacement BlockEntity. Otherwise, the number of blocks in the world will always be zero.** |
+| Value      | `Integer`<br />(Default: 0)    | **No**    | The value to compare the number of blocks in the world with.                                                                                                                                                                                                    |
+| LessThan   | \`Boolean<br />(Default: true) | **No**    | If true, the interaction will fail if the number of blocks in the world is greater than or equal to Value. If false, the interaction will fail if the number of blocks in the world is less than or equal to Value.                                             |
+
+### BreakBlock
+
+This interaction attempts to break the target block while acting as the User entity. The User entity must be a player. It
+is not guaranteed to work, depending on world settings and the User entity's current state, it may not work.  If it
+fails, it will fail the interaction under some circumstances, but not others.
+
+**Note: In particular, if `Harvest`=false and the player is in Survival mode, the player will simply execute a damage operation
+against the block. Even when the Tool field is specified, the player's currently-held item can impact the results in unintuitive
+ways.**
+
+This interaction will fail if there is no block target, if `Harvest`=true and the
+block is not harvestable, or if the world settings prevent the Harvest/Break operation.
+It will generally not fail otherwise, even if the block was not broken or damaged.
+The block will generally break every time if `Harvest`=true or the player is in
+Creative mode.
+
+**BreakBlock Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                                                                                                                                                                                                  |
+| ---------------- | ------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction.                                                                                                                                                                      |
+| Harvest          | `Boolean` (Default: false)      | **No**    | If true, harvest the block and deposit the drops in the player's inventory. This operation will generally always succeed.  If false, this interaction will effectively perform whatever action would have occurred if the player had left-clicked the block.                                           |
+| Tool             | `String`                        | **No**    | If `Harvest`=true, the player is in Survival mode, and this field is provided, then the break operation will be performed as though with this tool type.<br />**This field mostly doesn't work.  Your held item will be used for most block damage calculations regardless of this field's contents.** |
+| MatchTool        | `Boolean` (Default: false)      | **No**    | If true, `Harvest`=true, the player is in Survival mode, and `Tool` is provided, block breaking will be prevented unless `Tool` is a valid gathering tool for the target block. The interaction will not be failed, even if block breaking is prevented in this manner.                                |
+
+### ChangeBlock
+
+This interaction requires a mapping from one or more current BlockTypes to one or more target BlockTypes.  If the
+target block is one of the key BlockTypes, then it will be changed to the mapped target BlockType.  If the current
+BlockType of the target block does not appear as a key in the Changes field, then this interaction fails.
+
+**ChangeBlock Fields**
+
+| Field Name        | Type                                                        | Required? | Notes                                                                                                                             |
+| ----------------- | ----------------------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget  | `Boolean`<br />(Default: false)                             | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+| Changes           | `Map`<br />(Key Type: `BlockType`, Value Type: `BlockType`) | **No**    | A list of potential block type changes, with each entry having a current and new BlockType id.                                    |
+| WorldSoundEventId | `Asset`<br />(Asset Type: `SoundEvent`)                     | **No**    | If provided, this SoundEvent is played in the world at the position of the block if the block successfully changes.               |
+| RequireNotBroken  | `Boolean`<br />(Default: false)                             | **No**    | If true, this interaction will fail if the player's held item is broken (durability 0), and the block change will not take place. |
+
+### ChangeState
+
+This interaction requires a mapping from one or more current block state names to one or more state names. If the
+target block is in one of the key block states, then it will be changed to the mapped target blocks tate. If the
+current block state of the target block does nto appear as a key in the Changes field, then this interaction fails.
+
+All blocks start out with a null state by default.  This null state can be referenced by the key "default" and the block
+can be returned to that state with the value "default".
+
+**ChangeState Fields**
+
+| Field Name       | Type                                                  | Required? | Notes                                                                                                                                          |
+| ---------------- | ----------------------------------------------------- | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false)                       | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction.              |
+| Changes          | `Map`<br />(Key Type: `String`, Value Type: `String`) | **No**    | A list of potential block state changes, with each entry having a current and new state name.                                                  |
+| UpdateBlockState | `Boolean`<br />(Default: false)                       | **No**    | If true, performs a full refresh of the block's BlockEntity component and notifies nearby players as though a full block type change occurred. |
+
+### CycleBlockGroup
+
+This interaction will attempt to change the target block to the next block type in one of the BlockGroups it belongs to.
+If the block type belongs to multiple BlockGroups, which one is used is effectively arbitrary. The User entity must be
+a player. If the block cannot be changed for any reason (entity not a player, no block target, block does not belong
+to a BlockGroup, etc.). If the block is the only entry in the BlockGroup, this interaction will succeed and the block
+will be considered changed despite nothing happening.  Unlike most other block-changing interactions, this one will
+fail if the world settings prevent players from breaking blocks.
+
+**This interaction always reduces the player's held item's durability by a single 'hit' worth of damage if the block
+changes. There is no way to prevent it. The block type will change and the interaction will succeed even if the player's
+held item is broken, however.**
+
+**CycleBlockGroup Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+
+### DestroyBlock
+
+This interaction destroys the target block without dropping anything.  It will successfully destroy the block if the
+target block exists and this interaction has no failure conditions.
+
+**This interaction has no additional fields.**
+
+### PickBlock
+
+This interaction is effectively equivalent to using the middle mouse button in creative mode. In survival mode, the
+block's item will be moved to the user's current active hotbar slot if it is in the player's inventory.  This
+interaction is performed entirely on the client and cannot be performed by non-players.  It is unclear if this
+interaction has failure conditions.
+
+**PickBlock Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+
+### PlaceBlock
+
+This interaction is effectively identical to a right clicking while holding a block in their hand, with some
+additional options. For one, it can be executed with any LivingEntity as the User entity. For another, it has some
+useful fields.  For the most part, though, it follows the same behaviors and rules as any ordinary block placement
+by a player.
+
+It's not clear under what circumstances this interaction can fail. The server will not fail the interaction under any
+special circumstances (including when there is no target block, or when `BlockTypeToPlace` is not provided and the
+LivingEntity is not holding a block). However, the client is very involved with the function of this interaction and
+its behavior is unknown.
+
+**PlaceBlock Fields**
+
+| Field Name         | Type                                   | Required? | Notes                                                                                                                                                                                                                                                                                                                                                           |
+| ------------------ | -------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| BlockTypeToPlace   | `Asset`<br />(Asset Type: `BlockType`) | **No**    | If provided, the block placed by this interaction will be the specified BlockType. If not provided, the User entity's held item will be used, instead, if it is a block.                                                                                                                                                                                        |
+| RemoveItemInHand   | `Boolean`<br />(Default: True)         | **No**    | If true and the User entity is not a player in Creative mode, the item in the player's hand must match the block being placed and one quantity will be removed for each block placed. If the item does not match, the block cannot be placed.  If false, the player's hand item is ignored entirely.\*\*                                                        |
+| AllowDragPlacement | `Boolean`<br />(Default: True)         | **No**    | If true and the interaction was triggered on the client by a player, then the player can hold the input that was used to activate this interaction chain and move the mouse around in order to execute this interaction repeatedly and place several blocks. The interaction chain will not move onto the next interaction until the player releases the input. |
+
+### RunOnBlockTypes
+
+This interaction retrieves all blocks within a provided radius of the User entity. For each block that matches any of
+the provided BlockSets, a new interaction chain will be forked that uses the matching block as the target block.
+This interaction will continue executing until all forked interaction chains have completed.  The interaction will fail if no
+blocks within the radius match the provided BlockSets or if all of the forked interaction chains fail.
+
+**RunOnBlockTypes Fields**
+
+| Field Name   | Type                                         | Required?        | Notes                                                                                                                                                                                                                                                                                      |
+| ------------ | -------------------------------------------- | ---------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| Range        | `Integer`                                    | **Yes**          | The spherical radius around the User entity to search for blocks. Must be at least 1.                                                                                                                                                                                                      |
+| BlockSets    | `AssetArray`<br />(Element Type: `BlockSet`) | **No**           | A list of BlockSets to match nearby blocks again. Only blocks that match any of the BlockSets will have interaction chains forked for them.                                                                                                                                                |
+| MaxCount     | `Integer`                                    | **Yes**          | The maximum number of blocks that will be located with the search. Further blocks will be ignored. If there are more matching blocks within the radius than this number, the specific set of blocks that will be found is completely arbitrary and may change from execution to execution. |
+| Interactions | `Asset`<br />(Asset Type: `RootInteraction`) | **No, but yes.** | The RootInteraction that will be forked for each matching block.  This interaction will not fail to validate if it is missing, but every execution of this interaction will fail.                                                                                                          |
+
+### UseBlock
+
+If the target block has an interaction for this interaction chain's interaction type, execute it immediately as part of
+this interaction chain. The execution will be wrapped in UseBlockEvent.Pre and UseBlockEvent.Post events, and cancellations
+of the UserBlockEvent.Pre event are respected. The User entity is considered the triggering entity for both events.
+
+If the target block does not have an interaction for this interaction chain's interaction type, this interaction fails.
+
+**This interaction has no additional fields.**
+
+## Items
+
+These are interactions intended to interface with an entity's inventory. There is no concept of an "item target",
+unfortunately, so these generally either interact with the entity's held item or the entity's inventory at a high level.
+
+### AddItem
+
+Adds a specified quantity of a specified item to the User entity's inventory, preferring to add it to the
+entity's hotbar where possible. This interaction will have no effect on User entities that are not LivingEntities.
+This interaction has no failure states.
+
+**Note: This interaction has a bug in its field validators that will cause interactions that reference items declared
+in the same mod to fail validation on startup.  Additionally, this interaction has a bug that will cause it to
+fail and have no effect if the User entity has no block target. Use ModifyInventory instead.**
+
+**AddItem Fields**
+
+| Field Name       | Type                              | Required? | Notes                                                                                                                             |
+| ---------------- | --------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false)   | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+| ItemId           | `Asset`<br />(Asset Type: `Item`) | **Yes**   | The item id of the item to add to the player's inventory.                                                                         |
+| Quantity         | `Integer`<br />(Default: 0)       | **No**    | The quantity of the item to add to the player's inventory.                                                                        |
+
+### CheckUniqueItemUsage
+
+This interaction will check whether it has run once for the User entity with their currently-held item before. If it hasn't,
+it will succeed. If it has, it will fail. It will also fail if the User entity is not a player. The interaction will record
+the item id of the User entity's currently-held item on success, ensuring it cannot be successfully run with that player
+and item id combination again.
+
+**This interaction has no additional fields.**
+
+### ChangeActiveSlot
+
+This interaction does not inherit from SimpleInteraction and therefore has no Next or Failed fields.  The `CancelOnItemChange`
+field is ignored for this interaction and is always treated as false. This interaction will set the User entity's currently-
+active hotbar slot to the specified slot index. If none is specified, the interaction chain's target slot will be used,
+if any. Otherwise, slot 0 will be used.  If a slot is specified and it is already active, then this interaction will
+have no effect, but if no slot is specified and the interaction chain's target slot is already active, the logic in
+the next paragraph will still be executed. This interaction will also have no effect if the User entity is not a
+LivingEntity.
+
+Once the slot has changed, a new SwapTo interaction chain will be forked off for the selected slot.
+If a target slot was specified, then the interaction chain's current target slot will be set to the specified slot, as will
+the forked SwapTo interaction chain. If this interaction chain was initiated by a player swapping an item into or out of
+an occupied active hotbar slot, then the swap will be executed after the slot is changed and before the SwapTo
+interaction is forked. Not running this interaction in the resulting SwapFrom interaction chain is a way for the server
+to cancel players performing these sorts of swap interactions. The default behavior for these swap interactions is that
+the SwapFrom interaction chain will be initiated with the currently-active-slot as the target slot. As a result, the
+target slot will usually not change when this interaction runs, it merely exists as a signal for the server to continue the
+item swap.
+
+**ChangeActiveSlot Fields**
+
+| Field Name | Type      | Required? | Notes                                                                                                                                                                                                     |
+| ---------- | --------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| TargetSlot | `Integer` | **No**    | If not provided, indicates the slot the player's active hotbar slot should be changed to.  Otherwise, the interaction chain's target slot will be used (which is usually the already-active hotbar slot). |
+
+### EquipItem
+
+This interaction will equip the User entity's currently-held item into the appropriate armor slot, if it is armor. The
+interaction will fail if the item is armor but it cannot be equipped for some reason. The interaction will succeed but
+take no action if the User entity cannot equip armor or if the item is not armor.
+
+**This interaction has no additional fields.**
+
+### IncreaseBackpackCapacity
+
+This interaction will increase the User entity's backpack size by the provided amount.  **It will additionally remove one
+quantity from the player's currently-held item. There is no way to prevent this.**  This interaction will have no effect
+if the User entity is not a player.  This interaction has no special failure conditions, even if the User entity
+is not a player, or the player is not currently holding an item.
+
+| Field Name | Type                        | Required? | Notes                                                                                   |
+| ---------- | --------------------------- | --------- | --------------------------------------------------------------------------------------- |
+| Capacity   | `Integer`<br />(Default: 1) | **No**    | The additional backpack capacity to add to the player. **Must be between 1 and 32767.** |
+
+### ModifyInventory
+
+This interaction attempts to perform one or more inventory-modifying actions against the User entity. The User entity must
+be a player. If they are not, no actions will be performed, but the interaction will not fail. Any item removals performed
+by this interaction, either as a result of `ItemToRemove` or `AdjustHeldItemQuantity`, are both atomic (meaning the entire
+quantity must be removed, or none) and required (meaning that the interaction will fail and no further actions taken if
+the removal fails for any reason).  Item additions performed by this interaction, either as a result of `ItemToAdd` or
+`AdjustHeldItemQuantity` will drop excess items on the ground near the player if necesary and continue on.
+
+This interaction first executes the item removal in `ItemToRemove`, if any, then adjusts the held item as specified by
+`AdjustHeldItemQuantity`, if provided, then executes the item addition in `ItemToAdd`, if any, and then finally executes
+the damage/healing of the held item in `AdjustHeldItemDurability`, if provided.
+
+**ModifyDurability Fields**
+
+| Field Name               | Type                            | Required? | Notes                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
+| ------------------------ | ------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| RequiredGameMode         | `GameMode`                      | **No**    | If provided, only execute the inventory-modifying actions if the player is in the provided GameMode. The interaction will not fail if the GameMode doesn't match.                                                                                                                                                                                                                                                                                                                                                                               |
+| ItemToRemove             | `ItemStack`                     | **No**    | If provided, a matching item will be removed in the provided quantity. If there is no matching item in the player inventory in the required quantity, then the interaction will fail and further actions will not be executed.                                                                                                                                                                                                                                                                                                                  |
+| AdjustHeldItemQuantity   | `Integer`<br />(Default: 0)     | **No**    | The player's held item, if any, will have its quantity will be modified by the provided amount- subtracted from if this number is negative or added to if this item is positive.  If the player has no held item, then this field will have no effect regardless of its value and the interaction will NOT fail.  If the player's inventory does not have sufficient quantity of items to support the removal, this interaction will fail and further actions will not be executed. Excess items will be dropped on the ground near the player. |
+| ItemToAdd                | `ItemStack`                     | **No**    | If provided, the ItemStack will be added to the player's inventory. Excess items will be dropped on the ground near the player.                                                                                                                                                                                                                                                                                                                                                                                                                 |
+| AdjustHeldItemDurability | `Double`<br />(Default: 0.0)    | **No**    | The player's held item, if any, will have its durability adjusted by the specified amount.  The durability cannot go below 0 or raise above the item's maximum durability. Invalid durability values in this field will not cause the interaction to fail. Neither will it fail if the player has no held item.                                                                                                                                                                                                                                 |
+| BrokenItem               | `String`                        | **No**    | This field should contain an ItemId, but it is not validated by the server on startup, so be careful.  This field can have the value of "Empty" to specify no item, or an empty hand. If specified and the `AdjustHeldItemDurability` operation reduces the player's held item to 0 durability, the player's held item is changed to this ItemId. If the inventory replacement fails, this interaction will fail.                                                                                                                               |
+| NotifyOnBreak            | `Boolean`<br />(Default: false) | **No**    | If true and the `AdjustHeldItemDurability` operation reduces the player's held item to 0 durability, this interaction will perform the usual audiovisual feedback of a broken tool. It will play the usual tool breaking sound and send the player a text message in chat that their item has broken.                                                                                                                                                                                                                                           |
+| NotifyOnBreakMessage     | `String`                        | **No**    | If provided, and `NotifyOnBreak` is true, when the player is notified of a broken tool by this interaction, the message sent to their chat will instead be the translation key specified by this field. The translation key supports the templating parameter `{itemName}`. See the translation key `server.general.repair.itemBroken_Hoe` for an example.                                                                                                                                                                                      |
+
+**GameMode Values**
+
+- `Creative`: The game is currently in Creative Mode
+- `Adventure`: The game is currently in Adventure Mode
+
+**ItemStack Fields**
+
+| Field Name                   | Type                              | Required? | Notes                                                                                |
+| ---------------------------- | --------------------------------- | --------- | ------------------------------------------------------------------------------------ |
+| Id                           | `Asset`<br />(Asset Type: `Item`) | **Yes**   | The id of the Item asset this stack contains.                                        |
+| Quantity                     | `Integer`<br />(Default: 1)       | **No**    | The number of items in this stack.<br />**Must be greater than 0.**                  |
+| Durability                   | `Double`<br />(Default: 0.0)      | **No**    | The durability of the item stack.<br />**Cannot be negative.**                       |
+| MaxDurability                | `Double`<br />(Default: 0.0)      | **No**    | The maximum durability of the item this stack contains.<br />**Cannot be negative.** |
+| Metadata                     | `Bson Document`                   | **No**    | If provided, applies the bson to the item stack metadata.                            |
+| OverrideDroppedItemAnimation | `Boolean`\*(Default: false)       | **No**    | ???                                                                                  |
+
+### PickupItem
+
+This interaction will attempt to pick up the User entity's current target entity and add it to their inventory. It will
+fail if the User entity is not a player, if they do not have a target entity, or if the target entity is not an item
+located in the world.  It will not fail if the player simply cannot pick up the item.
+
+**This interaction has no additional fields.**
+
+### RefillContainer
+
+This interaction will fail if the User entity is not a player. The interaction will draw a ray from the player's head
+down their look direction until the edge of the player's held item's interaction range or until the first solid block.
+The nearest fluid block of a type listed in this interaction's `States` map will result in the one of the player's
+currently-held items being converted to the fluid's related item state.  If the `States` map indicates a durability
+for the new item state, then the converted item will use that durability. If the item is already in the fluid's related
+item state, then this interaction will fail if the player's held item is already at maximum durability (unless the
+`States` map indicates a durability value greater than the item's maximum, in which case the interaction will succeed
+but the item will not change).  Otherwise, the durability listed for the fluid in the `States` map will be added to the
+item's current durability.
+
+If the interaction has not failed by this point, the fluid block in the world may be transformed to a different type if one is listed
+in the `States` map.
+
+If any part of this process does not proceed for any reason (for instance, if the player is not holding an item),
+then this interaction will fail.
+
+**RefillContainer Fields**
+
+| Field Name | Type                                                       | Required? | Notes                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| ---------- | ---------------------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| States     | `Map`<br />(Key Type: `String`, Value Type: `RefillState`) | **Yes**   | A map from item state names to `RefillState` objects, which contain information such as acceptable fluid block types, durability increases, and what fluid type to convert the targeted fluid block to after refill, if any. If the player targets a fluid block that matches one of the fluid types in the `RefillState`, the item will be converted to the keyed item state and the `RefillState` will be used to decide what happens next. |
+
+**RefillState Fields**
+
+| Field Name     | Type                                  | Required? | Notes                                                                                                                                                                                                                                                                                                                           |
+| -------------- | ------------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| AllowedFluids  | `Array`<br />(Element Type: `String`) | **Yes**   | If any of these fluids are targeted by the player, the player's held item will be converted to the keyed item state and `Durability` and `TransformFluid` will be used.                                                                                                                                                         |
+| Durability     | `Double`<br />(Default: -1.0)         | **No**    | If the player's held item changes item states, this value is the new item's durability, unless it is negative, in which case the item will begin at full durability. If the player's held item is already in the item state, and the item is not already at full durability, this value will be added to the item's durability. |
+| TransformFluid | `String`                              | **No**    | If provided, this field is a fluid id that the targeted fluid block should be transformed to if the player's held item is successfully updated.                                                                                                                                                                                 |
+
+## Entities
+
+### DamageEntity
+
+This interaction does not inherit from SimpleInteraction, but adds its own Next and Failed fields that
+work similarly.
+
+This interaction will cause the User entity to damage the Target entity.  It has the capability to apply different
+damage based on the direction of the attack or what body part was targeted by the User entity, with each possibility
+providing different damage calculations, effects, and Next interaction. If multiple entires match the attack, `TargetedDamage`
+(body part damage) takes highest priority, then the first matching `AngledDamage` in the list, then the default
+damage in the base interaction fields.  It is possible for elements of these different damage priorities to be taken peacemeal if higher-priority
+damage fields do not overwrite lower-priority damage fields. For instance,
+damage calculation could be taken from `TargetedDamage`, the damage effects could be taken from the first matching
+`AngledDamage`, and the Next interaction coming from the default damage field.
+
+If all damage dealt by this interaction is cancelled, then this interaction will fail, and the `Failed` interaction
+will be executed next in the chain. If any damage dealt by this interaction is blocked, then this interaction will
+succeed, but the `Blocked` interaction wil lbe executed next in the chain. Otherwise, the highest-precedent matching
+`Next` interaction that you provide will be executed.  For instance, if you provide `Next` interactions for all
+`TargetedDamage` and `AngledDamage` entries, and one in the interaction's `Next` field, then a headshot could result
+in a unique `Next` interaction being executed, even if there is a matching `AngledDamage` entry. However, if you leave
+the `Next` interaction out of your `TargetedDamage` entries, a special `Next` interaction for backstabs could be
+executed.  Otherwise, the `Next` field in the root of the interaction will be executed instead.
+
+DamageEntity has an unusual relationship with `RunTime`. This interaction always ends immediately after its first tick,
+regardless of the status of `RunTime` or `WaitForAnimationToFinish`.  However, if damage dealt by this interaction is
+calculated as `DamageCalculatorType` `Dps`, then the `RunTime` will be used to determine the precise amount of damage to
+deal. If `RunTime` is 0, then no damage will be dealt.
+
+**DamageEntity Fields**
+
+| Field Name       | Type                                                          | Required?                                                                                                                    | Notes                                                                                                                                                                                                                                                                                                                                                                         |
+| ---------------- | ------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| DamageCalculator | `DamageCalculator`                                            | **No**                                                                                                                       | If provided, describes the damage amounts and types to apply to the Target entity.                                                                                                                                                                                                                                                                                            |
+| DamageEffects    | `DamageEffects`                                               | **No**                                                                                                                       | If provided, describes particles, sounds, knockback, etc. to apply to the target entity on damage.                                                                                                                                                                                                                                                                            |
+| Next             | `Asset`<br />(Asset Type: `Interaction`)                      | **No**  After this interaction has finished, "Next" will be executed if damage was dealt to the target and none was blocked. |                                                                                                                                                                                                                                                                                                                                                                               |
+| AngledDamage     | `Array`<br />(Element Type: `AngledDamage`)                   | **No**                                                                                                                       | If provided, allows alternative `DamageCalculator`, `DamageEffects`, and `Next` entries for attacks that approach the target from certain angles.                                                                                                                                                                                                                             |
+| TargetedDamage   | `Map`<br />(Key Type: `String`, Value Type: `TargetedDamage`) | **Yes**                                                                                                                      | This field must be provided, but is not required to have any entries.  This is a map from body part names to `TargetedDamage` values. Hypixel only uses one body part name: `Head`, and it is not clear whether there are others.  If provided, allows alternative `DamageCalculator`, `DamageEffects`, and `Next` entries for attacks that damage specific enemy body parts. |
+| EntityStatsOnHit | `Array`<br />(Element Type: `EntityStatOnHit`)                | **No**                                                                                                                       | If provided, allows this attack to reduce enemy stats other than health.  Each individual damage application dealt by the same ability will apply stat reductions, at diminishing returns. All damage dealt in interaction chains forked by a Selector interaction will share the number of hits across all targets.                                                          |
+| Failed           | `Asset`<br />(Asset Type: `Interaction`)                      | **No**                                                                                                                       | After this interaction has finished, "Failed" will be executed if no damage hits were applied to the player, or if all damage hits were cancelled.                                                                                                                                                                                                                            |
+| Blocked          | `Asset`<br />(Asset Type: `Interaction`)                      | **No**                                                                                                                       | After this interaction has finished, "Blocked" will be executed if any damage hits were blocked by the target.                                                                                                                                                                                                                                                                |
+
+**DamageCalculator Fields**
+
+| Field Name                | Type                                                      | Required? | Notes                                                                                                                                                                                                                                                 |
+| ------------------------- | --------------------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Type                      | `DamageCalculatorType`<br />(Default: Absolute)           | **No**    | Whether the damage being applied is `Absolute` or \`Dps'.                                                                                                                                                                                             |
+| Class                     | `DamageClass`<br />(Default: Unknown)                     | **No**    | The type of attack producing the damage. Some weapon systems apply equipment modifiers based on this value.                                                                                                                                           |
+| BaseDamage                | `Map`<br />(Key Type: `DamageCause`, Value Type: `Float`) | **No**    | A set of DamageCauses and how much base damage is dealt for each.                                                                                                                                                                                     |
+| SequentialModifierStep    | `Float`<br />(Default: 0.0)                               | **No**    | Value between 0.0-1.0. Each additional hit from a single ability will have its damage reduced by this much as a percentage. All damage dealt in interaction chains forked by a Selector interaction will share the number of hits across all targets. |
+| SequentialModifierMinimum | `Float`<br />(Default: 0.0)                               | **No**    | Value between 0.0-1.0. `SequentialModifierStep` cannot reduce damage below this percentage regardless of the number of hits.                                                                                                                          |
+| RandomPercentageModifier  | `Float`<br />(Default: 0.0)                               | **No**    | A random value between +/- this amount multiplied by the base damage will be added to the base damage.                                                                                                                                                |
+
+**DamageEffects Fields**
+
+| Field Name             | Type                                         | Required? | Notes                                                                                   |
+| ---------------------- | -------------------------------------------- | --------- | --------------------------------------------------------------------------------------- |
+| ModelParticles         | `Array`<br />(Element Type: `ModelParticle`) | **No**    | Particle systems to trigger in the first-person view.                                   |
+| WorldParticles         | `Array`<br />(Element Type: `WorldParticle`) | **No**    | Particle systems to trigger in the third-person view.                                   |
+| LocalSoundEventId      | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | 2D sound to play locally to the attacking entity if they are a player.                  |
+| WorldSoundEventId      | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | Sound to play in the world at the Target entity's location.                             |
+| PlayerSoundEventId     | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | 2D sound to play locally to the Target entity if they are a player.                     |
+| ViewDistance           | `Double`<br />(Default: 75.0)                | **No**    | Distance at which these effects should play for other players.                          |
+| Knockback              | `Knockback`                                  | **No**    | The properties of the knockback that will be applied.                                   |
+| CameraEffect           | `Asset`<br />(Asset Type: `CameraEffect`)    | **No**    | CameraEffect to briefly apply locally to the Target entity if they are a player.        |
+| StaminaDrainMultiplier | `Float`<br />(Default: 1.0)                  | **No**    | This multiplier is applied to the stamina cost incurred by the target blocking, if any. |
+
+**AngledDamage Fields**
+
+| Field Name       | Type                                     | Required? | Notes                                                                                                                                                                                                     |
+| ---------------- | ---------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| AngleDistance    | `Float`<br />(Default: 0)                | **No**    | The width in degrees of the matching arc around the Target entity. If the attack against the Target originates from within the arc, then the properties below will be applied to the attack, if provided. |
+| Angle            | `Float`<br />(Default: 0.0)              | **No**    | The angle in degrees around the Target entity at which the matching arc is centered.                                                                                                                      |
+| DamageCalculator | `DamageCalculator`                       | **No**    | If provided and the attack against the Target entity originates from within the provided arc, this DamageCalculator will override the interaction's `DamageCalculator` field.                             |
+| DamageEffects    | `DamageEffects`                          | **No**    | If provided and the attack against the Target entity originates from within the provided arc, this DamageEffects will override the interaction's `DamageEffects` field.                                   |
+| Next             | `Asset`<br />(Asset Type: `Interaction`) | **No**    | If provided and the attack against the Target entity originates from within the provided arc, this Interaction will override the interaction's `Next` field.                                              |
+
+**TargetedDamage Fields**
+
+| Field Name       | Type                                     | Required? | Notes                                                                                                                                                                                            |
+| ---------------- | ---------------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| DamageCalculator | `DamageCalculator`                       | **No**    | If provided and this TargetedDamage was matched, this DamageCalculator will override the interaction's `DamageCalculator` field and the `DamageCalculator` field of any matching `AngledDamage`. |
+| DamageEffects    | `DamageEffects`                          | **No**    | If provided and this TargetedDamage was matched, this DamageEffects will override the interaction's `DamageEffects` field and the `DamageEffects` field of any matching `AngledDamage`.          |
+| Next             | `Asset`<br />(Asset Type: `Interaction`) | **No**    | If provided and this TargetedDamage was matched, this Interaction will override the interaction's `Next` field and the `Next` field of any matching `AngledDamage`.                              |
+
+**EntityStatOnHit Fields**
+
+| Field Name                  | Type                                                                       | Required? | Notes                                                                                                                                                                                                                                                                                        |
+| --------------------------- | -------------------------------------------------------------------------- | --------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| EntityStatId                | `Asset`<br />(AssetType: `EntityStatType`)                                 | **Yes**   | Which entity stat to affect.                                                                                                                                                                                                                                                                 |
+| Amount                      | `Float`<br />(Default: 0.0)                                                | **No**    | How much of the stat to apply for each damage application. Use negative numbers to reduce stats.                                                                                                                                                                                             |
+| MultipliersPerEntitiesHit   | `Array`<br />(Element Type: `Float`, Default: `[1.0, 0.6, 0.4, 0.2, 0.1]`) | **No**    | The diminishing returns curve to be applied for multiple damage applications by the same ability. Each hit's stat impact will be multiplied by the next value in the list.  If there are more hits than array elements, subsequent hits will be multiplied by `MultiplierPerExtraEntityHit`. |
+| MultiplierPerExtraEntityHit | `Float`<br />(Default: 0.05)                                               | **No**    | If an ability carries out more damage applications than there are elements in the `MultipliersPerEntitiesHit` array, then subsequent stat values will be multiplied by this number.                                                                                                          |
+
+**Knockback Fields**
+
+| Field Name     | Type                                       | Required? | Notes                                                                                                                      |
+| -------------- | ------------------------------------------ | --------- | -------------------------------------------------------------------------------------------------------------------------- |
+| Type           | `String`                                   | **No**    | If provided, specifies a type of knockback to use. Each Target type may come with additional fields.                       |
+| Force          | `Double`<br />(Default: 0.0)               | **No**    | The amount of force to apply to the Owner entity.                                                                          |
+| Duration       | `Double`<br />(Default: 0.0)               | **No**    | If 0.0, apply the force as a single impulse.  If more, continuously apply the force over a period of time.                 |
+| VelocityType   | `ChangeVelocityType`<br />(Default: `Add`) | **No**    | How to apply the force, either adding it to the entity's current velocity, or setting the velocity to the knockback force. |
+| VelocityConfig | `VelocityConfig`                           | **No**    | Characteristics of friction as the Owner entity is thrown by this knockback.                                               |
+
+**Knockback Type: Force**
+
+Apply the calculated knockback force along the provided direction.
+
+| Field Name | Type                         | Required? | Notes                                                                                |
+| ---------- | ---------------------------- | --------- | ------------------------------------------------------------------------------------ |
+| Direction  | `Vector3`<br />(Default: Up) | **No**    | Which direction the entity should be flung, relative to the direction of the attack. |
+
+**Knockback Type: Point**
+
+Apply the calculated knockback force laterally along the XZ plane, plus provided Y velocity.
+
+| Field Name | Type                        | Required? | Notes                                                                                                   |
+| ---------- | --------------------------- | --------- | ------------------------------------------------------------------------------------------------------- |
+| OffsetX    | `Integer`<br />(Default: 0) | **No**    | Offset the source position of the knockback left or right perpendicular to the direction of the attack. |
+| OffsetZ    | `Integer`<br />(Default: 0) | **No**    | Offset the source position of the knockback, forward or backward along the directon of the attack.      |
+| RotateY    | `Integer`<br />(Default: 0) | **No**    | Rotate the knockback direction around the Y axis, where 0 is the default attack direction.              |
+| VelocityY  | `Float`<br />(Default: 0.0) | **No**    | Add vertical velocity to the knockback force after the direction and force has been calculated.         |
+
+**Knockback Type: Directional**
+
+Apply the calculated knockback force along the attack direction, removing any vertical component and replacing it with a provided Y velocity.
+
+| Field Name | Type                      | Required? | Notes                                                                                                                                            |
+| ---------- | ------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------ |
+| RelativeX  | `Float`<br />(Default: 0) | **No**    | Apply additional force left or right perpendicular to the direction of the attack. The additional force is multiplied by the knockback strength. |
+| RelativeZ  | `Float`<br />(Default: 0) | **No**    | Apply additional force forward or backward along the attack direction. The additional force is multiplied by the knockback strength.             |
+| VelocityY  | `Float`<br />(Default: 0) | **No**    | Replace the vertical velocity of the knockback with this value.  This value is not multiplied by knockback strength.                             |
+
+**VelocityConfig Fields**
+
+| Field Name          | Type                                              | Required? | Notes                                                                                                                                                                                           |
+| ------------------- | ------------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| GroundResistance    | `Float`<br />(Default: 0.82)                      | **No**    | The minimum amount of friction applied when the entity is in contact with the ground.  1.0 = no friction, 0.0 = total friction                                                                  |
+| GroundResistanceMax | `Float`<br />(Default: 0.0)                       | **No**    | The maximum amount of friction applied when the entity is in contact with the ground.  1.0 = no friction, 0.0 = total friction                                                                  |
+| AirResistance       | `Float`<br />(Default: 0.96)                      | **No**    | The minimum amount of friction applied when the entity is in the air. 1.0 = no friction, 0.0 = total friction                                                                                   |
+| AirResistanceMax    | `Float`<br />(Default: 0.0)                       | **No**    | The maximum amount of friction applied when the entity is in the air. 1.0 = no friction, 0.0 = total friction                                                                                   |
+| Threshold           | `Float`<br />(Default: 1.0)                       | **No**    | The speed at which the maximum amount of friction will be applied to the entity. The amount of friction applied will increase from minimum to maximum as the entity moves from 0 to this speed. |
+| Style               | `VelocityThresholdStyle`<br />(Default: `Linear`) | **No**    | The curve that friction follows as the entity's speed increases toward the `Threshold`.                                                                                                         |
+
+**DamageCalculatorType Values**
+
+- `Absolute`
+- `Dps`
+
+**DamageClass Values**
+
+- `Unknown`
+- `Light`
+- `Charged`
+- `Signature`
+
+**ChangeVelocityType Values**
+
+- `Add`
+- `Set`
+
+**VelocityThresholdStyle Values**
+
+- `Linear`
+- `Exp`
+
+### LaunchProjectile
+
+This is just a worse version of Projectile and is slated to be removed.  Use Projectile.
+
+### Projectile
+
+This interaction will spawn a new projectile at the User entity's eye position that will travel in its look direction.
+
+| Field Name | Type                                          | Required? | Notes                                                  |
+| ---------- | --------------------------------------------- | --------- | ------------------------------------------------------ |
+| Config     | `Asset`<br />(Asset Type: `ProjectileConfig`) | **No**    | Configuration describing the projectile to be spawned. |
+
+### RemoveEntity
+
+Despawns the specified entity from the world. This interaction will have no effect if the specified entity is a player. This
+interaction has no special failure conditions.
+
+| Field Name | Type                                     | Required? | Notes                  |
+| ---------- | ---------------------------------------- | --------- | ---------------------- |
+| Entity     | `InteractionTarget`<br />(Default: User) | **No**    | The entity to despawn. |
+
+**InteractionTarget Values**
+
+- `User` - The user of this interaction chain. The entity whose actions caused this interaction chain to be executed. This is usually the same as the Owner.
+- `Owner` - The owner of this interaction chain. The entity upon whom this interaction chain is executing.
+- `Target` - The entity target of this interaction chain, if any.  This value is mutable (and can therefore come from many places) but most commonly, it is an entity the User was targeting when this interaction chain began executing.
+
+### SendMessage
+
+This interaction sends a message to the Owner entity if that entity can receive messages.  Otherwise, the message
+is written to the server logs.  If the entity is a player, the message will appear in the player's chat window.
+
+\*\*SendMessage
+
+| Field Name | Type     | Required? | Notes                                                                                                                 |
+| ---------- | -------- | --------- | --------------------------------------------------------------------------------------------------------------------- |
+| Message    | `String` | **No**    | A text message to be sent to the Owner entity.  If this field is not provided, `Key` is used instead.                 |
+| Key        | `String` | **No**    | A translation key for a message to be sent to the Owner entity. If `Message` is provided, then this field is ignored. |
+
+### UseEntity
+
+This interaction is not in use by Hypixel and has some unusual qualities that mean it probably won't do what you want it
+to.  Do not use it.
+
+This interaction will retrieve the entity currently targeted by the client (NOT the interaction chain's current Target
+entity) and execute that entity's RootInteraction for this interaction chain's current interaction type. The
+RootInteraction will be executed as part of this current interaction chain. None of the properties of this interaction
+chain will be modified.
+
+This interaction will fail if the client is not currently targeting an entity, or if no interaction for the current
+interaction type exists on the entity.
+
+## Stats
+
+Hytale's resource system has been written about fairly extensively.  You can use these interactions to modify stats in
+response to actions or use stats as a cost for abilities.
+
+### ChangeStat
+
+This interaction applies a set of raw stat changes to the User entity. It has no special failure conditions.
+
+| Field Name    | Type                                                         | Required? | Notes                                                                                                                                                                                                                      |
+| ------------- | ------------------------------------------------------------ | --------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| StatModifiers | `Map`<br />(Key Type: `EntityStatType`, Value Type: `Float`) | **Yes**   | A set of stats to modify and what value to apply to them.                                                                                                                                                                  |
+| ValueType     | `ValueType`<br />(Default: Absolute)                         | **No**    | Whether the values in the `StatModifiers` map represent flat values to apply to the stat total, or percentages (0.0-100.0). Percentage values are percentage of the difference between the maximum and minimum stat value. |
+| Behaviour     | `ChangeStatBehavior`<br />(Default: Add)                     | **No**    | Whether the values in the `StatModifiers` map represent deltas to add into the User entity's current stat values, or fixed values to set the entity's stats to.                                                            |
+
+**ValueType Values**
+
+- `Absolute`
+- `Percent`
+
+**ChangeStatBehaviour Values**
+
+- `Add`
+- `Set`
+
+### ChangeStatWithModifier
+
+This interaction is like ChangeStat, except an armor stat modifier can be chosen which will apply bonuses and penalties
+to a stat from the User entity's equipped armor before it is applied.
+
+| Field Name            | Type                                                         | Required? | Notes                                                                                                                                                                                                                      |
+| --------------------- | ------------------------------------------------------------ | --------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| StatModifiers         | `Map`<br />(Key Type: `EntityStatType`, Value Type: `Float`) | **Yes**   | A set of stats to modify and what value to apply to them.                                                                                                                                                                  |
+| ValueType             | `ValueType`<br />(Default: Absolute)                         | **No**    | Whether the values in the `StatModifiers` map represent flat values to apply to the stat total, or percentages (0.0-100.0). Percentage values are percentage of the difference between the maximum and minimum stat value. |
+| Behaviour             | `ChangeStatBehavior`<br />(Default: Add)                     | **No**    | Whether the values in the `StatModifiers` map represent deltas to add into the User entity's current stat values, or fixed values to set the entity's stats to.                                                            |
+| InteractionModifierId | `InteractionModifierId`                                      | **Yes**   | The armor interaction modifier to apply bonuses and penalties for.                                                                                                                                                         |
+
+**ValueType Values**
+
+- `Absolute`
+- `Percent`
+
+**ChangeStatBehaviour Values**
+
+- `Add`
+- `Set`
+
+**InteractionModifierId Values**
+
+- `Dodge`
+
+### StatsCondition
+
+This interaction will fail if the User entity cannot afford the specified stats costs, or if it does not have the
+requested stats.
+
+| Field Name | Type                                                         | Required? | Notes                                                                                                                                                                                    |
+| ---------- | ------------------------------------------------------------ | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Costs      | `Map`<br />(Key Type:` EntityStatType`, Value Type: `Float`) | **Yes**   | A set of costs that the User entity needs to be able to afford for this interaction to succeed.                                                                                          |
+| ValueType  | `ValueType`<br />(Default: Absolute)                         | **No**    | Whether the values in the `Costs` map represetn flat values or percentages (0.0-100.0).  Percentage values are percentage of the difference between the maximum and minimum value.       |
+| LessThan   | `Boolean`<br />(Default: false)                              | **No**    | If true, this interaction will fail unless the User entity's current stat values are at or **below** the specified levels.  If false, they must be at or **above** the specified levels. |
+| Lenient    | `Boolean`<br />(Default: false)                              | **No**    | If true and `LessThan` is true, and a player's minimum stat value is below zero, then the player can afford a stat cost if the current value of a stat if above 0.                       |
+
+**ValueType Values**
+
+- `Absolute`
+- `Percent`
+
+### StatsConditionWithModifier
+
+This interaction is like StatsCondition, except an armor stat modifier can be chosen which will apply bonuses and penalties
+to a stat's cost from the User entity's equipped armor before it is compared.
+
+| Field Name            | Type                                                         | Required? | Notes                                                                                                                                                                                    |
+| --------------------- | ------------------------------------------------------------ | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Costs                 | `Map`<br />(Key Type:` EntityStatType`, Value Type: `Float`) | **Yes**   | A set of costs that the User entity needs to be able to afford for this interaction to succeed.                                                                                          |
+| ValueType             | `ValueType`<br />(Default: Absolute)                         | **No**    | Whether the values in the `Costs` map represetn flat values or percentages (0.0-100.0).  Percentage values are percentage of the difference between the maximum and minimum value.       |
+| LessThan              | `Boolean`<br />(Default: false)                              | **No**    | If true, this interaction will fail unless the User entity's current stat values are at or **below** the specified levels.  If false, they must be at or **above** the specified levels. |
+| Lenient               | `Boolean`<br />(Default: false)                              | **No**    | If true and `LessThan` is true, and a player's minimum stat value is below zero, then the player can afford a stat cost if the current value of a stat if above 0.                       |
+| InteractionModifierId | `InteractionModifierId`                                      | **Yes**   | The armor interaction modifier to apply bonuses and penalties for.                                                                                                                       |
+
+**ValueType Values**
+
+- `Absolute`
+- `Percent`
+
+**InteractionModifierId Values**
+
+- `Dodge`
+
+## EntityEffects
+
+EntityEffects are buff or debuff effects that can be applied to a LivingEntity.  These can have a variety of effects from
+movement speed changes to periodic damage.
+
+### EffectCondition
+
+This interaction will fail if the specified entity's EntityEffects do not match the provided conditions.
+
+**EffectCondition Fields**
+
+| Field Name      | Type                                             | Required? | Notes                                                                                                                                                                                                             |
+| --------------- | ------------------------------------------------ | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Entity          | `InteractionTarget`<br />(Default: User)         | **Yes**   | The entity to examine for EntityEffects. This field can indicate the Owner, User, or Target of this interaction chain.                                                                                            |
+| Match           | `Match`<br />(Default: All)                      | **No**    | If `All`, then this interaction will fail if any EntityEffect in the `EntityEffectIds` is not on the specified entity. If `None`, then this interaction will fail if any EntityEffect IS on the specified entity. |
+| EntityEffectIds | `AssetArray`<br />(Element Type: `EntityEffect`) | **Yes**   | The set of EntityEffects to check against the specified entity and `Match`.                                                                                                                                       |
+
+**InteractionTarget Values**
+
+- `User` - The user of this interaction chain. The entity whose actions caused this interaction chain to be executed. This is usually the same as the Owner.
+- `Owner` - The owner of this interaction chain. The entity upon whom this interaction chain is executing.
+- `Target` - The entity target of this interaction chain, if any.  This value is mutable (and can therefore come from many places) but most commonly, it is an entity the User was targeting when this interaction chain began executing.
+
+**Match Values**
+
+- `All` - All EntityEffects must be on the specified entity for this interaction to succeed.
+- `None` - None of the EntityEffects must be on the specified entity for this interaction to succeed.
+
+### ApplyEffect
+
+This interaction will apply the specified EntityEffect to the specified Entity.  It has no special failure conditions.
+
+**ApplyEffect Fields**
+
+| Field Name | Type                                      | Required? | Notes                                                                                                                  |
+| ---------- | ----------------------------------------- | --------- | ---------------------------------------------------------------------------------------------------------------------- |
+| Entity     | `InteractionTarget`<br />(Default: User)  | **Yes**   | The entity to apply the EntityEffect to. This field can indicate the Owner, User, or Target of this interaction chain. |
+| EffectId   | `Asset`<br />(Asset Type: `EntityEffect`) | **Yes**   | The effect to apply.                                                                                                   |
+
+**InteractionTarget Values**
+
+- `User` - The user of this interaction chain. The entity whose actions caused this interaction chain to be executed. This is usually the same as the Owner.
+- `Owner` - The owner of this interaction chain. The entity upon whom this interaction chain is executing.
+- `Target` - The entity target of this interaction chain, if any.  This value is mutable (and can therefore come from many places) but most commonly, it is an entity the User was targeting when this interaction chain began executing.
+
+### ClearEntityEffect
+
+This interaction will remove the specified EntityEffect from the specified Entity. It has no special failure conditions.
+It will not fail if the Entity does not have the EntityEffect.
+
+**ClearEntityEffect Fields**
+
+| Field Name | Type                                      | Required? | Notes                                                                                                                     |
+| ---------- | ----------------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------- |
+| Entity     | `InteractionTarget`<br />(Default: User)  | **Yes**   | The entity to remove the EntityEffect from. This field can indicate the Owner, User, or Target of this interaction chain. |
+| EffectId   | `Asset`<br />(Asset Type: `EntityEffect`) | **Yes**   | The effect to remove.                                                                                                     |
+
+**InteractionTarget Values**
+
+- `User` - The user of this interaction chain. The entity whose actions caused this interaction chain to be executed. This is usually the same as the Owner.
+- `Owner` - The owner of this interaction chain. The entity upon whom this interaction chain is executing.
+- `Target` - The entity target of this interaction chain, if any.  This value is mutable (and can therefore come from many places) but most commonly, it is an entity the User was targeting when this interaction chain began executing.
+
+## Farming
+
+These are interaction types built to support the in-game farming system in Hytale. They are mostly block-related interactions
+with a few exceptions.
+
+### ChangeFarmingStage
+
+If the target block is a farming block, this interaction will attempt to modify the current farming stage in one of
+three ways.  The interaction can optionally specify which StageSet to use for the new stage. If it is not specified,
+the current StageSet will be used. If any part of the the process of changing the growth stage fails, this interaction
+will fail, with the one exception that attempting to set the stage to the crop's existing stage will have no effect but
+still succeed.
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                                                                                                                                                                          |
+| ---------------- | ------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction.                                                                                                                                              |
+| StageSet         | `String`                        | **No**    | If provided, set the block's current stage to one in the provided StageSet. Otherwise, use the crop's current StageSet.                                                                                                                                                        |
+| Increase         | `Integer`                       | **No**    | If provided, increase the current stage by the specified amount. If the specified stage does not exist, the block will be set to the closest extant stage.                                                                                                                     |
+| Decrease         | `Integer`                       | **No**    | If provided and `Increase` is not provided, decrease the current stage by the specified amount. If the specified stage does not exist, the block will be set to the closest extant stage.                                                                                      |
+| Stage            | `Integer`<br />(Default: -1)    | **No**    | If provided and `Increase`/`Decrease` are not provided, set the current stage to the specified stage. If this value is less than 0, set the current stage to the final growth stage. If the specified stage does not exist, the block will be set to the closest extant stage. |
+
+### FertilizeSoil
+
+If the target block is unfertilized tilled soil or a farming block on top of unfertilized tilled soil, fertilizes the soil.
+The interaction will fail otherwise.
+
+**FertilizeSoil Fields**
+
+| Field Name       | Type                                  | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false)       | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+| RefreshModifiers | `Array`<br />(Element Type: `String`) | **No**    | Does nothing.                                                                                                                     |
+
+### HarvestCrop
+
+This interaction will attempt to execute the harvest action on the current block target and add the crop's drops to the User entity's
+inventory.  The block will either be destroyed or set to its post-harvest growth stage, depending on the farming
+configuration of the block.  This will happen (and the player will receive the full harvest drops) regardless of the
+block's current growth stage. This interaction has no special failure conditions, even if the block target isn't a
+farming block or gathering isn't permitted in the current world, but nothing will occur in those cases.
+
+**HarvestCrop Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+
+### UseWateringCan
+
+If the target block is tilled soil or a farming block on top of tilled soil, waters the soil for the specified duration.
+The interaction will fail otherwise.
+
+**UseWateringCan Fields**
+
+| Field Name       | Type                                  | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false)       | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+| Duration         | `Integer`<br />(Default: 0)           | **No**    | The duration in seconds to water the soil for.                                                                                    |
+| RefreshModifiers | `Array`<br />(Element Type: `String`) | **No**    | Does nothing.                                                                                                                     |
diff --git a/content/docs/pt-PT/contributing/pr-guidelines.mdx b/content/docs/pt-PT/contributing/pr-guidelines.mdx
index 7a251032..c226da04 100644
--- a/content/docs/pt-PT/contributing/pr-guidelines.mdx
+++ b/content/docs/pt-PT/contributing/pr-guidelines.mdx
@@ -19,6 +19,8 @@ To ensure a smooth and efficient review process, both contributors and reviewers
 4. **Code Quality**
    - Ensure your code follows the project's coding standards and best practices.
    - Include comments where necessary to explain complex logic.
+   - Always test your changes locally before submitting the PR to catch any issues early.
+   - Format your code using `bun format` to maintain consistency across the codebase.
 5. **Testing**
    - Test your changes thoroughly before submitting the PR.
    - If applicable, include unit tests or integration tests to verify your changes.
diff --git a/content/docs/pt-PT/contributing/translate.mdx b/content/docs/pt-PT/contributing/translate.mdx
new file mode 100644
index 00000000..c62ffdde
--- /dev/null
+++ b/content/docs/pt-PT/contributing/translate.mdx
@@ -0,0 +1,74 @@
+---
+title: Translate
+description: How to translate HytaleModding to your language
+---
+
+# Translating HytaleModding
+
+HytaleModding is translated with the help of the community using **Crowdin**. If you want to help translate or improve existing translations, this is the right place.
+
+## Steps to Translate
+
+All translations are managed **via Crowdin**.
+
+1. Visit [our Crowdin project](https://crowdin.com/project/hytalemodding) and log in if required.
+2. Click on your language.
+3. Click on the file/article you wish to translate. We recommend starting with Official Documentation, and then Server Plugin Documentation.
+4. Start translating!
+5. Approved translations will appear on the website.
+
+### Video Guide
+
+<iframe src="https://www.youtube.com/embed/NHiG1rDRgks" allowFullScreen />
+
+## How to discuss
+
+You can always report issues or discuss specific topics directly on Crowdin, but we recommend using Discord instead of the Crowdin comment system to keep everything organized in one place.
+
+1. Join [our Discord](https://discord.gg/hytalemodding)
+2. Open `#translations` channel. Here you can discuss or ask questions that are not related to a specific language.
+3. If you want to join a thread, you are required to run `/translator <your-language>` command here. The bot will add you to the thread for your language.
+
+## Translation Guidelines
+
+- You need to be confident in what you are translating. You should be able to read the text you just translated and understand the meaning of it very easily.
+- It should use the simplest form of language possible. Use English words if the translation is unknown to the majority in your country.
+- Use your imagination, trust yourself. Feel free to change any context as you wish as long as it can still get the same point across and is understandable.
+- These guidelines are more important than language-specific guidelines, but less important than Hytale terminology and rules.
+
+## What not to translate
+
+We request you all to not translate these specific sections of the website:
+
+### Callout types
+
+Callouts are the boxes that contain important information. We request you to not translate the types as they only work in English.
+
+**Example:**
+
+```mdx
+<Callout type="warning" title="Translate this title!">
+Translate the text inside the callout!
+</Callout>
+```
+
+In this example, please don't translate the word warning, the rest you can translate.
+
+### Icons
+
+Icon names must not be translated.
+They are technical identifiers mapped directly to existing icons. Translating them will break the icon rendering.
+
+```mdx
+icon: Globe
+```
+
+---
+
+{/* 
+For translators who will edit this page:
+
+- You are required to translate the Guidelines as they change.
+- General guidelines should be translated but not edited.
+- Learn how to use Markdown from writing_guides.mdx
+*/}
diff --git a/content/docs/pt-PT/established-information/server/content-categories/art-assets.mdx b/content/docs/pt-PT/established-information/server/content-categories/art-assets.mdx
index 39c2ed37..1e926874 100644
--- a/content/docs/pt-PT/established-information/server/content-categories/art-assets.mdx
+++ b/content/docs/pt-PT/established-information/server/content-categories/art-assets.mdx
@@ -14,7 +14,7 @@ Hytale provides comprehensive support for 3D modeling and texture art creation,
 Hytale uses **Blockbench** as the primary tool for 3D modeling and animation:
 
 * **Official support**: Used for "creating Hytale models, textures, and animations"
-* **Special plugin**: Hytale will have a dedicated Blockbench plugin, to be released ASAP
+* **Special plugin**: Hytale has a dedicated [Blockbench Plugin](https://www.blockbench.net/plugins/hytale_plugin).
 * **Direct compatibility**: The plugin allows creators to "create Hytale-compatible models, textures, and animations directly in Blockbench"
 * **Replaces legacy tools**: Fully replaces the old Hytale Model Maker to better support established creative workflows in the community
 * **Safety features**: Only allows you to add things compatible with the engine, so no need to worry about breaking anything
diff --git a/content/docs/pt-PT/guides/ecs/block-components.mdx b/content/docs/pt-PT/guides/ecs/block-components.mdx
new file mode 100644
index 00000000..ca68b38a
--- /dev/null
+++ b/content/docs/pt-PT/guides/ecs/block-components.mdx
@@ -0,0 +1,247 @@
+---
+title: Block Components
+description: Learn how to use the block components.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+  - name: oskarscot
+    link: https://oskar.scot
+---
+
+# Overview
+
+In this guide, you'll learn how to use block components to create a ticking block.
+
+<Callout>
+  For a more complete reference, you may also want to review FarmingSystems.Ticking, as much of the underlying logic is based on its implementation.
+</Callout>
+
+## Steps
+
+### 1. ExampleBlock - holds block behavior
+
+```java
+public class ExampleBlock implements Component<ChunkStore> {
+
+    public static final BuilderCodec CODEC = BuilderCodec.builder(ExampleBlock.class, ExampleBlock::new).build();
+
+    // Components usually require a copy constructor as well but since we don't actually hold any data in this component this is not neccessary
+    public ExampleBlock() { }
+
+    public static ComponentType getComponentType() {
+        return ExamplePlugin.get().getExampleBlockComponentType();
+    }
+
+    @Nullable
+    public Component<ChunkStore> clone() {
+        return new ExampleBlock();
+    }
+}
+```
+
+ExampleBlock is a custom component that stores the behavior and data for your ticking block. Here, it simply places an Ice Block at x + 1 relative to its current position when it ticks.
+
+---
+
+### 2. ExampleInitializer - marks blocks as ticking when placed
+
+```java
+public class ExampleInitializer extends RefSystem {
+
+    @Override
+    public void onEntityAdded(@Nonnull Ref ref, @Nonnull AddReason reason, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+        BlockModule.BlockStateInfo info = (BlockModule.BlockStateInfo) commandBuffer.getComponent(ref, BlockModule.BlockStateInfo.getComponentType());
+        if (info == null) return;
+
+        ExampleBlock generator = (ExampleBlock) commandBuffer.getComponent(ref, ExamplePlugin.get().getExampleBlockComponentType());
+        if (generator != null) {
+            int x = ChunkUtil.xFromBlockInColumn(info.getIndex());
+            int y = ChunkUtil.yFromBlockInColumn(info.getIndex());
+            int z = ChunkUtil.zFromBlockInColumn(info.getIndex());
+
+            WorldChunk worldChunk = (WorldChunk) commandBuffer.getComponent(info.getChunkRef(), WorldChunk.getComponentType());
+            if (worldChunk != null) {
+				worldChunk.setTicking(x, y, z, true);
+            }
+        }
+    }
+
+    @Override
+    public void onEntityRemove(@Nonnull Ref ref, @Nonnull RemoveReason reason, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+    }
+
+    @Override
+    public Query getQuery() {
+        return Query.and(BlockModule.BlockStateInfo.getComponentType(), ExamplePlugin.get().getExampleBlockComponentType());
+    }
+}
+```
+
+ExampleInitializer is a RefSystem that reacts when block entities with the ExampleBlock component are added or removed. This is crucial for marking blocks as ticking when they're first placed.
+
+**Key Points:**
+
+- Tells the game that this block should tick, allowing `ExampleSystem` to process it.
+
+```java
+worldChunk.setTicking(x, y, z, true);
+```
+
+---
+
+### 3. ExampleSystem - handles ticking
+
+```java
+public class ExampleSystem extends EntityTickingSystem {
+
+    public void tick(float dt, int index, @Nonnull ArchetypeChunk archetypeChunk, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+        BlockSection blocks = (BlockSection) archetypeChunk.getComponent(index, BlockSection.getComponentType());
+
+        assert blocks != null;
+
+        if (blocks.getTickingBlocksCountCopy() != 0) {
+            ChunkSection section = (ChunkSection) archetypeChunk.getComponent(index, ChunkSection.getComponentType());
+
+            assert section != null;
+
+            BlockComponentChunk blockComponentChunk = (BlockComponentChunk) commandBuffer.getComponent(section.getChunkColumnReference(), BlockComponentChunk.getComponentType());
+
+            assert blockComponentChunk != null;
+
+            blocks.forEachTicking(blockComponentChunk, commandBuffer, section.getY(), (blockComponentChunk1, commandBuffer1, localX, localY, localZ, blockId) -> {
+                Ref<ChunkStore> blockRef = blockComponentChunk.getEntityReference(ChunkUtil.indexBlockInColumn(localX, localY, localZ));
+                if (blockRef == null) {
+                    return BlockTickStrategy.IGNORED;
+                } else {
+                    ExampleBlock exampleBlock = (ExampleBlock) commandBuffer1.getComponent(blockRef, ExampleBlock.getComponentType());
+                    if (exampleBlock != null) {
+                        WorldChunk worldChunk = (WorldChunk) commandBuffer.getComponent(section.getChunkColumnReference(), WorldChunk.getComponentType());
+                        World world = worldChunk.getWorld();
+
+                        int globalX = localX + (worldChunk.getX() * 32);
+                        int globalZ = localZ + (worldChunk.getZ() * 32);
+
+                        // We need to execute setBlock on the world thread as you cannot call store functions from a system
+                        // This is because of the architecture of the server, depending on your needs you can also use the CommandBuffer
+                        world.execute(() -> {
+                            world.setBlock(globalX + 1, localY, globalZ, "Rock_Ice");
+                        });
+
+                        return BlockTickStrategy.CONTINUE;
+
+                    } else {
+                        return BlockTickStrategy.IGNORED;
+                    }
+                }
+            });
+        }
+    }
+
+    @Nullable
+    public Query getQuery() {
+        return Query.and(BlockSection.getComponentType(), ChunkSection.getComponentType());;
+    }
+}
+```
+
+ExampleSystem is an EntityTickingSystem that runs every tick to execute the logic for all ticking blocks with the ExampleBlock component.
+
+**Key Points:**
+
+- **Get the block component**
+
+```java
+ExampleBlock exampleBlock = (ExampleBlock) commandBuffer.getComponent(blockRef, ExampleBlock.getComponentType());
+```
+
+- **Convert local chunk coordinates to world coordinates**
+
+```java
+int globalX = localX + (worldChunk.getX() * 32);
+int globalZ = localZ + (worldChunk.getZ() * 32);
+```
+
+- **Run the block logic**
+
+```java
+exampleBlock.runBlockAction(globalX, localY, globalZ, worldChunk.getWorld());
+```
+
+- **Keep the block ticking in the next tick**
+
+```java
+return BlockTickStrategy.CONTINUE;
+```
+
+---
+
+### 4. ExamplePlugin - registers components and systems
+
+```java
+public class ExamplePlugin extends JavaPlugin {
+    protected static ExamplePlugin instance;
+    private static final HytaleLogger LOGGER = HytaleLogger.forEnclosingClass();
+    private ComponentType exampleBlockComponentType;
+
+    public static ExamplePlugin get() {
+        return instance;
+    }
+
+    public ExamplePlugin(@Nonnull JavaPluginInit init) {
+        super(init);
+        LOGGER.atInfo().log("Hello from " + this.getName() + " version " + this.getManifest().getVersion().toString());
+    }
+
+    @Override
+    protected void setup() {
+        instance = this;
+        LOGGER.atInfo().log("Setting up plugin " + this.getName());
+        this.exampleBlockComponentType = this.getChunkStoreRegistry().registerComponent(ExampleBlock.class, "ExampleBlock", ExampleBlock.CODEC);
+    }
+	
+	@Override
+	protected void start() {
+		this.getChunkStoreRegistry().registerSystem(new ExampleSystem());
+		this.getChunkStoreRegistry().registerSystem(new ExampleInitializer());
+	}
+
+    public ComponentType getExampleBlockComponentType() {
+        return this.exampleBlockComponentType;
+    }
+}
+```
+
+---
+
+### 5. Configure In-Game
+
+![block-component-1](/assets/guides/block-component-1.png)
+
+![block-component-2](/assets/guides/block-component-2.png)
+
+With this logic, the block will now continuously place an Ice Block at the coordinates x + 1 relative to its current position every time it ticks.
+
+---
+
+## Common Issues
+
+### NullPointerException on Startup
+
+**Error message:**
+
+```java
+java.lang.NullPointerException: Cannot invoke "com.hypixel.hytale.component.query.Query.validateRegistry(com.hypixel.hytale.component.ComponentRegistry)" because "query" is null
+```
+
+**Cause:**
+This error occurs when your module is loaded **before** the required Hytale modules.
+
+**Fix:**
+Add `EntityModule` and `BlockModule` as dependencies in your `manifest.json` to ensure proper load order.
+
+```json
+"Dependencies": {
+  "Hytale:EntityModule": "*",
+  "Hytale:BlockModule": "*"
+}
+```
diff --git a/content/docs/pt-PT/guides/ecs/hytale-ecs-theory.mdx b/content/docs/pt-PT/guides/ecs/hytale-ecs-theory.mdx
index 20c3a94d..52d8b1f5 100644
--- a/content/docs/pt-PT/guides/ecs/hytale-ecs-theory.mdx
+++ b/content/docs/pt-PT/guides/ecs/hytale-ecs-theory.mdx
@@ -29,7 +29,7 @@ for now this is the basic understanding for the `ChunkStore`. You can use it to
 
 ## Holder
 
-A Holder is essentially a blueprint for an entity. Before an entity exists in the Store (and thus in the world), is exists as a `Holder`. It collects and holds all the necessary components (data). You can compare it analogous to shopping cart. You grab all components you need and once you have everything, check out at the store which will take your cart and create a valid entity ID and hand you back a receipt (a Ref).
+A Holder is essentially a blueprint for an entity. Before an entity exists in the Store (and thus in the world), it exists as a `Holder`. It collects and holds all the necessary components (data). You can compare it analogous to shopping cart. You grab all components you need and once you have everything, check out at the store which will take your cart and create a valid entity ID and hand you back a receipt (a Ref).
 
 Let's take a look at an example: initializing players. In `Universe`, the `addPlayer` method demonstrates it perfectly.
 When a player connects, we don't immediately throw them into the ECS. We first construct their data in a Holder.
@@ -167,7 +167,7 @@ MyComponent comp = commandBuffer.getComponent(ref, componentType);
 
 Codecs handle serialization and deserialization of components. Hytale uses them to save and load entity data to and from disk as well as sending component data over the network. When creating a custom component, you must also create a corresponding Codec.
 
-There are mutliple Codec types already implemented in the default Codec Interface:
+There are multiple Codec types already implemented in the default Codec Interface:
 
 - Codec.STRING
 - Codec.BOOLEAN
@@ -215,7 +215,7 @@ This might seem tedious at first but it ensures that your component can be corre
   KeyedCodec<Integer> exampleInt = new KeyedCodec<Integer>("ExampleIntIdForCodec", Codec.INTEGER);
   ```
 
-- **Setter Function**: This is a lambda function that takes an instance of your component and returns the value of the field you want to serialize. For example, if you have a field called `myCustomField` in your custom component, your getter function would look like this:
+- **Setter Function**: This is a lambda function that takes an instance of your component + the value to set and sets the field value on the component. For example, if you have a field called `myCustomField` in your custom component, your setter function would look like this:
   ```java
   (data, value) -> data.myCustomField = value
   ```
@@ -276,7 +276,7 @@ public class PoisonComponent implements Component<EntityStore> {
 
 You can also add validators to your Codec fields to ensure that the data being serialized/deserialized meets certain criteria. For example, if you want to ensure that the `damagePerTick` field is always non-negative or the poison name is never null, you can add a validator like this:
 
-````java
+```java
 .append(
     new KeyedCodec<Float>("DamagePerTick", Codec.FLOAT),
     (data, value) -> data.damagePerTick = value,
@@ -292,14 +292,15 @@ You can also add validators to your Codec fields to ensure that the data being s
 )
 .addValidator(Validators.nonNull())
 .add()
+```
 
 ### Complex Codec Examples
 
-If you want to have a map inside your component, you can use the MapCodec class to build a KeyedCoded for it. Here's an example of how to create a Codec for a Map field:
+If you want to have a map inside your component, you can use the MapCodec class to build a KeyedCodec for it. Here's an example of how to create a Codec for a Map field:
 
 ```java
 var damagePerTick = new KeyedCodec<>("DamagePerTick", new MapCodec<>(Codec.FLOAT, HashMap<String, Float>::new));
-````
+```
 
 <Callout type="info">
   This also works with custom Objects as long as you have a Codec defined for the Object type.
diff --git a/content/docs/pt-PT/guides/java-basics/00-introduction.mdx b/content/docs/pt-PT/guides/java-basics/00-introduction.mdx
index a03ad638..b0130d74 100644
--- a/content/docs/pt-PT/guides/java-basics/00-introduction.mdx
+++ b/content/docs/pt-PT/guides/java-basics/00-introduction.mdx
@@ -7,7 +7,7 @@ Welcome to your journey into Java Programming! This guide is designed to introdu
 
 ## What is Java?
 
-Java is a powerful, object-oriented programming language created in 1995. It's one of the most popular programming languages in the world and is used for everything from mobile apps to enterprise software. Most importantly for us, it's the language Hytale uses for it's servers & modding API.
+Java is a powerful, object-oriented programming language created in 1995. It's one of the most popular programming languages in the world and is used for everything from mobile apps to enterprise software. Most importantly for us, it's the language Hytale uses for its servers & modding API.
 
 ## What You'll Learn
 
diff --git a/content/docs/pt-PT/guides/java-basics/02-operators.mdx b/content/docs/pt-PT/guides/java-basics/02-operators.mdx
index a132b1c0..18634665 100644
--- a/content/docs/pt-PT/guides/java-basics/02-operators.mdx
+++ b/content/docs/pt-PT/guides/java-basics/02-operators.mdx
@@ -119,7 +119,7 @@ String greetingWithName = "Hello, " + name + "!"; // "Hello, Alice!"
 
 ## Operator Precedence
 
-Operator Precendence means which operator gets evaluated first in an line of code. Think of it like BODMAS/PEMDAS in math!
+Operator Precedence means which operator gets evaluated first in an line of code. Think of it like BODMAS/PEMDAS in math!
 
 ```java
 int result = 10 + 5 * 2; // result is 20, not 30
diff --git a/content/docs/pt-PT/guides/java-basics/03-control-flow-if.mdx b/content/docs/pt-PT/guides/java-basics/03-control-flow-if.mdx
index b9d6c479..af2d1c22 100644
--- a/content/docs/pt-PT/guides/java-basics/03-control-flow-if.mdx
+++ b/content/docs/pt-PT/guides/java-basics/03-control-flow-if.mdx
@@ -7,7 +7,7 @@ Programs need to make decisions. If statements let your code choose different pa
 
 ## Basic If Statement
 
-The simplest form checks one condition;
+The simplest form checks one condition:
 
 ```java
 int health = 20;
diff --git a/content/docs/pt-PT/guides/java-basics/08-access-modifiers.mdx b/content/docs/pt-PT/guides/java-basics/08-access-modifiers.mdx
index af560932..da2bf33b 100644
--- a/content/docs/pt-PT/guides/java-basics/08-access-modifiers.mdx
+++ b/content/docs/pt-PT/guides/java-basics/08-access-modifiers.mdx
@@ -484,7 +484,7 @@ class Data {
     // Static member:
     // cannot access to non-static variables
     public static void bar() {
-        x = 100; // Error: non-static variable x cannot be renference from a static context
+        x = 100; // Error: non-static variable x cannot be referenced from a static context
         y = 100; // OK
     }
 }
@@ -504,7 +504,7 @@ Data.x = 1000; // Error: cannot access instanced variables in a static context
 
 ### Static Fields
 
-A static field represents a data member owned by the class type rather then the object. Static fields are also stored in a specific memory location that's been shared between all the object instances that are created.
+A static field represents a data member owned by the class type rather than the object. Static fields are also stored in a specific memory location that's been shared between all the object instances that are created.
 
 It is declared as following:
 
diff --git a/content/docs/pt-PT/guides/plugin/animated-block-textures.mdx b/content/docs/pt-PT/guides/plugin/animated-block-textures.mdx
new file mode 100644
index 00000000..42bfa51f
--- /dev/null
+++ b/content/docs/pt-PT/guides/plugin/animated-block-textures.mdx
@@ -0,0 +1,101 @@
+---
+title: Animated Block Textures
+description: Learn how to attach a .blockyanim to a block
+authors:
+  - name: Burkino
+---
+
+import { File, Folder, Files } from 'fumadocs-ui/components/files';
+
+So, you want to make your blocks feel more alive through animations, do you?\
+Now for the most part this is the exact same as [Creating custom blocks](./creating-block).
+![blue fire gif](/assets/guides/blue_fire.gif)
+
+## Prerequisites
+
+This is NOT a guide on animating or texturing or even using BlockBench, why? Because I don't know how to do that.\
+The only thing we will be doing is taking the fire texture, changing the color, and applying it to our new fire block.
+
+## Setup
+
+To start, you're obviously going to want to grab the `Common/VFX/Fire/Fire.png` file. How you do it is up to you, in the Asset Editor you'll need to switch to the Common tab.\
+I'll assume you know how colorize or change the hue of an image, so go ahead and do that now and save it as `Blue_Fire.png`.
+
+The other assets used in this guide are `Common/VFX/Fire/Fire.blockymodel` and `Common/Blocks/Animations/Fire/Fire_Burn.blockyanim` (both renamed to `Blue_Fire`) but since we won't be changing them it's probably fine to leave them. I will reference the `Blue_Fire` versions as a way to point out what should be custom assets.\
+I will also duplicate `Server/Item/Item/Deco/Deco_Fire.json` and call it `Deco_Blue_Fire.json`.
+
+## Applying the changes
+
+The `Deco_Blue_Fire` block is actually just a particle emitter, however we will not be using particles, so lets start by removing them in `Block > Particles`.\
+Next we want to set the Block Model (called `CustomModel` in JSON) to `VFX/Blue_Fire/Blue_Fire.blockymodel` and Block Model Textures (`CustomModelTexture` in JSON) to
+
+```json
+[
+    {
+        "Texture": "VFX/Blue_Fire/Blue_Fire.png",
+        "Weight": 1
+    }
+]
+```
+
+Finally, we will apply the .blockyanim to our model, this is done through the Block Model Animation property (`CustomModelAnimation` in JSON) and the value should be `Blocks/Animations/Blue_Fire/Blue_Fire_Burn.blockyanim`.
+
+## Final Code
+
+With that your new blue fire should be done. Here is the minimal JSON for our blue fire.\
+There is an additional `Looping` and `RequiresAlphaBlending` property that I have not gone over, however I hope it is self-explanatory.
+
+```json
+{
+  "BlockType": {
+    "DrawType": "Model",
+    "CustomModel": "VFX/Blue_Fire/Blue_Fire.blockymodel",
+    "CustomModelAnimation": "Blocks/Animations/Blue_Fire/Blue_Fire_Burn.blockyanim",
+    "CustomModelTexture": [
+      {
+        "Texture": "VFX/Blue_Fire/Blue_Fire.png",
+        "Weight": 1
+      }
+    ],
+    "Looping": true,
+    "RequiresAlphaBlending": false
+  },
+  "PlayerAnimationsId": "Block"
+}
+```
+
+<Files>
+  <Folder name="resources" defaultOpen>
+    <Folder name="Server" defaultOpen>
+      <Folder name="Item" defaultOpen>
+        <Folder name="Items" defaultOpen>
+          <Folder name="Deco" defaultOpen>
+            <File name="Deco_Blue_Fire.json" />
+          </Folder>
+        </Folder>
+      </Folder>
+    </Folder>
+
+    <Folder name="Common" defaultOpen>
+      <Folder name="Blocks" defaultOpen>
+        <Folder name="Animations" defaultOpen>
+          <Folder name="Blue_Fire" defaultOpen>
+            <File name="Blue_Fire_Burn.blockyanim" />
+          </Folder>
+        </Folder>
+      </Folder>
+
+      <Folder name="VFX" defaultOpen>
+        <Folder name="Blue_Fire" defaultOpen>
+          <File name="Blue_Fire.blockymodel" />
+
+          <File name="Blue_Fire.png" />
+        </Folder>
+      </Folder>
+    </Folder>
+  </Folder>
+</Files>
+
+## Next steps
+
+Now that you know how to attach an animation to a block, try adding it to a block state.
diff --git a/content/docs/pt-PT/guides/plugin/build-and-test.mdx b/content/docs/pt-PT/guides/plugin/build-and-test.mdx
index 0e7fe7eb..f37534c3 100644
--- a/content/docs/pt-PT/guides/plugin/build-and-test.mdx
+++ b/content/docs/pt-PT/guides/plugin/build-and-test.mdx
@@ -9,18 +9,18 @@ If you followed along with the [Setting Up Your Development Environment](./setti
 
 ## Building Your Mod
 
-In our case, we've **Maven** as the build system. Maven is a powerful build automation tool that manages dependencies, compiles your code, and packages everything into a distributable JAR file.
+In our case, we've **Gradle** as the build system. Gradle is a powerful build automation tool that manages dependencies, compiles your code, and packages everything into a distributable JAR file.
 
-### Understanding Maven
+### Understanding Gradle
 
-Maven uses a `pom.xml` file (Project Object Model) to define your project's configuration, dependencies, and build settings. You can learn more about Maven at the [official Apache Maven website](https://maven.apache.org/).
+Gradle can use a `build.gradle.kts` file (Kotlin DSL) to define your project's configuration, dependencies, and build settings. You can learn more about Gradle at the [official Gradle website](https://gradle.org/).
 
-### Building with Maven
+### Building with Gradle
 
 To build your mod, open a terminal in your project directory and run:
 
 ```bash
-mvn package
+./gradlew build
 ```
 
 This command will:
@@ -29,16 +29,35 @@ This command will:
 2. Run any tests (if present)
 3. Package everything into a JAR file
 
+<Callout type="info">
+  If you are using the plugin template from the [Setting Up Your Development Environment](./setting-up-env) guide, then the build script is already set up for you. It includes paths to your Hytale game library and handles the packaging of your mod, managing hytale dependencies and manifest changes.
+
+  If you have a different path to your Hytale installation, you may receive the following error:
+
+  ```bash
+  FAILURE: Build failed with an exception.
+
+  * What went wrong:
+  Failed to find Hytale at the expected location. Please make sure you have installed the game. The expected location can be changed using the hytale.home_path property. Currently looking in 'C:\Path\To\Hytale'
+  ```
+
+  You can change the path by adding a property to your `gradle.properties` file (if it doesn't exist, create it in the root of your project):
+
+  ```properties
+  hytale.home_path=C:\Correct\Path\To\Hytale
+  ```
+</Callout>
+
 ### Build Output
 
-Once the build completes successfully, your mod will be located in the `target` directory and named:
+Once the build completes successfully, your mod will be located in the `build/libs` directory and named:
 
 ```
-ExamplePlugin-1.0-SNAPSHOT.jar
+ExamplePlugin-1.0.jar
 ```
 
 <Callout type="info">
-  The exact name may vary depending on what you configured in your `pom.xml` file. Check the `artifactId` and `version` fields to see what your JAR will be named.
+  The exact name may vary depending on what you configured in your `build.gradle.kts` and `settings.gradle.kts` file. Check the `rootProject.name` and `version` fields to see what your JAR will be named.
 </Callout>
 
 ## Testing Your Mod
@@ -49,11 +68,11 @@ Now that you've built your mod, it's time to test it in Hytale!
 
 First, you need to find Hytale's mods directory:
 
-1. Press **Win + R** on your keyboard
-2. Type `%appdata%` and press Enter
-3. Navigate to: `Hytale\UserData\Mods`
+1. Go to your Hytale installation directory (The default location is usually in your AppData folder)
+   > On Windows, you can access it by clicking `windows + R` and typing `%appdata%`.
+2. Navigate to: `/UserData/Mods`
 
-The full path should look like:
+The default path would look like:
 
 ```
 C:\Users\YourUsername\AppData\Roaming\Hytale\UserData\Mods
@@ -65,7 +84,7 @@ C:\Users\YourUsername\AppData\Roaming\Hytale\UserData\Mods
 
 ### 2. Copy Your Mod
 
-Copy the `ExamplePlugin-1.0-SNAPSHOT.jar` file from your project's `target` directory into the `Mods` folder you just located.
+Copy the `ExamplePlugin-1.0.jar` file from your project's `build/libs` directory into the `Mods` folder you just located.
 
 ### 3. Launch Hytale and Verify
 
@@ -84,7 +103,7 @@ If your mod doesn't appear in the mods list:
 - Make sure the JAR file is in the correct `Mods` folder
 - Check that your `manifest.json` file is properly configured
 - Look for any error messages in the Hytale logs
-- Verify that you're using the correct version of Java and Maven
+- Verify that you're using the correct version of Java and Gradle
 
 ## Next Steps
 
diff --git a/content/docs/pt-PT/guides/plugin/creating-commands.mdx b/content/docs/pt-PT/guides/plugin/creating-commands.mdx
index d33597f3..08572f16 100644
--- a/content/docs/pt-PT/guides/plugin/creating-commands.mdx
+++ b/content/docs/pt-PT/guides/plugin/creating-commands.mdx
@@ -8,6 +8,8 @@ authors:
     url: https://oskar.scot
   - name: jacobwojoski
     url: https://github.com/jacobwojoski
+  - name: Marcel-TO
+    url: https://marcel-to.net
 ---
 
 In this guide, you will learn how to create custom commands for your Hytale mod.
@@ -36,7 +38,7 @@ The most basic command is an `AbstractAsyncCommand`. It has very minimal data av
   `AbstractAsyncCommand` runs on its own background thread. This means its execute is not tied to any world instance and because of this it can not edit any **Stores** or **Refs** without getting the desired world first. To access this data any of the other command types would be preferred and are likely what you will want to use instead.
 </Callout>
 
-The main purpose for a command like this would be for something that can happen everywhere and is not tied to a specific world. For example a `serverRules` command to tell the user thats running the command in chat what the servers rules are nomatter what world they are in.
+The main purpose for a command like this would be for something that can happen everywhere and is not tied to a specific world. For example a `serverRules` command to tell the user that's running the command in chat what the server's rules are no matter what world they are in.
 
 ```java
 // Command that can be run that lists the server rules in chat to the player
@@ -49,7 +51,7 @@ public class ServerRulesCommand extends AbstractAsyncCommand {
     }
 
     // Run the command
-    // conetext - info about who ran the command. Server console?, Some player?
+    // context - info about who ran the command. Server console?, Some player?
     @Override
     protected CompletableFuture<Void> executeAsync(@Nonnull CommandContext context) {
         context.sendMessage(Message.raw("The only rule is there are no rules."));
@@ -134,7 +136,7 @@ Uses a Ray to see what the player is looking at and tries to run the command on
 
 ## Adding Arguments
 
-Arguments are additional fields that the user can input when running a command. The different types of arguments along with small snipits and a large example can be seen below.
+Arguments are additional fields that the user can input when running a command. The different types of arguments along with small snippets and a large example can be seen below.
 
 ### Command Argument Types
 
@@ -163,14 +165,14 @@ this.messageArg = this.withOptionalArg("message", "Message to print while healin
 
 ### Default Arguments
 
-Adding a default argument has two additional arguemnt for the default value and default value description. You need to use `withDefaultArg` method.
+Adding a default argument has two additional argument for the default value and default value description. You need to use `withDefaultArg` method.
 
 ```java
 // args <Command String> <Description> <Default Value> <Desc of default value>
 this.healthArg = this.withDefaultArg("health", "Amount to heal player", ArgTypes.FLOAT, (float)100, "Desc of Default: 100");
 ```
 
-### Flag Arguemnts
+### Flag Arguments
 
 Similar as above but the flags return is either true if it exists or false if it does not. You need to use `withFlagArg` method.
 
@@ -181,20 +183,13 @@ this.debugArg = this.withFlagArg("debug", "Add debug logs");
 
 ### ArgTypes
 
-The following ArgTypes are available (only lists common types):
-
-- `ArgTypes.STRING`
-- `ArgTypes.INTEGER`
-- `ArgTypes.BOOLEAN`
-- `ArgTypes.FLOAT`
-- `ArgTypes.DOUBLE`
-- `ArgTypes.UUID`
+You can find all the available argument types on the [ArgTypes](../../argtypes) page.
 
 ### Example Command Arg Types
 
-Shows all Command arguemnt types with different various input types.
+Shows all Command argument types with different various input types.
 
-**NOTE:** When getting the value of an argument during execute you need to pass the context with `someArg.get(commandContext)`. Where `commandContext` is the first variable in the execute funtion.
+**NOTE:** When getting the value of an argument during execute you need to pass the context with `someArg.get(commandContext)`. Where `commandContext` is the first variable in the execute function.
 
 ```java
 // Example usage: /healplayer --health 50 --message "Feels Good" --debug
@@ -204,7 +199,7 @@ public class HealPlayerCommand extends AbstractTargetPlayerCommand {
     private final FlagArg debugArg;
 
     public HealPlayerCommand() {
-        super("healplayer", "Healing a player for an <input> ammount of HP (default: 100)");
+        super("healplayer", "Healing a player for an <input> amount of HP (default: 100)");
 
         // Abstract TargetPlayerCommand passes the player that ran the command by default and implements
         // the use of `--player <value>` to specify someone else
@@ -213,10 +208,10 @@ public class HealPlayerCommand extends AbstractTargetPlayerCommand {
         this.healthArg = this.withDefaultArg("health", "Amount to heal player", ArgTypes.FLOAT, (float)100, "Desc of Default: 100");
 
         // Or you could do the following making the health value required instead of with a default.
-        //    You would need to change the decleration to RequiredArg<Float>
+        //    You would need to change the declaration to RequiredArg<Float>
         // this.healthArg = this.withRequiredArg("health", "Amount to heal player", ArgTypes.FLOAT);
 
-        // Optional args reguare the user the input `--<key> <value>` so the following would require `--message "Good Luck"`
+// Optional args require the user the input `--<key> <value>` so the following would require `--message "Good Luck"`
         this.messageArg = this.withOptionalArg("message", "Message to print while healing", ArgTypes.STRING);
 
         // No type needed due to being a bool
@@ -230,7 +225,7 @@ public class HealPlayerCommand extends AbstractTargetPlayerCommand {
             commandContext.sendMessage(Message.raw("We are debugging"));
         }
 
-        // Health is stored in a generic stat map to allowing mods/future contect to easily add more stats if desired.
+        // Health is stored in a generic stat map to allowing mods/future content to easily add more stats if desired.
         EntityStatMap stats = store.getComponent(ref, EntityStatMap.getComponentType());
         int healthIdx = DefaultEntityStatTypes.getHealth();
         EntityStatValue health = stats.get(healthIdx);
@@ -252,7 +247,7 @@ public class HealPlayerCommand extends AbstractTargetPlayerCommand {
 
 ## Argument Validators
 
-Argument validators are a way to check the command before the command gets executed. They are added with the `addValidator` method on an argument when calling `withXxxArg`. They provide a nice output to the user when an input value is invalid.
+Argument validators are a way to check the command before the command gets executed. They are added with the `addValidator` method on an argument when calling `withXxxArg`. They provide a nice output to the user when an input value is invalid. There are some common validators provided in the `Validators` class such as `greaterThan`, `lessThan`, and `or`, `max`, `range`, etc.
 
 ```java
 ...
@@ -260,18 +255,59 @@ Argument validators are a way to check the command before the command gets execu
     OptionalArg<Integer> healAmount = withOptionalArg("amount", "Heal Amount", ArgTypes.INTEGER)
         .addValidator(Validators.greaterThan(0))
         .addValidator(Validators.lessThan(1000));
-
-    // Custom check example
-    OptionalArg<Integer> healAmount = withOptionalArg("amount", "Heal Amount", ArgTypes.INTEGER)
-            .addValidator( value -> {
-                if (value != null && value <= 0) {
-                    return ValidationResult.error("ammount argument must be a positive number");
-                }
-                return ValidationResult.success();
-            });
 ...
 ```
 
+### Custom Validators
+
+You can also create custom validators by implementing the `com.hypixel.hytale.codec.validation.Validator` interface. The interfaces forces you to implement the `accept` and `updateSchema` method. The `accept` method takes in the argument value and validates it. If the validation fails, you can use the `fail` method of the `com.hypixel.hytale.codec.validation.ValidationResults` class to return an error message.
+The `updateSchema` method is used to update the schema of the command argument. This is used for commands that have dynamic schemas based on the input value. For example, if you have a command that takes in a player name as an argument, you can use the `updateSchema` method to update the schema to include a list of online players for validation.
+
+Here is an example of a custom validator that checks if a string value is equal to a banned word. In this example, the banned word is "badword". If the input value is "badword", the validator will fail and return an error message.
+
+```java
+import com.hypixel.hytale.codec.schema.SchemaContext;
+import com.hypixel.hytale.codec.schema.config.Schema;
+import com.hypixel.hytale.codec.validation.ValidationResults;
+import com.hypixel.hytale.codec.validation.Validator;
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+
+public class MyCustomValidator implements Validator<String> {
+    @Nonnull
+    private final String value;
+
+    public MyCustomValidator(@Nonnull String value) {
+        this.value = value;
+    }
+
+    @Override
+    public void accept(@Nullable String input, @Nonnull ValidationResults results) {
+        if (this.value.equalsIgnoreCase(input)) {
+            results.fail("The given role has been banned.");
+        }
+    }
+
+    @Override
+    public void updateSchema(SchemaContext context, @Nonnull Schema target) {
+        // This method can be used to update the schema of the command argument. This is useful for commands that have dynamic schemas based on the input value. For example, if you have a command that takes in a player name as an argument, you can use the `updateSchema` method to update the schema to include a list of online players for validation.
+        throw new UnsupportedOperationException("Not implemented yet.");
+    }
+}
+```
+
+After the custom validator is created, you can add it to an argument like the following example. In this example, we add the `MyCustomValidator` to a string argument called "role". If the user inputs "badword" as the role, the command will fail and return the error message defined in the `MyCustomValidator`.
+
+```java
+    ...
+    // Custom validator example
+    String bannedRole = "badword";
+
+    OptionalArg<String> roleArg = withOptionalArg("role", "Role to assign", ArgTypes.STRING)
+        .addValidator(new MyCustomValidator(bannedRole));
+    ...
+```
+
 ---
 
 ## Permissions
@@ -312,7 +348,7 @@ This allows the server to control who has access to specific commands. You add t
 
 If you want variants of the same command without doing argument parsing you can instead use `addUsageVariant(new OtherCommandClass())` in the original commands constructor.
 
-The only difference is in the `OtherCommandClass()` constrcutor you don't pass the command name to the super class.
+The only difference is in the `OtherCommandClass()` constructor you don't pass the command name to the super class.
 
 <Callout type="info">
   You can also use `addAliases("some_alias", "some_other_alias")` as a way to add shorthand or other ways to write the same command.
@@ -387,7 +423,7 @@ public class AdminCommand extends AbstractCommandCollection {
     public AdminCommand () {
         super("admin", "Admin commands");
         addSubCommand(new UserCommandCollection());
-        addSybCommand(new ServerCommandCollection);
+        addSubCommand(new ServerCommandCollection);
     }
 }
 ```
@@ -417,5 +453,5 @@ public class MyPlugin extends JavaPlugin {
 
 ## Video Link
 
-_Special Thanks to [TroubleDev](https://www.youtube.com/@TroubleDEV) for his excelent video guide on all of these features._
+_Special Thanks to [TroubleDev](https://www.youtube.com/@TroubleDEV) for his excellent video guide on all of these features._
 _Video Link: [TroubleDev - Hytale's Command API Explained](https://www.youtube.com/watch?v=KnmhG9MDMgo)_
diff --git a/content/docs/pt-PT/guides/plugin/creating-events.mdx b/content/docs/pt-PT/guides/plugin/creating-events.mdx
index 95863990..d3f0925d 100644
--- a/content/docs/pt-PT/guides/plugin/creating-events.mdx
+++ b/content/docs/pt-PT/guides/plugin/creating-events.mdx
@@ -1,6 +1,6 @@
 ---
-title: Creating Events
-description: Learn how to create custom events for your Hytale mod.
+title: Creating Events Listeners
+description: Learn how to create event listeners for your Hytale mod.
 authors:
   - name: Neil Revin
     url: https://itsneil.dev
@@ -10,7 +10,7 @@ authors:
 
 ## Event Class
 
-You can import a Event class and create a function with the Event as a argument. [Click here](../../server/events) to look at all available events.
+You can import an Event class and create a function with the Event as an argument. [Click here](../../server/events) to look at all available events.
 
 Example plugin when a player is ready (joins a server):
 
diff --git a/content/docs/pt-PT/guides/plugin/item-registry.mdx b/content/docs/pt-PT/guides/plugin/item-registry.mdx
new file mode 100644
index 00000000..9a0fd53a
--- /dev/null
+++ b/content/docs/pt-PT/guides/plugin/item-registry.mdx
@@ -0,0 +1,95 @@
+---
+title: Working with the Item Registry
+description: Learn how to access and query the game's item registry to list all items, check if items exist, and retrieve item properties.
+authors:
+  - name: Denis
+---
+
+In this guide, you'll learn how to work with Hytale's Item Registry system. This is useful when you need to programmatically list all available items, validate item IDs, or retrieve item properties at runtime.
+
+## Prerequisites
+
+Before diving in, you should be familiar with:
+
+- [Setting up your development environment](./setting-up-env)
+- [Creating commands](./creating-commands) (optional, for testing)
+
+## Required Imports
+
+To work with the Item Registry, you'll need the following imports:
+
+```java
+import com.hypixel.hytale.assetstore.map.DefaultAssetMap;
+import com.hypixel.hytale.server.core.asset.type.item.config.Item;
+```
+
+## Getting the Item Registry
+
+The Item Registry is accessed through the `Item.getAssetMap()` method, which returns a `DefaultAssetMap<String, Item>` containing all registered items in the game:
+
+```java
+DefaultAssetMap<String, Item> itemMap = Item.getAssetMap();
+```
+
+## Listing All Items
+
+To iterate through all items in the registry, you can get the underlying map and loop through its entries:
+
+```java
+DefaultAssetMap<String, Item> itemMap = Item.getAssetMap();
+var map = itemMap.getAssetMap();
+
+for (var entry : map.entrySet()) {
+    String itemId = String.valueOf(entry.getKey());
+    Item item = entry.getValue();
+    
+    // Do something with the item
+    LOGGER.atInfo().log("Item ID: " + itemId);
+}
+```
+
+You can also get the total count of registered items:
+
+```java
+int totalItems = map.size();
+```
+
+## Checking if an Item Exists
+
+To check if a specific item exists in the registry, use `getAsset()` and verify the result:
+
+```java
+public boolean itemExists(String itemId) {
+    var assetMap = Item.getAssetMap();
+    if (assetMap != null) {
+        Item item = assetMap.getAsset(itemId);
+        return item != null && item != Item.UNKNOWN;
+    }
+    return false;
+}
+```
+
+<Callout type="info">
+  The `Item.UNKNOWN` constant represents an invalid or unrecognized item. Always check for both `null` and `Item.UNKNOWN` when validating items.
+</Callout>
+
+## Accessing Item Properties
+
+Once you have an `Item` instance, you can access various properties:
+
+```java
+var assetMap = Item.getAssetMap();
+Item item = assetMap.getAsset("Soil_Grass");
+
+if (item != null && item != Item.UNKNOWN) {
+    String id = item.getId(); // Soil_Grass
+    int maxStack = item.getMaxStack(); // 100
+    boolean isBlock = item.hasBlockType(); // true
+    boolean isConsumable = item.isConsumable(); // false
+}
+```
+
+## Related Guides
+
+- [Inventory Management](./inventory-management) - Learn how to add and remove items from player inventories
+- [Create Custom Item and Interaction](./item-interaction) - Learn how to create your own custom items
diff --git a/content/docs/pt-PT/guides/plugin/permission-management.mdx b/content/docs/pt-PT/guides/plugin/permission-management.mdx
index 6b7cfd46..55f06101 100644
--- a/content/docs/pt-PT/guides/plugin/permission-management.mdx
+++ b/content/docs/pt-PT/guides/plugin/permission-management.mdx
@@ -10,132 +10,569 @@ authors:
     link: https://discord.com/users/292656109939064833
   - name: Ivan
     link: https://discord.com/users/505770451218333717
+  - name: ZenithDevHQ
+    link: https://github.com/ZenithDevHQ
 ---
 
-In this guide, you'll learn how to manage permission nodes and groups in your Hytale plugin.
+In this guide, you'll learn how to manage permission nodes and groups in your Hytale plugin. Permissions control what actions players can perform on your server, from basic commands to advanced administrative functions.
 
-## The `PermissionsModule` class
+## What Are Permissions?
 
-The `PermissionsModule` class is responsible for managing permission nodes and groups in your plugin. It provides methods to check, grant and revoke permissions and groups for players. It allows the following operations
+Permissions are string identifiers that control access to features and commands. When a player tries to perform an action (like using a command), the server checks if they have the required permission.
 
-- Add permissions to user
-- Remove permissions from user
-- Add permissions to group (this also creates the group if it doesn't exist)
-- Remove permissions from group
-- Add user to group
-- Remove user from group
-- List all groups for a user
-- Check if a user has a permission (it checks both user and group permissions for the given player UUID)
+**Example permission nodes:**
 
-With this class you cannot:
+- `hytale.command.gamemode` - Permission to use the gamemode command
+- `hytale.editor.brush.use` - Permission to use brush tools
+- `myplugin.teleport.home` - A custom permission for your plugin
 
-- List all defined groups
-- Remove a group
+Permissions follow a hierarchical naming pattern: `namespace.category.action`
 
-### Adding Permission Nodes
+## Key Concepts
 
-You need a `Set<String>` containing all the permission nodes you want to add, these are added on top of the already existing permission nodes the user may have, it is not a replacement.
+Before diving into code, let's understand the core concepts:
+
+| Concept             | Description                                                                |
+| ------------------- | -------------------------------------------------------------------------- |
+| **Permission Node** | A string like `myplugin.feature.use` that represents a specific permission |
+| **Group**           | A named collection of permissions (e.g., "Admin", "VIP", "Default")        |
+| **Provider**        | The backend that stores and retrieves permissions                          |
+| **Wildcard**        | A pattern like `*` or `myplugin.*` that matches multiple permissions       |
+
+### How Permissions Are Checked
+
+When checking if a player has a permission, Hytale follows this order:
+
+1. **User's direct permissions** - Permissions granted directly to the player
+2. **Group permissions** - Permissions from groups the player belongs to
+3. **Virtual groups** - Game-mode-based permissions (e.g., Creative mode grants builder tools)
+4. **Default value** - Falls back to `false` if no match found
+
+<Callout type="info">
+  The first definitive match wins. If a player has a permission granted at the user level, group permissions won't override it.
+</Callout>
+
+---
+
+## The `PermissionsModule` Class
+
+The `PermissionsModule` class is the central hub for managing permissions. Access it using the singleton pattern:
 
 ```java
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.addUserPermission(playerUUID, permissions);
 ```
 
-### Removing Permission Nodes
+### Available Operations
+
+The module supports these operations:
+
+| Operation                     | Method                                          |
+| ----------------------------- | ----------------------------------------------- |
+| Add permissions to user       | `addUserPermission(uuid, permissions)`          |
+| Remove permissions from user  | `removeUserPermission(uuid, permissions)`       |
+| Add permissions to group      | `addGroupPermission(groupName, permissions)`    |
+| Remove permissions from group | `removeGroupPermission(groupName, permissions)` |
+| Add user to group             | `addUserToGroup(uuid, groupName)`               |
+| Remove user from group        | `removeUserFromGroup(uuid, groupName)`          |
+| Get user's groups             | `getGroupsForUser(uuid)`                        |
+| Check permission              | `hasPermission(uuid, permissionNode)`           |
+
+<Callout type="warning">
+  The module does **not** support:
+
+  - Listing all defined groups
+  - Deleting a group entirely
+
+  Groups are implicitly created when you first add permissions to them.
+</Callout>
+
+---
 
-Same as above, we just use the `removeUserPermission` method instead to remove permission nodes.
+## Checking Permissions
+
+The most common operation is checking if a player has a permission.
+
+### Basic Permission Check
+
+```java
+// Returns true if player has the permission, false otherwise
+boolean canUse = PermissionsModule.get().hasPermission(playerUUID, "myplugin.feature.use");
+
+if (canUse) {
+    // Player has permission, allow the action
+} else {
+    // Player lacks permission, deny or show error
+}
+```
+
+### Permission Check with Default Value
+
+You can specify what to return when no permission is explicitly set:
+
+```java
+// Returns true by default if no explicit permission is found
+boolean canUse = PermissionsModule.get().hasPermission(playerUUID, "myplugin.feature.use", true);
+```
+
+This is useful for features that should be enabled by default but can be revoked.
+
+### Using PermissionHolder Interface
+
+Players and command senders implement `PermissionHolder`, allowing direct checks:
+
+```java
+// In a command or event handler where you have access to the player
+if (player.hasPermission("myplugin.admin.manage")) {
+    // Player has admin permission
+}
+```
+
+---
+
+## Managing User Permissions
+
+### Adding Permissions to a User
+
+Permissions are additive - new permissions are added on top of existing ones, not replaced.
+
+```java
+PermissionsModule perms = PermissionsModule.get();
+
+// Add a single permission
+perms.addUserPermission(playerUUID, Set.of("myplugin.vip.chat"));
+
+// Add multiple permissions at once
+Set<String> newPerms = Set.of(
+    "myplugin.vip.chat",
+    "myplugin.vip.fly",
+    "myplugin.vip.kit"
+);
+perms.addUserPermission(playerUUID, newPerms);
+```
+
+### Removing Permissions from a User
 
 ```java
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.removeUserPermission(playerUUID, permissions);
+
+// Remove specific permissions
+Set<String> toRemove = Set.of("myplugin.vip.fly");
+perms.removeUserPermission(playerUUID, toRemove);
 ```
 
-### Add permissions to group
+---
+
+## Managing Groups
+
+Groups let you assign a collection of permissions to multiple players. This is more manageable than assigning permissions individually.
+
+### Adding Permissions to a Group
+
+If the group doesn't exist, it will be created automatically.
 
 ```java
-String groupName = "testGroup";
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.addGroupPermission(groupName, permissions);
+
+// Create/update the "VIP" group with permissions
+Set<String> vipPerms = Set.of(
+    "myplugin.vip.chat",
+    "myplugin.vip.fly",
+    "myplugin.vip.kit"
+);
+perms.addGroupPermission("VIP", vipPerms);
 ```
 
-### Remove permissions from group
+### Removing Permissions from a Group
 
 ```java
-String groupName = "testGroup";
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.removeGroupPermission(groupName, permissions);
+
+// Remove specific permissions from the group
+Set<String> toRemove = Set.of("myplugin.vip.fly");
+perms.removeGroupPermission("VIP", toRemove);
 ```
 
-### Add user to group
+### Adding a User to a Group
 
 ```java
-String groupName = "testGroup";
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.addUserToGroup(playerUUID, groupName);
+
+// Add player to the VIP group - they now have all VIP permissions
+perms.addUserToGroup(playerUUID, "VIP");
 ```
 
-### Remove user from group
+### Removing a User from a Group
 
 ```java
-String groupName = "testGroup";
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.removeUserFromGroup(playerUUID, groupName);
+
+// Remove player from VIP group
+perms.removeUserFromGroup(playerUUID, "VIP");
 ```
 
-### List all groups for a user
+### Getting a User's Groups
 
 ```java
 PermissionsModule perms = PermissionsModule.get();
-perms.getGroupsForUser(playerUUID);
+
+// Get all groups the player belongs to
+Set<String> groups = perms.getGroupsForUser(playerUUID);
+
+for (String group : groups) {
+    System.out.println("Player is in group: " + group);
+}
 ```
 
-### Check Permission Nodes
+---
+
+## Built-in Groups
+
+Hytale includes two default groups:
+
+| Group     | Default Permissions   | Purpose                           |
+| --------- | --------------------- | --------------------------------- |
+| `OP`      | `*` (all permissions) | Server operators with full access |
+| `Default` | None                  | Base group for all players        |
+
+Players without any explicit group assignment are automatically part of the `Default` group.
 
-To check if a player has a specific permission node, you can use the `hasPermission` method.
+---
+
+## Wildcards
+
+Wildcards let you grant or deny multiple permissions with a single pattern.
+
+### Wildcard Patterns
+
+| Pattern             | Meaning                                          |
+| ------------------- | ------------------------------------------------ |
+| `*`                 | Grants **all** permissions                       |
+| `myplugin.*`        | Grants all permissions starting with `myplugin.` |
+| `-*`                | Denies **all** permissions                       |
+| `-myplugin.admin.*` | Denies all admin permissions in your plugin      |
+
+### Example: Admin Group with Wildcards
 
 ```java
-boolean hasPermission = PermissionsModule.hasPermission(playerUUID, "permission.node");
+// Grant all permissions to admins
+perms.addGroupPermission("Admin", Set.of("*"));
+
+// Grant all plugin permissions to moderators
+perms.addGroupPermission("Moderator", Set.of("myplugin.*"));
+
+// Grant all permissions except admin commands
+perms.addGroupPermission("Helper", Set.of(
+    "*",
+    "-myplugin.admin.*"  // Deny admin permissions
+));
 ```
 
-## Additional: Defining your own provider for permissions and groups
+<Callout type="warning">
+  Negation permissions (starting with `-`) take precedence at each level. Use them carefully to avoid accidentally blocking permissions.
+</Callout>
+
+---
+
+## Built-in Permission Nodes
+
+Hytale provides constants for common permissions in the `HytalePermissions` class:
+
+### Command Permissions
+
+```java
+// Generate permission for a command
+String perm = HytalePermissions.fromCommand("gamemode");
+// Result: "hytale.command.gamemode"
+
+// Generate permission for a subcommand
+String perm = HytalePermissions.fromCommand("gamemode", "creative");
+// Result: "hytale.command.gamemode.creative"
+```
+
+### Common Permission Nodes
+
+| Permission                    | Description                  |
+| ----------------------------- | ---------------------------- |
+| `hytale.command.op.add`       | Add players to OP group      |
+| `hytale.command.op.remove`    | Remove players from OP group |
+| `hytale.editor.brush.use`     | Use brush tools              |
+| `hytale.editor.prefab.use`    | Use prefabs                  |
+| `hytale.editor.selection.use` | Use selection tools          |
+| `hytale.editor.history`       | Undo/redo operations         |
+| `hytale.camera.flycam`        | Use fly camera mode          |
+
+---
+
+## Listening to Permission Events
+
+You can react to permission changes using Hytale's event system.
+
+### Available Events
+
+| Event                                            | Triggered When                   |
+| ------------------------------------------------ | -------------------------------- |
+| `PlayerPermissionChangeEvent.PermissionsAdded`   | Permissions added to a user      |
+| `PlayerPermissionChangeEvent.PermissionsRemoved` | Permissions removed from a user  |
+| `PlayerGroupEvent.Added`                         | User added to a group            |
+| `PlayerGroupEvent.Removed`                       | User removed from a group        |
+| `GroupPermissionChangeEvent.Added`               | Permissions added to a group     |
+| `GroupPermissionChangeEvent.Removed`             | Permissions removed from a group |
 
-The PermissionsModule also enables us to define our own PermissionProvider's, this can be useful for:
+### Example: Reacting to Permission Changes
 
-- Cross server permission systems
-- Implementing features missing in the `HytalePermissionsProvider` like permission expiry
+```java
+public class PermissionListener {
+
+    public static void onPermissionsAdded(PlayerPermissionChangeEvent.PermissionsAdded event) {
+        UUID playerUUID = event.getPlayerUuid();
+        Set<String> added = event.getAddedPermissions();
+
+        System.out.println("Permissions added to " + playerUUID + ": " + added);
 
-To implement our PermissionProvider, first we need to define a provider class that implements PermissionProvider:
+        // Maybe notify the player or update cached data
+    }
+
+    public static void onGroupAdded(PlayerGroupEvent.Added event) {
+        UUID playerUUID = event.getPlayerUuid();
+        String groupName = event.getGroupName();
+
+        System.out.println("Player " + playerUUID + " joined group: " + groupName);
+    }
+}
+```
+
+### Registering the Events
 
 ```java
-public class DatabasePermissionProvider implements PermissionProvider
+public class MyPlugin extends JavaPlugin {
+
+    @Override
+    public void setup() {
+        EventRegistry events = this.getEventRegistry();
+
+        events.registerGlobal(
+            PlayerPermissionChangeEvent.PermissionsAdded.class,
+            PermissionListener::onPermissionsAdded
+        );
+
+        events.registerGlobal(
+            PlayerGroupEvent.Added.class,
+            PermissionListener::onGroupAdded
+        );
+    }
+}
 ```
 
-Then we just implement the required methods using a database implementation.
+---
+
+## Creating a Custom Permission Provider
+
+For advanced use cases, you can create your own permission provider. This is useful for:
+
+- Database-backed permissions (MySQL, MongoDB, etc.)
+- Cross-server permission synchronization
+- Custom features like permission expiry or contexts
+
+### Implementing PermissionProvider
+
+```java
+public class DatabasePermissionProvider implements PermissionProvider {
+
+    @Nonnull
+    @Override
+    public String getName() {
+        return "DatabasePermissionProvider";
+    }
+
+    // User permission methods
+    @Override
+    public void addUserPermissions(@Nonnull UUID uuid, @Nonnull Set<String> permissions) {
+        // Save to your database
+    }
+
+    @Override
+    public void removeUserPermissions(@Nonnull UUID uuid, @Nonnull Set<String> permissions) {
+        // Remove from your database
+    }
+
+    @Override
+    public Set<String> getUserPermissions(@Nonnull UUID uuid) {
+        // Query your database
+        return Set.of();
+    }
+
+    // Group permission methods
+    @Override
+    public void addGroupPermissions(@Nonnull String group, @Nonnull Set<String> permissions) {
+        // Save to your database
+    }
+
+    @Override
+    public void removeGroupPermissions(@Nonnull String group, @Nonnull Set<String> permissions) {
+        // Remove from your database
+    }
+
+    @Override
+    public Set<String> getGroupPermissions(@Nonnull String group) {
+        // Query your database
+        return Set.of();
+    }
+
+    // User-group membership methods
+    @Override
+    public void addUserToGroup(@Nonnull UUID uuid, @Nonnull String group) {
+        // Save to your database
+    }
+
+    @Override
+    public void removeUserFromGroup(@Nonnull UUID uuid, @Nonnull String group) {
+        // Remove from your database
+    }
+
+    @Override
+    public Set<String> getGroupsForUser(@Nonnull UUID uuid) {
+        // Query your database
+        return Set.of("Default");
+    }
+}
+```
 
 <Callout type="warning">
-  Hytale will try to use the first available permissions provider to add/remove gamemode groups (i.e. `Creative`, `Adventure`).
+  Hytale automatically assigns players to game-mode groups (like `Creative` or `Adventure`) using the first available provider.
+
+  If your provider throws an error when the group doesn't exist, the player will be disconnected! Always handle missing groups gracefully.
+</Callout>
+
+### Registering Your Provider
 
-  If your provider throws an error (for instance, if the group does not exist) when the server is preparing the player, the player will be disconnected.
+```java
+public class MyPlugin extends JavaPlugin {
+
+    @Override
+    public void setup() {
+        // Add your provider alongside the default one
+        PermissionsModule.get().addProvider(new DatabasePermissionProvider());
+    }
+}
+```
+
+The `PermissionsModule` aggregates permissions from all registered providers. This means:
+
+- Permission checks query all providers
+- Write operations (add/remove) use the **first** provider
+
+### Replacing the Default Provider
+
+If you want full control, you can remove the default provider:
+
+```java
+public class MyPlugin extends JavaPlugin {
+
+    @Override
+    public void setup() {
+        PermissionsModule perms = PermissionsModule.get();
+
+        // Remove the default provider FIRST
+        perms.removeProvider(perms.getFirstPermissionProvider());
+
+        // Then add your provider
+        perms.addProvider(new DatabasePermissionProvider());
+    }
+}
+```
+
+<Callout type="info">
+  When you remove the default provider, the `/op self` command will stop working since it checks for provider tampering.
 </Callout>
 
-We can then register the provider using the built-in permission module:
+---
+
+## Best Practices
+
+### Permission Naming Conventions
+
+Follow the pattern: `namespace.category.action`
 
 ```java
-PermissionsModule.get().addProvider(new DatabasePermissionProvider());
+// Good - clear hierarchy
+"myplugin.admin.ban"
+"myplugin.user.teleport.home"
+"myplugin.vip.chat.color"
+
+// Bad - unclear structure
+"myplugin_ban"
+"teleport"
+"vipChatColor"
 ```
 
-Please note that the `HytalePermissionsProvider` will still be enabled alongside your provider.
-The `PermissionsModule` will aggregate groups and permissions from all available providers.
+### Use Constants for Permissions
 
-If you want to disable the default `HytalePermissionsProvider`, you can use:
+Define your permissions as constants to avoid typos:
 
 ```java
-// put this **before** you add your provider
-PermissionsModule.get().removeProvider(PermissionsModule.get().getFirstPermissionProvider());
+public final class MyPermissions {
+    public static final String ADMIN_BAN = "myplugin.admin.ban";
+    public static final String ADMIN_KICK = "myplugin.admin.kick";
+    public static final String USER_HOME = "myplugin.user.home";
+    public static final String VIP_FLY = "myplugin.vip.fly";
+}
+
+// Usage
+if (player.hasPermission(MyPermissions.ADMIN_BAN)) {
+    // ...
+}
 ```
+
+### Don't Over-Permission
+
+Only create permissions for actions that genuinely need access control. Not everything needs a permission check.
+
+### Thread Safety
+
+If you create a custom provider, ensure it's thread-safe. Permission checks can occur from multiple threads simultaneously. Use `ReadWriteLock` or `ConcurrentHashMap` for your data structures.
+
+---
+
+## In-Game Commands
+
+Hytale provides built-in commands for managing permissions:
+
+### `/op` Command
+
+| Command               | Description                                                        |
+| --------------------- | ------------------------------------------------------------------ |
+| `/op self`            | Toggle your own OP status (singleplayer or with `--allow-op` flag) |
+| `/op add <player>`    | Add a player to the OP group                                       |
+| `/op remove <player>` | Remove a player from the OP group                                  |
+
+### `/perm` Command
+
+Use `/perm --help` in-game for full usage. Common operations:
+
+| Command                                  | Description                   |
+| ---------------------------------------- | ----------------------------- |
+| `/perm user list <uuid>`                 | List user's permissions       |
+| `/perm user add <uuid> <perm>`           | Add permission to user        |
+| `/perm user remove <uuid> <perm>`        | Remove permission from user   |
+| `/perm user group list <uuid>`           | List user's groups            |
+| `/perm user group add <uuid> <group>`    | Add user to group             |
+| `/perm user group remove <uuid> <group>` | Remove user from group        |
+| `/perm group list <group>`               | List group's permissions      |
+| `/perm group add <group> <perm>`         | Add permission to group       |
+| `/perm group remove <group> <perm>`      | Remove permission from group  |
+| `/perm test <perm>`                      | Test if you have a permission |
+
+---
+
+## Summary
+
+You've learned how to:
+
+- **Check permissions** using `PermissionsModule.hasPermission()`
+- **Manage user permissions** with `addUserPermission()` and `removeUserPermission()`
+- **Work with groups** using `addGroupPermission()`, `addUserToGroup()`, etc.
+- **Use wildcards** like `*` and `myplugin.*` for bulk permissions
+- **Listen to events** for permission changes
+- **Create custom providers** for database-backed permissions
+
+For more advanced permission systems with features like inheritance, expiry, and contexts, we're looking into expanding this guide with advanced permission management techniques in the future.
diff --git a/content/docs/pt-PT/guides/plugin/setting-up-env.mdx b/content/docs/pt-PT/guides/plugin/setting-up-env.mdx
index d2718098..5be5e9e0 100644
--- a/content/docs/pt-PT/guides/plugin/setting-up-env.mdx
+++ b/content/docs/pt-PT/guides/plugin/setting-up-env.mdx
@@ -4,6 +4,10 @@ description: Learn how to set up your development environment for modding Hytale
 authors:
   - name: Neil Revin
     link: https://itsneil.dev
+  - name: Marcel-TO
+    url: https://marcel-to.net
+  - name: Ádám Liszkai
+    link: https://adaliszk.dev
 ---
 
 This guide will walk you through setting up a complete development environment for Hytale modding, including all necessary tools and dependencies.
@@ -19,24 +23,73 @@ Before we begin, make sure you have:
 
 ## Required Software
 
-### 1. Java Development Kit (JDK)
+### Integrated Development Environment (IDE)
 
+We recommend IntelliJ IDEA Community Edition for Hytale modding. If you use IntelliJ IDEA, **almost everything is built-in**. You can clone a template, open a new project, and start working right away!
+
+1. Download from [JetBrains website](https://www.jetbrains.com/idea/download/)
+2. Install with default settings
+3. Launch and complete the initial setup wizard
+
+When opening a project, wait for indexing to finish, then start coding.
+Now, IDEA may say "No JDK configured" at the top of the source file you have.
+In that case, you can click Download JDK and choose JetBrains JDK 25.
+
+<Callout type="success">
+  If IDEA opened the project without errors, your environment is ready.
+</Callout>
+
+More details by [JetBrains](https://www.jetbrains.com/help/idea/2026.1/run-for-the-first-time.html)
+help page, where we recommend that you also check the
+[SDK configuration](https://www.jetbrains.com/help/idea/2026.1/sdk.html) guide.
+
+<Callout type="info">
+  We recommened following
+  [TheNullicorn's](https://gist.github.com/TheNullicorn/90a619796c40f20ae1fcf13094c1a57d) guide to ensure
+  you are using the correct `Nonnull` in your projects.
+</Callout>
+
+#### What the IDE Does for You
+
+When opened in IntelliJ IDEA, the project automatically:
+
+- Detects and configures Gradle or Maven
+- Downloads all dependencies
+- Sets up project structure and classpaths
+- Configures run/build tasks
+
+You do **not** need to manually install or configure Maven or Gradle if you stay inside the IDE.
+
+Skip to the [Setting Up Your Workspace](#setting-up-your-workspace).
+
+### Manual Setup: Java Development Kit (JDK)
+
+For any other setup, you will need to install and configure your system to have and load Java.
 Hytale modding requires Java 25 or later. We recommend using OpenJDK.
 
-#### Windows
+#### Windows via Installer
 
 1. Download OpenJDK 25 from [Adoptium](https://adoptium.net/)
 2. Run the installer with default settings
+   - Optionally enable feature `Set or Override JAVA_HOME variable` to resolve version related build issues with your project.
 3. Verify installation by opening Command Prompt and running:
 
+#### Windows via Scoop
+
+1. Install Scoop via PowerShell using [scoop.sh](https://scoop.sh/)
+2. Install OpenJDK 25:
+
 ```bash
-java -version
+scoop bucket add java
+scoop install java/openjdk25
 ```
 
 #### macOS
 
+1. Install Brew via Terminal using [brew.sh](https://brew.sh)
+2. Install JDK via Homebrew:
+
 ```bash
-# Using Homebrew
 brew install openjdk@25
 ```
 
@@ -51,22 +104,41 @@ brew install openjdk@25
 
 #### Linux (Ubuntu/Debian)
 
+1. Install JDK via the built-in package repository:
+
 ```bash
 sudo apt update
 sudo apt install openjdk-25-jdk
 ```
 
-### 2. Integrated Development Environment (IDE)
+### Verify installation:
 
-We recommend IntelliJ IDEA Community Edition for Hytale modding.
+Run the following command to see what version of Java you have:
 
-1. Download from [JetBrains website](https://www.jetbrains.com/idea/download/)
-2. Install with default settings
-3. Launch and complete the initial setup wizard
+```bash
+java -version
+```
+
+### Java Build Tool (Optional)
+
+We recommend using a Gradle Wrapper for managing dependencies and building your Hytale plugins. It provides benefits by eliminating the need for a system-wide Gradle installation and ensuring consistent Gradle versions across different environments. (Alternatively you can use Maven, but this guide focuses on Gradle since it is the default for our plugin template.)
+
+The plugin template in the following sections includes a Gradle Wrapper, so you can skip this step if you plan to use the template.
+
+#### Choosing Gradle (if not using the template)
+
+If you prefer to install Gradle manually, follow these steps:
 
-### 3) Java Build Tool
+1. Visit the official website: https://gradle.org/releases/
+2. Download the newest gradle binary: `gradle-9.3.1-bin.zip` (Binary zip archive)
+3. Unzip it
+4. Add the `gradle-9.3.1/bin/` folder to your PATH
+
+You can now try the command `gradle -version` to verify Gradle is installed correctly. Make sure to do this in a fresh new terminal instead of one you had opened from before!
+
+#### Choosing Maven (if not using the template)
 
-We recommend using Apache Maven for managing dependencies and building your Hytale plugins. (Alternatively you can use Gradle, but this guide focuses on Maven.)
+If you prefer to use Maven instead of Gradle, follow these steps to install Maven:
 
 1. Visit the official website: https://maven.apache.org/download.cgi
 2. Download this file: `apache-maven-3.9.12-bin.zip` (Binary zip archive)
@@ -89,22 +161,61 @@ cd MyFirstMod
 
 If you don't have Git installed, you can download the ZIP file from the repository page and extract it to a folder named `MyFirstMod`.
 
-### 2. Open Plugin in your IDEA
+### 2. Open Plugin in your IDE
 
-1. Open IntelliJ IDEA
+1. Open Your IDE (e.g., IntelliJ IDEA)
 2. Click "Open" and navigate to your `MyFirstMod` directory
-3. IntelliJ will automatically detect it as a Maven project
+3. Most IDEs like IntelliJ will automatically detect it as a Gradle project
 4. Wait for the project to index and dependencies to download
 
-<Callout type="info">
-  We recommened following [this](https://gist.github.com/TheNullicorn/90a619796c40f20ae1fcf13094c1a57d) guide to ensure you are using the correct `Nonnull` in your projects.
-</Callout>
+## Alternate Approach: Hytale Dependency
+
+If you prefer to set up your project from scratch without using the template and importing the hytale dependencies manually, ensure your build configuration includes the Hytale repositories and dependencies:
+
+For Gradle, add the following to your `build.gradle.kts`:
+
+```kotlin
+repositories {
+    mavenCentral()
+    maven {
+        name = "hytale"
+        url = uri("https://maven.hytale.com/release") // Or "hytale-pre-release" for pre-release versions
+    }
+}
+dependencies {
+    // + here means the latest version, but you can hard-wire any known version!
+    implementation("com.hypixel.hytale:Server:+")
+}
+```
+
+For Maven, add the following to your `pom.xml`:
+
+```xml
+<project>
+    <repositories>
+        <repository>
+            <id>hytale-release</id> <!-- Or "hytale-pre-release" for pre-release versions -->
+            <url>https://maven.hytale.com/release</url> <!-- Or "https://maven.hytale.com/pre-release" -->
+        </repository>
+    </repositories>
+
+    <dependencies>
+        <dependency>
+            <groupId>com.hypixel.hytale</groupId>
+            <artifactId>Server</artifactId>
+            <!-- Replace with latest version, Hytale provides jars for the last five releases -->
+            <version>LATEST_VERSION_HERE</version>
+            <scope>provided</scope>
+        </dependency>
+    </dependencies>
+</project>
+```
 
 ## Next Steps
 
 Now that you have your development environment set up with the plugin template:
 
-1. **Customize the template** - Edit the `pom.xml` and `manifest.json` file to change your mod's name and details
+1. **Customize the template** - Edit the `settings.gradle.kts`, `build.gradle.kts` and `manifest.json` file to change your mod's name and details
 2. **Explore the code structure** - Familiarize yourself with the template's organization
 3. **Start modding** - Begin writing your first Hytale plugin!
 
diff --git a/content/docs/pt-PT/guides/plugin/spawning-entities.mdx b/content/docs/pt-PT/guides/plugin/spawning-entities.mdx
index e12c0aea..15be2fb3 100644
--- a/content/docs/pt-PT/guides/plugin/spawning-entities.mdx
+++ b/content/docs/pt-PT/guides/plugin/spawning-entities.mdx
@@ -36,7 +36,7 @@ Store<EntityStore> store = world.getEntityStore().getStore();
 
 ## Creating Entities
 
-Once you have the `EntityStore` instance, you can start to create a entity and give it components. Entities are just instances of `Holder<EntityStore>` with several components attached to them.
+Once you have the `EntityStore` instance, you can start to create an entity and give it components. Entities are just instances of `Holder<EntityStore>` with several components attached to them.
 
 <Callout type="warning">
   To interact with the `World` instance, some methods require you to run the code inside the world's execution context.
@@ -118,3 +118,48 @@ Finally, we can add the entity to the world by calling the `addEntity` method on
 ```java
 store.addEntity(holder, AddReason.SPAWN);
 ```
+
+## Making the entity persist
+
+Hytale automatically saves all entities, but the `NetworkId` component (required for players to be able to see the entity) needs to be manually added every time the entity is loaded.
+
+### Using a system
+
+If you have a component that is unique to your entities, this can be done by creating and registering a custom system as follows:
+
+```java
+public class AddNetworkIdToMyEntitySystem extends HolderSystem<EntityStore> {
+    private final ComponentType<EntityStore, MyEntityComponent> myEntityComponentType = MyEntityComponent.getComponentType();
+    private final ComponentType<EntityStore, NetworkId> networkIdComponentType = NetworkId.getComponentType();
+    private final Query<EntityStore> query = Query.and(this.myEntityComponentType, Query.not(this.networkIdComponentType));
+
+    @Override
+    public void onEntityAdd(@NotNull Holder<EntityStore> holder, @NotNull AddReason reason, @NotNull Store<EntityStore> store) {
+        if (!holder.getArchetype().contains(NetworkId.getComponentType())) {
+            holder.addComponent(NetworkId.getComponentType(), new NetworkId(store.getExternalData().takeNextNetworkId()));
+        }
+    }
+
+    @Override
+    public void onEntityRemoved(@NotNull Holder<EntityStore> holder, @NotNull RemoveReason reason, @NotNull Store<EntityStore> store) {}
+
+    @Override
+    public @Nullable Query<EntityStore> getQuery() {
+        return query;
+    }
+}
+```
+
+In your plugin's `setup()` function
+
+```java
+this.getEntityStoreRegistry().registerSystem(new AddNetworkIdToMyEntitySystem())
+```
+
+### Using PropComponent
+
+Alternatively you can add `PropComponent` to your entity. Hytale adds `PropComponent` to entities spawned with the Entity Tool, and such entities automatically get `NetworkId` and `PrefabCopyableComponent` (which makes the entity work with prefabs).
+
+<Callout type="warning">
+  There is no guarantee, that Hytale will not add some other behavior to this component in the future, which may break your entity, so be careful if you decide to rely on it.
+</Callout>
diff --git a/content/docs/pt-PT/guides/plugin/store-persistent-data.mdx b/content/docs/pt-PT/guides/plugin/store-persistent-data.mdx
new file mode 100644
index 00000000..1071dff3
--- /dev/null
+++ b/content/docs/pt-PT/guides/plugin/store-persistent-data.mdx
@@ -0,0 +1,171 @@
+---
+title: Storing Persistent Data on the Player
+description: Learn how to save and load persistent data using Components
+authors:
+  - name: Neil Revin
+    url: https://itsneil.dev/
+  - name: ArcticDev
+    url: https://github.com/ArcticRaven
+  - name: oskarscot
+    url: https://oskar.scot
+  - name: JammingEng
+    url: https://github.com/JammingEnd
+---
+
+Here is how to store persistent data using a custom component on a Player.
+
+## Build your Component Class
+
+Creating a custom component class leverages the Component system made with the ECS architecture in mind. For more information on Components, check out the [ECS Guide](../ecs/hytale-ecs-theory#components).
+
+Start by creating your custom component class. This will be extremely similar to how regular components are created, however we'll setup a custom Codec so the server can translate this data to BSON, or the server's internal json encoder.
+
+<Callout type="info">
+  Each variable you want to store in your component must have its own Codec field defined in the BuilderCodec.
+  For more information on how to create custom Codecs, check out the [ECS Codec Guide](../ecs/hytale-ecs-theory#codec).
+</Callout>
+
+```java
+public class YourPlayerData implements Component<EntityStore> {
+
+    // define some vars!
+    private int someInteger;
+    private String someString;
+    private Map<String, String> someMap;
+
+    public static final BuilderCodec<YourPlayerData> CODEC =
+            BuilderCodec.builder(YourPlayerData.class, YourPlayerData::new)
+            .append(new KeyedCodec<>("SomeInteger", Codec.INTEGER),
+                    (data, value) -> data.someInteger = value, // setter
+                    data -> data.someInteger) // getter
+            .addValidator(Validators.nonNull())
+            .add()
+            .append(new KeyedCodec<>("SomeString", Codec.STRING),
+                    (data, value) -> data.someString = value, // setter
+                    data -> data.someString) // getter
+            .add()
+            .append(new KeyedCodec<>("SomeMap",
+                            new MapCodec<>(Codec.STRING, HashMap::new, false)),
+                    (data, value) -> data.someMap = value, // setter
+                    data -> data.someMap) // getter
+            .add()
+            .build();
+
+
+
+    // Getters and Setters are for the purpose of this example omitted.
+
+    // constructor
+    public YourPlayerData() {
+        this.someInteger = 0;
+        this.someString = "";
+        this.someMap = new HashMap<>();
+    }
+
+    // copy constructor for cloning
+    public YourPlayerData(YourPlayerData clone) {
+        this.someInteger = clone.someInteger;
+        this.someString = clone.someString;
+        this.someMap = clone.someMap;
+    }
+
+    @Nonnull
+    @Override
+    public Component<EntityStore> clone() {
+        return new YourPlayerData(this);
+    }
+}
+```
+
+## Register your Component
+
+Inside your main class's `setup()` method, register your new Component.
+
+```java
+public class YourPlugin extends JavaPlugin {
+
+    private ComponentType<EntityStore, YourPlayerData> yourPlayerDataComponent;
+
+    public YourPlugin(@Nonnull JavaPluginInit init) {
+        super(init);
+    }
+
+    @Override
+    protected void setup(){
+        this.yourPlayerDataComponent = this.getEntityStoreRegistry().registerComponent(
+            YourPlayerData.class,
+            "YourPlayerDataComponent",
+            YourPlayerData.CODEC
+        );
+    }
+
+    public ComponentType<EntityStore, YourPlayerData> getYourPlayerDataComponent() {
+        return this.yourPlayerDataComponent;
+    }
+}
+```
+
+## Using your Component
+
+To use your newly created component, you can add the Component to a player using the `addComponent` method, although this only adds it temporarily, meaning when the player/entity leaves the world, the component is removed. You can use `putComponent` to ensure the component persists between sessions.
+
+```java
+// You will need the Ref and Store to apply components
+private void someEntryMethod(@Nonnull Ref<EntityStore> ref, @Nonnull Store<EntityStore> store)
+{
+       // Any entity will work, for now we will use the player
+      Player player = (Player) store.getComponent(ref, Player.getComponentType());
+
+      // since we're using putComponent, it could be useful to check if it already exists on the player in case we want to update it
+     if(store.getComponent(ref, YourPlugin.instance().getYourPlayerDataComponent()) != null)
+     {
+          // here we implement logic that updates the component
+         var comp = store.getComponent(ref, YourPlugin.instance().getYourPlayerDataComponent())
+         // declare public fields or methods in the component class
+         comp.SomeString = "An Updated Field";
+     } else {
+          // Here we put the component
+          var myCustomComp = new CustomComponent();
+          // declare public fields or methods in the component class
+          myCustomComp.SomeString = "Edited String";
+
+          // putComponent allows you to insert declared objects
+          store.putComponent(ref, YourPlugin.instance().getYourPlayerDataComponent(), myCustomComp);
+     }
+}
+```
+
+## Using your Data
+
+Your component will be stored within the `Store<EntityStore>` when added to the player. In the provided example,
+we'll fetch this data off the player using the `ensureAndGetComponent()` method, which will add the component to
+the player if it does not exist with the default values.
+
+```java
+public class IncompleteCustomCommand extends AbstractPlayerCommand {
+
+    public IncompleteCustomCommand() {
+        super("nope", "don't use this command");
+    }
+
+    @Override
+    protected void execute(
+        @NonNullDecl CommandContext commandContext,
+        @NonNullDecl Store<EntityStore> store,
+        @NonNullDecl Ref<EntityStore> ref,
+        @NonNullDecl PlayerRef playerRef,
+        @NonNullDecl World world
+    ) {
+        YourPlayerData customData = store.ensureAndGetComponent(ref, YourPlugin.instance().getYourPlayerDataComponent());
+        // ensureAndGetComponent adds the component to the ref, with the default values defined inside your component.
+ 		// use your data
+    }
+}
+```
+
+And that's it! Your data will now be saved and loaded automatically with the player.
+
+Using custom components to store persistent data on players is a powerful way to maintain state across sessions.
+By following the steps outlined above, you can easily create, register, and utilize your own data structures within the Hytale ECS framework.
+This approach ensures that your data is seamlessly integrated with the game's existing systems.
+For more information about Hytale's Entity Component System visit the [Hytale ECS Theory](https://hytalemodding.dev/en/docs/guides/ecs/hytale-ecs-theory) guide.
diff --git a/content/docs/pt-PT/guides/plugin/teleporting-players.mdx b/content/docs/pt-PT/guides/plugin/teleporting-players.mdx
index 57cee77f..32ce0435 100644
--- a/content/docs/pt-PT/guides/plugin/teleporting-players.mdx
+++ b/content/docs/pt-PT/guides/plugin/teleporting-players.mdx
@@ -1,26 +1,32 @@
 ---
 title: Teleporting the player
 description: Learn how to teleport the player.
+authors:
+  - name: oskarscot
+    url: https://oskar.scot
 ---
 
-To teleport players in Hytale, you will need to get a `World` object so we can safely run the teleport on the world thread. The world thread manages all entity updates, so modifying entities off-thread can crash the server or cause inconsistent state.
-Next, we get the entity store and make a `Teleport` object.
-We add a `Teleport` component to the player’s entity reference in the entity store. This triggers the teleportation logic for that player.
+Teleporting players in Hytale works by simply attaching a `Teleport` component to a player with the desired world and transform.
+You can only trigger teleports from a world where the player is currently present.
+Teleport itself is a component but it also provides factory methods to configure the Teleport. Just as with any entity component, an EntityStore and a Ref to the EntityStore is required
+
+We can create a simple teleport utility like this:
 
 ```java
-public static void teleportPlayer(Player player, int x, int y, int z) {
-        World world = player.getWorld();
-        if (world == null) return;
-        world.execute(() -> {
-            if (player.getReference() == null) return;
-            Store<EntityStore> store = player.getReference().getStore();
-            Teleport teleport = Teleport.createForPlayer(world,
-                new Vector3d(x ,y, z), // Target position
-                new Vector3f(0, 0, 0)  // Target rotation (pitch, yaw, roll)
-            );
+public static void teleportPlayer(Ref<EntityStore> ref, Store<EntityStore> store, World targetWorld, double x, double y, double z) {                                                                                       
+    Transform transform = new Transform(x, y, z);                                                                                                                           
+    Teleport teleport = Teleport.createForPlayer(targetWorld, transform);                                                                                                   
+    store.addComponent(ref, Teleport.getComponentType(), teleport);                                                                                                         
+}  
+```
 
-            store.addComponent(player.getReference(), Teleport.getComponentType(), teleport);
-        });
+A `Transform` is a representation of a position Vector3d and rotation Vector3f which works in the following way:
 
-}
+```java
+Transform transform = new Transform(
+    new Vector3d(x, y, z),      // Position
+    new Rotation(yaw, pitch, 0) // Rotation, last value seems to always be 0
+);
+Teleport teleport = Teleport.createForPlayer(targetWorld, transform);
+store.addComponent(ref, Teleport.getComponentType(), teleport);
 ```
diff --git a/content/docs/pt-PT/guides/plugin/tracking-mod-analytics-with-hstats.mdx b/content/docs/pt-PT/guides/plugin/tracking-mod-analytics-with-hstats.mdx
new file mode 100644
index 00000000..45c022e0
--- /dev/null
+++ b/content/docs/pt-PT/guides/plugin/tracking-mod-analytics-with-hstats.mdx
@@ -0,0 +1,65 @@
+---
+title: Tracking Mod Analytics with HStats
+description: Learn how you can track Analytics for your Hytale Mod for Free using hstats.dev
+authors:
+  - name: Al3x
+    url: https://hstats.dev
+---
+
+In this guide, you will learn how to integrate HStats into your Plugin/Mod which will allow you to track how many Servers are using it along with other stats.
+
+<Callout type="info">
+  HStats is a third-party tool and is not affiliated with HytaleModding or Hypixel Studios
+</Callout>
+
+# Step 1: Register your Mod to HStats
+
+Before you touch any code, you will need to add your mod to the HStats website which will give you a UUID for your mod.
+
+- Create or Login to an Account on https://hstats.dev
+- Navigate to the dashboard page (https://hstats.dev/dashboard)
+- On the left, type in your mod's name and click "Add Mod"
+- Keep note of the UUID generated for later.
+
+# Step 2: Add the HStats Class to Your Project
+
+To keep things simple, HStats uses a single Java class file that handles everything for you.
+
+- Download / Copy the File from the GitHub page (https://github.com/hstats-dev/HStatsExamplePlugin/blob/main/src/main/java/com/al3x/HStats.java)
+- Paste into your Project. You should now have a HStats.java file somewhere in your projects directory.
+- Update the package name from com.al3x to whatever fits your project.
+
+# Step 3: Initialize HStats in your code
+
+You only need to add one line of code to your mod's setup method in your main class to start tracking.
+
+`new HStats("YOUR-MOD-UUID", "1.0.0");`
+
+Replace `YOUR-MOD-UUID` with the Mod UUID we made note of earlier and change the `1.0.0` version to whatever version your mod is currently on.
+
+Your setup method should now look something like this:
+
+```java
+@Override
+protected void setup() {
+  super.setup();
+  new HStats("c34a2b2a-afd8-4d6a-821e-7a63e12c5ea6", "1.0.0");
+}
+```
+
+# Extras
+
+Your done! Your mod should now be listed under the Mods page (https://hstats.dev/mods) as well as under your dashboard.
+
+Servers using your mod should now post updates about every minute to HStats which you can view in the Dashboard.
+
+### Embeds
+
+HStats allows you to generate an Embed Card that you can place on your CurseForge or GitHub page. This is useful for server owners to be able to see how many other servers are using your mod.
+
+- In your dashboard, scroll down to the Embed Card section.
+- Customize the appearance (Light/Dark mode, layout, etc).
+- Copy the generated URL to display your "Active Servers" and "Players Online" live on your mod's description page
+
+Heres an example of what they look like:
+![HStats Example](https://api.hstats.dev/api/embed/d52fa672-6966-47b2-b501-1a11bddebac3/card.svg?theme=light\&layout=compact\&size=md\&show_id=true\&dark=false)
diff --git a/content/docs/pt-PT/guides/plugin/world-gen.mdx b/content/docs/pt-PT/guides/plugin/world-gen.mdx
index 4c23b0c9..7b193ffd 100644
--- a/content/docs/pt-PT/guides/plugin/world-gen.mdx
+++ b/content/docs/pt-PT/guides/plugin/world-gen.mdx
@@ -100,7 +100,7 @@ Biome biome = biomeGen.generateBiomeAt(zoneResult, seed, x, z);
 
 ### Zone & Cave Integration
 
-Each zone defines it's own cave patterns:
+Each zone defines its own cave patterns:
 
 ```java
 Zone zone = /* ... */;
diff --git a/content/docs/pt-PT/guides/prefabs.mdx b/content/docs/pt-PT/guides/prefabs.mdx
index 08404b30..b1a55109 100644
--- a/content/docs/pt-PT/guides/prefabs.mdx
+++ b/content/docs/pt-PT/guides/prefabs.mdx
@@ -14,7 +14,7 @@ Prefabs are Hytale's way of creating reusable structures.
 There are a few fundamental concepts to understand about prefabs:
 
 - Users interact with prefabs via a prefab editing world.
-- Prefabs the physical structures in the game world, and are saved as JSON files.
+- Prefabs are the physical structures in the game world, and are saved as JSON files.
 
 ## How to Create a Prefab
 
diff --git a/content/docs/pt-PT/official-documentation/custom-ui/common-styling.mdx b/content/docs/pt-PT/official-documentation/custom-ui/common-styling.mdx
new file mode 100644
index 00000000..c36e3e3a
--- /dev/null
+++ b/content/docs/pt-PT/official-documentation/custom-ui/common-styling.mdx
@@ -0,0 +1,50 @@
+---
+title: Common Styling
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# Common Styling
+
+## Common UI Styling Library
+
+This document describes the shared UI components and styles defined in `Common.ui`.
+
+---
+
+### Styles
+
+We are providing some styles that can be re-used in any custom UI that, provide a cohesive UI experience with the core game UI. These styles are available in the `Common.ui` file.
+
+You can find a list of all the styles defined with live examples by running the `/ui-gallery` command ingame.
+
+<Callout type="warning">
+  This command is not available yet, but will be in a future patch.
+</Callout>
+
+![Gallery](/assets/official-documentation/ui/gallery.png)
+
+### Importing
+
+To use these styles in your UI file:
+
+```
+$Common = "Common.ui";
+
+// Then reference styles and components:
+$Common.@TextButton { @Text = "My Button"; }
+$Common.@Container { ... }
+```
+
+<Callout type="info">
+  The `Common.ui` file is at `Common/UI/Custom/Common.ui` within the Hytale pack. If your custom ui document is in a subfolder of `Common/UI/Custom/`, reference it via relative path traversal:
+
+  ```
+  $Common = "../Common.ui";
+  ```
+
+  You can find more info about paths [here](markup#path).
+</Callout>
diff --git a/content/docs/pt-PT/official-documentation/custom-ui/index.mdx b/content/docs/pt-PT/official-documentation/custom-ui/index.mdx
new file mode 100644
index 00000000..f94c4e88
--- /dev/null
+++ b/content/docs/pt-PT/official-documentation/custom-ui/index.mdx
@@ -0,0 +1,125 @@
+---
+title: Custom UI
+icon: LayoutDashboard
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# Custom UI
+
+## What is Custom UI?
+
+Custom UI is Hytale's framework for creating **custom user interfaces** controlled by the game server. Unlike the built-in Client UI (which is part of the game client and cannot be modified), Server UI allows you to create interactive screens and HUD overlays through Java plugins and asset packs.
+
+As a modder, Custom UI gives you the power to:
+
+- **Create custom interactive pages** - Shop interfaces, quest dialogs, server settings menus, admin panels
+- **Add custom HUD overlays** - Quest trackers, status displays, custom health bars, server information
+- **Design with markup** - Use `.ui` files to define reusable UI templates
+- **Handle user interactions** - Respond to button clicks, form submissions, and other events
+- **Localize your UI** - Support multiple languages using the game's translation system
+
+## How Custom UI Fits Into Hytale's UI
+
+Hytale's user interface is divided into two main categories:
+
+### Client UI (Not Moddable)
+
+Built-in interfaces controlled by the C# game client:
+
+- Main menu and settings
+- Character creation
+- Built-in HUD (health, hotbar, chat)
+- Inventory and crafting screens
+- Development tools
+
+**You cannot modify these** - they are part of the core game client.
+
+### In-Game UI (Moddable via Server)
+
+Server-controlled interfaces that you can create and customize:
+
+#### Custom Pages
+
+Full-screen interactive overlays that appear during gameplay:
+
+- Can be dismissed by the player (ESC key)
+- Capture all input (keyboard and mouse)
+- Support loading states while waiting for server responses
+- Perfect for: shops, dialogs, menus, configuration screens
+
+#### Custom HUDs
+
+Persistent overlay elements drawn on top of the game world:
+
+- Display-only (no user interaction)
+- Always visible during gameplay
+- Lightweight and non-intrusive
+- Perfect for: quest objectives, status indicators, server info panels
+
+## Architecture Overview
+
+Server UI uses a **command-based architecture**:
+
+```
+┌─────────────────────┐         ┌──────────────────────┐
+│   Java Server       │         │    C# Client         │
+│   (Your Plugin)     │         │    (Game)            │
+├─────────────────────┤         ├──────────────────────┤
+│                     │         │                      │
+│ InteractiveCustomUI │         │   CustomPage or      │
+│ Page                │         │   CustomHud          │
+│   ↓ build()         ├────────→│     ↓ Apply          │
+│ UICommandBuilder    │         │   Element Tree       │
+│   - append()        │         │     ↓ Layout         │
+│   - set()           │         │   Rendered UI        │
+│   - clear()         │         │                      │
+│                     │         │                      │
+│ ↓ handleDataEvent() │← Events │   User Interaction   │
+│   Process input     │         │   (click, type, etc) │
+│   sendUpdate()      │         │                      │
+└─────────────────────┘         └──────────────────────┘
+```
+
+**The flow:**
+
+1. Your Java code builds UI using `UICommandBuilder`
+2. Commands are sent to the client as data
+3. Client parses `.ui` markup files and creates visual elements
+4. User interacts with the UI
+5. Events are sent back to your Java code
+6. You process events and send updates back
+
+## Key Principles
+
+### Declarative, Not Imperative
+
+You don't create UI objects directly. Instead, you send **commands** that describe what you want:
+
+- "Append this button template to that container"
+- "Set this label's text to 'Hello World'"
+- "Clear all children from this list"
+
+### Asset-Driven
+
+UI structure is defined in `.ui` markup files (assets), not hardcoded in Java. This enables:
+
+- Designers to modify layouts without touching code
+- Reusable UI components
+- Consistent visual language
+
+### Event-Driven
+
+User interactions trigger events that flow back to your server code. You register event bindings and handle them in `handleDataEvent()`.
+
+### Selector-Based
+
+You target specific UI elements using **selectors:**
+
+- `#MyButton` - Element with ID "MyButton"
+- `#List[0]` - First child of element "List"
+- `#List[0] #Title` - Element with ID "Title" in the first child of element "List"
+- `#Label.TextColor` - The TextColor property of element "Label"
diff --git a/content/docs/pt-PT/official-documentation/custom-ui/layout.mdx b/content/docs/pt-PT/official-documentation/custom-ui/layout.mdx
new file mode 100644
index 00000000..0a24ca09
--- /dev/null
+++ b/content/docs/pt-PT/official-documentation/custom-ui/layout.mdx
@@ -0,0 +1,492 @@
+---
+title: Layout
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# Layout
+
+The layout system determines how UI elements are positioned and sized on screen. Understanding layout is crucial for creating well-structured, responsive interfaces.
+
+## Layout Fundamentals
+
+Every UI element has:
+
+- **Container Rectangle** - The space allocated by the parent
+- **Anchor** - How the element positions/sizes itself within the container
+- **Padding** - Inner spacing that affects child layout
+- **LayoutMode** - How the element arranges its children (if it's a container)
+
+```
+┌─────────────────────────────────────┐
+│  Container Rectangle (from parent)  │
+│  ┌───────────────────────────────┐  │
+│  │  Anchored Rectangle           │  │
+│  │  ┌─────────────────────────┐  │  │
+│  │  │ Padding                 │  │  │
+│  │  │  ┌───────────────────┐  │  │  │
+│  │  │  │  Content Area     │  │  │  │
+│  │  │  └───────────────────┘  │  │  │
+│  │  └─────────────────────────┘  │  │
+│  └───────────────────────────────┘  │
+└─────────────────────────────────────┘
+```
+
+## Anchor
+
+`Anchor` controls how an element positions and sizes itself within its container rectangle.
+
+### Fixed Size
+
+```
+Button {
+    Anchor: (Width: 200, Height: 40);
+}
+```
+
+Creates a 200×40 pixel button.
+
+### Positioning
+
+```
+Label {
+    Anchor: (Top: 10, Left: 20, Width: 100, Height: 30);
+}
+```
+
+- **Top**: 10 pixels from container's top edge
+- **Left**: 20 pixels from container's left edge
+- **Width**: 100 pixels wide
+- **Height**: 30 pixels tall
+
+### Anchoring to Edges
+
+```
+Button {
+    Anchor: (Bottom: 10, Right: 10, Width: 100, Height: 30);
+}
+```
+
+Anchors the button to the bottom-right corner, 10 pixels from each edge.
+
+### Stretching
+
+```
+Group {
+    Anchor: (Top: 0, Bottom: 0, Left: 0, Right: 0);
+}
+```
+
+Stretches to fill the entire container (all edges at 0 pixels).
+
+**Shorthand:**
+
+```
+Group {
+    Anchor: (Full: 0);
+}
+```
+
+### Mixed Anchoring
+
+```
+Panel {
+    Anchor: (Top: 10, Bottom: 10, Left: 20, Width: 300);
+}
+```
+
+- Fixed width of 300 pixels
+- Stretches vertically between top and bottom edges
+- 10 pixels from top and bottom
+- 20 pixels from left
+
+## Padding
+
+`Padding` creates inner spacing, affecting where children are positioned.
+
+### Uniform Padding
+
+```
+Group {
+    Padding: (Full: 20);
+}
+```
+
+20 pixels of padding on all sides.
+
+### Directional Padding
+
+```
+Group {
+    Padding: (Top: 10, Bottom: 20, Left: 15, Right: 15);
+}
+```
+
+Different padding per edge.
+
+### Shorthand
+
+```
+// Horizontal and vertical
+Group {
+    Padding: (Horizontal: 20, Vertical: 10);
+}
+
+// Equivalent to:
+// Top: 10, Bottom: 10, Left: 20, Right: 20
+```
+
+### Effect on Children
+
+```
+Group {
+    Anchor: (Width: 200, Height: 100);
+    Padding: (Full: 10);
+
+    Label {
+        Anchor: (Full: 0);
+    }
+}
+```
+
+The label fills the group, but there's a 10-pixel gap on all sides due to padding.
+
+```
+┌──────────────────────┐
+│ Group (200×100)      │
+│  ┌────────────────┐  │
+│  │ Label          │  │ ← 10px padding all around
+│  │                │  │
+│  └────────────────┘  │
+└──────────────────────┘
+```
+
+## LayoutMode
+
+`LayoutMode` determines how a container arranges its children.
+
+### Top (Vertical Stack)
+
+```
+Group {
+    LayoutMode: Top;
+
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+}
+```
+
+Children stack vertically from top to bottom:
+
+```
+┌──────────┐
+│ Button 1 │
+├──────────┤
+│ Button 2 │
+├──────────┤
+│ Button 3 │
+└──────────┘
+
+
+```
+
+Each child's `Anchor.Bottom` adds spacing between elements:
+
+```
+Button { Anchor: (Height: 30, Bottom: 10); }  // 10px gap after this button
+```
+
+### Bottom (Vertical Stack)
+
+```
+Group {
+    LayoutMode: Bottom;
+
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+}
+```
+
+Children stack vertically from top to bottom but aligned to the bottom edge of the parent:
+
+```
+
+
+
+┌──────────┐
+│ Button 1 │
+├──────────┤
+│ Button 2 │
+├──────────┤
+│ Button 3 │
+└──────────┘
+```
+
+### Left (Horizontal Stack)
+
+```
+Group {
+    LayoutMode: Left;
+
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+}
+```
+
+Children arrange horizontally from left to right:
+
+```
+┌────────┬────────┬────────┐
+│ Button │ Button │ Button │
+│   1    │   2    │   3    │
+└────────┴────────┴────────┘
+```
+
+Use `Anchor.Right` for spacing between elements.
+
+### Right (Horizontal Stack)
+
+```
+Group {
+    LayoutMode: Right;
+
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+}
+```
+
+Children arrange horizontally from left to right but aligned to the right side of the parent:
+
+```
+                                                                 ┌────────┬────────┬────────┐
+                                                                 │ Button │ Button │ Button │
+                                                                 │   1    │   2    │   3    │
+                                                                 └────────┴────────┴────────┘
+```
+
+### Center
+
+```
+Group {
+    LayoutMode: Center;
+
+    Group #Dialog {
+        Anchor: (Width: 400, Height: 300);
+    }
+}
+```
+
+Centers the children horizontally.
+
+### Middle
+
+```
+Group {
+    LayoutMode: Middle;
+
+    Group #Dialog {
+        Anchor: (Width: 400, Height: 300);
+    }
+}
+```
+
+Centers the children vertically.
+
+### CenterMiddle (Horizontal Stack, Fully Centered)
+
+```
+Group {
+    LayoutMode: CenterMiddle;
+
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+}
+```
+
+Children stack horizontally from left to right, centered both horizontally and vertically within the parent:
+
+```
+┌────────────────────────────────────────────┐
+│                                            │
+│                                            │
+│         ┌──────┐ ┌──────┐ ┌──────┐         │
+│         │  B1  │ │  B2  │ │  B3  │         │
+│         └──────┘ └──────┘ └──────┘         │
+│                                            │
+│                                            │
+└────────────────────────────────────────────┘
+```
+
+---
+
+### MiddleCenter (Vertical Stack, Fully Centered)
+
+```
+Group {
+    LayoutMode: MiddleCenter;
+
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+}
+```
+
+Children stack vertically from top to bottom, centered both horizontally and vertically within the parent:
+
+```
+┌────────────────────────────────────────────┐
+│                                            │
+│              ┌──────────┐                  │
+│              │ Button 1 │                  │
+│              ├──────────┤                  │
+│              │ Button 2 │                  │
+│              ├──────────┤                  │
+│              │ Button 3 │                  │
+│              └──────────┘                  │
+│                                            │
+└────────────────────────────────────────────┘
+```
+
+---
+
+### Full
+
+```
+Group {
+    LayoutMode: Full;
+
+    Label {
+        Anchor: (Top: 20, Left: 20, Width: 100, Height: 30);
+    }
+}
+```
+
+Children use absolute positioning via their `Anchor` properties.
+
+### TopScrolling
+
+```
+Group {
+    LayoutMode: TopScrolling;
+    ScrollbarStyle: $Common.@DefaultScrollbar;
+
+    // ... many children
+}
+```
+
+Like `Top`, but adds a scrollbar if content exceeds container height.
+
+Or use `BottomScrolling` for bottom-aligned content.
+
+### LeftScrolling
+
+```
+Group {
+    LayoutMode: LeftScrolling;
+    ScrollbarStyle: $Common.@DefaultScrollbar;
+
+    // ... many children
+}
+```
+
+Like `Left`, but adds a scrollbar for horizontal scrolling.
+
+Or use `RightScrolling` for right-aligned content.
+
+### LeftCenterWrap (Wrapping Horizontal Stack, Horizontally Centered)
+
+```
+Group {
+    LayoutMode: LeftCenterWrap;
+
+    Button { Anchor: (Width: 80, Height: 30); }
+    Button { Anchor: (Width: 80, Height: 30); }
+    Button { Anchor: (Width: 80, Height: 30); }
+    Button { Anchor: (Width: 80, Height: 30); }
+    Button { Anchor: (Width: 80, Height: 30); }
+}
+```
+
+Children flow left to right. When there's no more horizontal space, they wrap to the next row. Each row is horizontally centered within the parent:
+
+```
+┌────────────────────────────────────────────┐
+│                                            │
+│       ┌──────┐ ┌──────┐ ┌──────┐           │
+│       │  B1  │ │  B2  │ │  B3  │           │
+│       └──────┘ └──────┘ └──────┘           │
+│            ┌──────┐ ┌──────┐               │
+│            │  B4  │ │  B5  │               │
+│            └──────┘ └──────┘               │
+│                                            │
+└────────────────────────────────────────────┘
+```
+
+## FlexWeight
+
+`FlexWeight` distributes remaining space among children.
+
+```
+Group {
+    LayoutMode: Left;
+    Anchor: (Width: 400);
+
+    Button {
+        Anchor: (Width: 100);
+    }
+
+    Group {
+        FlexWeight: 1;  // Takes all remaining space
+    }
+
+    Button {
+        Anchor: (Width: 100);
+    }
+}
+```
+
+Result:
+
+- First button: 100px
+- Middle group: 200px (400 - 100 - 100 = 200)
+- Last button: 100px
+
+### Multiple FlexWeights
+
+```
+Group {
+    LayoutMode: Left;
+    Anchor: (Width: 600);
+
+    Group { FlexWeight: 1; }
+    Group { FlexWeight: 2; }
+    Group { FlexWeight: 1; }
+}
+```
+
+Remaining space (600px) is split:
+
+- First group: 600 × (1/4) = 150px
+- Second group: 600 × (2/4) = 300px
+- Third group: 600 × (1/4) = 150px
+
+## Visibility
+
+```
+Button #HiddenButton {
+    Visible: false;
+}
+```
+
+**Effect:**
+
+- Element and its children are not displayed
+- Element is **not included in layout** (doesn't take up space)
diff --git a/content/docs/pt-PT/official-documentation/custom-ui/markup.mdx b/content/docs/pt-PT/official-documentation/custom-ui/markup.mdx
new file mode 100644
index 00000000..564110ed
--- /dev/null
+++ b/content/docs/pt-PT/official-documentation/custom-ui/markup.mdx
@@ -0,0 +1,226 @@
+---
+title: Markup
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# Markup
+
+## Markup
+
+An element is the basic building block of a user interface. There are various types of elements with different properties, which are documented below.
+
+Here's what the syntax looks like:
+
+```
+// Basic declaration of an element
+// with its Anchor property set to attach on all sides of its parent
+// with 10 pixels of margin
+Group { Anchor: (Left: 10, Top: 10, Right: 10, Bottom: 10); }
+
+Group { Anchor: (Full: 10); } // More concise version
+
+// Declaration of a Label with a name
+// (can be used to access the element from game code)
+Label #MyLabel {
+  Style: LabelStyle(FontSize: 16); // or just Style: (FontSize: 16), type can be inferred.
+  Text: "Hi! I am text.";
+}
+
+// Declaration of a Group containing 2 children
+// You can use FlexWeight to distribute any left-over space after explicit widths/heights have been subtracted
+Group {
+  LayoutMode: Left;
+  Label { Text: "Child 1"; FlexWeight: 2; }
+  Label { Text: "Child 2"; FlexWeight: 1; }
+}
+```
+
+### Documents
+
+A UI document (_.ui_ file) contains trees of elements. There can be multiple root elements.
+
+### Named Expressions
+
+Named expressions can be declared at any level of a document (including at the root) and will be scoped to that subtree, though they need to be declared at the top of the block.
+
+```
+// Example of named expressions, declared and used with @ prefix
+@Title = "Hytale";
+@ExtraSpacing = 5;
+
+Label {
+  Text: @Title;
+  Style: (LetterSpacing: 2 + @ExtraSpacing);
+}
+```
+
+You can use the spread operator `...` to reuse a named expression while overriding some of its fields:
+
+```
+@MyBaseStyle = LabelStyle(FontSize: 24, LetterSpacing: 2);
+
+Label {
+  Style: (...@MyBaseStyle, FontSize: 36);
+}
+```
+
+You can even layer multiple named expressions like so:
+
+```
+@TitleStyle = LabelStyle(FontSize: 24, HorizontalAlignment: Center);
+@SpacedTextStyle = LabelStyle(LetterSpacing: 2);
+
+Label {
+  Style: (...@BigTextStyle, ...@SpacedTextStyle);
+}
+```
+
+#### Document references
+
+A document can reference another document and access its named expressions.
+
+```
+// Document references are defined with $ prefix
+$Common = "../Common.ui";
+
+TextButton {
+  Style: $Common.@DefaultButtonStyle;
+}
+```
+
+### Templates
+
+You can declare a reusable bit of interface as a named expression and then instantiate it as many times as you want in the tree while customizing it.
+
+You can override local named expressions as well as insert additional children at any point in the template tree. However, local named expressions must be defined at the very top of the block, before properties and child elements.
+
+```
+// This is the template
+@Row = Group {
+  Anchor: (Height: 50);
+  Label #Label { Anchor: (Left: 0, Width: 100); Text: @LabelText; }
+  Group #Content { Anchor: (Left: 100); }
+};
+
+// Here we'll be using it twice in the document tree
+Group #Rows {
+  LayoutMode: TopScrolling;
+
+  @Row #MyFirstRow {
+    @LabelText = "First row";
+    #Content { TextInput {} }
+  }
+
+  @Row #MySecondRow {
+    @LabelText = "Second row";
+  }
+}
+```
+
+### Property Types
+
+#### Basic Types
+
+- **Boolean**
+  - `Visible: false;`
+  - `Visible: true;`
+- **Int**
+  - `Height: 20;`
+- **Float, Double, Decimal**
+  - `Min: 0.2;`
+- **String**
+  - `Text: "Hi!";`
+- **Char**
+  - `PasswordChar: "*";`
+  - _Note: The syntax is the same as a string, however a value of this type cannot contain more than one character!_
+- **Color**
+  - `Background: #ffffff;`&#x20;
+- **Objects**
+  - `Style: (Background: #ffffff)`
+- **Array**&#x20;
+  - `TextSpans: [(Text: "Hi", IsBold: true)]`
+
+#### Translations
+
+Translation keys can be referenced anywhere in markup where you can provide a string, and they are then converted to a string when an element gets instantiated.
+
+**Example:**
+
+```
+Label {
+  Text: %ui.general.cancel;
+}
+```
+
+#### Colors
+
+A color literal can be written as follows:
+
+- `#rrggbb`: 6-digit hexadecimal representation for red, green, blue (fully opaque)
+- `#rrggbb(a.a)`: 6-digit hexadecimal representation for red, green, blue with alpha between 0 and 1
+- `#rrggbbaa`: 8-digit hexadecimal representation for red, green, blue and alpha
+
+```
+Group {
+  Background: #000000(0.3);
+}
+```
+
+<Callout>
+  The `#rrggbb(a.a)` format is prefered over the `#rrggbbaa` format for
+  readability reasons.
+</Callout>
+
+#### Font Name
+
+Font names can be referenced directly by their string ID. Internally this is using a custom type called `UIFontName`, however strings will be converted automatically to this type in markup.
+
+```
+Label {
+  Text: "Hi";
+  Style: (FontName: "Secondary");
+}
+```
+
+**Available Font Names**
+
+- _Default_ - This is the default font that is used for most text and is always used unless a different option has been specified
+- _Secondary_ - This font is mostly used for headlines or elements that are supposed to stick out
+- _Mono_ - This is only used for development; For things such as profiling or error overlays.
+
+#### Path
+
+We can reference other UI assets with the `UIPath` type. Similar to `UIFontName`_,_ Strings are automatically converted to a `UIPath`. Paths are always relative to the file where they have been declared in. Looking up _MyButton.png_ in _Menu/MyAwesomeMenu.ui_ will result in _Menu/MyButton.png_. If you want to reference a file that is in a parent folder you can go back one directory by writing two dots (_../MyButton.png_).
+
+The markup syntax of a `UIPath` is the same as a String. (e.g. `Path: "Test.png"`)
+
+Here are some more examples:
+
+| UIPath             | .ui File                              | Resulting Path    |
+| ------------------ | ------------------------------------- | ----------------- |
+| MyButton.png       | Menu/MyAwesomeMenu.ui                 | Menu/MyButton.png |
+| ../MyButton.png    | Menu/MyAwesomeMenu.ui                 | MyButton.png      |
+| ../../MyButton.png | Menu/Popup/Templates/MyAwesomeMenu.ui | Menu/MyButton.png |
+
+#### Objects
+
+Objects contain a set of properties. In this example we are assigning an Anchor object to the _Anchor_ property:
+
+```
+Group {
+  Anchor: (
+   Height: 10,
+   Width: 20
+ );
+}
+```
+
+You can find all objects that can be used in markup [here](type-documentation#elements).
+
+## Visual Studio Code Extension
+
+There is an official extension for Visual Studio Code which adds syntax highlighting for .ui files. You can find it [here](https://marketplace.visualstudio.com/items?itemName=HypixelStudiosCanadaInc.vscode-hytaleui).
diff --git a/content/docs/pt-PT/official-documentation/custom-ui/type-documentation/index.mdx b/content/docs/pt-PT/official-documentation/custom-ui/type-documentation/index.mdx
new file mode 100644
index 00000000..69cea406
--- /dev/null
+++ b/content/docs/pt-PT/official-documentation/custom-ui/type-documentation/index.mdx
@@ -0,0 +1,127 @@
+---
+title: Type Documentation
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# Type Documentation
+
+This is a generated list of UI elements accessible by markup. More information about the User Interface framework can be found in the main documentation.
+
+## Elements
+
+- [ActionButton](type-documentation/elements/actionbutton)
+- [AssetImage](type-documentation/elements/assetimage)
+- [BackButton](type-documentation/elements/backbutton)
+- [BlockSelector](type-documentation/elements/blockselector)
+- [Button](type-documentation/elements/button)
+- [CharacterPreviewComponent](type-documentation/elements/characterpreviewcomponent)
+- [CheckBox](type-documentation/elements/checkbox)
+- [CheckBoxContainer](type-documentation/elements/checkboxcontainer)
+- [CircularProgressBar](type-documentation/elements/circularprogressbar)
+- [CodeEditor](type-documentation/elements/codeeditor)
+- [ColorOptionGrid](type-documentation/elements/coloroptiongrid)
+- [ColorPicker](type-documentation/lements/colorpicker)
+- [ColorPickerDropdownBox](type-documentation/elements/colorpickerdropdownbox)
+- [CompactTextField](type-documentation/elements/compacttextfield)
+- [DropdownBox](type-documentation/elements/dropdownbox)
+- [DropdownEntry](type-documentation/elements/dropdownentry)
+- [DynamicPane](type-documentation/elements/dynamicpane)
+- [DynamicPaneContainer](type-documentation/elements/dynamicpanecontainer)
+- [FloatSlider](type-documentation/elements/floatslider)
+- [FloatSliderNumberField](type-documentation/elements/floatslidernumberfield)
+- [Group](type-documentation/elements/group)
+- [HotkeyLabel](type-documentation/elements/hotkeylabel)
+- [ItemGrid](type-documentation/elements/itemgrid)
+- [ItemIcon](type-documentation/elements/itemicon)
+- [ItemPreviewComponent](type-documentation/elements/itempreviewcomponent)
+- [ItemSlot](type-documentation/elements/itemslot)
+- [ItemSlotButton](type-documentation/elements/itemslotbutton)
+- [Label](type-documentation/elements/label)
+- [LabeledCheckBox](type-documentation/elements/labeledcheckbox)
+- [MenuItem](type-documentation/elements/menuitem)
+- [MultilineTextField](type-documentation/elements/multilinetextfield)
+- [NumberField](type-documentation/elements/numberfield)
+- [Panel](type-documentation/elements/panel)
+- [ProgressBar](type-documentation/elements/progressbar)
+- [ReorderableList](type-documentation/elements/reorderablelist)
+- [ReorderableListGrip](type-documentation/elements/reorderablelistgrip)
+- [SceneBlur](type-documentation/elements/sceneblur)
+- [Slider](type-documentation/elements/slider)
+- [SliderNumberField](type-documentation/elements/slidernumberfield)
+- [Sprite](type-documentation/elements/sprite)
+- [TabButton](type-documentation/elements/tabbutton)
+- [TabNavigation](type-documentation/elements/tabnavigation)
+- [TextButton](type-documentation/elements/textbutton)
+- [TextField](type-documentation/elements/textfield)
+- [TimerLabel](type-documentation/elements/timerlabel)
+- [ToggleButton](type-documentation/elements/togglebutton)
+
+## Property Types
+
+- [Anchor](type-documentation/property-types/anchor)
+- [BlockSelectorStyle](type-documentation/property-types/blockselectorstyle)
+- [ButtonSounds](type-documentation/property-types/buttonsounds)
+- [ButtonStyle](type-documentation/property-types/buttonstyle)
+- [ButtonStyleState](type-documentation/property-types/buttonstylestate)
+- [CheckBoxStyle](type-documentation/property-types/checkboxstyle)
+- [CheckBoxStyleState](type-documentation/property-types/checkboxstylestate)
+- [ClientItemStack](type-documentation/property-types/clientitemstack)
+- [ColorOptionGridStyle](type-documentation/property-types/coloroptiongridstyle)
+- [ColorPickerDropdownBoxStateBackground](type-documentation/property-types/colorpickerdropdownboxstatebackground)
+- [ColorPickerDropdownBoxStyle](type-documentation/property-types/colorpickerdropdownboxstyle)
+- [ColorPickerStyle](type-documentation/property-types/colorpickerstyle)
+- [DropdownBoxSearchInputStyle](type-documentation/property-types/dropdownboxsearchinputstyle)
+- [DropdownBoxSounds](type-documentation/property-types/dropdownboxsounds)
+- [DropdownBoxStyle](type-documentation/property-types/dropdownboxstyle)
+- [InputFieldButtonStyle](type-documentation/property-types/inputfieldbuttonstyle)
+- [InputFieldDecorationStyle](type-documentation/property-types/inputfielddecorationstyle)
+- [InputFieldDecorationStyleState](type-documentation/property-types/inputfielddecorationstylestate)
+- [InputFieldIcon](type-documentation/property-types/inputfieldicon)
+- [InputFieldStyle](type-documentation/property-types/inputfieldstyle)
+- [ItemGridSlot](type-documentation/property-types/itemgridslot)
+- [ItemGridStyle](type-documentation/property-types/itemgridstyle)
+- [LabeledCheckBoxStyle](type-documentation/property-types/labeledcheckboxstyle)
+- [LabeledCheckBoxStyleState](type-documentation/property-types/labeledcheckboxstylestate)
+- [LabelSpan](type-documentation/property-types/labelspan)
+- [LabelStyle](type-documentation/property-types/labelstyle)
+- [NumberFieldFormat](type-documentation/property-types/numberfieldformat)
+- [Padding](type-documentation/property-types/padding)
+- [PatchStyle](type-documentation/property-types/patchstyle)
+- [PopupStyle](type-documentation/property-types/popupstyle)
+- [ScrollbarStyle](type-documentation/property-types/scrollbarstyle)
+- [SliderStyle](type-documentation/property-types/sliderstyle)
+- [SoundStyle](type-documentation/property-types/soundstyle)
+- [SpriteFrame](type-documentation/property-types/spriteframe)
+- [SubMenuItemStyle](type-documentation/property-types/submenuitemstyle)
+- [SubMenuItemStyleState](type-documentation/property-types/submenuitemstylestate)
+- [Tab](type-documentation/property-types/tab)
+- [TabNavigationStyle](type-documentation/property-types/tabnavigationstyle)
+- [TabStyle](type-documentation/property-types/tabstyle)
+- [TabStyleState](type-documentation/property-types/tabstylestate)
+- [TextButtonStyle](type-documentation/property-types/textbuttonstyle)
+- [TextButtonStyleState](type-documentation/property-types/textbuttonstylestate)
+- [TextTooltipStyle](type-documentation/property-types/texttooltipstyle)
+- [ToggleButtonStyle](type-documentation/property-types/togglebuttonstyle)
+- [ToggleButtonStyleState](type-documentation/property-types/togglebuttonstylestate)
+
+## Enums
+
+- [ActionButtonAlignment](type-documentation/enums/actionbuttonalignment)
+- [CodeEditorLanguage](type-documentation/enums/codeeditorlanguage)
+- [ColorFormat](type-documentation/enums/colorformat)
+- [DropdownBoxAlign](type-documentation/enums/dropdownboxalign)
+- [InputFieldButtonSide](type-documentation/enums/inputfieldbuttonside)
+- [InputFieldIconSide](type-documentation/enums/inputfieldiconside)
+- [ItemGridInfoDisplayMode](type-documentation/enums/itemgridinfodisplaymode)
+- [LabelAlignment](type-documentation/enums/labelalignment)
+- [LayoutMode](type-documentation/enums/layoutmode)
+- [MouseWheelScrollBehaviourType](type-documentation/enums/mousewheelscrollbehaviourtype)
+- [ProgressBarAlignment](type-documentation/enums/progressbaralignment)
+- [ProgressBarDirection](type-documentation/enums/progressbardirection)
+- [ResizeType](type-documentation/enums/resizetype)
+- [TimerDirection](type-documentation/enums/timerdirection)
+- [TooltipAlignment](type-documentation/enums/tooltipalignment)
diff --git a/content/docs/pt-PT/official-documentation/npc/2-getting-started-with-templates.mdx b/content/docs/pt-PT/official-documentation/npc/2-getting-started-with-templates.mdx
index 91081ca1..99d078e0 100644
--- a/content/docs/pt-PT/official-documentation/npc/2-getting-started-with-templates.mdx
+++ b/content/docs/pt-PT/official-documentation/npc/2-getting-started-with-templates.mdx
@@ -9,7 +9,7 @@ authors:
 
 There are no hard and fast rules for making a start on a template. I like to duplicate **BlankTemplate** and start from there because it already provides the basic structure of the file.
 
-This leaves me with the following template (`Template_Goblin_Ogre.json`): (note: the file could be looking different in the current version of the game)
+This leaves me with the following template (`Template_Goblin_Ogre.json`): (**note: the file could be looking different in the current version of the game**)
 
 ```json
 {
@@ -33,7 +33,7 @@ This leaves me with the following template (`Template_Goblin_Ogre.json`): (note:
     }
   },
   "Appearance": { "Compute": "Appearance" },
-  "DropList": { "Compute": "Droplist" },
+  "DropList": { "Compute": "DropList" },
   "MaxHealth": { "Compute": "MaxHealth" },
   "MotionControllerList": [
     {
@@ -65,10 +65,10 @@ And the following variant (`Goblin_Ogre.json`) next to the template. There's a t
   "Type": "Variant",
   "Reference": "Template_Goblin_Ogre",
   "Modify": {
-    "Appearance": "Goblin_Ogre",
+    "Appearance": "Goblin",
     "MaxHealth": 124
   }
 }
 ```
 
-Our artists have defined the `Goblin_Ogre` appearance already so I'm going to use that.
+Our artists have not yet finished animations for the `Goblin_Ogre`, for that sake of the tutorial I am going to use appearance `Goblin`, because it offers a more complete set of animations that we will need.
diff --git a/content/docs/pt-PT/official-documentation/worldgen/pack-tutorial/asset-packs.mdx b/content/docs/pt-PT/official-documentation/worldgen/pack-tutorial/asset-packs.mdx
index 38809fad..dcf1f3b9 100644
--- a/content/docs/pt-PT/official-documentation/worldgen/pack-tutorial/asset-packs.mdx
+++ b/content/docs/pt-PT/official-documentation/worldgen/pack-tutorial/asset-packs.mdx
@@ -9,13 +9,13 @@ authors:
 
 <OfficialDocumentationNotice />
 
-# How to modify Hytale
+# How to modify Hytale?
 
-## What's an Asset Pack
+## What's an Asset Pack?
 
-Hytales gameplay is driven by assets in the game that can be modified by creators. Asset Packs are our solution to let you override or add features to the base game with your own work. These can in the form of zip files of folders, which contain a custom set of assets. This is not the only way for a creator to change Hytale but this is the most accessible form.;
+Hytales gameplay is driven by assets in the game that can be modified by creators. Asset Packs are our solution to let you override or add features to the base game with your own work. These can be the form of zip files of folders, which contain a custom set of assets. This is not the only way for a creator to change Hytale but this is the most accessible form.;
 
-### How do I make an Asset Pack
+### How do I make an Asset Pack?
 
 <video controls className="my-6 aspect-video w-full rounded-lg border">
   <source src="https://cdn.internal.hytalemodding.dev/guides/official/how-to-asset-pack.mp4" type="video/mp4" />
@@ -48,7 +48,7 @@ An asset pack is typically a zip or folder, with a `manifest.json` inside. This
 }
 ```
 
-### Where are they stored
+### Where are they stored?
 
 Asset Packs are stored with other mods in the Mods folder.
 
@@ -76,7 +76,7 @@ C:\Users\<user>\AppData\Roaming\Hytale\UserData\Saves\New World 5\mods
 
 When you have Asset Packs or Mods installed, these will appear in the New World menu under the Options menu.;
 
-### How do I change an existing asset
+### How do I change an existing asset?
 
 <video controls className="my-6 aspect-video w-full rounded-lg border">
   <source src="https://cdn.internal.hytalemodding.dev/guides/official/how-to-asset.mp4" type="video/mp4" />
diff --git a/content/docs/pt-PT/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx b/content/docs/pt-PT/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx
index 44528376..24e628b5 100644
--- a/content/docs/pt-PT/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx
+++ b/content/docs/pt-PT/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx
@@ -106,7 +106,7 @@ If a BaseHeight is provided, the TopY and BottomY values are relative to the Bas
 
 Applies a Material Provider slot on a set of horizontal stripes of blocks of varying thickness and position. Below is an example image of basalt stripes into a stone cliff.
 
-{/* ![](https://540086904-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F7KAmBkOg6d13nZCkf9ku%2Fuploads%2FbcxO9LpArn8gPCaBwFg5%2Funknown.png?alt=media&token=1c72b67a-8253-4d03-8c64-1ad5f6830050) */}
+![Example of basalt stripes](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/basalt-stripes-example.png)
 
 #### Parameters:
 
diff --git a/content/docs/pt-PT/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx b/content/docs/pt-PT/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx
index 5e34acd4..a4418473 100644
--- a/content/docs/pt-PT/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx
+++ b/content/docs/pt-PT/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx
@@ -294,7 +294,7 @@ Combines all the positions into a single Positioins field.
 
 ---
 
-### SimpleHoritontal
+### SimpleHorizontal
 
 Keeps only the positions that are within the provided range.
 
diff --git a/content/docs/pt-PT/official-documentation/worldgen/worldgen-tutorial/README.mdx b/content/docs/pt-PT/official-documentation/worldgen/worldgen-tutorial/README.mdx
new file mode 100644
index 00000000..5f66d245
--- /dev/null
+++ b/content/docs/pt-PT/official-documentation/worldgen/worldgen-tutorial/README.mdx
@@ -0,0 +1,166 @@
+---
+title: How to edit and create Biomes
+description: Explores where world generation assets can be found and how to edit them.
+---
+
+### Where are the Assets
+
+World generation assets are kept in the HytaleGenerator directory within the assets.
+
+```
+/Server/HytaleGenerator/
+```
+
+<div className="flex flex-row rounded-lg border p-4">
+  <div className="flex-1/2 border-r pr-4">
+    ```
+    /Biomes
+    ```
+
+    Biome assets, with content configurations.
+  </div>
+
+  <div className="flex-1/2 pl-4">
+    ```
+    /WorldStructure
+    ```
+
+    Generator files that define which biomes spawn together.
+  </div>
+</div>
+
+<div className="flex flex-row rounded-lg border p-4">
+  <div className="flex-1/2 border-r pr-4">
+    ```
+    /Density
+    ```
+
+    Density assets that can be referenced by any other assets.
+  </div>
+
+  <div className="flex-1/2 pl-4">
+    ```
+    /Assignments
+    ```
+
+    Prop assets that can be referenced by any Biome assets.
+  </div>
+</div>
+
+***
+
+An example of this structure can be found bellow, packed in an asset pack with the instance configuration.
+
+[https://drive.google.com/file/d/1sIz_CluANIIe3n8vNiOi-4PQdeqCO0qY/view?usp=drive_link](https://drive.google.com/file/d/1sIz_CluANIIe3n8vNiOi-4PQdeqCO0qY/view?usp=drive_link)
+
+<Callout>
+  Ensure you place your asset pack in the correct directory, under Mods.
+</Callout>
+
+### How to visit our worlds
+
+https://drive.google.com/file/d/1BJurxyj-taE-PXWm04bk7Dl6X7ZHTH92/view?usp=sharing
+
+#### Requirements
+
+- You must be an **Operator** in the world.
+  - To do this, run <mark style="color:$danger;">`/op self`</mark>
+- You must be in **Creative mode**.
+  - Press the <mark style="color:$danger;">`O`</mark> key, O for Orange.&#x20;
+
+The generation assets define a set of generators but on their own you cannot visit these. Currently you require an Instance with a generator that will allow you to visit your work.
+
+```
+/Server/Instances/
+```
+
+Instances are separate worlds that players can join using the `/instances` command. Each instance has an `Instance.bson` configuration asset that specifies which generator to use, among other worldly settings.
+
+```json
+{
+  "WorldGen": {
+    "Type": "HytaleGenerator",
+    "WorldStructure": "Basic",
+    "playerSpawn" : {
+      "X" : 123,
+      "Y" : 480,
+      "Z" : 10000,
+      "Pitch" : 0,
+      "Yaw" : 0,
+      "Roll" : 0
+    }
+  }
+}
+```
+
+<Callout>
+  You can create custom instances for different world structures and biomes as you need them.
+</Callout>
+
+### How to edit Biomes
+
+<video>
+  <source src="https://cdn.internal.hytalemodding.dev/guides/official/How-to-edit-Biomes.mp4" type="video/mp4" />
+</video>
+
+We currently use the Hytale Node Editor when editing world generation assets. This can be accessed while in-game from the Content Creation menu when pressing B. The node editor is then found under the asset editor dropdown on the upper left.&#x20;
+
+![Node Editor 1](/assets/official-documentation/worldgen/worldgen-tutorial/biomes/node-editor-1.png)
+
+Once you have the Hytale Node Editor open, through the file menu you can open Biomes by navigating to the Biomes directory and selecting one from your pack.&#x20;
+
+```
+/Server/HytaleGenerator/Biomes/
+```
+
+### Biome Asset Structure
+
+Every Biome has a root Biome node, this node splits into 5 structures. This is covered briefly but more information on each field can be found on the World Generation Concepts page.
+
+![Node Editor 2](/assets/official-documentation/worldgen/worldgen-tutorial/biomes/node-editor-2.png)
+
+<Callout>
+  Each biome is for the most part self contained, meaning it has control over what appears with the biome. The only exception to this are Base Heights.
+</Callout>
+
+<Tabs>
+  <Tab value="Terrain">
+    Mathematical function nodes that calculate the physical shape of the Biome's terrain.
+  </Tab>
+
+  <Tab value="Materials">
+    Logical nodes that determine what materials (blocks) make up a Biome's terrain.
+  </Tab>
+
+  <Tab value="Props">
+    Function nodes that add objects like prefabs and decorations to the terrain.
+  </Tab>
+
+  <Tab value="Environments">
+    Logical nodes that determine the environment asset at a given coordinate within the biome. This asset determines things like weather, NPC spawns, and sounds.
+  </Tab>
+
+  <Tab value="Tints">
+    Logical function nodes that determine a colour code that can be used by certain blocks in the world. Typically this will be grasses and soils.
+  </Tab>
+</Tabs>
+
+### How to preview your work
+
+[https://drive.google.com/file/d/1mNcHn9LhFnWDF0DzWFH6_YllmKAUvUry/view?t=6](https://drive.google.com/file/d/1mNcHn9LhFnWDF0DzWFH6_YllmKAUvUry/view?t=6)
+
+Once you are in an Instance world with the Hytale Generator active you will only be able to see your work by generating new chunks. There are a few ways to do this.
+
+The viewport command selects an area around the Player that will live reload as you make changes to the generator.&#x20;
+
+```
+/viewport --radius 5 
+```
+
+You can also create a new world to show your changes.&#x20;
+
+```
+/instances spawn <instance> 
+```
+
+The last option is to simply fly south, new chunks will generate with the changes made.
diff --git a/content/docs/pt-PT/quick-start.mdx b/content/docs/pt-PT/quick-start.mdx
index 653644f4..249d803a 100644
--- a/content/docs/pt-PT/quick-start.mdx
+++ b/content/docs/pt-PT/quick-start.mdx
@@ -9,3 +9,8 @@ Welcome to the Hytale modding documentation! Here you'll find everything you nee
 * [Setting up your dev environment](./guides/plugin/setting-up-env)
 * [Entity Component System (ECS)](./guides/ecs/entity-component-system)
 * [Publishing your mod](./publishing)
+
+### Useful Links
+
+* [Kaupenjoe's Modding Videos](https://www.youtube.com/@ModdingByKaupenjoe)
+* [TroubleDEV's Modding Videos](https://www.youtube.com/@TroubleDEV)
diff --git a/content/docs/pt-PT/server/argtypes.mdx b/content/docs/pt-PT/server/argtypes.mdx
new file mode 100644
index 00000000..e54a442e
--- /dev/null
+++ b/content/docs/pt-PT/server/argtypes.mdx
@@ -0,0 +1,61 @@
+---
+title: ArgTypes
+description: Available ArgTypes
+icon: List
+full: true
+authors:
+  - name: Valeena
+---
+
+| Name                        | Target Class                           | Description                                                                                                                               |   |
+| :-------------------------- | :------------------------------------- | :---------------------------------------------------------------------------------------------------------------------------------------- | - |
+| Boolean                     | java.lang.Boolean                      | A 'true' or 'false' input                                                                                                                 |   |
+| Integer                     | java.lang.Integer                      | A whole number                                                                                                                            |   |
+| String                      | java.lang.String                       | Words, text, numbers, letters. To input more than one word at a time, you may need to wrap it with double quotes (`"my fancy sentence"`). |   |
+| Float                       | java.lang.Float                        | A floating-pointer number                                                                                                                 |   |
+| Double                      | java.lang.Double                       | A decimal number                                                                                                                          |   |
+| UUID                        | java.util.UUID                         | A UUID (Universally Unique IDentifier)                                                                                                    |   |
+| Player_UUID                 | java.util.UUID                         | A UUID or an online player username                                                                                                       |   |
+| Game_Profile_Lookup_Async   | ProfileServiceClient.PublicGameProfile | A player UUID or username. If not found locally, performs a remote lookup via the Profile Service.                                        |   |
+| Relative_Double_Coord       | Coord                                  | An x, y, or z coordinate as a decimal, optionally relative by specifying a tilde (~) in front of the number                               |   |
+| Relative_Int_Coord          | IntCoord                               | An x, y, or z coordinate as a whole number, optionally relative by specifying a tilde (~) in front of the number                          |   |
+| Relative_Integer            | RelativeInteger                        | A tilde to mark an integer relative to a base                                                                                             |   |
+| Relative_Float              | RelativeFloat                          | A tilde to mark a float relative to a base                                                                                                |   |
+| Player_Ref                  | PlayerRef                              | A UUID or an online player's username                                                                                                     |   |
+| World                       | World                                  | A world folder name                                                                                                                       |   |
+| Model_Asset                 | ModelAsset                             | A reference to an Asset of type Model                                                                                                     |   |
+| Weather_Asset               | Weather                                | A reference to an Asset of type Weather                                                                                                   |   |
+| Interaction_Asset           | Interaction                            | A reference to an Asset of type Interaction                                                                                               |   |
+| Root_Interaction_Asset      | RootInteraction                        | A reference to an Asset of type Root Interaction                                                                                          |   |
+| Effect_Asset                | EntityEffect                           | A refernece to an Asset of type EntityEffect                                                                                              |   |
+| Environment_Asset           | Environment                            | A reference to an Asset of type Environment                                                                                               |   |
+| Item_Asset                  | Item                                   | A reference to an Asset of type Item                                                                                                      |   |
+| Block_Type_Asset            | BlockType                              | A reference to an Asset of type BlockType                                                                                                 |   |
+| Particle_System             | ParticleSystem                         | A reference to an Asset of type ParticleSystem                                                                                            |   |
+| Hitbox_Collision_Config     | HitboxCollisionConfig                  | A reference to an Asset of type HitboxCollisionConfig                                                                                     |   |
+| Repulsion_Config            | RepulsionConfig                        | A reference to an Asset of type RepulsionConfig                                                                                           |   |
+| Sound_Event_Asset           | SoundEvent                             | A reference to an Asset of type SoundEvent                                                                                                |   |
+| Ambiance_Fx_Asset           | AmbianceFX                             | A reference to an Asset of type AmbianceFX                                                                                                |   |
+| Sound_Category              | SoundCategory                          | A sound category (sfx, music, ambient, ui)                                                                                                |   |
+| Entity_ID                   | `ArgWrapper<EntityWrappedArg, UUID>`   | A UUID representing an entity id                                                                                                          |   |
+| Integer_Comparison_Operator | IntegerComparisonOperator              | A mathematical sign for integer comparison                                                                                                |   |
+| Integer_Operation           | IntegerOperation                       | A mathematical sign for performing an operation                                                                                           |   |
+| Int_Range                   | `Pair<Integer, Integer>`               | Two integers representing a minimum and maximum of a range                                                                                |   |
+| Relative_Int_Range          | RelativeIntRange                       | Two integers representing a minimum and maximum of a range                                                                                |   |
+| Vector2I                    | Vector2i                               | Two integers, generally corresponding to x/z axis                                                                                         |   |
+| Vector3I                    | Vector3i                               | Three integers, generally corresponding to x/y/z axis                                                                                     |   |
+| Relative_Vector3I           | RelativeVector3i                       | Three optionally relative integers, generally corresponding to x/y/z axis                                                                 |   |
+| Relative_Block_Position     | RelativeIntPosition                    | A position with three integer coordinates, representing a block's location in world space.                                                |   |
+| Relative_Position           | Relative                               | A position with three decimal coordinates, representing a location in world space.                                                        |   |
+| Relative_Chunk_Position     | RealtiveChunkPosition                  | A position with two integer coordinates (x, z), representing a chunk's location.                                                          |   |
+| Rotation                    | Vector3f                               | A rotation with three coordinates, representing the pitch, yaw, and roll respectively                                                     |   |
+| Block_Type_Key              | String                                 | A block type                                                                                                                              |   |
+| Block_ID                    | Integer                                | A block type, converted to an int id                                                                                                      |   |
+| Color                       | Integer                                | A color value in hex format, hex integer, or decimal integer                                                                              |   |
+| Weighted_Block_Type         | `Pair<Integer, String>`                | A weight corresponding to a blocktype                                                                                                     |   |
+| Weighted_Block_Entry        | String                                 | A block with optional weight prefix                                                                                                       |   |
+| Block_Pattern               | BlockPattern                           | A list of blocks with optional weights                                                                                                    |   |
+| Individual_Block_Mask       | BlockMask                              | Create a block mask using symbols and block names                                                                                         |   |
+| Block_Mask                  | BlockMask                              | A tick rate value (e.g., 30tps, 33ms, or 30)                                                                                              |   |
+| Tick_Rate                   | Integer                                | A list of block masks that combine together                                                                                               |   |
+| Game_Mode                   | GameMode                               | GameMode                                                                                                                                  |   |
diff --git a/content/docs/pt-PT/server/interaction-reference.mdx b/content/docs/pt-PT/server/interaction-reference.mdx
new file mode 100644
index 00000000..6c0d01b3
--- /dev/null
+++ b/content/docs/pt-PT/server/interaction-reference.mdx
@@ -0,0 +1,1586 @@
+---
+title: Interactions
+description: A list of most Interaction types provided by Hypixel, along with the meaning of their fields, and how they fit together.
+icon: List
+authors:
+  - name: Stephen Baynham
+    url: https://github.com/cannibalvox
+---
+
+### The Interaction Base Type
+
+All interactions of every type below are inherited from Interaction and have these fields.
+
+**Interaction Fields**
+
+| Field Name                | Type                                                                 | Required? | Notes                                                                                                                                                                                                                       |
+| ------------------------- | -------------------------------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| ViewDistance              | `Double`<br />(Default: 96.0)                                        | **No**    | Distance in blocks at which other players can see the effects from this interaction.                                                                                                                                        |
+| Effects                   | `InteractionEffects`                                                 | **No**    | Sound, animations, and particle effects that should trigger when this interaction begins executing.                                                                                                                         |
+| HorizontalSpeedMultiplier | `Float`<br />(Default: 1.0)                                          | **No**    | Multiplier applied to the User entity's movement speed while this interaction is executing                                                                                                                                  |
+| RunTime                   | `Float`                                                              | **No**    | If provided, this interaction will continue executing for at least this long before the interaction chain moves onto the next interaction.                                                                                  |
+| CancelOnItemChange        | `Boolean`<br />(Default: true)                                       | **No**    | If true, this interaction will be cancelled if the User entity's held item changes during execution. This can happen either due to the selected hotbar slot changing or the contents of the item's inventory slot changing. |
+| Rules                     | `InteractionRules`                                                   | **Yes**   | If provided, adds additional limitations and cancellation conditions to this interaction.                                                                                                                                   |
+| Settings                  | `Map`<br />(Key Type: `GameMode`, Value Type: `InteractionSettings`) | **No**    | If provided, adds additional per-GameMode settings to the interaction.                                                                                                                                                      |
+| Camera                    | `InteractionCameraSettings`                                          | **No**    | Arrays of camera motion keyframes for cutscenes and reveals.                                                                                                                                                                |
+
+**GameMode Values**
+
+- `Creative`: The game is currently in Creative Mode
+- `Adventure`: The game is currently in Adventure Mode
+
+**InteractionEffects Fields**
+
+| Field Name               | Type                                              | Required? | Notes                                                                                                                                                 |
+| ------------------------ | ------------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Particles                | `Array`<br />(Element Type: `ModelParticle`)      | **No**    | Particle systems to activate when this interaction begins if the player is in third-person mode.                                                      |
+| FirstPersonParticles     | `Array`<br />(Element Type: `ModelParticle`)      | **No**    | Particle systems to activate when this interaction begins if the player is in first-person mode.                                                      |
+| WorldSoundEventId        | `Asset`<br />(Asset Type: `SoundEvent`)           | **No**    | A sound to play in the world at the User entity's location when this interaction begins.<br />**The SoundEvent must be single-channel (mono) sound.** |
+| LocalSoundEventId        | `Asset`<br />(Asset Type: `SoundEvent`)           | **No**    | A 2D sound to play for the User entity when this interaction begins. Ignored if the User entity is not a player.                                      |
+| Trails                   | `Array`<br />(Element Type: `ModelTrail`)         | **No**    | Trail effects to activate on the User entity when this interaction begins.                                                                            |
+| WaitForAnimationToFinish | `Boolean`<br />(Default: false)                   | **No**    | If true, this interaction will continue executing for at least the length of any animations in this InteractionEffects object.                        |
+| ItemPlayerAnimationsId   | `Asset`<br />(Asset Type: `ItemPlayerAnimations`) | **No**    | If provided, the User entity will use this ItemPlayerAnimations set while this interaction is executing.                                              |
+| ItemAnimationId          | `String`                                          | **No**    | Id of an animation to trigger when this interaction begins executing.<br />**This animation id is not validated on server start.**                    |
+| ClearAnimationOnFinish   | `Boolean`<br />(Default: false)                   | **No**    | If true, animations triggered by this interaction will be halted when the interaction completes.                                                      |
+| ClearSoundEventOnFinish  | `Boolean`<br />(Default: false)                   | **No**    | If true, sounds triggered by this interaction will be halted when the interaction completes.                                                          |
+| CameraEffect             | `Asset`<br />(Asset Type: `CameraEffect` )        | **No**    | If provided, the CameraEffect will be applied while this interaction is executing.                                                                    |
+| MovementEffects          | `MovementEffects`                                 | **No**    | If provided, apply the movement effects to the User entity while this interaction is executing.                                                       |
+| StartDelay               | `Float`<br />(Default: 0.0f)                      | **No**    | The interaction will wait this many seconds before triggering the effects in this object.                                                             |
+
+**InteractionRules Fields**
+
+| Field Name          | Type                                                                                                | Required? | Notes                                                                                                                                                                                                                                     |
+| ------------------- | --------------------------------------------------------------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| BlockedBy           | `Array`<br />(Element Type: `InteractionType`)<br />(Default: Based on the chain's InteractionType) | **No**    | If provided, this RootInteraction cannot be executed while interaction chains of the provided types are executing.<br />**This field only functions for rules attached to a RootInteraction. It has no effect on an Interaction.**        |
+| Blocking            | `Array`<br />(Element Type: `InteractionType`)                                                      | **No**    | If provided, interaction chains with the specified InteractionTypes cannot be executed while this interaction is executing.                                                                                                               |
+| InterruptedBy       | `Array`<br />(Element Type: `InteractionType`)                                                      | **No**    | If provided, interaction chains with the specified InteractionTypes will cancel this interaction chain when they execute.<br />**This field only functions for rules attached to a RootInteraction. It has no effect on an Interaction.** |
+| Interrupting        | `Array`<br />(Element Type: `InteractionType`)                                                      | **No**    | If provided, interaction chains with the specified InteractionTypes will be canceled when this interaction begins.                                                                                                                        |
+| BlockedByBypass     | `String`                                                                                            | **No**    | If provided, this RootInteraction cannot be blocked by interaction chains whose RootInteraction has this value as an asset tag.                                                                                                           |
+| BlockingBypass      | `String`                                                                                            | **No**    | If provided, this interaction will not block RootInteractions that have the this value as an asset tag.                                                                                                                                   |
+| InterruptedByBypass | `String`                                                                                            | **No**    | If provided, this RootInteraction cannot be canceled by RootInteractions that have this value as an asset tag.                                                                                                                            |
+| InterruptingBypass  | `String`                                                                                            | **No**    | If provided, this interaction will not cancel interaction chains whose RootInteraction has this value as an asset tag.                                                                                                                    |
+
+**InteractionType Values**
+
+- `Primary`
+- `Secondary`
+- `Ability1`
+- `Ability2`
+- `Ability3`
+- `Use`
+- `Pick`
+- `Pickup`
+- `CollisionEnter`
+- `CollisionLeave`
+- `Collision`
+- `EntityStatEffect`
+- `SwapTo`
+- `SwapFrom`
+- `Death`
+- `Wielding`
+- `ProjectileSpawn`
+- `ProjectileHit`
+- `ProjectileMiss`
+- `ProjectileBounce`
+- `Held`
+- `HeldOffhand`
+- `Equipped`
+- `Dodge`
+- `GameModeSwap`
+
+**InteractionSettings Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                        |
+| ---------------- | ------------------------------- | --------- | -------------------------------------------------------------------------------------------- |
+| AllowSkipOnClick | `Boolean`<br />(Default: false) | **No**    | If true, the user will be able to skip this interaction by clicking shortly after it starts. |
+
+**InteractionCameraSettings Fields**
+
+| Field Name  | Type                                             | Required? | Notes                                                                                                                                                           |
+| ----------- | ------------------------------------------------ | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| FirstPerson | `Array`<br />(Element Type: `InteractionCamera`) | **No**    | A list of camera keyframes to be played if the player is in first-person.<br />**The time of each keyframe must be after the keyframe before it in the array.** |
+| ThirdPerson | `Array`<br />(Element Type: `InteractionCamera`) | **No**    | A list of camera keyframes to be played if the player is in third-person.<br />**The time of each keyframe must be after the keyframe before it in the array.** |
+
+**InteractionCamera Fields**
+
+| Field Name | Type                         | Required? | Notes                                                                                                                                       |
+| ---------- | ---------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------- |
+| Time       | `Float`<br />(Default: 0.1f) | **No**    | How long after the interaction begins executing that the camera should arrive at this keyframe.<br />**Cannot be less than or equal to 0.** |
+| Position   | `Vector3`                    | **Yes**   | Where the camera should be located when it arrives at this keyframe.                                                                        |
+| Rotation   | `Direction`                  | **Yes**   | Where the camera should be pointing when it arrives at this keyframe.                                                                       |
+
+### SimpleInteraction
+
+Most interaction types below are inherited from SimpleInteraction and have these
+fields.  If a type does not have these fields, the documentation will mention it.
+
+The purpose of SimpleInteraction is to facilitate Interaction chaining by taking different paths
+based on whether the Interaction succeeded or failed.  The circumstances under which
+a given Interaction fails are generally type-specific (and described in the documentation
+below), but all interactions will be marked failed if they are cancelled via one of the
+many, many mechanisms for doing so.
+
+It is valid to create an interaction asset of type "Simple", which can be valuable when you want to use the
+interaction fields with no additional functionality.
+
+**SimpleInteraction Fields**
+
+| Field Name | Type                                     | Required? | Notes                                                                                          |
+| ---------- | ---------------------------------------- | --------- | ---------------------------------------------------------------------------------------------- |
+| Next       | `Asset`<br />(Asset Type: `Interaction`) | **No**    | After this Interaction has finished, "Next" will be executed if this Interaction did not fail. |
+| Failed     | `Asset`<br />(Asset Type: `Interaction`) | **No**    | After this Interaction has finished, "Failed" will be executed if this Interaction failed.     |
+
+## Flow Control
+
+These are interaction types used to control the flow of an interaction chain and allow interactions
+to be composed into more complex behaviors.  These interaction types generally do not pertain to
+the game and instead pertain to the interaction system itself.
+
+### Condition
+
+This interaction will fail if one of the fields is provided but does not match the current state.
+
+**Condition Fields**
+
+| Field Name       | Type       | Required? | Notes                                                                                                                                                                                    |
+| ---------------- | ---------- | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| RequiredGameMode | `GameMode` | **No**    | If provided, the interaction will fail if the current GameMode does not match the provided value.                                                                                        |
+| Jumping          | `Boolean`  | **No**    | If provided, the interaction will fail if the player's Jumping state does not match the provided value. (i.e. if True, the player must be jumping, if False, the player must not be)     |
+| Swimming         | `Boolean`  | **No**    | If provided, the interaction will fail if the player's Swimming state does not match the provided value. (i.e. if True, the player must be swimming, if False, the player must not be)   |
+| Crouching        | `Boolean`  | **No**    | If provided, the interaction will fail if the player's Crouching state does not match the provided value. (i.e. if True, the player must be crouching, if False, the player must not be) |
+| Running          | `Boolean`  | **No**    | If provided, the interaction will fail if the player's Running state does not match the provided value. (i.e. if True, the player must be running, if False, the player must not be)     |
+| Flying           | `Boolean`  | **No**    | If provided, the interaction will fail if the player's Flying state does not match the provided value. (i.e. if True, the player must be flying, if False, the player must not be)       |
+
+**GameMode Values**
+
+- `Creative`: The game is currently in Creative Mode
+- `Adventure`: The game is currently in Adventure Mode
+
+### FirstClick
+
+This interaction does not inherit from SimpleInteraction and therefore has no Next or Failed fields.
+
+This interaction has two fields that each contain a reference to an Interaction: Click and Hold.  If the root interaction
+of the chain was initiated by a client button/key press (or simulated NPC input) and the input was a tap, then
+the Click interaction is run. if it was a longer press, then the Hold interaction is run.
+
+As a minor implementation detail, this interaction is internally marked as failed when the Hold path is followed.
+This generally shouldn't matter.  If the interaction was not initiated by a key press at all, the Click path will be followed,
+but it seems risky to rely on that behavior.
+
+**FirstClick Fields**
+
+| Field Name | Type                                     | Required? | Notes                                                                                                                                                    |
+| ---------- | ---------------------------------------- | --------- | -------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Click      | `Asset`<br />(Asset Type: `Interaction`) | **No**    | If provided and the root interaction of the chain was initiated by button/key press, this interaction is executed next if the press was a quick tap.     |
+| Hold       | `Asset`<br />(Asset Type: `Interaction`) | **No**    | If provided and the root interaction of the chain was initiated by a button/key press, this interaction is executed next if the press was a longer hold. |
+
+### Interrupt
+
+This interaction can be used to cancel one or more running interaction chains on an entity and **all forked interaction
+chains those chains have spawned that are still currently running**.  All interaction chains canceled in this manner will be marked as
+Failed, which may have additional implications if the canceled chains are themselves forked from
+other chains that are still running.
+
+**Interrupt Fields**
+
+| Field Name     | Type                                           | Required? | Notes                                                                                                                                                                                               |
+| -------------- | ---------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Entity         | `InteractionTarget`<br />(Default: User)       | **Yes**   | The entity that is the owner of the target interaction chains.  This field can indicate the Owner, User, or Target of this interaction chain.                                                       |
+| InterruptTypes | `Array`<br />(Element Type: `InteractionType`) | **No**    | A set of InteractionTypes that are to be interrupted. Only interactions of these types are affected. If null, all types will be interrupted.<br />**(Note: An empty set will interrupt NO TYPES.)** |
+| RequiredTag    | `String`                                       | **No**    | An asset tag that, if provided, the RootInteraction of the interaction chain must have in order to be canceled.                                                                                     |
+| ExcludedTag    | `String`                                       | **No**    | An asset tag that, if provided, the RootInteraction of the interaction chain must not have in order to be canceled.                                                                                 |
+
+**InteractionTarget Values**
+
+- `User` - The user of this interaction chain. The entity whose actions caused this interaction chain to be executed. This is usually the same as the Owner.
+- `Owner` - The owner of this interaction chain. The entity upon whom this interaction chain is executing.
+- `Target` - The entity target of this interaction chain, if any.  This value is mutable (and can therefore come from many places) but most commonly, it is an entity the User was targeting when this interaction chain began executing.
+
+**InteractionType Values**
+
+- `Primary`
+- `Secondary`
+- `Ability1`
+- `Ability2`
+- `Ability3`
+- `Use`
+- `Pick`
+- `Pickup`
+- `CollisionEnter`
+- `CollisionLeave`
+- `Collision`
+- `EntityStatEffect`
+- `SwapTo`
+- `SwapFrom`
+- `Death`
+- `Wielding`
+- `ProjectileSpawn`
+- `ProjectileHit`
+- `ProjectileMiss`
+- `ProjectileBounce`
+- `Held`
+- `HeldOffhand`
+- `Equipped`
+- `Dodge`
+- `GameModeSwap`
+
+### Parallel
+
+This interaction does not inherit from SimpleInteraction and therefore has no Next or Failed fields.
+
+This interaction has a field `Interactions` that is an array of RootInteraction assets. The list must contain at least
+two RootInteractions.  This interaction will fork all of its children except for the first into their
+own interaction chains and immediately complete. After this interaction completes, this interaction chain will
+execute the first RootInteraction in the `Interactions` list.
+
+This interaction does not have any failure conditions and is indifferent to the fate of the forked interaction chains.
+
+**Parallel Fields**
+
+| Field Name   | Type                                                | Required? | Notes                                                         |
+| ------------ | --------------------------------------------------- | --------- | ------------------------------------------------------------- |
+| Interactions | `AssetArray`<br />(Element Type: `RootInteraction`) | **Yes**   | An array of RootInteractions that will be forked or executed. |
+
+### Repeat
+
+This interaction has a field `ForkInteractions` that is an asset of type RootInteraction. This interaction will fork that
+RootInteraction into its own interaction chain and then wait for it to complete. If the RootInteraction fails, this
+interaction will complete immediately and be marked failed. Otherwise, the RootInteraction will be forked and run again,
+up to a specified total number of times.
+
+**Repeat Fields**
+
+| Field Name       | Type                                                                                   | Required? | Notes                                                                                                                                                                                                              |
+| ---------------- | -------------------------------------------------------------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| ForkInteractions | `Asset`<br />(Asset Type: `RootInteraction`)                                           | **Yes**   | A RootInteraction that will be forked.                                                                                                                                                                             |
+| Repeat           | `Integer`<br />(Default: 1)<br />**Must be -1 or a positive integer. 0 is not valid.** | **No**    | The total number of times to fork ForkInteractions. If -1 is provided, ForkInteractions will continue being forked and executed indefinitely, until this interaction is cancelled or until ForkInteractions fails. |
+
+### Replace
+
+This interaction does not inherit from SimpleInteraction and therefore has no Next or Failed fields.
+
+This interaction uses the InteractionVars system that is avaiable for items. InteractionVars are RootInteractions that
+can be attached to an Item asset with a name.
+
+This interaction specifies a var name, and if this interaction chain was executed through
+an item and that item has an InteractionVar of the same name, then this interaction will immediately execute
+the RootInteraction on the var.  Otherwise, it will execute the default RootInteraction specified in this interaction.
+If no default is specified, then this interaction will be marked as failed.
+
+**Replace Fields**
+
+| Field Name   | Type                                         | Required? | Notes                                                                                                                                                                                                           |
+| ------------ | -------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Var          | `String`                                     | **Yes**   | The name of the InteractionVar to execute.                                                                                                                                                                      |
+| DefaultValue | `Asset`<br />(Asset Type: `RootInteraction`) | **No**    | The RootInteraction to execute if the owning item does not have an InteractionVar by the specified name. If not provided, the interaction will be marked as failed instead.                                     |
+| DefaultOk    | `Boolean`<br />(Default: false)              | **No**    | If false, then an angry message will be printed to the server logs if the owning item does not have an InteractionVar by the specified name.  The functioning of this interaction will be otherwise unaffected. |
+
+### RunRootInteraction
+
+This interaction immediately executes the provided RootInteraction as part of this interaction chain. This interaction
+does not have any failure conditions.
+
+**RunRootInteraction Fields**
+
+| Field Name      | Type                                         | Required? | Notes                           |
+| --------------- | -------------------------------------------- | --------- | ------------------------------- |
+| RootInteraction | `Asset`<br />(Asset Type: `RootInteraction`) | **Yes**   | The RootInteraction to execute. |
+
+### Selector
+
+This interaction will execute a Selector to find entities and/or blocks (depending on the Selector) and fork off an
+interaction chain for each located entity or block. This interaction will not wait for those interaction chains
+to complete and is indifferent to their fate. The forked interaction chains will use the located entity/block as
+their target entity/target block. Each entity or block will only fork one interaction chain over the life of this
+interaction.  The Selector is guaranteed to run once for each execution of this interaction, but some Selectors
+are intended to be run over a period of time and sweep across an area to locate targets. In order to use those Selectors
+properly, you will need to extend the execution time of this interaction using `RunTime` or `WaitForAnimationToFinish`.
+The Selector will be executed repeatedly over the lifetime of the interaction.
+
+If the Selector is configured to locate entities, you can add additional sets of entity matching rules. If a located entity
+matches one of the rules, the matching RootInteraction will be forked instead of the standard `HitEntity` RootInteraction.
+
+Entities located by the Selector will be ignored if they do not have a NetworkId, if they are dead, or if they are invulnerable.
+The only exception to this rule is that players in Creative Mode that are marked to receive hits will not be ignored.
+
+This interaction's failure conditions are configurable via the `FailOn` field. You can configure this interaction to never
+fail, to fail if the Selector does not locate any blocks before this interaction finishes executing, to fail if the
+Selector does not locate any entities before this interaction finishes executing, or to fail in either case.
+
+**Selector Fields**
+
+| Field Name     | Type                                         | Required? | Notes                                                                                                                                                                                                                                     |
+| -------------- | -------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Selector       | `Selector`                                   | **Yes**   | The Selector is executed at least once and may be executed repeatedly to locate blocks and/or entities in an area.                                                                                                                        |
+| HitEntity      | `Asset`<br />(Asset Type: `RootInteraction`) | **No**    | If included and the `Selector` locates an entity that does not match any `HitEntityRules`, this RootInteraction will be forked into a new interaction chain with the located entity as the target entity.                                 |
+| HitEntityRules | `Array`<br />(Element Type: `HitEntity`)     | **No**    | If included, these rules will be matched against any entity located by the `Selector`. If an entity matches a set of rules, the RootInteraction associated with the rules will be forked instead of the standard `HitEntity` interaction. |
+| HitBlock       | `Asset`<br />(Asset Type: `RootInteraction`) | **No**    | If included and the `Selector` locates a block, this RootInteraction will be forked into a new interaction chain with the located block as the block target.                                                                              |
+| FailOn         | `FailOnType`<br />(Default: `Neither`)       | **No**    | Defines under what circumstances this interaction will fail.  It can be marked to fail when it completes without locating any blocks, it can be marked to fail when it completes without locating any entities, both, or neither.         |
+| IgnoreOwner    | `Boolean`<br />(Default: true)               | **No**    | If true, the Selector will not locate the User entity of this interaction.                                                                                                                                                                |
+
+**HitEntity Fields**
+
+| Field Name | Type                                         | Required? | Notes                                                                                                 |
+| ---------- | -------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------- |
+| Matchers   | `Array`<br />(Element Type: `EntityMatcher`) | **Yes**   | A set of rules that an entity must match. An entity must successful match all rules to be considered. |
+| Next       | `Asset`<br />(Asset Type: `RootInteraction`) | **Yes**   | The RootInteraction to fork if an entity matches all rules.                                           |
+
+**EntityMatcher Fields**
+
+| Field Name | Type                            | Required? | Notes                                                                                                     |
+| ---------- | ------------------------------- | --------- | --------------------------------------------------------------------------------------------------------- |
+| Type       | `String`                        | **Yes**   | If provided, specifies a type of EntityMatcher to use. Each matcher type may come with additional fields. |
+| Invert     | `Boolean`<br />(Default: false) | **No**    | If true, an entity must fail this rule for it to be marked as succeeded.                                  |
+
+**EntityMatcher Type: Player**
+
+This EntityMatcher will succesfully match the entity only if they are a player.
+
+**EntityMatcher Type: Vulnerable**
+
+This Entitymatcher will successfully match the entity only if they are not marked as invulnerable.
+
+**FailOnType Values**
+
+- `Neither`
+- `Entity`
+- `Block`
+- `Either`
+
+### Serial
+
+This interaction does not inherit from SimpleInteraction and therefore has no Next or Failed fields.
+
+This interaction has a field `Interactions` which is a list of Interaction assets. This interaction immediately
+completes and the interaction chain continues by executing the interactions in the list one at a time. This
+interaction does not have any failure conditions.
+
+**Serial Fields**
+
+| Field Name   | Type                                            | Required? | Notes                                      |
+| ------------ | ----------------------------------------------- | --------- | ------------------------------------------ |
+| Interactions | `AssetArray`<br />(Element Type: `Interaction`) | **Yes**   | An array of Interaction assets to execute. |
+
+## Cooldowns
+
+RootInteractions interface with a complex cooldown system that can be used for a variety of purposes. Aside from simply
+adding an important aspect of resource management to your game design, cooldowns can be used to ensure that click-activated
+interaction chains don't repeatedly spam if the player holds down the input.
+
+By default, every RootInteraction has a cooldown timer that is keyed to the RootInteraction name, and by default, it
+will launch a cooldown of 0.35 seconds when activated by client input.  Otherwise, no cooldown will be activated.  However,
+by configuring your RootInteraction, you can change the key for the cooldown (so that multiple RootInteractions can share
+a single cooldown), set the cooldown timer to whatever you like, and configure multiple charges that can build up over time
+to allow the entity to activate the RootInteraction multiple times before being forced to pause.
+
+One important concept to keep in mind is the difference between **cooldown** and **charge time**.  The cooldown, if any,
+is activated each time a RootInteraction triggers, even if the player has more available charges. If the RootInteraction
+is configured to use charges, then they will gradually build up over time. In order for a RootInteraction to be activated,
+the cooldown (if any) must be expired, and the RootInteraction must have at least one charge (if it has been
+configured to use charges).
+
+Bear in mind that the entire Cooldown configuration is shared between different RootInteractions with the same cooldown id.
+If you activate an ability with 5 charges and a short cooldown and then another ability with a much longer cooldown and no
+charges, the second ability will use the cooldown properties of the first ability until/unless the first ability finishes
+charging and is cleared from the system.  You should generally only have multiple RootInteractions share a cooldown id
+if they have the same configuration.
+
+The interactions below interact with the cooldown system to allow you to manipulate cooldowns via the interaction system. By
+using these interactions, you can have several interaction chains with different cooldown configurations share cooldowns
+that are checked and activated as part of the interaction chain itself, or have some components of an interaction change
+use a second cooldown separate from the main one.
+
+### CooldownCondition
+
+**CooldownCondition Fields**
+
+This interaction will fail if the specified cooldown id is on cooldown for the User entity.  This interaction will only
+function for players- the interaction will always succeed for NPCs.  In order for this interaction to succeed, the
+cooldown, if any, must have expired and at least one charge, if any, must have filled.
+
+| Field Name | Type     | Required? | Notes                     |
+| ---------- | -------- | --------- | ------------------------- |
+| Id         | `String` | **Yes**   | The cooldown id to check. |
+
+### IncrementCooldown
+
+**IncrementCooldown Fields**
+
+This interaction will modify a cooldown that is currently active on the User entity, allowing charges and remaining
+cooldown to be modified.
+Despite its name, this interaction can be used to reduce a cooldown as well as increase it. If the cooldown is not
+currently active, this interaction will have no effect. The interaction has no special failure conditions.
+
+| Field Name        | Type                        | Required? | Notes                                                                                                                                                                                                                                                                                     |
+| ----------------- | --------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Id                | `String`                    | **No**    | If provided, the cooldown id of the cooldown to be manipulated. If not provided, the cooldown id of the current chain's RootInteraction will be used.                                                                                                                                     |
+| Time              | `Float`<br />(Default: 0.0) | **No**    | The amount to increase the remaining cooldown by. Can be negative. The remaining cooldown time will not be reduced below zero or increased above the maximum cooldown time.                                                                                                               |
+| ChargeTime        | `Float`<br />(Default: 0.0) | **No**    | The amount to increase the remaining time until the next charge is filled by. Can be negative. The remaining charge time cannot be reduced below zero or increased above the maximum cooldown time. **This will not work on abilities that have a maximum of 1 charge, for some reason.** |
+| Charge            | `Integer`<br />(Default: 0) | **No**    | The amount to increase the number of charges by. Can be negative. The number of charges cannot be reduced below 0 or increased above the maximum.                                                                                                                                         |
+| InterruptRecharge | `Boolean`(Default: false)   | **No**    | If true and `Charge` is not 0, will reset the remaining time to the next charge to the maximum value after changing the charge count.                                                                                                                                                     |
+
+### ResetCooldown
+
+This interaction will trigger a cooldown on the User entity with a specified configuration. The charges will be refilled
+but the cooldown will be immediately triggered.  The mechanisms for deciding on the configuration are a little bit complicated.
+You may specify a cooldown configuration via the `Cooldown` field. If you do not include an `Id` field, then the
+interaction chain's RootInteraction will be used for any field not specified in the configuration. If there is an active
+cooldown under the specified `Id` (or under the RootInteraction's cooldown id if none is specified) then the fields
+from that active cooldown will overwrite data in the RootInteraction's cooldown, but not data in your `Cooldown` field.
+
+**ResetCooldown Fields**
+
+| Field Name | Type                  | Required? | Notes                                                        |
+| ---------- | --------------------- | --------- | ------------------------------------------------------------ |
+| Cooldown   | `InteractionCooldown` | **No**    | A cooldown configuration to use for the new, reset cooldown. |
+
+**InteractionCooldown Fields**
+
+| Field Name        | Type                                 | Required? | Notes                                                                                                                                                                                                 |
+| ----------------- | ------------------------------------ | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Id                | `String`                             | **No**    | The cooldown id to use for this cooldown. If not provided, the RootInteraction's cooldown id will be used, if any.                                                                                    |
+| Cooldown          | `Float`<br />(Default: 0.0)          | **No**    | The duration of the cooldown, in seconds.                                                                                                                                                             |
+| Charges           | `Array`<br />(Element Type: `Float`) | **No**    | If provided, a list of how many charges this cooldown can build, and how long each charge takes to build, in seconds.                                                                                 |
+| InterruptRecharge | `Boolean`<br />(Default: false)      | **No**    | If true, the charge time will be reset when the number of charges changes.                                                                                                                            |
+| ClickBypass       | `Boolean`<br />(Default: false)      | **No**    | If true, RootInteractions keyed to this cooldown can still be activated when it is on cooldown provided that the RootInteraction was triggered by a distinct key or mouse button press on the client. |
+
+### TriggerCooldown
+
+This interaction is similar to ResetCooldown, except instead of refilling the cooldown's charges, one charge will be deducted
+as normal.
+
+**TriggerCooldown Fields**
+
+| Field Name | Type                  | Required? | Notes                                                        |
+| ---------- | --------------------- | --------- | ------------------------------------------------------------ |
+| Cooldown   | `InteractionCooldown` | **No**    | A cooldown configuration to use for the new, reset cooldown. |
+
+**InteractionCooldown Fields**
+
+| Field Name        | Type                                 | Required? | Notes                                                                                                                                                                                                 |
+| ----------------- | ------------------------------------ | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Id                | `String`                             | **No**    | The cooldown id to use for this cooldown. If not provided, the RootInteraction's cooldown id will be used, if any.                                                                                    |
+| Cooldown          | `Float`<br />(Default: 0.0)          | **No**    | The duration of the cooldown, in seconds.                                                                                                                                                             |
+| Charges           | `Array`<br />(Element Type: `Float`) | **No**    | If provided, a list of how many charges this cooldown can build, and how long each charge takes to build, in seconds.                                                                                 |
+| InterruptRecharge | `Boolean`<br />(Default: false)      | **No**    | If true, the charge time will be reset when the number of charges changes.                                                                                                                            |
+| ClickBypass       | `Boolean`<br />(Default: false)      | **No**    | If true, RootInteractions keyed to this cooldown can still be activated when it is on cooldown provided that the RootInteraction was triggered by a distinct key or mouse button press on the client. |
+
+## Combo Chains
+
+Hytale additionally comes with a rich "combo chaining" system, which allows several inputs in a row to result in different
+attacks and special moves.  Rather than being attached to the RootInteraction like the cooldown system, these are
+primarily driven by the `Chaining` interaction.
+
+### Chaining
+
+This interaction does not inherit from SimpleInteraction and therefore has no Failed field. Its Next field works differently
+from most interaction types.
+
+Chaining is a type of flow control interaction- each time a Chaining interaction with the same `ChainId` is called, a single
+interaction in the `Next` list is chosen and the others are ignored. The first time the `ChainId` is used, the first
+interaction in the list is chosen, the next time the second, etc. Once the end of the list is reached, the first
+interaction will be chosen again.
+
+Bear in mind: the progress through the Next list is based on the **ChainId**, not the interaction!  That means that two
+different Chaining interactions can share a single combo chain. You could have a pair of daggers that attacks with
+the left when the left mouse button is clicked and with the right when the right mouse button is clicked.  You could give
+both interaction chains a Chaining interaction with the same `ChainId` and three `Next` entries that do a light-light-heavy
+combo.  Each specific hit would occur with either the left or the right knife based on which button you clicked, but
+the combo would be otherwise identical regardless of which you chose.
+
+The Chaining interaction also has a concept called "flags".  It is possible to attach named flags to a `ChainId` by using
+the ChainFlag interaction.  Then, you specify the flag name in Chaining's `Flags` field. If a Flag is active when the
+Chaining interaction is run, the Flag's interaction will be run instead of the appropriate interaction in `Next`.
+Bear in mind: the entity's progress through the `Next` list still advances, the resulting `Next` interaction is just not
+run.  Only one flag can be active at a time.
+
+Lastly, it is possible to cancel the entity's progress through the combo chain and reset them to the first interaction in
+the list. This can be done with the CancelChain interaction, but it will also happen automatically if the player does
+not trigger an interaction with the ChainId for the specified ChainingAllowance.  When either of these happen, all flags will be
+canceled as well.
+
+All of these effects are triggered on the User entity only. Non-players can use the chaining system, but Flags do not currently
+work for non-players.  This interaction has no special failure conditions.
+
+**Chaining Fields**
+
+| Field Name        | Type                                                       | Required? | Notes                                                                                                                                                                                                                       |
+| ----------------- | ---------------------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| ChainId           | `String`                                                   | **No**    | If provided, acts as a key that multiple Chaining interactions can use to share combo chain progress and flags. If not provided, a unique ChainId will be generated for this interaction.                                   |
+| ChainingAllowance | `Double`<br />(Default: 0.0)                               | **No**    | If, at the time this interaction is triggered, it has been this long in seconds since the last time a Chaining interaction with the same ChainId was executed, all state for this ChainId will be cleared before execution. |
+| Next              | `AssetArray`<br />(Element Type: `Interaction`)            | **Yes**   | A list of interactions to cycle between each time this interaction is run.                                                                                                                                                  |
+| Flags             | `Map`<br />(Key Type: `String`, Value Type: `Interaction`) | **No**    | A map of flag names to interactions to run if the flag is active when this interaction executes.                                                                                                                            |
+
+### CancelChain
+
+This interaction resets all progress and flag data on the User entity for the provided `ChainId`.  The next time a Chaining
+interaction is called for the provided `ChainId`, it will begin at the first interaction in the `Next` list. This
+interaction has no special failure conditions.
+
+**CancelChain Fields**
+
+| Field Name | Type     | Required? | Notes                                 |
+| ---------- | -------- | --------- | ------------------------------------- |
+| ChainId    | `String` | **Yes**   | A ChainId whose data should be reset. |
+
+### ChainFlag
+
+This interaction activates a flag on the User entity for the provided `ChainId`, which can be used to change behavior the
+next time a Chaining interaction with this `ChainId` is run. This will overwrite any flag that has
+already been raised. This interaction will have no effect for non-players. This interaction has no special failure
+conditions.
+
+| Field Name | Type     | Required? | Notes                                        |
+| ---------- | -------- | --------- | -------------------------------------------- |
+| ChainId    | `String` | **Yes**   | A ChainId on whom the flag should be raised. |
+| Flag       | `String` | **Yes**   | The name of the flag to raise.               |
+
+## Charging
+
+A unique flow-control interaction that is frequently used is the Charging interaction.  It is a flow-control interaction
+that delays while the input button used to trigger the interaction chain is held.  When it is released (or the interaction
+is forced to end), the interaction chain can continue with a different interaction based on how long the input was held
+for.
+
+These interactions are all related by either being the Charging interaction, or other interaction types that inherit the
+Charging interaction's behavior.
+
+### Charging
+
+This interaction does not inherit from SimpleInteraction and therefore its Next field works different from most interactions.
+This interaction adds its own Failed field which works the same way that SimpleInteraction's does.
+
+This interaction only works properly when its interaction chain was triggered by a client key or button press (or
+NPC-simulated equivalent). This interaction will continue executing for as long as the key or button press is held (with
+some exceptions, covered below) by the User entity.  Like other interactions, it has a `Next` field indicating which interaction to execute
+after this one, but the field is a map from `Float` values to `Interaction` assets. When this interaction ends, either
+due to the input being released or the charge duration completing, this interaction will determine the largest `Float` key that is less
+than the amount of time in seconds that the interaction was executing for.  The Interaction mapped to that key will be
+executed next.
+
+The interaction includes some cancellation conditions that are specific to this interaction. For instance, the interaction
+has a `CancelOnOtherClick` field that matches the field on RootInteraction. If it is active on this interaction but not
+the RootInteraction, then clicking while charging will cancel this interaction (and execute the `Failed` interaction rather
+than any of the `Next` interactions) but otherwise continue the interaction chain.
+
+Another valuable feature Charging has is the `Forks` field.  For input-triggered interactions that are triggered while the
+Charging interaction is executing, you can add an entry for the relevant InteractionType to this field and instead of
+triggering the usual interaction chain based on held item, targeted block, etc. the RootInteraction specified in the
+`Forks` field will be triggered.  This can unlock rich attack modes and behaviors. For instance, having a shield bash attack
+triggered off left click while blocking, or a special attack that triggers when both mouse buttons are pressed at the
+same time.
+
+There are two modes of operation for the Charging interaction. One is to have the ability charge for as long
+as the input is held and only end execution when the entity releases the input.  Bows in the main Hytale game work
+that way.  That is accomplished by setting `AllowIndefiniteHold` to true.  Another mode of operation is to have the
+interaction complete execution when the execution time has surpassed the largest key value in the `Next` field and
+immediately begin executing the Interaction mapped to that key.  Food in the main Hytale game work like this.  It
+is accomplished by setting `AllowIndefiniteHold` to false.
+
+One pitfall to be careful of when setting `AllowIndefiniteHold` to false is the way it interacts with cooldowns.\
+Normally, input-initiated interaction chains start a 0.35s cooldown on the triggered RootInteraction that prevents
+holding the mouse button from immediately spamming a new interaction when the first one completes.  However, if the
+duration of a Charging interaction is longer than 0.35s, then the cooldown will have already completed when the
+interaction chain finishes, which will often result in a new execution beginning immediately before the player can
+stop pressing the mouse button.  One solution for this problem is to add a `Simple` interaction to the end of your
+interaction chain with a `RunTime` of 0.35s to simulate the cooldown.  Alternatively, you can add a longer cooldown
+(the maximum duration of your Charging interaction plus 0.35s) to the RootInteraction. However, the longer cooldown is
+not always desirable, as the interaction may have ended prematurely, resulting in an unusually long lockout between
+executions.
+
+**Charging Fields**
+
+| Field Name                         | Type                                                                    | Required? | Notes                                                                                                                                                                                                                                                                                                                                                                                       |
+| ---------------------------------- | ----------------------------------------------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| FailOnDamage                       | `Boolean`<br />(Default: false)                                         | **No**    | If true, this interaction will fail and end immediately if the User entity takes any damage while it is executing.                                                                                                                                                                                                                                                                          |
+| CancelOnOtherClick                 | `Boolean`<br />(Default: true)                                          | **No**    | If true, this interaction will fail and end immediately if the User entity sends another button or key press while it is executing.                                                                                                                                                                                                                                                         |
+| Forks                              | `Map`<br />(Key Type: `InteractionType`, Value Type: `RootInteraction`) | **No**    | A map of InteractionType to RootInteraction. If entity input triggers the InteractionType while this interaction is executing, the mapped RootInteraction will be forked into its own interaction chain. This will happen instead of the usual handling for that InteractionType.  This fork will occur even if `CancelOnOtherClick` is set to true.                                        |
+| Failed                             | `Asset`<br />(Asset Type: `Interaction`)                                | **No**    | After this Interaction has finished, "Failed" will be executed if this Interaction failed.                                                                                                                                                                                                                                                                                                  |
+| AllowIndefiniteHold                | `Boolean`<br />(Default: false)                                         | **No**    | If true, this interaction will continue executing for as long as the User entity continues to hold the input. If false, execution will end as soon as the execution time in seconds reaches the largest key value in the `Next` map.                                                                                                                                                        |
+| DisplayProgress                    | `Boolean`<br />(Default: true)                                          | **No**    | If true, players executing this interaction will see a progress bar will be displayed below their cursor indicating how close to reaching the highest key value in `Next` they are.                                                                                                                                                                                                         |
+| Next                               | `Map`<br />(Key Type: `Float`, Value Type: `Interaction`)               | **No**    | A map from `Float` to `Interaction`.  When this interaction successfully finishes executing (either because the input was released or because the maximum duration was reached), this interaction will find the `Float` value with the largest duration in seconds that is less than the amount of time this interaction executed for. That key's mapped Interaction will then be executed. |
+| MouseSensitivityAdjustmentTarget   | `Float`<br />(Default: 1.0)                                             | **No**    | While charging, this mouse sensitivity multiplier will gradually be applied.                                                                                                                                                                                                                                                                                                                |
+| MouseSensitivityAdjustmentDuration | `Float`<br />(Default: 1.0)                                             | **No**    | Duration in seconds. After this many seconds, `MouseSensitivityAdjustmentTarget` will be fully applied to the mouse sensitivity.                                                                                                                                                                                                                                                            |
+| Delay                              | `ChargingDelay`                                                         | **No**    | Settings that allow charging progress to be pushed back when the User entity takes damage.                                                                                                                                                                                                                                                                                                  |
+
+**ChargingDelay Fields**
+
+| Field Name    | Type                        | Required? | Notes                                                                                                                                                                                                                                                                     |
+| ------------- | --------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| MinHealth     | `Float`<br />(Default: 0.0) | **No**    | Damage taken as a percentage of entity health (0.0-1.0). If a hit deals less than this much damage, no pushback will be applied.  If a hit deals exactly this much damage, `MinDelay` seconds worth of pushback will be applied.                                          |
+| MaxHealth     | `Float`<br />(Default: 0.0) | **No**    | Damage taken as a percentage of entity health (0.0-1.0). If a hit deals at least this much damage, `MaxDelay` seconds worth of pushback will be applied.                                                                                                                  |
+| MinDelay      | `Float`<br />(Default: 0)   | **No**    | The amount of pushback, in seconds, to apply if the entity takes a hit that deals `MinHealth` damage. The amount of pushback applied by a hit is a gradiant between `MinDelay` and `MaxDelay` based on the amount of damage between `MinHealth` and `MaxHealth`.          |
+| MaxDelay      | `Float`<br />(Default: 0)   | **No**    | The amount of pushback, in seconds, to apply if the entity takes a hit that deals at least `MaxHealth` damage. The amount of pushback applied by a hit is a gradiant between `MinDelay` and `MaxDelay` based on the amount of damage between `MinHealth` and `MaxHealth`. |
+| MaxTotalDelay | `Float`<br />(Deault: 0)    | **No**    | The maximum amount of pushback the entity can receive over the course of a single charge, regardless of how many times they are hit.                                                                                                                                      |
+
+**InteractionType Values**
+
+- `Primary`
+- `Secondary`
+- `Ability1`
+- `Ability2`
+- `Ability3`
+- `Use`
+- `Pick`
+- `Pickup`
+- `CollisionEnter`
+- `CollisionLeave`
+- `Collision`
+- `EntityStatEffect`
+- `SwapTo`
+- `SwapFrom`
+- `Death`
+- `Wielding`
+- `ProjectileSpawn`
+- `ProjectileHit`
+- `ProjectileMiss`
+- `ProjectileBounce`
+- `Held`
+- `HeldOffhand`
+- `Equipped`
+- `Dodge`
+- `GameModeSwap`
+
+### Wielding
+
+This interaction is inherited from Charging rather than SimpleInteraction.  However, its `Failed` and `Next` fields function
+identically to SimpleInteraction.  It does not inherit all fields from Charging, so be sure to pay close attention to
+the field list below.
+
+This interaction drives most blocking behavior in the game. While this interaction is executing, attacks made against
+the Owner entity will (conditionally) trigger effects defined in this interaction.  Unlike the Charging interaction,
+this interaction can always execute indefinitely and will only end when it fails or when the input is released.
+
+One option available in Wielding is `AngledWielding`, which allows damage and knockback modifiers to only be applied
+depending on the direction the attack against the Owner entity is coming from.  The AngledWielding type has a
+field `Angle` which determines which direction the protection points relative to the player (0 is the player's
+front), and `AngleDistance` which determines how wide the cone of protection extends around the player.  Block effects
+from this interaction (such as `BlockedEffects`, `BlockedInteractions`, and `StaminaCost`) will only apply if
+the DamageCause matches `DamageModifiers` OR if the DamageCause matches `AngledWielding.DamageModifiers` and
+the source of the damage matches `Angle` and `AngleDistance`.  It is possible for damage and knockback multipliers
+specified on both this interaction's modifier fields and `AngledWielding`'s modifier fields to stack, if both
+have entries for the same DamageCause.
+
+This interaction will only have an effect on damage taken by one of the DamageCause entries in `DamageModifiers` or
+`AngledWielding.DamageModifiers`.  If a DamageCause is in `DamageModifiers`, then the block effect will be triggered
+and the damage modifier applied regardless of what direction the Owner entity is attacked from.  If a DamageCause is in
+`AngledWielding.DamageModifiers`, then the damage modifier is only applied if the
+
+\*\* Wielding Fields\*\*
+
+| Field Name          | Type                                                                    | Required? | Notes                                                                                                                                                                                                                                                                                                                                                                                                      |
+| ------------------- | ----------------------------------------------------------------------- | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| FailOnDamage        | `Boolean`<br />(Default: false)                                         | **No**    | If true, this interaction will fail and end immediately if the User entity takes any damage while it is executing.                                                                                                                                                                                                                                                                                         |
+| CancelOnOtherClick  | `Boolean`<br />(Default: true)                                          | **No**    | If true, this interaction will fail and end immediately if the User entity sends another button or key press while it is executing.                                                                                                                                                                                                                                                                        |
+| Forks               | `Map`<br />(Key Type: `InteractionType`, Value Type: `RootInteraction`) | **No**    | A map of InteractionType to RootInteraction. If entity input triggers the InteractionType while this interaction is executing, the mapped RootInteraction will be forked into its own interaction chain. This will happen instead of the usual handling for that InteractionType.  This fork will occur even if `CancelOnOtherClick` is set to true (after which this interaction chain will be canceled). |
+| Next                | `Asset`<br />(Asset Type: `Interaction`)                                | **No**    | After this interaction has finished, "Next" will be executed if this interaction did not fail.                                                                                                                                                                                                                                                                                                             |
+| Failed              | `Asset`<br />(Asset Type: `Interaction`)                                | **No**    | After this interaction has finished, "Failed" will be executed if this interaction failed.                                                                                                                                                                                                                                                                                                                 |
+| DamageModifiers     | `Map`<br />(Key Type: `DamageCause`, Value Type: `Float`)               | **No**    | A map from DamageCause to Float, where the Float is multiplied against any damage received from the mapped DamageCause while this interaction is executing.                                                                                                                                                                                                                                                |
+| KnockbackModifiers  | `Map`<br />(Key Type: `DamageCause`, Value Type: `Float`)               | **No**    | A map from DamageCause to Float, where the Float is multiplied against any knockback force received from the mapped DamageCause while this interaction is executing.                                                                                                                                                                                                                                       |
+| AngledWielding      | `AngledWielding`                                                        | **No**    | Configuration to only trigger block effects from certain angles.                                                                                                                                                                                                                                                                                                                                           |
+| StaminaCost         | `StaminaCost`                                                           | **No**    | If the Owner entity receives damage that matches `DamageModifiers` or `AngledWielding` while this interaction is executing, then the entity's stamina will be deducted according to this configuration.                                                                                                                                                                                                    |
+| BlockedEffects      | `DamageEffects`                                                         | **No**    | If the Owner entity receives damage that matches `DamageModifiers` or `AngledWielding` while this interaction is executing, then these effects will be applied to the instance of damage.                                                                                                                                                                                                                  |
+| BlockedInteractions | `Asset`<br />(Asset Type: `RootInteraction`)                            | **No**    | If the Owner entity receives damage that matches `DamageModifiers` or `AngledWielding` while this interaction is executing, then this RootInteraction will be launched as a brand new interaction chain with the Owner entity as both Owner and User, and the attacker as the Target entity.  This new interaction chain is, notably, brand new, **not** forked from the current one.                      |
+
+**AngledWielding Fields**
+
+| Field Name         | Type                                                      | Required? | Notes                                                                                                                                                                                                            |
+| ------------------ | --------------------------------------------------------- | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Angle              | `Float`<br />(Default: 0.0)                               | **No**    | Angle in degrees relative to the Owner entity where the angled protection is centered. 0.0 means pointed towards the front of the Owner entity.                                                                  |
+| AngleDistance      | `Float`<br />(Default: 0.0)                               | **No**    | Angle in degrees indicating how wide the cone of protection is.                                                                                                                                                  |
+| DamageModifiers    | `Map`<br />(Key Type: `DamageCause`, Value Type: `Float`) | **No**    | A map from DamageCause to Float, where the Float is multiplied against any damage received from the mapped DamageCause received from within the cone of protection while this interaction is executing.          |
+| KnockbackModifiers | `Map`<br />(Key Type: `DamageCause`, Value Type: `Float`) | **No**    | A map from DamageCause to Float, where the Float is multiplied against any knockback force received from the mapped DamageCause received from within the cone of protection while this interaction is executing. |
+
+**StaminaCost Fields**
+
+| Field Name | Type                                             | Required? | Notes                                                                                                                                                                                                                                                |
+| ---------- | ------------------------------------------------ | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| CostType   | `CostType`<br />(Default: `MaxHealthPercentage`) | **No**    | How to calculate stamina consumed by blocking from the raw pre-block damage. If `Damage`, then the stamina consumed will be `rawDamage / Value`. If `MaxHealthPercentage`, then the stamina consumed will be `rawDamage / (EntityMaxHealth * Value)` |
+| Value      | `Float`<br />(Default: 0.04)                     | **No**    | The value to use in the `CostType` formula.                                                                                                                                                                                                          |
+
+**DamageEffects Fields**
+
+| Field Name             | Type                                         | Required? | Notes                                                                           |
+| ---------------------- | -------------------------------------------- | --------- | ------------------------------------------------------------------------------- |
+| ModelParticles         | `Array`<br />(Element Type: `ModelParticle`) | **No**    | Particle systems to trigger in the first-person view.                           |
+| WorldParticles         | `Array`<br />(Element Type: `WorldParticle`) | **No**    | Particle systems to trigger in the third-person view.                           |
+| LocalSoundEventId      | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | 2D sound to play locally to the attacking entity if they are a player.          |
+| WorldSoundEventId      | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | Sound to play in the world at the Owner entity's location.                      |
+| PlayerSoundEventId     | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | 2D sound to play locally to the Owner entity if they are a player.              |
+| ViewDistance           | `Double`<br />(Default: 75.0)                | **No**    | Distance at which these effects should play for other players.                  |
+| Knockback              | `Knockback`                                  | **No**    | The properties of the knockback that will be applied.                           |
+| CameraEffect           | `Asset`<br />(Asset Type: `CameraEffect`)    | **No**    | CameraEffect to briefly apply locally to the Owner entity if they are a player. |
+| StaminaDrainMultiplier | `Float`<br />(Default: 1.0)                  | **No**    | This multiplier is applied to the `StaminaCost`, if any.                        |
+
+**Knockback Fields**
+
+| Field Name     | Type                                       | Required? | Notes                                                                                                                      |
+| -------------- | ------------------------------------------ | --------- | -------------------------------------------------------------------------------------------------------------------------- |
+| Type           | `String`                                   | **No**    | If provided, specifies a type of knockback to use. Each knockback type may come with additional fields.                    |
+| Force          | `Double`<br />(Default: 0.0)               | **No**    | The amount of force to apply to the Owner entity.                                                                          |
+| Duration       | `Double`<br />(Default: 0.0)               | **No**    | If 0.0, apply the force as a single impulse.  If more, continuously apply the force over a period of time.                 |
+| VelocityType   | `ChangeVelocityType`<br />(Default: `Add`) | **No**    | How to apply the force, either adding it to the entity's current velocity, or setting the velocity to the knockback force. |
+| VelocityConfig | `VelocityConfig`                           | **No**    | Characteristics of friction as the Owner entity is thrown by this knockback.                                               |
+
+**Knockback Type: Force**
+
+Apply the calculated knockback force along the provided direction.
+
+| Field Name | Type                         | Required? | Notes                                                                                |
+| ---------- | ---------------------------- | --------- | ------------------------------------------------------------------------------------ |
+| Direction  | `Vector3`<br />(Default: Up) | **No**    | Which direction the player should be flung, relative to the direction of the attack. |
+
+**Knockback Type: Point**
+
+Apply the calculated knockback force laterally along the XZ plane, plus provided Y velocity.
+
+| Field Name | Type                        | Required? | Notes                                                                                                   |
+| ---------- | --------------------------- | --------- | ------------------------------------------------------------------------------------------------------- |
+| OffsetX    | `Integer`<br />(Default: 0) | **No**    | Offset the source position of the knockback left or right perpendicular to the direction of the attack. |
+| OffsetZ    | `Integer`<br />(Default: 0) | **No**    | Offset the source position of the knockback, forward or backward along the directon of the attack.      |
+| RotateY    | `Integer`<br />(Default: 0) | **No**    | Rotate the knockback direction around the Y axis, where 0 is the default attack direction.              |
+| VelocityY  | `Float`<br />(Default: 0.0) | **No**    | Add vertical velocity to the knockback force after the direction and force has been calculated.         |
+
+**Knockback Type: Directional**
+
+Apply the calculated knockback force along the attack direction, removing any vertical component and replacing it with a provided Y velocity.
+
+| Field Name | Type                      | Required? | Notes                                                                                                                                            |
+| ---------- | ------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------ |
+| RelativeX  | `Float`<br />(Default: 0) | **No**    | Apply additional force left or right perpendicular to the direction of the attack. The additional force is multiplied by the knockback strength. |
+| RelativeZ  | `Float`<br />(Default: 0) | **No**    | Apply additional force forward or backward along the attack direction. The additional force is multiplied by the knockback strength.             |
+| VelocityY  | `Float`<br />(Default: 0) | **No**    | Replace the vertical velocity of the knockback with this value.  This value is not multiplied by knockback strength.                             |
+
+**VelocityConfig Fields**
+
+| Field Name          | Type                                              | Required? | Notes                                                                                                                                                                                           |
+| ------------------- | ------------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| GroundResistance    | `Float`<br />(Default: 0.82)                      | **No**    | The minimum amount of friction applied when the entity is in contact with the ground.  1.0 = no friction, 0.0 = total friction                                                                  |
+| GroundResistanceMax | `Float`<br />(Default: 0.0)                       | **No**    | The maximum amount of friction applied when the entity is in contact with the ground.  1.0 = no friction, 0.0 = total friction                                                                  |
+| AirResistance       | `Float`<br />(Default: 0.96)                      | **No**    | The minimum amount of friction applied when the entity is in the air. 1.0 = no friction, 0.0 = total friction                                                                                   |
+| AirResistanceMax    | `Float`<br />(Default: 0.0)                       | **No**    | The maximum amount of friction applied when the entity is in the air. 1.0 = no friction, 0.0 = total friction                                                                                   |
+| Threshold           | `Float`<br />(Default: 1.0)                       | **No**    | The speed at which the maximum amount of friction will be applied to the entity. The amount of friction applied will increase from minimum to maximum as the entity moves from 0 to this speed. |
+| Style               | `VelocityThresholdStyle`<br />(Default: `Linear`) | **No**    | The curve that friction follows as the entity's speed increases toward the `Threshold`.                                                                                                         |
+
+**CostType Values**
+
+- `MaxHealthPercentage`
+- `Damage`
+
+**ChangeVelocityType Values**
+
+- `Add`
+- `Set`
+
+**VelocityThresholdStyle Values**
+
+- `Linear`
+- `Exp`
+
+## Blocks
+
+These are interaction types meant to reason about and modify blocks in the world.  The most important concept unique
+to these interactions is the Block Target.  Like the Entity Target, it is mutable and can come from many places.
+However, for interaction chains initiated by the client, the block target will initially be the block that the player's cursor was
+over, if any.
+
+Additionally, for interaction chains initiated by the client, the client will send along which face of the block is targeted,
+which is used by a few block-related interactions.
+It is left up to each interaction type that cares about block faces as to how to handle this behavior for simulated input
+(i.e. NPCs initiating chains that are normally initated by the client).  At the time of this writing, all block-related
+interactions choose the top face where relevant in simulated input.
+
+### BlockCondition
+
+This interaction has a field `Matchers` which specifies certain conditions, such as block type, state, etc.  This
+interaction fails if the current target block does not match all of them.
+
+**BlockCondition Fields**
+
+| Field Name       | Type                                        | Required? | Notes                                                                                                                                                                                                                                                                                                                                   |
+| ---------------- | ------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false)             | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction.                                                                                                                                                                                                       |
+| Matchers         | `Array`<br />(Element Type: `BlockMatcher`) | **Yes**   | A list of conditions that the target block must match or this condition will fail.<br />**Note: This field is technically not required but there is a bug that makes it dangerous to not provide at the time of this writing.**<br />**Note: If no conditions are added to this array, the interaction will fail, counterintuitively.** |
+
+**BlockMatcher Fields**
+
+| Field Name | Type                       | Required? | Notes                                                                          |
+| ---------- | -------------------------- | --------- | ------------------------------------------------------------------------------ |
+| Block      | `BlockIdMatcher`           | **No**    | If provided, requires the block itself match some set of conditions.           |
+| Face       | `BlockFace`                | **No**    | If provided and not 'None', requires a specific block face be targeted.        |
+| StaticFace | `Boolean` (Default: false) | **No**    | If false, the face condition will be adjusted by the block's current rotation. |
+
+**BlockFace Values**
+
+- `Up`
+- `Down`
+- `North`
+- `South`
+- `East`
+- `West`
+- `None`
+
+**BlockIdMatcher Fields**
+
+| Field Name | Type                                   | Required? | Notes                                                                      |
+| ---------- | -------------------------------------- | --------- | -------------------------------------------------------------------------- |
+| Id         | `Asset`<br />(Asset Type: `BlockType`) | **No**    | If provided, the block must match the specified `BlockType`.               |
+| State      | `String`                               | **No**    | If provided, the block's current state must match the provided state name. |
+| Tag        | `String`                               | **No**    | If provided, the block type's asset tags must contain the provided tag.    |
+
+### DestroyCondition
+
+This interaction fails if the current User entity cannot destroy the current target blcok.
+
+**DestroyCondition Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+
+### PlacementCountCondition
+
+This interaction accepts the name of a BlockType that has the TrackedPlacement BlockEntity. The interaction will fail if the number of
+blocks of the provided BlockType in the world do not match the provided condition.
+
+**PlacementCountCondition Fields**
+
+| Field Name | Type                           | Required? | Notes                                                                                                                                                                                                                                                           |
+| ---------- | ------------------------------ | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Block      | `String`                       | **Yes**   | The BlockType to examine. The number of instances of the BlockType in the world will be compared to Value.<br />**Note: The specified BlockType must have the TrackedPlacement BlockEntity. Otherwise, the number of blocks in the world will always be zero.** |
+| Value      | `Integer`<br />(Default: 0)    | **No**    | The value to compare the number of blocks in the world with.                                                                                                                                                                                                    |
+| LessThan   | \`Boolean<br />(Default: true) | **No**    | If true, the interaction will fail if the number of blocks in the world is greater than or equal to Value. If false, the interaction will fail if the number of blocks in the world is less than or equal to Value.                                             |
+
+### BreakBlock
+
+This interaction attempts to break the target block while acting as the User entity. The User entity must be a player. It
+is not guaranteed to work, depending on world settings and the User entity's current state, it may not work.  If it
+fails, it will fail the interaction under some circumstances, but not others.
+
+**Note: In particular, if `Harvest`=false and the player is in Survival mode, the player will simply execute a damage operation
+against the block. Even when the Tool field is specified, the player's currently-held item can impact the results in unintuitive
+ways.**
+
+This interaction will fail if there is no block target, if `Harvest`=true and the
+block is not harvestable, or if the world settings prevent the Harvest/Break operation.
+It will generally not fail otherwise, even if the block was not broken or damaged.
+The block will generally break every time if `Harvest`=true or the player is in
+Creative mode.
+
+**BreakBlock Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                                                                                                                                                                                                  |
+| ---------------- | ------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction.                                                                                                                                                                      |
+| Harvest          | `Boolean` (Default: false)      | **No**    | If true, harvest the block and deposit the drops in the player's inventory. This operation will generally always succeed.  If false, this interaction will effectively perform whatever action would have occurred if the player had left-clicked the block.                                           |
+| Tool             | `String`                        | **No**    | If `Harvest`=true, the player is in Survival mode, and this field is provided, then the break operation will be performed as though with this tool type.<br />**This field mostly doesn't work.  Your held item will be used for most block damage calculations regardless of this field's contents.** |
+| MatchTool        | `Boolean` (Default: false)      | **No**    | If true, `Harvest`=true, the player is in Survival mode, and `Tool` is provided, block breaking will be prevented unless `Tool` is a valid gathering tool for the target block. The interaction will not be failed, even if block breaking is prevented in this manner.                                |
+
+### ChangeBlock
+
+This interaction requires a mapping from one or more current BlockTypes to one or more target BlockTypes.  If the
+target block is one of the key BlockTypes, then it will be changed to the mapped target BlockType.  If the current
+BlockType of the target block does not appear as a key in the Changes field, then this interaction fails.
+
+**ChangeBlock Fields**
+
+| Field Name        | Type                                                        | Required? | Notes                                                                                                                             |
+| ----------------- | ----------------------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget  | `Boolean`<br />(Default: false)                             | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+| Changes           | `Map`<br />(Key Type: `BlockType`, Value Type: `BlockType`) | **No**    | A list of potential block type changes, with each entry having a current and new BlockType id.                                    |
+| WorldSoundEventId | `Asset`<br />(Asset Type: `SoundEvent`)                     | **No**    | If provided, this SoundEvent is played in the world at the position of the block if the block successfully changes.               |
+| RequireNotBroken  | `Boolean`<br />(Default: false)                             | **No**    | If true, this interaction will fail if the player's held item is broken (durability 0), and the block change will not take place. |
+
+### ChangeState
+
+This interaction requires a mapping from one or more current block state names to one or more state names. If the
+target block is in one of the key block states, then it will be changed to the mapped target blocks tate. If the
+current block state of the target block does nto appear as a key in the Changes field, then this interaction fails.
+
+All blocks start out with a null state by default.  This null state can be referenced by the key "default" and the block
+can be returned to that state with the value "default".
+
+**ChangeState Fields**
+
+| Field Name       | Type                                                  | Required? | Notes                                                                                                                                          |
+| ---------------- | ----------------------------------------------------- | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false)                       | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction.              |
+| Changes          | `Map`<br />(Key Type: `String`, Value Type: `String`) | **No**    | A list of potential block state changes, with each entry having a current and new state name.                                                  |
+| UpdateBlockState | `Boolean`<br />(Default: false)                       | **No**    | If true, performs a full refresh of the block's BlockEntity component and notifies nearby players as though a full block type change occurred. |
+
+### CycleBlockGroup
+
+This interaction will attempt to change the target block to the next block type in one of the BlockGroups it belongs to.
+If the block type belongs to multiple BlockGroups, which one is used is effectively arbitrary. The User entity must be
+a player. If the block cannot be changed for any reason (entity not a player, no block target, block does not belong
+to a BlockGroup, etc.). If the block is the only entry in the BlockGroup, this interaction will succeed and the block
+will be considered changed despite nothing happening.  Unlike most other block-changing interactions, this one will
+fail if the world settings prevent players from breaking blocks.
+
+**This interaction always reduces the player's held item's durability by a single 'hit' worth of damage if the block
+changes. There is no way to prevent it. The block type will change and the interaction will succeed even if the player's
+held item is broken, however.**
+
+**CycleBlockGroup Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+
+### DestroyBlock
+
+This interaction destroys the target block without dropping anything.  It will successfully destroy the block if the
+target block exists and this interaction has no failure conditions.
+
+**This interaction has no additional fields.**
+
+### PickBlock
+
+This interaction is effectively equivalent to using the middle mouse button in creative mode. In survival mode, the
+block's item will be moved to the user's current active hotbar slot if it is in the player's inventory.  This
+interaction is performed entirely on the client and cannot be performed by non-players.  It is unclear if this
+interaction has failure conditions.
+
+**PickBlock Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+
+### PlaceBlock
+
+This interaction is effectively identical to a right clicking while holding a block in their hand, with some
+additional options. For one, it can be executed with any LivingEntity as the User entity. For another, it has some
+useful fields.  For the most part, though, it follows the same behaviors and rules as any ordinary block placement
+by a player.
+
+It's not clear under what circumstances this interaction can fail. The server will not fail the interaction under any
+special circumstances (including when there is no target block, or when `BlockTypeToPlace` is not provided and the
+LivingEntity is not holding a block). However, the client is very involved with the function of this interaction and
+its behavior is unknown.
+
+**PlaceBlock Fields**
+
+| Field Name         | Type                                   | Required? | Notes                                                                                                                                                                                                                                                                                                                                                           |
+| ------------------ | -------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| BlockTypeToPlace   | `Asset`<br />(Asset Type: `BlockType`) | **No**    | If provided, the block placed by this interaction will be the specified BlockType. If not provided, the User entity's held item will be used, instead, if it is a block.                                                                                                                                                                                        |
+| RemoveItemInHand   | `Boolean`<br />(Default: True)         | **No**    | If true and the User entity is not a player in Creative mode, the item in the player's hand must match the block being placed and one quantity will be removed for each block placed. If the item does not match, the block cannot be placed.  If false, the player's hand item is ignored entirely.\*\*                                                        |
+| AllowDragPlacement | `Boolean`<br />(Default: True)         | **No**    | If true and the interaction was triggered on the client by a player, then the player can hold the input that was used to activate this interaction chain and move the mouse around in order to execute this interaction repeatedly and place several blocks. The interaction chain will not move onto the next interaction until the player releases the input. |
+
+### RunOnBlockTypes
+
+This interaction retrieves all blocks within a provided radius of the User entity. For each block that matches any of
+the provided BlockSets, a new interaction chain will be forked that uses the matching block as the target block.
+This interaction will continue executing until all forked interaction chains have completed.  The interaction will fail if no
+blocks within the radius match the provided BlockSets or if all of the forked interaction chains fail.
+
+**RunOnBlockTypes Fields**
+
+| Field Name   | Type                                         | Required?        | Notes                                                                                                                                                                                                                                                                                      |
+| ------------ | -------------------------------------------- | ---------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| Range        | `Integer`                                    | **Yes**          | The spherical radius around the User entity to search for blocks. Must be at least 1.                                                                                                                                                                                                      |
+| BlockSets    | `AssetArray`<br />(Element Type: `BlockSet`) | **No**           | A list of BlockSets to match nearby blocks again. Only blocks that match any of the BlockSets will have interaction chains forked for them.                                                                                                                                                |
+| MaxCount     | `Integer`                                    | **Yes**          | The maximum number of blocks that will be located with the search. Further blocks will be ignored. If there are more matching blocks within the radius than this number, the specific set of blocks that will be found is completely arbitrary and may change from execution to execution. |
+| Interactions | `Asset`<br />(Asset Type: `RootInteraction`) | **No, but yes.** | The RootInteraction that will be forked for each matching block.  This interaction will not fail to validate if it is missing, but every execution of this interaction will fail.                                                                                                          |
+
+### UseBlock
+
+If the target block has an interaction for this interaction chain's interaction type, execute it immediately as part of
+this interaction chain. The execution will be wrapped in UseBlockEvent.Pre and UseBlockEvent.Post events, and cancellations
+of the UserBlockEvent.Pre event are respected. The User entity is considered the triggering entity for both events.
+
+If the target block does not have an interaction for this interaction chain's interaction type, this interaction fails.
+
+**This interaction has no additional fields.**
+
+## Items
+
+These are interactions intended to interface with an entity's inventory. There is no concept of an "item target",
+unfortunately, so these generally either interact with the entity's held item or the entity's inventory at a high level.
+
+### AddItem
+
+Adds a specified quantity of a specified item to the User entity's inventory, preferring to add it to the
+entity's hotbar where possible. This interaction will have no effect on User entities that are not LivingEntities.
+This interaction has no failure states.
+
+**Note: This interaction has a bug in its field validators that will cause interactions that reference items declared
+in the same mod to fail validation on startup.  Additionally, this interaction has a bug that will cause it to
+fail and have no effect if the User entity has no block target. Use ModifyInventory instead.**
+
+**AddItem Fields**
+
+| Field Name       | Type                              | Required? | Notes                                                                                                                             |
+| ---------------- | --------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false)   | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+| ItemId           | `Asset`<br />(Asset Type: `Item`) | **Yes**   | The item id of the item to add to the player's inventory.                                                                         |
+| Quantity         | `Integer`<br />(Default: 0)       | **No**    | The quantity of the item to add to the player's inventory.                                                                        |
+
+### CheckUniqueItemUsage
+
+This interaction will check whether it has run once for the User entity with their currently-held item before. If it hasn't,
+it will succeed. If it has, it will fail. It will also fail if the User entity is not a player. The interaction will record
+the item id of the User entity's currently-held item on success, ensuring it cannot be successfully run with that player
+and item id combination again.
+
+**This interaction has no additional fields.**
+
+### ChangeActiveSlot
+
+This interaction does not inherit from SimpleInteraction and therefore has no Next or Failed fields.  The `CancelOnItemChange`
+field is ignored for this interaction and is always treated as false. This interaction will set the User entity's currently-
+active hotbar slot to the specified slot index. If none is specified, the interaction chain's target slot will be used,
+if any. Otherwise, slot 0 will be used.  If a slot is specified and it is already active, then this interaction will
+have no effect, but if no slot is specified and the interaction chain's target slot is already active, the logic in
+the next paragraph will still be executed. This interaction will also have no effect if the User entity is not a
+LivingEntity.
+
+Once the slot has changed, a new SwapTo interaction chain will be forked off for the selected slot.
+If a target slot was specified, then the interaction chain's current target slot will be set to the specified slot, as will
+the forked SwapTo interaction chain. If this interaction chain was initiated by a player swapping an item into or out of
+an occupied active hotbar slot, then the swap will be executed after the slot is changed and before the SwapTo
+interaction is forked. Not running this interaction in the resulting SwapFrom interaction chain is a way for the server
+to cancel players performing these sorts of swap interactions. The default behavior for these swap interactions is that
+the SwapFrom interaction chain will be initiated with the currently-active-slot as the target slot. As a result, the
+target slot will usually not change when this interaction runs, it merely exists as a signal for the server to continue the
+item swap.
+
+**ChangeActiveSlot Fields**
+
+| Field Name | Type      | Required? | Notes                                                                                                                                                                                                     |
+| ---------- | --------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| TargetSlot | `Integer` | **No**    | If not provided, indicates the slot the player's active hotbar slot should be changed to.  Otherwise, the interaction chain's target slot will be used (which is usually the already-active hotbar slot). |
+
+### EquipItem
+
+This interaction will equip the User entity's currently-held item into the appropriate armor slot, if it is armor. The
+interaction will fail if the item is armor but it cannot be equipped for some reason. The interaction will succeed but
+take no action if the User entity cannot equip armor or if the item is not armor.
+
+**This interaction has no additional fields.**
+
+### IncreaseBackpackCapacity
+
+This interaction will increase the User entity's backpack size by the provided amount.  **It will additionally remove one
+quantity from the player's currently-held item. There is no way to prevent this.**  This interaction will have no effect
+if the User entity is not a player.  This interaction has no special failure conditions, even if the User entity
+is not a player, or the player is not currently holding an item.
+
+| Field Name | Type                        | Required? | Notes                                                                                   |
+| ---------- | --------------------------- | --------- | --------------------------------------------------------------------------------------- |
+| Capacity   | `Integer`<br />(Default: 1) | **No**    | The additional backpack capacity to add to the player. **Must be between 1 and 32767.** |
+
+### ModifyInventory
+
+This interaction attempts to perform one or more inventory-modifying actions against the User entity. The User entity must
+be a player. If they are not, no actions will be performed, but the interaction will not fail. Any item removals performed
+by this interaction, either as a result of `ItemToRemove` or `AdjustHeldItemQuantity`, are both atomic (meaning the entire
+quantity must be removed, or none) and required (meaning that the interaction will fail and no further actions taken if
+the removal fails for any reason).  Item additions performed by this interaction, either as a result of `ItemToAdd` or
+`AdjustHeldItemQuantity` will drop excess items on the ground near the player if necesary and continue on.
+
+This interaction first executes the item removal in `ItemToRemove`, if any, then adjusts the held item as specified by
+`AdjustHeldItemQuantity`, if provided, then executes the item addition in `ItemToAdd`, if any, and then finally executes
+the damage/healing of the held item in `AdjustHeldItemDurability`, if provided.
+
+**ModifyDurability Fields**
+
+| Field Name               | Type                            | Required? | Notes                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
+| ------------------------ | ------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| RequiredGameMode         | `GameMode`                      | **No**    | If provided, only execute the inventory-modifying actions if the player is in the provided GameMode. The interaction will not fail if the GameMode doesn't match.                                                                                                                                                                                                                                                                                                                                                                               |
+| ItemToRemove             | `ItemStack`                     | **No**    | If provided, a matching item will be removed in the provided quantity. If there is no matching item in the player inventory in the required quantity, then the interaction will fail and further actions will not be executed.                                                                                                                                                                                                                                                                                                                  |
+| AdjustHeldItemQuantity   | `Integer`<br />(Default: 0)     | **No**    | The player's held item, if any, will have its quantity will be modified by the provided amount- subtracted from if this number is negative or added to if this item is positive.  If the player has no held item, then this field will have no effect regardless of its value and the interaction will NOT fail.  If the player's inventory does not have sufficient quantity of items to support the removal, this interaction will fail and further actions will not be executed. Excess items will be dropped on the ground near the player. |
+| ItemToAdd                | `ItemStack`                     | **No**    | If provided, the ItemStack will be added to the player's inventory. Excess items will be dropped on the ground near the player.                                                                                                                                                                                                                                                                                                                                                                                                                 |
+| AdjustHeldItemDurability | `Double`<br />(Default: 0.0)    | **No**    | The player's held item, if any, will have its durability adjusted by the specified amount.  The durability cannot go below 0 or raise above the item's maximum durability. Invalid durability values in this field will not cause the interaction to fail. Neither will it fail if the player has no held item.                                                                                                                                                                                                                                 |
+| BrokenItem               | `String`                        | **No**    | This field should contain an ItemId, but it is not validated by the server on startup, so be careful.  This field can have the value of "Empty" to specify no item, or an empty hand. If specified and the `AdjustHeldItemDurability` operation reduces the player's held item to 0 durability, the player's held item is changed to this ItemId. If the inventory replacement fails, this interaction will fail.                                                                                                                               |
+| NotifyOnBreak            | `Boolean`<br />(Default: false) | **No**    | If true and the `AdjustHeldItemDurability` operation reduces the player's held item to 0 durability, this interaction will perform the usual audiovisual feedback of a broken tool. It will play the usual tool breaking sound and send the player a text message in chat that their item has broken.                                                                                                                                                                                                                                           |
+| NotifyOnBreakMessage     | `String`                        | **No**    | If provided, and `NotifyOnBreak` is true, when the player is notified of a broken tool by this interaction, the message sent to their chat will instead be the translation key specified by this field. The translation key supports the templating parameter `{itemName}`. See the translation key `server.general.repair.itemBroken_Hoe` for an example.                                                                                                                                                                                      |
+
+**GameMode Values**
+
+- `Creative`: The game is currently in Creative Mode
+- `Adventure`: The game is currently in Adventure Mode
+
+**ItemStack Fields**
+
+| Field Name                   | Type                              | Required? | Notes                                                                                |
+| ---------------------------- | --------------------------------- | --------- | ------------------------------------------------------------------------------------ |
+| Id                           | `Asset`<br />(Asset Type: `Item`) | **Yes**   | The id of the Item asset this stack contains.                                        |
+| Quantity                     | `Integer`<br />(Default: 1)       | **No**    | The number of items in this stack.<br />**Must be greater than 0.**                  |
+| Durability                   | `Double`<br />(Default: 0.0)      | **No**    | The durability of the item stack.<br />**Cannot be negative.**                       |
+| MaxDurability                | `Double`<br />(Default: 0.0)      | **No**    | The maximum durability of the item this stack contains.<br />**Cannot be negative.** |
+| Metadata                     | `Bson Document`                   | **No**    | If provided, applies the bson to the item stack metadata.                            |
+| OverrideDroppedItemAnimation | `Boolean`\*(Default: false)       | **No**    | ???                                                                                  |
+
+### PickupItem
+
+This interaction will attempt to pick up the User entity's current target entity and add it to their inventory. It will
+fail if the User entity is not a player, if they do not have a target entity, or if the target entity is not an item
+located in the world.  It will not fail if the player simply cannot pick up the item.
+
+**This interaction has no additional fields.**
+
+### RefillContainer
+
+This interaction will fail if the User entity is not a player. The interaction will draw a ray from the player's head
+down their look direction until the edge of the player's held item's interaction range or until the first solid block.
+The nearest fluid block of a type listed in this interaction's `States` map will result in the one of the player's
+currently-held items being converted to the fluid's related item state.  If the `States` map indicates a durability
+for the new item state, then the converted item will use that durability. If the item is already in the fluid's related
+item state, then this interaction will fail if the player's held item is already at maximum durability (unless the
+`States` map indicates a durability value greater than the item's maximum, in which case the interaction will succeed
+but the item will not change).  Otherwise, the durability listed for the fluid in the `States` map will be added to the
+item's current durability.
+
+If the interaction has not failed by this point, the fluid block in the world may be transformed to a different type if one is listed
+in the `States` map.
+
+If any part of this process does not proceed for any reason (for instance, if the player is not holding an item),
+then this interaction will fail.
+
+**RefillContainer Fields**
+
+| Field Name | Type                                                       | Required? | Notes                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| ---------- | ---------------------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| States     | `Map`<br />(Key Type: `String`, Value Type: `RefillState`) | **Yes**   | A map from item state names to `RefillState` objects, which contain information such as acceptable fluid block types, durability increases, and what fluid type to convert the targeted fluid block to after refill, if any. If the player targets a fluid block that matches one of the fluid types in the `RefillState`, the item will be converted to the keyed item state and the `RefillState` will be used to decide what happens next. |
+
+**RefillState Fields**
+
+| Field Name     | Type                                  | Required? | Notes                                                                                                                                                                                                                                                                                                                           |
+| -------------- | ------------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| AllowedFluids  | `Array`<br />(Element Type: `String`) | **Yes**   | If any of these fluids are targeted by the player, the player's held item will be converted to the keyed item state and `Durability` and `TransformFluid` will be used.                                                                                                                                                         |
+| Durability     | `Double`<br />(Default: -1.0)         | **No**    | If the player's held item changes item states, this value is the new item's durability, unless it is negative, in which case the item will begin at full durability. If the player's held item is already in the item state, and the item is not already at full durability, this value will be added to the item's durability. |
+| TransformFluid | `String`                              | **No**    | If provided, this field is a fluid id that the targeted fluid block should be transformed to if the player's held item is successfully updated.                                                                                                                                                                                 |
+
+## Entities
+
+### DamageEntity
+
+This interaction does not inherit from SimpleInteraction, but adds its own Next and Failed fields that
+work similarly.
+
+This interaction will cause the User entity to damage the Target entity.  It has the capability to apply different
+damage based on the direction of the attack or what body part was targeted by the User entity, with each possibility
+providing different damage calculations, effects, and Next interaction. If multiple entires match the attack, `TargetedDamage`
+(body part damage) takes highest priority, then the first matching `AngledDamage` in the list, then the default
+damage in the base interaction fields.  It is possible for elements of these different damage priorities to be taken peacemeal if higher-priority
+damage fields do not overwrite lower-priority damage fields. For instance,
+damage calculation could be taken from `TargetedDamage`, the damage effects could be taken from the first matching
+`AngledDamage`, and the Next interaction coming from the default damage field.
+
+If all damage dealt by this interaction is cancelled, then this interaction will fail, and the `Failed` interaction
+will be executed next in the chain. If any damage dealt by this interaction is blocked, then this interaction will
+succeed, but the `Blocked` interaction wil lbe executed next in the chain. Otherwise, the highest-precedent matching
+`Next` interaction that you provide will be executed.  For instance, if you provide `Next` interactions for all
+`TargetedDamage` and `AngledDamage` entries, and one in the interaction's `Next` field, then a headshot could result
+in a unique `Next` interaction being executed, even if there is a matching `AngledDamage` entry. However, if you leave
+the `Next` interaction out of your `TargetedDamage` entries, a special `Next` interaction for backstabs could be
+executed.  Otherwise, the `Next` field in the root of the interaction will be executed instead.
+
+DamageEntity has an unusual relationship with `RunTime`. This interaction always ends immediately after its first tick,
+regardless of the status of `RunTime` or `WaitForAnimationToFinish`.  However, if damage dealt by this interaction is
+calculated as `DamageCalculatorType` `Dps`, then the `RunTime` will be used to determine the precise amount of damage to
+deal. If `RunTime` is 0, then no damage will be dealt.
+
+**DamageEntity Fields**
+
+| Field Name       | Type                                                          | Required?                                                                                                                    | Notes                                                                                                                                                                                                                                                                                                                                                                         |
+| ---------------- | ------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| DamageCalculator | `DamageCalculator`                                            | **No**                                                                                                                       | If provided, describes the damage amounts and types to apply to the Target entity.                                                                                                                                                                                                                                                                                            |
+| DamageEffects    | `DamageEffects`                                               | **No**                                                                                                                       | If provided, describes particles, sounds, knockback, etc. to apply to the target entity on damage.                                                                                                                                                                                                                                                                            |
+| Next             | `Asset`<br />(Asset Type: `Interaction`)                      | **No**  After this interaction has finished, "Next" will be executed if damage was dealt to the target and none was blocked. |                                                                                                                                                                                                                                                                                                                                                                               |
+| AngledDamage     | `Array`<br />(Element Type: `AngledDamage`)                   | **No**                                                                                                                       | If provided, allows alternative `DamageCalculator`, `DamageEffects`, and `Next` entries for attacks that approach the target from certain angles.                                                                                                                                                                                                                             |
+| TargetedDamage   | `Map`<br />(Key Type: `String`, Value Type: `TargetedDamage`) | **Yes**                                                                                                                      | This field must be provided, but is not required to have any entries.  This is a map from body part names to `TargetedDamage` values. Hypixel only uses one body part name: `Head`, and it is not clear whether there are others.  If provided, allows alternative `DamageCalculator`, `DamageEffects`, and `Next` entries for attacks that damage specific enemy body parts. |
+| EntityStatsOnHit | `Array`<br />(Element Type: `EntityStatOnHit`)                | **No**                                                                                                                       | If provided, allows this attack to reduce enemy stats other than health.  Each individual damage application dealt by the same ability will apply stat reductions, at diminishing returns. All damage dealt in interaction chains forked by a Selector interaction will share the number of hits across all targets.                                                          |
+| Failed           | `Asset`<br />(Asset Type: `Interaction`)                      | **No**                                                                                                                       | After this interaction has finished, "Failed" will be executed if no damage hits were applied to the player, or if all damage hits were cancelled.                                                                                                                                                                                                                            |
+| Blocked          | `Asset`<br />(Asset Type: `Interaction`)                      | **No**                                                                                                                       | After this interaction has finished, "Blocked" will be executed if any damage hits were blocked by the target.                                                                                                                                                                                                                                                                |
+
+**DamageCalculator Fields**
+
+| Field Name                | Type                                                      | Required? | Notes                                                                                                                                                                                                                                                 |
+| ------------------------- | --------------------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Type                      | `DamageCalculatorType`<br />(Default: Absolute)           | **No**    | Whether the damage being applied is `Absolute` or \`Dps'.                                                                                                                                                                                             |
+| Class                     | `DamageClass`<br />(Default: Unknown)                     | **No**    | The type of attack producing the damage. Some weapon systems apply equipment modifiers based on this value.                                                                                                                                           |
+| BaseDamage                | `Map`<br />(Key Type: `DamageCause`, Value Type: `Float`) | **No**    | A set of DamageCauses and how much base damage is dealt for each.                                                                                                                                                                                     |
+| SequentialModifierStep    | `Float`<br />(Default: 0.0)                               | **No**    | Value between 0.0-1.0. Each additional hit from a single ability will have its damage reduced by this much as a percentage. All damage dealt in interaction chains forked by a Selector interaction will share the number of hits across all targets. |
+| SequentialModifierMinimum | `Float`<br />(Default: 0.0)                               | **No**    | Value between 0.0-1.0. `SequentialModifierStep` cannot reduce damage below this percentage regardless of the number of hits.                                                                                                                          |
+| RandomPercentageModifier  | `Float`<br />(Default: 0.0)                               | **No**    | A random value between +/- this amount multiplied by the base damage will be added to the base damage.                                                                                                                                                |
+
+**DamageEffects Fields**
+
+| Field Name             | Type                                         | Required? | Notes                                                                                   |
+| ---------------------- | -------------------------------------------- | --------- | --------------------------------------------------------------------------------------- |
+| ModelParticles         | `Array`<br />(Element Type: `ModelParticle`) | **No**    | Particle systems to trigger in the first-person view.                                   |
+| WorldParticles         | `Array`<br />(Element Type: `WorldParticle`) | **No**    | Particle systems to trigger in the third-person view.                                   |
+| LocalSoundEventId      | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | 2D sound to play locally to the attacking entity if they are a player.                  |
+| WorldSoundEventId      | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | Sound to play in the world at the Target entity's location.                             |
+| PlayerSoundEventId     | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | 2D sound to play locally to the Target entity if they are a player.                     |
+| ViewDistance           | `Double`<br />(Default: 75.0)                | **No**    | Distance at which these effects should play for other players.                          |
+| Knockback              | `Knockback`                                  | **No**    | The properties of the knockback that will be applied.                                   |
+| CameraEffect           | `Asset`<br />(Asset Type: `CameraEffect`)    | **No**    | CameraEffect to briefly apply locally to the Target entity if they are a player.        |
+| StaminaDrainMultiplier | `Float`<br />(Default: 1.0)                  | **No**    | This multiplier is applied to the stamina cost incurred by the target blocking, if any. |
+
+**AngledDamage Fields**
+
+| Field Name       | Type                                     | Required? | Notes                                                                                                                                                                                                     |
+| ---------------- | ---------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| AngleDistance    | `Float`<br />(Default: 0)                | **No**    | The width in degrees of the matching arc around the Target entity. If the attack against the Target originates from within the arc, then the properties below will be applied to the attack, if provided. |
+| Angle            | `Float`<br />(Default: 0.0)              | **No**    | The angle in degrees around the Target entity at which the matching arc is centered.                                                                                                                      |
+| DamageCalculator | `DamageCalculator`                       | **No**    | If provided and the attack against the Target entity originates from within the provided arc, this DamageCalculator will override the interaction's `DamageCalculator` field.                             |
+| DamageEffects    | `DamageEffects`                          | **No**    | If provided and the attack against the Target entity originates from within the provided arc, this DamageEffects will override the interaction's `DamageEffects` field.                                   |
+| Next             | `Asset`<br />(Asset Type: `Interaction`) | **No**    | If provided and the attack against the Target entity originates from within the provided arc, this Interaction will override the interaction's `Next` field.                                              |
+
+**TargetedDamage Fields**
+
+| Field Name       | Type                                     | Required? | Notes                                                                                                                                                                                            |
+| ---------------- | ---------------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| DamageCalculator | `DamageCalculator`                       | **No**    | If provided and this TargetedDamage was matched, this DamageCalculator will override the interaction's `DamageCalculator` field and the `DamageCalculator` field of any matching `AngledDamage`. |
+| DamageEffects    | `DamageEffects`                          | **No**    | If provided and this TargetedDamage was matched, this DamageEffects will override the interaction's `DamageEffects` field and the `DamageEffects` field of any matching `AngledDamage`.          |
+| Next             | `Asset`<br />(Asset Type: `Interaction`) | **No**    | If provided and this TargetedDamage was matched, this Interaction will override the interaction's `Next` field and the `Next` field of any matching `AngledDamage`.                              |
+
+**EntityStatOnHit Fields**
+
+| Field Name                  | Type                                                                       | Required? | Notes                                                                                                                                                                                                                                                                                        |
+| --------------------------- | -------------------------------------------------------------------------- | --------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| EntityStatId                | `Asset`<br />(AssetType: `EntityStatType`)                                 | **Yes**   | Which entity stat to affect.                                                                                                                                                                                                                                                                 |
+| Amount                      | `Float`<br />(Default: 0.0)                                                | **No**    | How much of the stat to apply for each damage application. Use negative numbers to reduce stats.                                                                                                                                                                                             |
+| MultipliersPerEntitiesHit   | `Array`<br />(Element Type: `Float`, Default: `[1.0, 0.6, 0.4, 0.2, 0.1]`) | **No**    | The diminishing returns curve to be applied for multiple damage applications by the same ability. Each hit's stat impact will be multiplied by the next value in the list.  If there are more hits than array elements, subsequent hits will be multiplied by `MultiplierPerExtraEntityHit`. |
+| MultiplierPerExtraEntityHit | `Float`<br />(Default: 0.05)                                               | **No**    | If an ability carries out more damage applications than there are elements in the `MultipliersPerEntitiesHit` array, then subsequent stat values will be multiplied by this number.                                                                                                          |
+
+**Knockback Fields**
+
+| Field Name     | Type                                       | Required? | Notes                                                                                                                      |
+| -------------- | ------------------------------------------ | --------- | -------------------------------------------------------------------------------------------------------------------------- |
+| Type           | `String`                                   | **No**    | If provided, specifies a type of knockback to use. Each Target type may come with additional fields.                       |
+| Force          | `Double`<br />(Default: 0.0)               | **No**    | The amount of force to apply to the Owner entity.                                                                          |
+| Duration       | `Double`<br />(Default: 0.0)               | **No**    | If 0.0, apply the force as a single impulse.  If more, continuously apply the force over a period of time.                 |
+| VelocityType   | `ChangeVelocityType`<br />(Default: `Add`) | **No**    | How to apply the force, either adding it to the entity's current velocity, or setting the velocity to the knockback force. |
+| VelocityConfig | `VelocityConfig`                           | **No**    | Characteristics of friction as the Owner entity is thrown by this knockback.                                               |
+
+**Knockback Type: Force**
+
+Apply the calculated knockback force along the provided direction.
+
+| Field Name | Type                         | Required? | Notes                                                                                |
+| ---------- | ---------------------------- | --------- | ------------------------------------------------------------------------------------ |
+| Direction  | `Vector3`<br />(Default: Up) | **No**    | Which direction the entity should be flung, relative to the direction of the attack. |
+
+**Knockback Type: Point**
+
+Apply the calculated knockback force laterally along the XZ plane, plus provided Y velocity.
+
+| Field Name | Type                        | Required? | Notes                                                                                                   |
+| ---------- | --------------------------- | --------- | ------------------------------------------------------------------------------------------------------- |
+| OffsetX    | `Integer`<br />(Default: 0) | **No**    | Offset the source position of the knockback left or right perpendicular to the direction of the attack. |
+| OffsetZ    | `Integer`<br />(Default: 0) | **No**    | Offset the source position of the knockback, forward or backward along the directon of the attack.      |
+| RotateY    | `Integer`<br />(Default: 0) | **No**    | Rotate the knockback direction around the Y axis, where 0 is the default attack direction.              |
+| VelocityY  | `Float`<br />(Default: 0.0) | **No**    | Add vertical velocity to the knockback force after the direction and force has been calculated.         |
+
+**Knockback Type: Directional**
+
+Apply the calculated knockback force along the attack direction, removing any vertical component and replacing it with a provided Y velocity.
+
+| Field Name | Type                      | Required? | Notes                                                                                                                                            |
+| ---------- | ------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------ |
+| RelativeX  | `Float`<br />(Default: 0) | **No**    | Apply additional force left or right perpendicular to the direction of the attack. The additional force is multiplied by the knockback strength. |
+| RelativeZ  | `Float`<br />(Default: 0) | **No**    | Apply additional force forward or backward along the attack direction. The additional force is multiplied by the knockback strength.             |
+| VelocityY  | `Float`<br />(Default: 0) | **No**    | Replace the vertical velocity of the knockback with this value.  This value is not multiplied by knockback strength.                             |
+
+**VelocityConfig Fields**
+
+| Field Name          | Type                                              | Required? | Notes                                                                                                                                                                                           |
+| ------------------- | ------------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| GroundResistance    | `Float`<br />(Default: 0.82)                      | **No**    | The minimum amount of friction applied when the entity is in contact with the ground.  1.0 = no friction, 0.0 = total friction                                                                  |
+| GroundResistanceMax | `Float`<br />(Default: 0.0)                       | **No**    | The maximum amount of friction applied when the entity is in contact with the ground.  1.0 = no friction, 0.0 = total friction                                                                  |
+| AirResistance       | `Float`<br />(Default: 0.96)                      | **No**    | The minimum amount of friction applied when the entity is in the air. 1.0 = no friction, 0.0 = total friction                                                                                   |
+| AirResistanceMax    | `Float`<br />(Default: 0.0)                       | **No**    | The maximum amount of friction applied when the entity is in the air. 1.0 = no friction, 0.0 = total friction                                                                                   |
+| Threshold           | `Float`<br />(Default: 1.0)                       | **No**    | The speed at which the maximum amount of friction will be applied to the entity. The amount of friction applied will increase from minimum to maximum as the entity moves from 0 to this speed. |
+| Style               | `VelocityThresholdStyle`<br />(Default: `Linear`) | **No**    | The curve that friction follows as the entity's speed increases toward the `Threshold`.                                                                                                         |
+
+**DamageCalculatorType Values**
+
+- `Absolute`
+- `Dps`
+
+**DamageClass Values**
+
+- `Unknown`
+- `Light`
+- `Charged`
+- `Signature`
+
+**ChangeVelocityType Values**
+
+- `Add`
+- `Set`
+
+**VelocityThresholdStyle Values**
+
+- `Linear`
+- `Exp`
+
+### LaunchProjectile
+
+This is just a worse version of Projectile and is slated to be removed.  Use Projectile.
+
+### Projectile
+
+This interaction will spawn a new projectile at the User entity's eye position that will travel in its look direction.
+
+| Field Name | Type                                          | Required? | Notes                                                  |
+| ---------- | --------------------------------------------- | --------- | ------------------------------------------------------ |
+| Config     | `Asset`<br />(Asset Type: `ProjectileConfig`) | **No**    | Configuration describing the projectile to be spawned. |
+
+### RemoveEntity
+
+Despawns the specified entity from the world. This interaction will have no effect if the specified entity is a player. This
+interaction has no special failure conditions.
+
+| Field Name | Type                                     | Required? | Notes                  |
+| ---------- | ---------------------------------------- | --------- | ---------------------- |
+| Entity     | `InteractionTarget`<br />(Default: User) | **No**    | The entity to despawn. |
+
+**InteractionTarget Values**
+
+- `User` - The user of this interaction chain. The entity whose actions caused this interaction chain to be executed. This is usually the same as the Owner.
+- `Owner` - The owner of this interaction chain. The entity upon whom this interaction chain is executing.
+- `Target` - The entity target of this interaction chain, if any.  This value is mutable (and can therefore come from many places) but most commonly, it is an entity the User was targeting when this interaction chain began executing.
+
+### SendMessage
+
+This interaction sends a message to the Owner entity if that entity can receive messages.  Otherwise, the message
+is written to the server logs.  If the entity is a player, the message will appear in the player's chat window.
+
+\*\*SendMessage
+
+| Field Name | Type     | Required? | Notes                                                                                                                 |
+| ---------- | -------- | --------- | --------------------------------------------------------------------------------------------------------------------- |
+| Message    | `String` | **No**    | A text message to be sent to the Owner entity.  If this field is not provided, `Key` is used instead.                 |
+| Key        | `String` | **No**    | A translation key for a message to be sent to the Owner entity. If `Message` is provided, then this field is ignored. |
+
+### UseEntity
+
+This interaction is not in use by Hypixel and has some unusual qualities that mean it probably won't do what you want it
+to.  Do not use it.
+
+This interaction will retrieve the entity currently targeted by the client (NOT the interaction chain's current Target
+entity) and execute that entity's RootInteraction for this interaction chain's current interaction type. The
+RootInteraction will be executed as part of this current interaction chain. None of the properties of this interaction
+chain will be modified.
+
+This interaction will fail if the client is not currently targeting an entity, or if no interaction for the current
+interaction type exists on the entity.
+
+## Stats
+
+Hytale's resource system has been written about fairly extensively.  You can use these interactions to modify stats in
+response to actions or use stats as a cost for abilities.
+
+### ChangeStat
+
+This interaction applies a set of raw stat changes to the User entity. It has no special failure conditions.
+
+| Field Name    | Type                                                         | Required? | Notes                                                                                                                                                                                                                      |
+| ------------- | ------------------------------------------------------------ | --------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| StatModifiers | `Map`<br />(Key Type: `EntityStatType`, Value Type: `Float`) | **Yes**   | A set of stats to modify and what value to apply to them.                                                                                                                                                                  |
+| ValueType     | `ValueType`<br />(Default: Absolute)                         | **No**    | Whether the values in the `StatModifiers` map represent flat values to apply to the stat total, or percentages (0.0-100.0). Percentage values are percentage of the difference between the maximum and minimum stat value. |
+| Behaviour     | `ChangeStatBehavior`<br />(Default: Add)                     | **No**    | Whether the values in the `StatModifiers` map represent deltas to add into the User entity's current stat values, or fixed values to set the entity's stats to.                                                            |
+
+**ValueType Values**
+
+- `Absolute`
+- `Percent`
+
+**ChangeStatBehaviour Values**
+
+- `Add`
+- `Set`
+
+### ChangeStatWithModifier
+
+This interaction is like ChangeStat, except an armor stat modifier can be chosen which will apply bonuses and penalties
+to a stat from the User entity's equipped armor before it is applied.
+
+| Field Name            | Type                                                         | Required? | Notes                                                                                                                                                                                                                      |
+| --------------------- | ------------------------------------------------------------ | --------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| StatModifiers         | `Map`<br />(Key Type: `EntityStatType`, Value Type: `Float`) | **Yes**   | A set of stats to modify and what value to apply to them.                                                                                                                                                                  |
+| ValueType             | `ValueType`<br />(Default: Absolute)                         | **No**    | Whether the values in the `StatModifiers` map represent flat values to apply to the stat total, or percentages (0.0-100.0). Percentage values are percentage of the difference between the maximum and minimum stat value. |
+| Behaviour             | `ChangeStatBehavior`<br />(Default: Add)                     | **No**    | Whether the values in the `StatModifiers` map represent deltas to add into the User entity's current stat values, or fixed values to set the entity's stats to.                                                            |
+| InteractionModifierId | `InteractionModifierId`                                      | **Yes**   | The armor interaction modifier to apply bonuses and penalties for.                                                                                                                                                         |
+
+**ValueType Values**
+
+- `Absolute`
+- `Percent`
+
+**ChangeStatBehaviour Values**
+
+- `Add`
+- `Set`
+
+**InteractionModifierId Values**
+
+- `Dodge`
+
+### StatsCondition
+
+This interaction will fail if the User entity cannot afford the specified stats costs, or if it does not have the
+requested stats.
+
+| Field Name | Type                                                         | Required? | Notes                                                                                                                                                                                    |
+| ---------- | ------------------------------------------------------------ | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Costs      | `Map`<br />(Key Type:` EntityStatType`, Value Type: `Float`) | **Yes**   | A set of costs that the User entity needs to be able to afford for this interaction to succeed.                                                                                          |
+| ValueType  | `ValueType`<br />(Default: Absolute)                         | **No**    | Whether the values in the `Costs` map represetn flat values or percentages (0.0-100.0).  Percentage values are percentage of the difference between the maximum and minimum value.       |
+| LessThan   | `Boolean`<br />(Default: false)                              | **No**    | If true, this interaction will fail unless the User entity's current stat values are at or **below** the specified levels.  If false, they must be at or **above** the specified levels. |
+| Lenient    | `Boolean`<br />(Default: false)                              | **No**    | If true and `LessThan` is true, and a player's minimum stat value is below zero, then the player can afford a stat cost if the current value of a stat if above 0.                       |
+
+**ValueType Values**
+
+- `Absolute`
+- `Percent`
+
+### StatsConditionWithModifier
+
+This interaction is like StatsCondition, except an armor stat modifier can be chosen which will apply bonuses and penalties
+to a stat's cost from the User entity's equipped armor before it is compared.
+
+| Field Name            | Type                                                         | Required? | Notes                                                                                                                                                                                    |
+| --------------------- | ------------------------------------------------------------ | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Costs                 | `Map`<br />(Key Type:` EntityStatType`, Value Type: `Float`) | **Yes**   | A set of costs that the User entity needs to be able to afford for this interaction to succeed.                                                                                          |
+| ValueType             | `ValueType`<br />(Default: Absolute)                         | **No**    | Whether the values in the `Costs` map represetn flat values or percentages (0.0-100.0).  Percentage values are percentage of the difference between the maximum and minimum value.       |
+| LessThan              | `Boolean`<br />(Default: false)                              | **No**    | If true, this interaction will fail unless the User entity's current stat values are at or **below** the specified levels.  If false, they must be at or **above** the specified levels. |
+| Lenient               | `Boolean`<br />(Default: false)                              | **No**    | If true and `LessThan` is true, and a player's minimum stat value is below zero, then the player can afford a stat cost if the current value of a stat if above 0.                       |
+| InteractionModifierId | `InteractionModifierId`                                      | **Yes**   | The armor interaction modifier to apply bonuses and penalties for.                                                                                                                       |
+
+**ValueType Values**
+
+- `Absolute`
+- `Percent`
+
+**InteractionModifierId Values**
+
+- `Dodge`
+
+## EntityEffects
+
+EntityEffects are buff or debuff effects that can be applied to a LivingEntity.  These can have a variety of effects from
+movement speed changes to periodic damage.
+
+### EffectCondition
+
+This interaction will fail if the specified entity's EntityEffects do not match the provided conditions.
+
+**EffectCondition Fields**
+
+| Field Name      | Type                                             | Required? | Notes                                                                                                                                                                                                             |
+| --------------- | ------------------------------------------------ | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Entity          | `InteractionTarget`<br />(Default: User)         | **Yes**   | The entity to examine for EntityEffects. This field can indicate the Owner, User, or Target of this interaction chain.                                                                                            |
+| Match           | `Match`<br />(Default: All)                      | **No**    | If `All`, then this interaction will fail if any EntityEffect in the `EntityEffectIds` is not on the specified entity. If `None`, then this interaction will fail if any EntityEffect IS on the specified entity. |
+| EntityEffectIds | `AssetArray`<br />(Element Type: `EntityEffect`) | **Yes**   | The set of EntityEffects to check against the specified entity and `Match`.                                                                                                                                       |
+
+**InteractionTarget Values**
+
+- `User` - The user of this interaction chain. The entity whose actions caused this interaction chain to be executed. This is usually the same as the Owner.
+- `Owner` - The owner of this interaction chain. The entity upon whom this interaction chain is executing.
+- `Target` - The entity target of this interaction chain, if any.  This value is mutable (and can therefore come from many places) but most commonly, it is an entity the User was targeting when this interaction chain began executing.
+
+**Match Values**
+
+- `All` - All EntityEffects must be on the specified entity for this interaction to succeed.
+- `None` - None of the EntityEffects must be on the specified entity for this interaction to succeed.
+
+### ApplyEffect
+
+This interaction will apply the specified EntityEffect to the specified Entity.  It has no special failure conditions.
+
+**ApplyEffect Fields**
+
+| Field Name | Type                                      | Required? | Notes                                                                                                                  |
+| ---------- | ----------------------------------------- | --------- | ---------------------------------------------------------------------------------------------------------------------- |
+| Entity     | `InteractionTarget`<br />(Default: User)  | **Yes**   | The entity to apply the EntityEffect to. This field can indicate the Owner, User, or Target of this interaction chain. |
+| EffectId   | `Asset`<br />(Asset Type: `EntityEffect`) | **Yes**   | The effect to apply.                                                                                                   |
+
+**InteractionTarget Values**
+
+- `User` - The user of this interaction chain. The entity whose actions caused this interaction chain to be executed. This is usually the same as the Owner.
+- `Owner` - The owner of this interaction chain. The entity upon whom this interaction chain is executing.
+- `Target` - The entity target of this interaction chain, if any.  This value is mutable (and can therefore come from many places) but most commonly, it is an entity the User was targeting when this interaction chain began executing.
+
+### ClearEntityEffect
+
+This interaction will remove the specified EntityEffect from the specified Entity. It has no special failure conditions.
+It will not fail if the Entity does not have the EntityEffect.
+
+**ClearEntityEffect Fields**
+
+| Field Name | Type                                      | Required? | Notes                                                                                                                     |
+| ---------- | ----------------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------- |
+| Entity     | `InteractionTarget`<br />(Default: User)  | **Yes**   | The entity to remove the EntityEffect from. This field can indicate the Owner, User, or Target of this interaction chain. |
+| EffectId   | `Asset`<br />(Asset Type: `EntityEffect`) | **Yes**   | The effect to remove.                                                                                                     |
+
+**InteractionTarget Values**
+
+- `User` - The user of this interaction chain. The entity whose actions caused this interaction chain to be executed. This is usually the same as the Owner.
+- `Owner` - The owner of this interaction chain. The entity upon whom this interaction chain is executing.
+- `Target` - The entity target of this interaction chain, if any.  This value is mutable (and can therefore come from many places) but most commonly, it is an entity the User was targeting when this interaction chain began executing.
+
+## Farming
+
+These are interaction types built to support the in-game farming system in Hytale. They are mostly block-related interactions
+with a few exceptions.
+
+### ChangeFarmingStage
+
+If the target block is a farming block, this interaction will attempt to modify the current farming stage in one of
+three ways.  The interaction can optionally specify which StageSet to use for the new stage. If it is not specified,
+the current StageSet will be used. If any part of the the process of changing the growth stage fails, this interaction
+will fail, with the one exception that attempting to set the stage to the crop's existing stage will have no effect but
+still succeed.
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                                                                                                                                                                          |
+| ---------------- | ------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction.                                                                                                                                              |
+| StageSet         | `String`                        | **No**    | If provided, set the block's current stage to one in the provided StageSet. Otherwise, use the crop's current StageSet.                                                                                                                                                        |
+| Increase         | `Integer`                       | **No**    | If provided, increase the current stage by the specified amount. If the specified stage does not exist, the block will be set to the closest extant stage.                                                                                                                     |
+| Decrease         | `Integer`                       | **No**    | If provided and `Increase` is not provided, decrease the current stage by the specified amount. If the specified stage does not exist, the block will be set to the closest extant stage.                                                                                      |
+| Stage            | `Integer`<br />(Default: -1)    | **No**    | If provided and `Increase`/`Decrease` are not provided, set the current stage to the specified stage. If this value is less than 0, set the current stage to the final growth stage. If the specified stage does not exist, the block will be set to the closest extant stage. |
+
+### FertilizeSoil
+
+If the target block is unfertilized tilled soil or a farming block on top of unfertilized tilled soil, fertilizes the soil.
+The interaction will fail otherwise.
+
+**FertilizeSoil Fields**
+
+| Field Name       | Type                                  | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false)       | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+| RefreshModifiers | `Array`<br />(Element Type: `String`) | **No**    | Does nothing.                                                                                                                     |
+
+### HarvestCrop
+
+This interaction will attempt to execute the harvest action on the current block target and add the crop's drops to the User entity's
+inventory.  The block will either be destroyed or set to its post-harvest growth stage, depending on the farming
+configuration of the block.  This will happen (and the player will receive the full harvest drops) regardless of the
+block's current growth stage. This interaction has no special failure conditions, even if the block target isn't a
+farming block or gathering isn't permitted in the current world, but nothing will occur in those cases.
+
+**HarvestCrop Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+
+### UseWateringCan
+
+If the target block is tilled soil or a farming block on top of tilled soil, waters the soil for the specified duration.
+The interaction will fail otherwise.
+
+**UseWateringCan Fields**
+
+| Field Name       | Type                                  | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false)       | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+| Duration         | `Integer`<br />(Default: 0)           | **No**    | The duration in seconds to water the soil for.                                                                                    |
+| RefreshModifiers | `Array`<br />(Element Type: `String`) | **No**    | Does nothing.                                                                                                                     |
diff --git a/content/docs/ro-RO/contributing/pr-guidelines.mdx b/content/docs/ro-RO/contributing/pr-guidelines.mdx
index 7a251032..c226da04 100644
--- a/content/docs/ro-RO/contributing/pr-guidelines.mdx
+++ b/content/docs/ro-RO/contributing/pr-guidelines.mdx
@@ -19,6 +19,8 @@ To ensure a smooth and efficient review process, both contributors and reviewers
 4. **Code Quality**
    - Ensure your code follows the project's coding standards and best practices.
    - Include comments where necessary to explain complex logic.
+   - Always test your changes locally before submitting the PR to catch any issues early.
+   - Format your code using `bun format` to maintain consistency across the codebase.
 5. **Testing**
    - Test your changes thoroughly before submitting the PR.
    - If applicable, include unit tests or integration tests to verify your changes.
diff --git a/content/docs/ro-RO/contributing/translate.mdx b/content/docs/ro-RO/contributing/translate.mdx
new file mode 100644
index 00000000..c62ffdde
--- /dev/null
+++ b/content/docs/ro-RO/contributing/translate.mdx
@@ -0,0 +1,74 @@
+---
+title: Translate
+description: How to translate HytaleModding to your language
+---
+
+# Translating HytaleModding
+
+HytaleModding is translated with the help of the community using **Crowdin**. If you want to help translate or improve existing translations, this is the right place.
+
+## Steps to Translate
+
+All translations are managed **via Crowdin**.
+
+1. Visit [our Crowdin project](https://crowdin.com/project/hytalemodding) and log in if required.
+2. Click on your language.
+3. Click on the file/article you wish to translate. We recommend starting with Official Documentation, and then Server Plugin Documentation.
+4. Start translating!
+5. Approved translations will appear on the website.
+
+### Video Guide
+
+<iframe src="https://www.youtube.com/embed/NHiG1rDRgks" allowFullScreen />
+
+## How to discuss
+
+You can always report issues or discuss specific topics directly on Crowdin, but we recommend using Discord instead of the Crowdin comment system to keep everything organized in one place.
+
+1. Join [our Discord](https://discord.gg/hytalemodding)
+2. Open `#translations` channel. Here you can discuss or ask questions that are not related to a specific language.
+3. If you want to join a thread, you are required to run `/translator <your-language>` command here. The bot will add you to the thread for your language.
+
+## Translation Guidelines
+
+- You need to be confident in what you are translating. You should be able to read the text you just translated and understand the meaning of it very easily.
+- It should use the simplest form of language possible. Use English words if the translation is unknown to the majority in your country.
+- Use your imagination, trust yourself. Feel free to change any context as you wish as long as it can still get the same point across and is understandable.
+- These guidelines are more important than language-specific guidelines, but less important than Hytale terminology and rules.
+
+## What not to translate
+
+We request you all to not translate these specific sections of the website:
+
+### Callout types
+
+Callouts are the boxes that contain important information. We request you to not translate the types as they only work in English.
+
+**Example:**
+
+```mdx
+<Callout type="warning" title="Translate this title!">
+Translate the text inside the callout!
+</Callout>
+```
+
+In this example, please don't translate the word warning, the rest you can translate.
+
+### Icons
+
+Icon names must not be translated.
+They are technical identifiers mapped directly to existing icons. Translating them will break the icon rendering.
+
+```mdx
+icon: Globe
+```
+
+---
+
+{/* 
+For translators who will edit this page:
+
+- You are required to translate the Guidelines as they change.
+- General guidelines should be translated but not edited.
+- Learn how to use Markdown from writing_guides.mdx
+*/}
diff --git a/content/docs/ro-RO/established-information/server/content-categories/art-assets.mdx b/content/docs/ro-RO/established-information/server/content-categories/art-assets.mdx
index 39c2ed37..1e926874 100644
--- a/content/docs/ro-RO/established-information/server/content-categories/art-assets.mdx
+++ b/content/docs/ro-RO/established-information/server/content-categories/art-assets.mdx
@@ -14,7 +14,7 @@ Hytale provides comprehensive support for 3D modeling and texture art creation,
 Hytale uses **Blockbench** as the primary tool for 3D modeling and animation:
 
 * **Official support**: Used for "creating Hytale models, textures, and animations"
-* **Special plugin**: Hytale will have a dedicated Blockbench plugin, to be released ASAP
+* **Special plugin**: Hytale has a dedicated [Blockbench Plugin](https://www.blockbench.net/plugins/hytale_plugin).
 * **Direct compatibility**: The plugin allows creators to "create Hytale-compatible models, textures, and animations directly in Blockbench"
 * **Replaces legacy tools**: Fully replaces the old Hytale Model Maker to better support established creative workflows in the community
 * **Safety features**: Only allows you to add things compatible with the engine, so no need to worry about breaking anything
diff --git a/content/docs/ro-RO/guides/ecs/block-components.mdx b/content/docs/ro-RO/guides/ecs/block-components.mdx
new file mode 100644
index 00000000..ca68b38a
--- /dev/null
+++ b/content/docs/ro-RO/guides/ecs/block-components.mdx
@@ -0,0 +1,247 @@
+---
+title: Block Components
+description: Learn how to use the block components.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+  - name: oskarscot
+    link: https://oskar.scot
+---
+
+# Overview
+
+In this guide, you'll learn how to use block components to create a ticking block.
+
+<Callout>
+  For a more complete reference, you may also want to review FarmingSystems.Ticking, as much of the underlying logic is based on its implementation.
+</Callout>
+
+## Steps
+
+### 1. ExampleBlock - holds block behavior
+
+```java
+public class ExampleBlock implements Component<ChunkStore> {
+
+    public static final BuilderCodec CODEC = BuilderCodec.builder(ExampleBlock.class, ExampleBlock::new).build();
+
+    // Components usually require a copy constructor as well but since we don't actually hold any data in this component this is not neccessary
+    public ExampleBlock() { }
+
+    public static ComponentType getComponentType() {
+        return ExamplePlugin.get().getExampleBlockComponentType();
+    }
+
+    @Nullable
+    public Component<ChunkStore> clone() {
+        return new ExampleBlock();
+    }
+}
+```
+
+ExampleBlock is a custom component that stores the behavior and data for your ticking block. Here, it simply places an Ice Block at x + 1 relative to its current position when it ticks.
+
+---
+
+### 2. ExampleInitializer - marks blocks as ticking when placed
+
+```java
+public class ExampleInitializer extends RefSystem {
+
+    @Override
+    public void onEntityAdded(@Nonnull Ref ref, @Nonnull AddReason reason, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+        BlockModule.BlockStateInfo info = (BlockModule.BlockStateInfo) commandBuffer.getComponent(ref, BlockModule.BlockStateInfo.getComponentType());
+        if (info == null) return;
+
+        ExampleBlock generator = (ExampleBlock) commandBuffer.getComponent(ref, ExamplePlugin.get().getExampleBlockComponentType());
+        if (generator != null) {
+            int x = ChunkUtil.xFromBlockInColumn(info.getIndex());
+            int y = ChunkUtil.yFromBlockInColumn(info.getIndex());
+            int z = ChunkUtil.zFromBlockInColumn(info.getIndex());
+
+            WorldChunk worldChunk = (WorldChunk) commandBuffer.getComponent(info.getChunkRef(), WorldChunk.getComponentType());
+            if (worldChunk != null) {
+				worldChunk.setTicking(x, y, z, true);
+            }
+        }
+    }
+
+    @Override
+    public void onEntityRemove(@Nonnull Ref ref, @Nonnull RemoveReason reason, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+    }
+
+    @Override
+    public Query getQuery() {
+        return Query.and(BlockModule.BlockStateInfo.getComponentType(), ExamplePlugin.get().getExampleBlockComponentType());
+    }
+}
+```
+
+ExampleInitializer is a RefSystem that reacts when block entities with the ExampleBlock component are added or removed. This is crucial for marking blocks as ticking when they're first placed.
+
+**Key Points:**
+
+- Tells the game that this block should tick, allowing `ExampleSystem` to process it.
+
+```java
+worldChunk.setTicking(x, y, z, true);
+```
+
+---
+
+### 3. ExampleSystem - handles ticking
+
+```java
+public class ExampleSystem extends EntityTickingSystem {
+
+    public void tick(float dt, int index, @Nonnull ArchetypeChunk archetypeChunk, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+        BlockSection blocks = (BlockSection) archetypeChunk.getComponent(index, BlockSection.getComponentType());
+
+        assert blocks != null;
+
+        if (blocks.getTickingBlocksCountCopy() != 0) {
+            ChunkSection section = (ChunkSection) archetypeChunk.getComponent(index, ChunkSection.getComponentType());
+
+            assert section != null;
+
+            BlockComponentChunk blockComponentChunk = (BlockComponentChunk) commandBuffer.getComponent(section.getChunkColumnReference(), BlockComponentChunk.getComponentType());
+
+            assert blockComponentChunk != null;
+
+            blocks.forEachTicking(blockComponentChunk, commandBuffer, section.getY(), (blockComponentChunk1, commandBuffer1, localX, localY, localZ, blockId) -> {
+                Ref<ChunkStore> blockRef = blockComponentChunk.getEntityReference(ChunkUtil.indexBlockInColumn(localX, localY, localZ));
+                if (blockRef == null) {
+                    return BlockTickStrategy.IGNORED;
+                } else {
+                    ExampleBlock exampleBlock = (ExampleBlock) commandBuffer1.getComponent(blockRef, ExampleBlock.getComponentType());
+                    if (exampleBlock != null) {
+                        WorldChunk worldChunk = (WorldChunk) commandBuffer.getComponent(section.getChunkColumnReference(), WorldChunk.getComponentType());
+                        World world = worldChunk.getWorld();
+
+                        int globalX = localX + (worldChunk.getX() * 32);
+                        int globalZ = localZ + (worldChunk.getZ() * 32);
+
+                        // We need to execute setBlock on the world thread as you cannot call store functions from a system
+                        // This is because of the architecture of the server, depending on your needs you can also use the CommandBuffer
+                        world.execute(() -> {
+                            world.setBlock(globalX + 1, localY, globalZ, "Rock_Ice");
+                        });
+
+                        return BlockTickStrategy.CONTINUE;
+
+                    } else {
+                        return BlockTickStrategy.IGNORED;
+                    }
+                }
+            });
+        }
+    }
+
+    @Nullable
+    public Query getQuery() {
+        return Query.and(BlockSection.getComponentType(), ChunkSection.getComponentType());;
+    }
+}
+```
+
+ExampleSystem is an EntityTickingSystem that runs every tick to execute the logic for all ticking blocks with the ExampleBlock component.
+
+**Key Points:**
+
+- **Get the block component**
+
+```java
+ExampleBlock exampleBlock = (ExampleBlock) commandBuffer.getComponent(blockRef, ExampleBlock.getComponentType());
+```
+
+- **Convert local chunk coordinates to world coordinates**
+
+```java
+int globalX = localX + (worldChunk.getX() * 32);
+int globalZ = localZ + (worldChunk.getZ() * 32);
+```
+
+- **Run the block logic**
+
+```java
+exampleBlock.runBlockAction(globalX, localY, globalZ, worldChunk.getWorld());
+```
+
+- **Keep the block ticking in the next tick**
+
+```java
+return BlockTickStrategy.CONTINUE;
+```
+
+---
+
+### 4. ExamplePlugin - registers components and systems
+
+```java
+public class ExamplePlugin extends JavaPlugin {
+    protected static ExamplePlugin instance;
+    private static final HytaleLogger LOGGER = HytaleLogger.forEnclosingClass();
+    private ComponentType exampleBlockComponentType;
+
+    public static ExamplePlugin get() {
+        return instance;
+    }
+
+    public ExamplePlugin(@Nonnull JavaPluginInit init) {
+        super(init);
+        LOGGER.atInfo().log("Hello from " + this.getName() + " version " + this.getManifest().getVersion().toString());
+    }
+
+    @Override
+    protected void setup() {
+        instance = this;
+        LOGGER.atInfo().log("Setting up plugin " + this.getName());
+        this.exampleBlockComponentType = this.getChunkStoreRegistry().registerComponent(ExampleBlock.class, "ExampleBlock", ExampleBlock.CODEC);
+    }
+	
+	@Override
+	protected void start() {
+		this.getChunkStoreRegistry().registerSystem(new ExampleSystem());
+		this.getChunkStoreRegistry().registerSystem(new ExampleInitializer());
+	}
+
+    public ComponentType getExampleBlockComponentType() {
+        return this.exampleBlockComponentType;
+    }
+}
+```
+
+---
+
+### 5. Configure In-Game
+
+![block-component-1](/assets/guides/block-component-1.png)
+
+![block-component-2](/assets/guides/block-component-2.png)
+
+With this logic, the block will now continuously place an Ice Block at the coordinates x + 1 relative to its current position every time it ticks.
+
+---
+
+## Common Issues
+
+### NullPointerException on Startup
+
+**Error message:**
+
+```java
+java.lang.NullPointerException: Cannot invoke "com.hypixel.hytale.component.query.Query.validateRegistry(com.hypixel.hytale.component.ComponentRegistry)" because "query" is null
+```
+
+**Cause:**
+This error occurs when your module is loaded **before** the required Hytale modules.
+
+**Fix:**
+Add `EntityModule` and `BlockModule` as dependencies in your `manifest.json` to ensure proper load order.
+
+```json
+"Dependencies": {
+  "Hytale:EntityModule": "*",
+  "Hytale:BlockModule": "*"
+}
+```
diff --git a/content/docs/ro-RO/guides/ecs/hytale-ecs-theory.mdx b/content/docs/ro-RO/guides/ecs/hytale-ecs-theory.mdx
index 20c3a94d..52d8b1f5 100644
--- a/content/docs/ro-RO/guides/ecs/hytale-ecs-theory.mdx
+++ b/content/docs/ro-RO/guides/ecs/hytale-ecs-theory.mdx
@@ -29,7 +29,7 @@ for now this is the basic understanding for the `ChunkStore`. You can use it to
 
 ## Holder
 
-A Holder is essentially a blueprint for an entity. Before an entity exists in the Store (and thus in the world), is exists as a `Holder`. It collects and holds all the necessary components (data). You can compare it analogous to shopping cart. You grab all components you need and once you have everything, check out at the store which will take your cart and create a valid entity ID and hand you back a receipt (a Ref).
+A Holder is essentially a blueprint for an entity. Before an entity exists in the Store (and thus in the world), it exists as a `Holder`. It collects and holds all the necessary components (data). You can compare it analogous to shopping cart. You grab all components you need and once you have everything, check out at the store which will take your cart and create a valid entity ID and hand you back a receipt (a Ref).
 
 Let's take a look at an example: initializing players. In `Universe`, the `addPlayer` method demonstrates it perfectly.
 When a player connects, we don't immediately throw them into the ECS. We first construct their data in a Holder.
@@ -167,7 +167,7 @@ MyComponent comp = commandBuffer.getComponent(ref, componentType);
 
 Codecs handle serialization and deserialization of components. Hytale uses them to save and load entity data to and from disk as well as sending component data over the network. When creating a custom component, you must also create a corresponding Codec.
 
-There are mutliple Codec types already implemented in the default Codec Interface:
+There are multiple Codec types already implemented in the default Codec Interface:
 
 - Codec.STRING
 - Codec.BOOLEAN
@@ -215,7 +215,7 @@ This might seem tedious at first but it ensures that your component can be corre
   KeyedCodec<Integer> exampleInt = new KeyedCodec<Integer>("ExampleIntIdForCodec", Codec.INTEGER);
   ```
 
-- **Setter Function**: This is a lambda function that takes an instance of your component and returns the value of the field you want to serialize. For example, if you have a field called `myCustomField` in your custom component, your getter function would look like this:
+- **Setter Function**: This is a lambda function that takes an instance of your component + the value to set and sets the field value on the component. For example, if you have a field called `myCustomField` in your custom component, your setter function would look like this:
   ```java
   (data, value) -> data.myCustomField = value
   ```
@@ -276,7 +276,7 @@ public class PoisonComponent implements Component<EntityStore> {
 
 You can also add validators to your Codec fields to ensure that the data being serialized/deserialized meets certain criteria. For example, if you want to ensure that the `damagePerTick` field is always non-negative or the poison name is never null, you can add a validator like this:
 
-````java
+```java
 .append(
     new KeyedCodec<Float>("DamagePerTick", Codec.FLOAT),
     (data, value) -> data.damagePerTick = value,
@@ -292,14 +292,15 @@ You can also add validators to your Codec fields to ensure that the data being s
 )
 .addValidator(Validators.nonNull())
 .add()
+```
 
 ### Complex Codec Examples
 
-If you want to have a map inside your component, you can use the MapCodec class to build a KeyedCoded for it. Here's an example of how to create a Codec for a Map field:
+If you want to have a map inside your component, you can use the MapCodec class to build a KeyedCodec for it. Here's an example of how to create a Codec for a Map field:
 
 ```java
 var damagePerTick = new KeyedCodec<>("DamagePerTick", new MapCodec<>(Codec.FLOAT, HashMap<String, Float>::new));
-````
+```
 
 <Callout type="info">
   This also works with custom Objects as long as you have a Codec defined for the Object type.
diff --git a/content/docs/ro-RO/guides/java-basics/00-introduction.mdx b/content/docs/ro-RO/guides/java-basics/00-introduction.mdx
index a03ad638..b0130d74 100644
--- a/content/docs/ro-RO/guides/java-basics/00-introduction.mdx
+++ b/content/docs/ro-RO/guides/java-basics/00-introduction.mdx
@@ -7,7 +7,7 @@ Welcome to your journey into Java Programming! This guide is designed to introdu
 
 ## What is Java?
 
-Java is a powerful, object-oriented programming language created in 1995. It's one of the most popular programming languages in the world and is used for everything from mobile apps to enterprise software. Most importantly for us, it's the language Hytale uses for it's servers & modding API.
+Java is a powerful, object-oriented programming language created in 1995. It's one of the most popular programming languages in the world and is used for everything from mobile apps to enterprise software. Most importantly for us, it's the language Hytale uses for its servers & modding API.
 
 ## What You'll Learn
 
diff --git a/content/docs/ro-RO/guides/java-basics/02-operators.mdx b/content/docs/ro-RO/guides/java-basics/02-operators.mdx
index a132b1c0..18634665 100644
--- a/content/docs/ro-RO/guides/java-basics/02-operators.mdx
+++ b/content/docs/ro-RO/guides/java-basics/02-operators.mdx
@@ -119,7 +119,7 @@ String greetingWithName = "Hello, " + name + "!"; // "Hello, Alice!"
 
 ## Operator Precedence
 
-Operator Precendence means which operator gets evaluated first in an line of code. Think of it like BODMAS/PEMDAS in math!
+Operator Precedence means which operator gets evaluated first in an line of code. Think of it like BODMAS/PEMDAS in math!
 
 ```java
 int result = 10 + 5 * 2; // result is 20, not 30
diff --git a/content/docs/ro-RO/guides/java-basics/03-control-flow-if.mdx b/content/docs/ro-RO/guides/java-basics/03-control-flow-if.mdx
index b9d6c479..af2d1c22 100644
--- a/content/docs/ro-RO/guides/java-basics/03-control-flow-if.mdx
+++ b/content/docs/ro-RO/guides/java-basics/03-control-flow-if.mdx
@@ -7,7 +7,7 @@ Programs need to make decisions. If statements let your code choose different pa
 
 ## Basic If Statement
 
-The simplest form checks one condition;
+The simplest form checks one condition:
 
 ```java
 int health = 20;
diff --git a/content/docs/ro-RO/guides/java-basics/08-access-modifiers.mdx b/content/docs/ro-RO/guides/java-basics/08-access-modifiers.mdx
index af560932..da2bf33b 100644
--- a/content/docs/ro-RO/guides/java-basics/08-access-modifiers.mdx
+++ b/content/docs/ro-RO/guides/java-basics/08-access-modifiers.mdx
@@ -484,7 +484,7 @@ class Data {
     // Static member:
     // cannot access to non-static variables
     public static void bar() {
-        x = 100; // Error: non-static variable x cannot be renference from a static context
+        x = 100; // Error: non-static variable x cannot be referenced from a static context
         y = 100; // OK
     }
 }
@@ -504,7 +504,7 @@ Data.x = 1000; // Error: cannot access instanced variables in a static context
 
 ### Static Fields
 
-A static field represents a data member owned by the class type rather then the object. Static fields are also stored in a specific memory location that's been shared between all the object instances that are created.
+A static field represents a data member owned by the class type rather than the object. Static fields are also stored in a specific memory location that's been shared between all the object instances that are created.
 
 It is declared as following:
 
diff --git a/content/docs/ro-RO/guides/plugin/animated-block-textures.mdx b/content/docs/ro-RO/guides/plugin/animated-block-textures.mdx
new file mode 100644
index 00000000..42bfa51f
--- /dev/null
+++ b/content/docs/ro-RO/guides/plugin/animated-block-textures.mdx
@@ -0,0 +1,101 @@
+---
+title: Animated Block Textures
+description: Learn how to attach a .blockyanim to a block
+authors:
+  - name: Burkino
+---
+
+import { File, Folder, Files } from 'fumadocs-ui/components/files';
+
+So, you want to make your blocks feel more alive through animations, do you?\
+Now for the most part this is the exact same as [Creating custom blocks](./creating-block).
+![blue fire gif](/assets/guides/blue_fire.gif)
+
+## Prerequisites
+
+This is NOT a guide on animating or texturing or even using BlockBench, why? Because I don't know how to do that.\
+The only thing we will be doing is taking the fire texture, changing the color, and applying it to our new fire block.
+
+## Setup
+
+To start, you're obviously going to want to grab the `Common/VFX/Fire/Fire.png` file. How you do it is up to you, in the Asset Editor you'll need to switch to the Common tab.\
+I'll assume you know how colorize or change the hue of an image, so go ahead and do that now and save it as `Blue_Fire.png`.
+
+The other assets used in this guide are `Common/VFX/Fire/Fire.blockymodel` and `Common/Blocks/Animations/Fire/Fire_Burn.blockyanim` (both renamed to `Blue_Fire`) but since we won't be changing them it's probably fine to leave them. I will reference the `Blue_Fire` versions as a way to point out what should be custom assets.\
+I will also duplicate `Server/Item/Item/Deco/Deco_Fire.json` and call it `Deco_Blue_Fire.json`.
+
+## Applying the changes
+
+The `Deco_Blue_Fire` block is actually just a particle emitter, however we will not be using particles, so lets start by removing them in `Block > Particles`.\
+Next we want to set the Block Model (called `CustomModel` in JSON) to `VFX/Blue_Fire/Blue_Fire.blockymodel` and Block Model Textures (`CustomModelTexture` in JSON) to
+
+```json
+[
+    {
+        "Texture": "VFX/Blue_Fire/Blue_Fire.png",
+        "Weight": 1
+    }
+]
+```
+
+Finally, we will apply the .blockyanim to our model, this is done through the Block Model Animation property (`CustomModelAnimation` in JSON) and the value should be `Blocks/Animations/Blue_Fire/Blue_Fire_Burn.blockyanim`.
+
+## Final Code
+
+With that your new blue fire should be done. Here is the minimal JSON for our blue fire.\
+There is an additional `Looping` and `RequiresAlphaBlending` property that I have not gone over, however I hope it is self-explanatory.
+
+```json
+{
+  "BlockType": {
+    "DrawType": "Model",
+    "CustomModel": "VFX/Blue_Fire/Blue_Fire.blockymodel",
+    "CustomModelAnimation": "Blocks/Animations/Blue_Fire/Blue_Fire_Burn.blockyanim",
+    "CustomModelTexture": [
+      {
+        "Texture": "VFX/Blue_Fire/Blue_Fire.png",
+        "Weight": 1
+      }
+    ],
+    "Looping": true,
+    "RequiresAlphaBlending": false
+  },
+  "PlayerAnimationsId": "Block"
+}
+```
+
+<Files>
+  <Folder name="resources" defaultOpen>
+    <Folder name="Server" defaultOpen>
+      <Folder name="Item" defaultOpen>
+        <Folder name="Items" defaultOpen>
+          <Folder name="Deco" defaultOpen>
+            <File name="Deco_Blue_Fire.json" />
+          </Folder>
+        </Folder>
+      </Folder>
+    </Folder>
+
+    <Folder name="Common" defaultOpen>
+      <Folder name="Blocks" defaultOpen>
+        <Folder name="Animations" defaultOpen>
+          <Folder name="Blue_Fire" defaultOpen>
+            <File name="Blue_Fire_Burn.blockyanim" />
+          </Folder>
+        </Folder>
+      </Folder>
+
+      <Folder name="VFX" defaultOpen>
+        <Folder name="Blue_Fire" defaultOpen>
+          <File name="Blue_Fire.blockymodel" />
+
+          <File name="Blue_Fire.png" />
+        </Folder>
+      </Folder>
+    </Folder>
+  </Folder>
+</Files>
+
+## Next steps
+
+Now that you know how to attach an animation to a block, try adding it to a block state.
diff --git a/content/docs/ro-RO/guides/plugin/build-and-test.mdx b/content/docs/ro-RO/guides/plugin/build-and-test.mdx
index 0e7fe7eb..f37534c3 100644
--- a/content/docs/ro-RO/guides/plugin/build-and-test.mdx
+++ b/content/docs/ro-RO/guides/plugin/build-and-test.mdx
@@ -9,18 +9,18 @@ If you followed along with the [Setting Up Your Development Environment](./setti
 
 ## Building Your Mod
 
-In our case, we've **Maven** as the build system. Maven is a powerful build automation tool that manages dependencies, compiles your code, and packages everything into a distributable JAR file.
+In our case, we've **Gradle** as the build system. Gradle is a powerful build automation tool that manages dependencies, compiles your code, and packages everything into a distributable JAR file.
 
-### Understanding Maven
+### Understanding Gradle
 
-Maven uses a `pom.xml` file (Project Object Model) to define your project's configuration, dependencies, and build settings. You can learn more about Maven at the [official Apache Maven website](https://maven.apache.org/).
+Gradle can use a `build.gradle.kts` file (Kotlin DSL) to define your project's configuration, dependencies, and build settings. You can learn more about Gradle at the [official Gradle website](https://gradle.org/).
 
-### Building with Maven
+### Building with Gradle
 
 To build your mod, open a terminal in your project directory and run:
 
 ```bash
-mvn package
+./gradlew build
 ```
 
 This command will:
@@ -29,16 +29,35 @@ This command will:
 2. Run any tests (if present)
 3. Package everything into a JAR file
 
+<Callout type="info">
+  If you are using the plugin template from the [Setting Up Your Development Environment](./setting-up-env) guide, then the build script is already set up for you. It includes paths to your Hytale game library and handles the packaging of your mod, managing hytale dependencies and manifest changes.
+
+  If you have a different path to your Hytale installation, you may receive the following error:
+
+  ```bash
+  FAILURE: Build failed with an exception.
+
+  * What went wrong:
+  Failed to find Hytale at the expected location. Please make sure you have installed the game. The expected location can be changed using the hytale.home_path property. Currently looking in 'C:\Path\To\Hytale'
+  ```
+
+  You can change the path by adding a property to your `gradle.properties` file (if it doesn't exist, create it in the root of your project):
+
+  ```properties
+  hytale.home_path=C:\Correct\Path\To\Hytale
+  ```
+</Callout>
+
 ### Build Output
 
-Once the build completes successfully, your mod will be located in the `target` directory and named:
+Once the build completes successfully, your mod will be located in the `build/libs` directory and named:
 
 ```
-ExamplePlugin-1.0-SNAPSHOT.jar
+ExamplePlugin-1.0.jar
 ```
 
 <Callout type="info">
-  The exact name may vary depending on what you configured in your `pom.xml` file. Check the `artifactId` and `version` fields to see what your JAR will be named.
+  The exact name may vary depending on what you configured in your `build.gradle.kts` and `settings.gradle.kts` file. Check the `rootProject.name` and `version` fields to see what your JAR will be named.
 </Callout>
 
 ## Testing Your Mod
@@ -49,11 +68,11 @@ Now that you've built your mod, it's time to test it in Hytale!
 
 First, you need to find Hytale's mods directory:
 
-1. Press **Win + R** on your keyboard
-2. Type `%appdata%` and press Enter
-3. Navigate to: `Hytale\UserData\Mods`
+1. Go to your Hytale installation directory (The default location is usually in your AppData folder)
+   > On Windows, you can access it by clicking `windows + R` and typing `%appdata%`.
+2. Navigate to: `/UserData/Mods`
 
-The full path should look like:
+The default path would look like:
 
 ```
 C:\Users\YourUsername\AppData\Roaming\Hytale\UserData\Mods
@@ -65,7 +84,7 @@ C:\Users\YourUsername\AppData\Roaming\Hytale\UserData\Mods
 
 ### 2. Copy Your Mod
 
-Copy the `ExamplePlugin-1.0-SNAPSHOT.jar` file from your project's `target` directory into the `Mods` folder you just located.
+Copy the `ExamplePlugin-1.0.jar` file from your project's `build/libs` directory into the `Mods` folder you just located.
 
 ### 3. Launch Hytale and Verify
 
@@ -84,7 +103,7 @@ If your mod doesn't appear in the mods list:
 - Make sure the JAR file is in the correct `Mods` folder
 - Check that your `manifest.json` file is properly configured
 - Look for any error messages in the Hytale logs
-- Verify that you're using the correct version of Java and Maven
+- Verify that you're using the correct version of Java and Gradle
 
 ## Next Steps
 
diff --git a/content/docs/ro-RO/guides/plugin/creating-commands.mdx b/content/docs/ro-RO/guides/plugin/creating-commands.mdx
index d33597f3..08572f16 100644
--- a/content/docs/ro-RO/guides/plugin/creating-commands.mdx
+++ b/content/docs/ro-RO/guides/plugin/creating-commands.mdx
@@ -8,6 +8,8 @@ authors:
     url: https://oskar.scot
   - name: jacobwojoski
     url: https://github.com/jacobwojoski
+  - name: Marcel-TO
+    url: https://marcel-to.net
 ---
 
 In this guide, you will learn how to create custom commands for your Hytale mod.
@@ -36,7 +38,7 @@ The most basic command is an `AbstractAsyncCommand`. It has very minimal data av
   `AbstractAsyncCommand` runs on its own background thread. This means its execute is not tied to any world instance and because of this it can not edit any **Stores** or **Refs** without getting the desired world first. To access this data any of the other command types would be preferred and are likely what you will want to use instead.
 </Callout>
 
-The main purpose for a command like this would be for something that can happen everywhere and is not tied to a specific world. For example a `serverRules` command to tell the user thats running the command in chat what the servers rules are nomatter what world they are in.
+The main purpose for a command like this would be for something that can happen everywhere and is not tied to a specific world. For example a `serverRules` command to tell the user that's running the command in chat what the server's rules are no matter what world they are in.
 
 ```java
 // Command that can be run that lists the server rules in chat to the player
@@ -49,7 +51,7 @@ public class ServerRulesCommand extends AbstractAsyncCommand {
     }
 
     // Run the command
-    // conetext - info about who ran the command. Server console?, Some player?
+    // context - info about who ran the command. Server console?, Some player?
     @Override
     protected CompletableFuture<Void> executeAsync(@Nonnull CommandContext context) {
         context.sendMessage(Message.raw("The only rule is there are no rules."));
@@ -134,7 +136,7 @@ Uses a Ray to see what the player is looking at and tries to run the command on
 
 ## Adding Arguments
 
-Arguments are additional fields that the user can input when running a command. The different types of arguments along with small snipits and a large example can be seen below.
+Arguments are additional fields that the user can input when running a command. The different types of arguments along with small snippets and a large example can be seen below.
 
 ### Command Argument Types
 
@@ -163,14 +165,14 @@ this.messageArg = this.withOptionalArg("message", "Message to print while healin
 
 ### Default Arguments
 
-Adding a default argument has two additional arguemnt for the default value and default value description. You need to use `withDefaultArg` method.
+Adding a default argument has two additional argument for the default value and default value description. You need to use `withDefaultArg` method.
 
 ```java
 // args <Command String> <Description> <Default Value> <Desc of default value>
 this.healthArg = this.withDefaultArg("health", "Amount to heal player", ArgTypes.FLOAT, (float)100, "Desc of Default: 100");
 ```
 
-### Flag Arguemnts
+### Flag Arguments
 
 Similar as above but the flags return is either true if it exists or false if it does not. You need to use `withFlagArg` method.
 
@@ -181,20 +183,13 @@ this.debugArg = this.withFlagArg("debug", "Add debug logs");
 
 ### ArgTypes
 
-The following ArgTypes are available (only lists common types):
-
-- `ArgTypes.STRING`
-- `ArgTypes.INTEGER`
-- `ArgTypes.BOOLEAN`
-- `ArgTypes.FLOAT`
-- `ArgTypes.DOUBLE`
-- `ArgTypes.UUID`
+You can find all the available argument types on the [ArgTypes](../../argtypes) page.
 
 ### Example Command Arg Types
 
-Shows all Command arguemnt types with different various input types.
+Shows all Command argument types with different various input types.
 
-**NOTE:** When getting the value of an argument during execute you need to pass the context with `someArg.get(commandContext)`. Where `commandContext` is the first variable in the execute funtion.
+**NOTE:** When getting the value of an argument during execute you need to pass the context with `someArg.get(commandContext)`. Where `commandContext` is the first variable in the execute function.
 
 ```java
 // Example usage: /healplayer --health 50 --message "Feels Good" --debug
@@ -204,7 +199,7 @@ public class HealPlayerCommand extends AbstractTargetPlayerCommand {
     private final FlagArg debugArg;
 
     public HealPlayerCommand() {
-        super("healplayer", "Healing a player for an <input> ammount of HP (default: 100)");
+        super("healplayer", "Healing a player for an <input> amount of HP (default: 100)");
 
         // Abstract TargetPlayerCommand passes the player that ran the command by default and implements
         // the use of `--player <value>` to specify someone else
@@ -213,10 +208,10 @@ public class HealPlayerCommand extends AbstractTargetPlayerCommand {
         this.healthArg = this.withDefaultArg("health", "Amount to heal player", ArgTypes.FLOAT, (float)100, "Desc of Default: 100");
 
         // Or you could do the following making the health value required instead of with a default.
-        //    You would need to change the decleration to RequiredArg<Float>
+        //    You would need to change the declaration to RequiredArg<Float>
         // this.healthArg = this.withRequiredArg("health", "Amount to heal player", ArgTypes.FLOAT);
 
-        // Optional args reguare the user the input `--<key> <value>` so the following would require `--message "Good Luck"`
+// Optional args require the user the input `--<key> <value>` so the following would require `--message "Good Luck"`
         this.messageArg = this.withOptionalArg("message", "Message to print while healing", ArgTypes.STRING);
 
         // No type needed due to being a bool
@@ -230,7 +225,7 @@ public class HealPlayerCommand extends AbstractTargetPlayerCommand {
             commandContext.sendMessage(Message.raw("We are debugging"));
         }
 
-        // Health is stored in a generic stat map to allowing mods/future contect to easily add more stats if desired.
+        // Health is stored in a generic stat map to allowing mods/future content to easily add more stats if desired.
         EntityStatMap stats = store.getComponent(ref, EntityStatMap.getComponentType());
         int healthIdx = DefaultEntityStatTypes.getHealth();
         EntityStatValue health = stats.get(healthIdx);
@@ -252,7 +247,7 @@ public class HealPlayerCommand extends AbstractTargetPlayerCommand {
 
 ## Argument Validators
 
-Argument validators are a way to check the command before the command gets executed. They are added with the `addValidator` method on an argument when calling `withXxxArg`. They provide a nice output to the user when an input value is invalid.
+Argument validators are a way to check the command before the command gets executed. They are added with the `addValidator` method on an argument when calling `withXxxArg`. They provide a nice output to the user when an input value is invalid. There are some common validators provided in the `Validators` class such as `greaterThan`, `lessThan`, and `or`, `max`, `range`, etc.
 
 ```java
 ...
@@ -260,18 +255,59 @@ Argument validators are a way to check the command before the command gets execu
     OptionalArg<Integer> healAmount = withOptionalArg("amount", "Heal Amount", ArgTypes.INTEGER)
         .addValidator(Validators.greaterThan(0))
         .addValidator(Validators.lessThan(1000));
-
-    // Custom check example
-    OptionalArg<Integer> healAmount = withOptionalArg("amount", "Heal Amount", ArgTypes.INTEGER)
-            .addValidator( value -> {
-                if (value != null && value <= 0) {
-                    return ValidationResult.error("ammount argument must be a positive number");
-                }
-                return ValidationResult.success();
-            });
 ...
 ```
 
+### Custom Validators
+
+You can also create custom validators by implementing the `com.hypixel.hytale.codec.validation.Validator` interface. The interfaces forces you to implement the `accept` and `updateSchema` method. The `accept` method takes in the argument value and validates it. If the validation fails, you can use the `fail` method of the `com.hypixel.hytale.codec.validation.ValidationResults` class to return an error message.
+The `updateSchema` method is used to update the schema of the command argument. This is used for commands that have dynamic schemas based on the input value. For example, if you have a command that takes in a player name as an argument, you can use the `updateSchema` method to update the schema to include a list of online players for validation.
+
+Here is an example of a custom validator that checks if a string value is equal to a banned word. In this example, the banned word is "badword". If the input value is "badword", the validator will fail and return an error message.
+
+```java
+import com.hypixel.hytale.codec.schema.SchemaContext;
+import com.hypixel.hytale.codec.schema.config.Schema;
+import com.hypixel.hytale.codec.validation.ValidationResults;
+import com.hypixel.hytale.codec.validation.Validator;
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+
+public class MyCustomValidator implements Validator<String> {
+    @Nonnull
+    private final String value;
+
+    public MyCustomValidator(@Nonnull String value) {
+        this.value = value;
+    }
+
+    @Override
+    public void accept(@Nullable String input, @Nonnull ValidationResults results) {
+        if (this.value.equalsIgnoreCase(input)) {
+            results.fail("The given role has been banned.");
+        }
+    }
+
+    @Override
+    public void updateSchema(SchemaContext context, @Nonnull Schema target) {
+        // This method can be used to update the schema of the command argument. This is useful for commands that have dynamic schemas based on the input value. For example, if you have a command that takes in a player name as an argument, you can use the `updateSchema` method to update the schema to include a list of online players for validation.
+        throw new UnsupportedOperationException("Not implemented yet.");
+    }
+}
+```
+
+After the custom validator is created, you can add it to an argument like the following example. In this example, we add the `MyCustomValidator` to a string argument called "role". If the user inputs "badword" as the role, the command will fail and return the error message defined in the `MyCustomValidator`.
+
+```java
+    ...
+    // Custom validator example
+    String bannedRole = "badword";
+
+    OptionalArg<String> roleArg = withOptionalArg("role", "Role to assign", ArgTypes.STRING)
+        .addValidator(new MyCustomValidator(bannedRole));
+    ...
+```
+
 ---
 
 ## Permissions
@@ -312,7 +348,7 @@ This allows the server to control who has access to specific commands. You add t
 
 If you want variants of the same command without doing argument parsing you can instead use `addUsageVariant(new OtherCommandClass())` in the original commands constructor.
 
-The only difference is in the `OtherCommandClass()` constrcutor you don't pass the command name to the super class.
+The only difference is in the `OtherCommandClass()` constructor you don't pass the command name to the super class.
 
 <Callout type="info">
   You can also use `addAliases("some_alias", "some_other_alias")` as a way to add shorthand or other ways to write the same command.
@@ -387,7 +423,7 @@ public class AdminCommand extends AbstractCommandCollection {
     public AdminCommand () {
         super("admin", "Admin commands");
         addSubCommand(new UserCommandCollection());
-        addSybCommand(new ServerCommandCollection);
+        addSubCommand(new ServerCommandCollection);
     }
 }
 ```
@@ -417,5 +453,5 @@ public class MyPlugin extends JavaPlugin {
 
 ## Video Link
 
-_Special Thanks to [TroubleDev](https://www.youtube.com/@TroubleDEV) for his excelent video guide on all of these features._
+_Special Thanks to [TroubleDev](https://www.youtube.com/@TroubleDEV) for his excellent video guide on all of these features._
 _Video Link: [TroubleDev - Hytale's Command API Explained](https://www.youtube.com/watch?v=KnmhG9MDMgo)_
diff --git a/content/docs/ro-RO/guides/plugin/creating-events.mdx b/content/docs/ro-RO/guides/plugin/creating-events.mdx
index 95863990..d3f0925d 100644
--- a/content/docs/ro-RO/guides/plugin/creating-events.mdx
+++ b/content/docs/ro-RO/guides/plugin/creating-events.mdx
@@ -1,6 +1,6 @@
 ---
-title: Creating Events
-description: Learn how to create custom events for your Hytale mod.
+title: Creating Events Listeners
+description: Learn how to create event listeners for your Hytale mod.
 authors:
   - name: Neil Revin
     url: https://itsneil.dev
@@ -10,7 +10,7 @@ authors:
 
 ## Event Class
 
-You can import a Event class and create a function with the Event as a argument. [Click here](../../server/events) to look at all available events.
+You can import an Event class and create a function with the Event as an argument. [Click here](../../server/events) to look at all available events.
 
 Example plugin when a player is ready (joins a server):
 
diff --git a/content/docs/ro-RO/guides/plugin/item-registry.mdx b/content/docs/ro-RO/guides/plugin/item-registry.mdx
new file mode 100644
index 00000000..9a0fd53a
--- /dev/null
+++ b/content/docs/ro-RO/guides/plugin/item-registry.mdx
@@ -0,0 +1,95 @@
+---
+title: Working with the Item Registry
+description: Learn how to access and query the game's item registry to list all items, check if items exist, and retrieve item properties.
+authors:
+  - name: Denis
+---
+
+In this guide, you'll learn how to work with Hytale's Item Registry system. This is useful when you need to programmatically list all available items, validate item IDs, or retrieve item properties at runtime.
+
+## Prerequisites
+
+Before diving in, you should be familiar with:
+
+- [Setting up your development environment](./setting-up-env)
+- [Creating commands](./creating-commands) (optional, for testing)
+
+## Required Imports
+
+To work with the Item Registry, you'll need the following imports:
+
+```java
+import com.hypixel.hytale.assetstore.map.DefaultAssetMap;
+import com.hypixel.hytale.server.core.asset.type.item.config.Item;
+```
+
+## Getting the Item Registry
+
+The Item Registry is accessed through the `Item.getAssetMap()` method, which returns a `DefaultAssetMap<String, Item>` containing all registered items in the game:
+
+```java
+DefaultAssetMap<String, Item> itemMap = Item.getAssetMap();
+```
+
+## Listing All Items
+
+To iterate through all items in the registry, you can get the underlying map and loop through its entries:
+
+```java
+DefaultAssetMap<String, Item> itemMap = Item.getAssetMap();
+var map = itemMap.getAssetMap();
+
+for (var entry : map.entrySet()) {
+    String itemId = String.valueOf(entry.getKey());
+    Item item = entry.getValue();
+    
+    // Do something with the item
+    LOGGER.atInfo().log("Item ID: " + itemId);
+}
+```
+
+You can also get the total count of registered items:
+
+```java
+int totalItems = map.size();
+```
+
+## Checking if an Item Exists
+
+To check if a specific item exists in the registry, use `getAsset()` and verify the result:
+
+```java
+public boolean itemExists(String itemId) {
+    var assetMap = Item.getAssetMap();
+    if (assetMap != null) {
+        Item item = assetMap.getAsset(itemId);
+        return item != null && item != Item.UNKNOWN;
+    }
+    return false;
+}
+```
+
+<Callout type="info">
+  The `Item.UNKNOWN` constant represents an invalid or unrecognized item. Always check for both `null` and `Item.UNKNOWN` when validating items.
+</Callout>
+
+## Accessing Item Properties
+
+Once you have an `Item` instance, you can access various properties:
+
+```java
+var assetMap = Item.getAssetMap();
+Item item = assetMap.getAsset("Soil_Grass");
+
+if (item != null && item != Item.UNKNOWN) {
+    String id = item.getId(); // Soil_Grass
+    int maxStack = item.getMaxStack(); // 100
+    boolean isBlock = item.hasBlockType(); // true
+    boolean isConsumable = item.isConsumable(); // false
+}
+```
+
+## Related Guides
+
+- [Inventory Management](./inventory-management) - Learn how to add and remove items from player inventories
+- [Create Custom Item and Interaction](./item-interaction) - Learn how to create your own custom items
diff --git a/content/docs/ro-RO/guides/plugin/permission-management.mdx b/content/docs/ro-RO/guides/plugin/permission-management.mdx
index 6b7cfd46..55f06101 100644
--- a/content/docs/ro-RO/guides/plugin/permission-management.mdx
+++ b/content/docs/ro-RO/guides/plugin/permission-management.mdx
@@ -10,132 +10,569 @@ authors:
     link: https://discord.com/users/292656109939064833
   - name: Ivan
     link: https://discord.com/users/505770451218333717
+  - name: ZenithDevHQ
+    link: https://github.com/ZenithDevHQ
 ---
 
-In this guide, you'll learn how to manage permission nodes and groups in your Hytale plugin.
+In this guide, you'll learn how to manage permission nodes and groups in your Hytale plugin. Permissions control what actions players can perform on your server, from basic commands to advanced administrative functions.
 
-## The `PermissionsModule` class
+## What Are Permissions?
 
-The `PermissionsModule` class is responsible for managing permission nodes and groups in your plugin. It provides methods to check, grant and revoke permissions and groups for players. It allows the following operations
+Permissions are string identifiers that control access to features and commands. When a player tries to perform an action (like using a command), the server checks if they have the required permission.
 
-- Add permissions to user
-- Remove permissions from user
-- Add permissions to group (this also creates the group if it doesn't exist)
-- Remove permissions from group
-- Add user to group
-- Remove user from group
-- List all groups for a user
-- Check if a user has a permission (it checks both user and group permissions for the given player UUID)
+**Example permission nodes:**
 
-With this class you cannot:
+- `hytale.command.gamemode` - Permission to use the gamemode command
+- `hytale.editor.brush.use` - Permission to use brush tools
+- `myplugin.teleport.home` - A custom permission for your plugin
 
-- List all defined groups
-- Remove a group
+Permissions follow a hierarchical naming pattern: `namespace.category.action`
 
-### Adding Permission Nodes
+## Key Concepts
 
-You need a `Set<String>` containing all the permission nodes you want to add, these are added on top of the already existing permission nodes the user may have, it is not a replacement.
+Before diving into code, let's understand the core concepts:
+
+| Concept             | Description                                                                |
+| ------------------- | -------------------------------------------------------------------------- |
+| **Permission Node** | A string like `myplugin.feature.use` that represents a specific permission |
+| **Group**           | A named collection of permissions (e.g., "Admin", "VIP", "Default")        |
+| **Provider**        | The backend that stores and retrieves permissions                          |
+| **Wildcard**        | A pattern like `*` or `myplugin.*` that matches multiple permissions       |
+
+### How Permissions Are Checked
+
+When checking if a player has a permission, Hytale follows this order:
+
+1. **User's direct permissions** - Permissions granted directly to the player
+2. **Group permissions** - Permissions from groups the player belongs to
+3. **Virtual groups** - Game-mode-based permissions (e.g., Creative mode grants builder tools)
+4. **Default value** - Falls back to `false` if no match found
+
+<Callout type="info">
+  The first definitive match wins. If a player has a permission granted at the user level, group permissions won't override it.
+</Callout>
+
+---
+
+## The `PermissionsModule` Class
+
+The `PermissionsModule` class is the central hub for managing permissions. Access it using the singleton pattern:
 
 ```java
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.addUserPermission(playerUUID, permissions);
 ```
 
-### Removing Permission Nodes
+### Available Operations
+
+The module supports these operations:
+
+| Operation                     | Method                                          |
+| ----------------------------- | ----------------------------------------------- |
+| Add permissions to user       | `addUserPermission(uuid, permissions)`          |
+| Remove permissions from user  | `removeUserPermission(uuid, permissions)`       |
+| Add permissions to group      | `addGroupPermission(groupName, permissions)`    |
+| Remove permissions from group | `removeGroupPermission(groupName, permissions)` |
+| Add user to group             | `addUserToGroup(uuid, groupName)`               |
+| Remove user from group        | `removeUserFromGroup(uuid, groupName)`          |
+| Get user's groups             | `getGroupsForUser(uuid)`                        |
+| Check permission              | `hasPermission(uuid, permissionNode)`           |
+
+<Callout type="warning">
+  The module does **not** support:
+
+  - Listing all defined groups
+  - Deleting a group entirely
+
+  Groups are implicitly created when you first add permissions to them.
+</Callout>
+
+---
 
-Same as above, we just use the `removeUserPermission` method instead to remove permission nodes.
+## Checking Permissions
+
+The most common operation is checking if a player has a permission.
+
+### Basic Permission Check
+
+```java
+// Returns true if player has the permission, false otherwise
+boolean canUse = PermissionsModule.get().hasPermission(playerUUID, "myplugin.feature.use");
+
+if (canUse) {
+    // Player has permission, allow the action
+} else {
+    // Player lacks permission, deny or show error
+}
+```
+
+### Permission Check with Default Value
+
+You can specify what to return when no permission is explicitly set:
+
+```java
+// Returns true by default if no explicit permission is found
+boolean canUse = PermissionsModule.get().hasPermission(playerUUID, "myplugin.feature.use", true);
+```
+
+This is useful for features that should be enabled by default but can be revoked.
+
+### Using PermissionHolder Interface
+
+Players and command senders implement `PermissionHolder`, allowing direct checks:
+
+```java
+// In a command or event handler where you have access to the player
+if (player.hasPermission("myplugin.admin.manage")) {
+    // Player has admin permission
+}
+```
+
+---
+
+## Managing User Permissions
+
+### Adding Permissions to a User
+
+Permissions are additive - new permissions are added on top of existing ones, not replaced.
+
+```java
+PermissionsModule perms = PermissionsModule.get();
+
+// Add a single permission
+perms.addUserPermission(playerUUID, Set.of("myplugin.vip.chat"));
+
+// Add multiple permissions at once
+Set<String> newPerms = Set.of(
+    "myplugin.vip.chat",
+    "myplugin.vip.fly",
+    "myplugin.vip.kit"
+);
+perms.addUserPermission(playerUUID, newPerms);
+```
+
+### Removing Permissions from a User
 
 ```java
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.removeUserPermission(playerUUID, permissions);
+
+// Remove specific permissions
+Set<String> toRemove = Set.of("myplugin.vip.fly");
+perms.removeUserPermission(playerUUID, toRemove);
 ```
 
-### Add permissions to group
+---
+
+## Managing Groups
+
+Groups let you assign a collection of permissions to multiple players. This is more manageable than assigning permissions individually.
+
+### Adding Permissions to a Group
+
+If the group doesn't exist, it will be created automatically.
 
 ```java
-String groupName = "testGroup";
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.addGroupPermission(groupName, permissions);
+
+// Create/update the "VIP" group with permissions
+Set<String> vipPerms = Set.of(
+    "myplugin.vip.chat",
+    "myplugin.vip.fly",
+    "myplugin.vip.kit"
+);
+perms.addGroupPermission("VIP", vipPerms);
 ```
 
-### Remove permissions from group
+### Removing Permissions from a Group
 
 ```java
-String groupName = "testGroup";
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.removeGroupPermission(groupName, permissions);
+
+// Remove specific permissions from the group
+Set<String> toRemove = Set.of("myplugin.vip.fly");
+perms.removeGroupPermission("VIP", toRemove);
 ```
 
-### Add user to group
+### Adding a User to a Group
 
 ```java
-String groupName = "testGroup";
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.addUserToGroup(playerUUID, groupName);
+
+// Add player to the VIP group - they now have all VIP permissions
+perms.addUserToGroup(playerUUID, "VIP");
 ```
 
-### Remove user from group
+### Removing a User from a Group
 
 ```java
-String groupName = "testGroup";
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.removeUserFromGroup(playerUUID, groupName);
+
+// Remove player from VIP group
+perms.removeUserFromGroup(playerUUID, "VIP");
 ```
 
-### List all groups for a user
+### Getting a User's Groups
 
 ```java
 PermissionsModule perms = PermissionsModule.get();
-perms.getGroupsForUser(playerUUID);
+
+// Get all groups the player belongs to
+Set<String> groups = perms.getGroupsForUser(playerUUID);
+
+for (String group : groups) {
+    System.out.println("Player is in group: " + group);
+}
 ```
 
-### Check Permission Nodes
+---
+
+## Built-in Groups
+
+Hytale includes two default groups:
+
+| Group     | Default Permissions   | Purpose                           |
+| --------- | --------------------- | --------------------------------- |
+| `OP`      | `*` (all permissions) | Server operators with full access |
+| `Default` | None                  | Base group for all players        |
+
+Players without any explicit group assignment are automatically part of the `Default` group.
 
-To check if a player has a specific permission node, you can use the `hasPermission` method.
+---
+
+## Wildcards
+
+Wildcards let you grant or deny multiple permissions with a single pattern.
+
+### Wildcard Patterns
+
+| Pattern             | Meaning                                          |
+| ------------------- | ------------------------------------------------ |
+| `*`                 | Grants **all** permissions                       |
+| `myplugin.*`        | Grants all permissions starting with `myplugin.` |
+| `-*`                | Denies **all** permissions                       |
+| `-myplugin.admin.*` | Denies all admin permissions in your plugin      |
+
+### Example: Admin Group with Wildcards
 
 ```java
-boolean hasPermission = PermissionsModule.hasPermission(playerUUID, "permission.node");
+// Grant all permissions to admins
+perms.addGroupPermission("Admin", Set.of("*"));
+
+// Grant all plugin permissions to moderators
+perms.addGroupPermission("Moderator", Set.of("myplugin.*"));
+
+// Grant all permissions except admin commands
+perms.addGroupPermission("Helper", Set.of(
+    "*",
+    "-myplugin.admin.*"  // Deny admin permissions
+));
 ```
 
-## Additional: Defining your own provider for permissions and groups
+<Callout type="warning">
+  Negation permissions (starting with `-`) take precedence at each level. Use them carefully to avoid accidentally blocking permissions.
+</Callout>
+
+---
+
+## Built-in Permission Nodes
+
+Hytale provides constants for common permissions in the `HytalePermissions` class:
+
+### Command Permissions
+
+```java
+// Generate permission for a command
+String perm = HytalePermissions.fromCommand("gamemode");
+// Result: "hytale.command.gamemode"
+
+// Generate permission for a subcommand
+String perm = HytalePermissions.fromCommand("gamemode", "creative");
+// Result: "hytale.command.gamemode.creative"
+```
+
+### Common Permission Nodes
+
+| Permission                    | Description                  |
+| ----------------------------- | ---------------------------- |
+| `hytale.command.op.add`       | Add players to OP group      |
+| `hytale.command.op.remove`    | Remove players from OP group |
+| `hytale.editor.brush.use`     | Use brush tools              |
+| `hytale.editor.prefab.use`    | Use prefabs                  |
+| `hytale.editor.selection.use` | Use selection tools          |
+| `hytale.editor.history`       | Undo/redo operations         |
+| `hytale.camera.flycam`        | Use fly camera mode          |
+
+---
+
+## Listening to Permission Events
+
+You can react to permission changes using Hytale's event system.
+
+### Available Events
+
+| Event                                            | Triggered When                   |
+| ------------------------------------------------ | -------------------------------- |
+| `PlayerPermissionChangeEvent.PermissionsAdded`   | Permissions added to a user      |
+| `PlayerPermissionChangeEvent.PermissionsRemoved` | Permissions removed from a user  |
+| `PlayerGroupEvent.Added`                         | User added to a group            |
+| `PlayerGroupEvent.Removed`                       | User removed from a group        |
+| `GroupPermissionChangeEvent.Added`               | Permissions added to a group     |
+| `GroupPermissionChangeEvent.Removed`             | Permissions removed from a group |
 
-The PermissionsModule also enables us to define our own PermissionProvider's, this can be useful for:
+### Example: Reacting to Permission Changes
 
-- Cross server permission systems
-- Implementing features missing in the `HytalePermissionsProvider` like permission expiry
+```java
+public class PermissionListener {
+
+    public static void onPermissionsAdded(PlayerPermissionChangeEvent.PermissionsAdded event) {
+        UUID playerUUID = event.getPlayerUuid();
+        Set<String> added = event.getAddedPermissions();
+
+        System.out.println("Permissions added to " + playerUUID + ": " + added);
 
-To implement our PermissionProvider, first we need to define a provider class that implements PermissionProvider:
+        // Maybe notify the player or update cached data
+    }
+
+    public static void onGroupAdded(PlayerGroupEvent.Added event) {
+        UUID playerUUID = event.getPlayerUuid();
+        String groupName = event.getGroupName();
+
+        System.out.println("Player " + playerUUID + " joined group: " + groupName);
+    }
+}
+```
+
+### Registering the Events
 
 ```java
-public class DatabasePermissionProvider implements PermissionProvider
+public class MyPlugin extends JavaPlugin {
+
+    @Override
+    public void setup() {
+        EventRegistry events = this.getEventRegistry();
+
+        events.registerGlobal(
+            PlayerPermissionChangeEvent.PermissionsAdded.class,
+            PermissionListener::onPermissionsAdded
+        );
+
+        events.registerGlobal(
+            PlayerGroupEvent.Added.class,
+            PermissionListener::onGroupAdded
+        );
+    }
+}
 ```
 
-Then we just implement the required methods using a database implementation.
+---
+
+## Creating a Custom Permission Provider
+
+For advanced use cases, you can create your own permission provider. This is useful for:
+
+- Database-backed permissions (MySQL, MongoDB, etc.)
+- Cross-server permission synchronization
+- Custom features like permission expiry or contexts
+
+### Implementing PermissionProvider
+
+```java
+public class DatabasePermissionProvider implements PermissionProvider {
+
+    @Nonnull
+    @Override
+    public String getName() {
+        return "DatabasePermissionProvider";
+    }
+
+    // User permission methods
+    @Override
+    public void addUserPermissions(@Nonnull UUID uuid, @Nonnull Set<String> permissions) {
+        // Save to your database
+    }
+
+    @Override
+    public void removeUserPermissions(@Nonnull UUID uuid, @Nonnull Set<String> permissions) {
+        // Remove from your database
+    }
+
+    @Override
+    public Set<String> getUserPermissions(@Nonnull UUID uuid) {
+        // Query your database
+        return Set.of();
+    }
+
+    // Group permission methods
+    @Override
+    public void addGroupPermissions(@Nonnull String group, @Nonnull Set<String> permissions) {
+        // Save to your database
+    }
+
+    @Override
+    public void removeGroupPermissions(@Nonnull String group, @Nonnull Set<String> permissions) {
+        // Remove from your database
+    }
+
+    @Override
+    public Set<String> getGroupPermissions(@Nonnull String group) {
+        // Query your database
+        return Set.of();
+    }
+
+    // User-group membership methods
+    @Override
+    public void addUserToGroup(@Nonnull UUID uuid, @Nonnull String group) {
+        // Save to your database
+    }
+
+    @Override
+    public void removeUserFromGroup(@Nonnull UUID uuid, @Nonnull String group) {
+        // Remove from your database
+    }
+
+    @Override
+    public Set<String> getGroupsForUser(@Nonnull UUID uuid) {
+        // Query your database
+        return Set.of("Default");
+    }
+}
+```
 
 <Callout type="warning">
-  Hytale will try to use the first available permissions provider to add/remove gamemode groups (i.e. `Creative`, `Adventure`).
+  Hytale automatically assigns players to game-mode groups (like `Creative` or `Adventure`) using the first available provider.
+
+  If your provider throws an error when the group doesn't exist, the player will be disconnected! Always handle missing groups gracefully.
+</Callout>
+
+### Registering Your Provider
 
-  If your provider throws an error (for instance, if the group does not exist) when the server is preparing the player, the player will be disconnected.
+```java
+public class MyPlugin extends JavaPlugin {
+
+    @Override
+    public void setup() {
+        // Add your provider alongside the default one
+        PermissionsModule.get().addProvider(new DatabasePermissionProvider());
+    }
+}
+```
+
+The `PermissionsModule` aggregates permissions from all registered providers. This means:
+
+- Permission checks query all providers
+- Write operations (add/remove) use the **first** provider
+
+### Replacing the Default Provider
+
+If you want full control, you can remove the default provider:
+
+```java
+public class MyPlugin extends JavaPlugin {
+
+    @Override
+    public void setup() {
+        PermissionsModule perms = PermissionsModule.get();
+
+        // Remove the default provider FIRST
+        perms.removeProvider(perms.getFirstPermissionProvider());
+
+        // Then add your provider
+        perms.addProvider(new DatabasePermissionProvider());
+    }
+}
+```
+
+<Callout type="info">
+  When you remove the default provider, the `/op self` command will stop working since it checks for provider tampering.
 </Callout>
 
-We can then register the provider using the built-in permission module:
+---
+
+## Best Practices
+
+### Permission Naming Conventions
+
+Follow the pattern: `namespace.category.action`
 
 ```java
-PermissionsModule.get().addProvider(new DatabasePermissionProvider());
+// Good - clear hierarchy
+"myplugin.admin.ban"
+"myplugin.user.teleport.home"
+"myplugin.vip.chat.color"
+
+// Bad - unclear structure
+"myplugin_ban"
+"teleport"
+"vipChatColor"
 ```
 
-Please note that the `HytalePermissionsProvider` will still be enabled alongside your provider.
-The `PermissionsModule` will aggregate groups and permissions from all available providers.
+### Use Constants for Permissions
 
-If you want to disable the default `HytalePermissionsProvider`, you can use:
+Define your permissions as constants to avoid typos:
 
 ```java
-// put this **before** you add your provider
-PermissionsModule.get().removeProvider(PermissionsModule.get().getFirstPermissionProvider());
+public final class MyPermissions {
+    public static final String ADMIN_BAN = "myplugin.admin.ban";
+    public static final String ADMIN_KICK = "myplugin.admin.kick";
+    public static final String USER_HOME = "myplugin.user.home";
+    public static final String VIP_FLY = "myplugin.vip.fly";
+}
+
+// Usage
+if (player.hasPermission(MyPermissions.ADMIN_BAN)) {
+    // ...
+}
 ```
+
+### Don't Over-Permission
+
+Only create permissions for actions that genuinely need access control. Not everything needs a permission check.
+
+### Thread Safety
+
+If you create a custom provider, ensure it's thread-safe. Permission checks can occur from multiple threads simultaneously. Use `ReadWriteLock` or `ConcurrentHashMap` for your data structures.
+
+---
+
+## In-Game Commands
+
+Hytale provides built-in commands for managing permissions:
+
+### `/op` Command
+
+| Command               | Description                                                        |
+| --------------------- | ------------------------------------------------------------------ |
+| `/op self`            | Toggle your own OP status (singleplayer or with `--allow-op` flag) |
+| `/op add <player>`    | Add a player to the OP group                                       |
+| `/op remove <player>` | Remove a player from the OP group                                  |
+
+### `/perm` Command
+
+Use `/perm --help` in-game for full usage. Common operations:
+
+| Command                                  | Description                   |
+| ---------------------------------------- | ----------------------------- |
+| `/perm user list <uuid>`                 | List user's permissions       |
+| `/perm user add <uuid> <perm>`           | Add permission to user        |
+| `/perm user remove <uuid> <perm>`        | Remove permission from user   |
+| `/perm user group list <uuid>`           | List user's groups            |
+| `/perm user group add <uuid> <group>`    | Add user to group             |
+| `/perm user group remove <uuid> <group>` | Remove user from group        |
+| `/perm group list <group>`               | List group's permissions      |
+| `/perm group add <group> <perm>`         | Add permission to group       |
+| `/perm group remove <group> <perm>`      | Remove permission from group  |
+| `/perm test <perm>`                      | Test if you have a permission |
+
+---
+
+## Summary
+
+You've learned how to:
+
+- **Check permissions** using `PermissionsModule.hasPermission()`
+- **Manage user permissions** with `addUserPermission()` and `removeUserPermission()`
+- **Work with groups** using `addGroupPermission()`, `addUserToGroup()`, etc.
+- **Use wildcards** like `*` and `myplugin.*` for bulk permissions
+- **Listen to events** for permission changes
+- **Create custom providers** for database-backed permissions
+
+For more advanced permission systems with features like inheritance, expiry, and contexts, we're looking into expanding this guide with advanced permission management techniques in the future.
diff --git a/content/docs/ro-RO/guides/plugin/setting-up-env.mdx b/content/docs/ro-RO/guides/plugin/setting-up-env.mdx
index d2718098..5be5e9e0 100644
--- a/content/docs/ro-RO/guides/plugin/setting-up-env.mdx
+++ b/content/docs/ro-RO/guides/plugin/setting-up-env.mdx
@@ -4,6 +4,10 @@ description: Learn how to set up your development environment for modding Hytale
 authors:
   - name: Neil Revin
     link: https://itsneil.dev
+  - name: Marcel-TO
+    url: https://marcel-to.net
+  - name: Ádám Liszkai
+    link: https://adaliszk.dev
 ---
 
 This guide will walk you through setting up a complete development environment for Hytale modding, including all necessary tools and dependencies.
@@ -19,24 +23,73 @@ Before we begin, make sure you have:
 
 ## Required Software
 
-### 1. Java Development Kit (JDK)
+### Integrated Development Environment (IDE)
 
+We recommend IntelliJ IDEA Community Edition for Hytale modding. If you use IntelliJ IDEA, **almost everything is built-in**. You can clone a template, open a new project, and start working right away!
+
+1. Download from [JetBrains website](https://www.jetbrains.com/idea/download/)
+2. Install with default settings
+3. Launch and complete the initial setup wizard
+
+When opening a project, wait for indexing to finish, then start coding.
+Now, IDEA may say "No JDK configured" at the top of the source file you have.
+In that case, you can click Download JDK and choose JetBrains JDK 25.
+
+<Callout type="success">
+  If IDEA opened the project without errors, your environment is ready.
+</Callout>
+
+More details by [JetBrains](https://www.jetbrains.com/help/idea/2026.1/run-for-the-first-time.html)
+help page, where we recommend that you also check the
+[SDK configuration](https://www.jetbrains.com/help/idea/2026.1/sdk.html) guide.
+
+<Callout type="info">
+  We recommened following
+  [TheNullicorn's](https://gist.github.com/TheNullicorn/90a619796c40f20ae1fcf13094c1a57d) guide to ensure
+  you are using the correct `Nonnull` in your projects.
+</Callout>
+
+#### What the IDE Does for You
+
+When opened in IntelliJ IDEA, the project automatically:
+
+- Detects and configures Gradle or Maven
+- Downloads all dependencies
+- Sets up project structure and classpaths
+- Configures run/build tasks
+
+You do **not** need to manually install or configure Maven or Gradle if you stay inside the IDE.
+
+Skip to the [Setting Up Your Workspace](#setting-up-your-workspace).
+
+### Manual Setup: Java Development Kit (JDK)
+
+For any other setup, you will need to install and configure your system to have and load Java.
 Hytale modding requires Java 25 or later. We recommend using OpenJDK.
 
-#### Windows
+#### Windows via Installer
 
 1. Download OpenJDK 25 from [Adoptium](https://adoptium.net/)
 2. Run the installer with default settings
+   - Optionally enable feature `Set or Override JAVA_HOME variable` to resolve version related build issues with your project.
 3. Verify installation by opening Command Prompt and running:
 
+#### Windows via Scoop
+
+1. Install Scoop via PowerShell using [scoop.sh](https://scoop.sh/)
+2. Install OpenJDK 25:
+
 ```bash
-java -version
+scoop bucket add java
+scoop install java/openjdk25
 ```
 
 #### macOS
 
+1. Install Brew via Terminal using [brew.sh](https://brew.sh)
+2. Install JDK via Homebrew:
+
 ```bash
-# Using Homebrew
 brew install openjdk@25
 ```
 
@@ -51,22 +104,41 @@ brew install openjdk@25
 
 #### Linux (Ubuntu/Debian)
 
+1. Install JDK via the built-in package repository:
+
 ```bash
 sudo apt update
 sudo apt install openjdk-25-jdk
 ```
 
-### 2. Integrated Development Environment (IDE)
+### Verify installation:
 
-We recommend IntelliJ IDEA Community Edition for Hytale modding.
+Run the following command to see what version of Java you have:
 
-1. Download from [JetBrains website](https://www.jetbrains.com/idea/download/)
-2. Install with default settings
-3. Launch and complete the initial setup wizard
+```bash
+java -version
+```
+
+### Java Build Tool (Optional)
+
+We recommend using a Gradle Wrapper for managing dependencies and building your Hytale plugins. It provides benefits by eliminating the need for a system-wide Gradle installation and ensuring consistent Gradle versions across different environments. (Alternatively you can use Maven, but this guide focuses on Gradle since it is the default for our plugin template.)
+
+The plugin template in the following sections includes a Gradle Wrapper, so you can skip this step if you plan to use the template.
+
+#### Choosing Gradle (if not using the template)
+
+If you prefer to install Gradle manually, follow these steps:
 
-### 3) Java Build Tool
+1. Visit the official website: https://gradle.org/releases/
+2. Download the newest gradle binary: `gradle-9.3.1-bin.zip` (Binary zip archive)
+3. Unzip it
+4. Add the `gradle-9.3.1/bin/` folder to your PATH
+
+You can now try the command `gradle -version` to verify Gradle is installed correctly. Make sure to do this in a fresh new terminal instead of one you had opened from before!
+
+#### Choosing Maven (if not using the template)
 
-We recommend using Apache Maven for managing dependencies and building your Hytale plugins. (Alternatively you can use Gradle, but this guide focuses on Maven.)
+If you prefer to use Maven instead of Gradle, follow these steps to install Maven:
 
 1. Visit the official website: https://maven.apache.org/download.cgi
 2. Download this file: `apache-maven-3.9.12-bin.zip` (Binary zip archive)
@@ -89,22 +161,61 @@ cd MyFirstMod
 
 If you don't have Git installed, you can download the ZIP file from the repository page and extract it to a folder named `MyFirstMod`.
 
-### 2. Open Plugin in your IDEA
+### 2. Open Plugin in your IDE
 
-1. Open IntelliJ IDEA
+1. Open Your IDE (e.g., IntelliJ IDEA)
 2. Click "Open" and navigate to your `MyFirstMod` directory
-3. IntelliJ will automatically detect it as a Maven project
+3. Most IDEs like IntelliJ will automatically detect it as a Gradle project
 4. Wait for the project to index and dependencies to download
 
-<Callout type="info">
-  We recommened following [this](https://gist.github.com/TheNullicorn/90a619796c40f20ae1fcf13094c1a57d) guide to ensure you are using the correct `Nonnull` in your projects.
-</Callout>
+## Alternate Approach: Hytale Dependency
+
+If you prefer to set up your project from scratch without using the template and importing the hytale dependencies manually, ensure your build configuration includes the Hytale repositories and dependencies:
+
+For Gradle, add the following to your `build.gradle.kts`:
+
+```kotlin
+repositories {
+    mavenCentral()
+    maven {
+        name = "hytale"
+        url = uri("https://maven.hytale.com/release") // Or "hytale-pre-release" for pre-release versions
+    }
+}
+dependencies {
+    // + here means the latest version, but you can hard-wire any known version!
+    implementation("com.hypixel.hytale:Server:+")
+}
+```
+
+For Maven, add the following to your `pom.xml`:
+
+```xml
+<project>
+    <repositories>
+        <repository>
+            <id>hytale-release</id> <!-- Or "hytale-pre-release" for pre-release versions -->
+            <url>https://maven.hytale.com/release</url> <!-- Or "https://maven.hytale.com/pre-release" -->
+        </repository>
+    </repositories>
+
+    <dependencies>
+        <dependency>
+            <groupId>com.hypixel.hytale</groupId>
+            <artifactId>Server</artifactId>
+            <!-- Replace with latest version, Hytale provides jars for the last five releases -->
+            <version>LATEST_VERSION_HERE</version>
+            <scope>provided</scope>
+        </dependency>
+    </dependencies>
+</project>
+```
 
 ## Next Steps
 
 Now that you have your development environment set up with the plugin template:
 
-1. **Customize the template** - Edit the `pom.xml` and `manifest.json` file to change your mod's name and details
+1. **Customize the template** - Edit the `settings.gradle.kts`, `build.gradle.kts` and `manifest.json` file to change your mod's name and details
 2. **Explore the code structure** - Familiarize yourself with the template's organization
 3. **Start modding** - Begin writing your first Hytale plugin!
 
diff --git a/content/docs/ro-RO/guides/plugin/spawning-entities.mdx b/content/docs/ro-RO/guides/plugin/spawning-entities.mdx
index e12c0aea..15be2fb3 100644
--- a/content/docs/ro-RO/guides/plugin/spawning-entities.mdx
+++ b/content/docs/ro-RO/guides/plugin/spawning-entities.mdx
@@ -36,7 +36,7 @@ Store<EntityStore> store = world.getEntityStore().getStore();
 
 ## Creating Entities
 
-Once you have the `EntityStore` instance, you can start to create a entity and give it components. Entities are just instances of `Holder<EntityStore>` with several components attached to them.
+Once you have the `EntityStore` instance, you can start to create an entity and give it components. Entities are just instances of `Holder<EntityStore>` with several components attached to them.
 
 <Callout type="warning">
   To interact with the `World` instance, some methods require you to run the code inside the world's execution context.
@@ -118,3 +118,48 @@ Finally, we can add the entity to the world by calling the `addEntity` method on
 ```java
 store.addEntity(holder, AddReason.SPAWN);
 ```
+
+## Making the entity persist
+
+Hytale automatically saves all entities, but the `NetworkId` component (required for players to be able to see the entity) needs to be manually added every time the entity is loaded.
+
+### Using a system
+
+If you have a component that is unique to your entities, this can be done by creating and registering a custom system as follows:
+
+```java
+public class AddNetworkIdToMyEntitySystem extends HolderSystem<EntityStore> {
+    private final ComponentType<EntityStore, MyEntityComponent> myEntityComponentType = MyEntityComponent.getComponentType();
+    private final ComponentType<EntityStore, NetworkId> networkIdComponentType = NetworkId.getComponentType();
+    private final Query<EntityStore> query = Query.and(this.myEntityComponentType, Query.not(this.networkIdComponentType));
+
+    @Override
+    public void onEntityAdd(@NotNull Holder<EntityStore> holder, @NotNull AddReason reason, @NotNull Store<EntityStore> store) {
+        if (!holder.getArchetype().contains(NetworkId.getComponentType())) {
+            holder.addComponent(NetworkId.getComponentType(), new NetworkId(store.getExternalData().takeNextNetworkId()));
+        }
+    }
+
+    @Override
+    public void onEntityRemoved(@NotNull Holder<EntityStore> holder, @NotNull RemoveReason reason, @NotNull Store<EntityStore> store) {}
+
+    @Override
+    public @Nullable Query<EntityStore> getQuery() {
+        return query;
+    }
+}
+```
+
+In your plugin's `setup()` function
+
+```java
+this.getEntityStoreRegistry().registerSystem(new AddNetworkIdToMyEntitySystem())
+```
+
+### Using PropComponent
+
+Alternatively you can add `PropComponent` to your entity. Hytale adds `PropComponent` to entities spawned with the Entity Tool, and such entities automatically get `NetworkId` and `PrefabCopyableComponent` (which makes the entity work with prefabs).
+
+<Callout type="warning">
+  There is no guarantee, that Hytale will not add some other behavior to this component in the future, which may break your entity, so be careful if you decide to rely on it.
+</Callout>
diff --git a/content/docs/ro-RO/guides/plugin/store-persistent-data.mdx b/content/docs/ro-RO/guides/plugin/store-persistent-data.mdx
new file mode 100644
index 00000000..1071dff3
--- /dev/null
+++ b/content/docs/ro-RO/guides/plugin/store-persistent-data.mdx
@@ -0,0 +1,171 @@
+---
+title: Storing Persistent Data on the Player
+description: Learn how to save and load persistent data using Components
+authors:
+  - name: Neil Revin
+    url: https://itsneil.dev/
+  - name: ArcticDev
+    url: https://github.com/ArcticRaven
+  - name: oskarscot
+    url: https://oskar.scot
+  - name: JammingEng
+    url: https://github.com/JammingEnd
+---
+
+Here is how to store persistent data using a custom component on a Player.
+
+## Build your Component Class
+
+Creating a custom component class leverages the Component system made with the ECS architecture in mind. For more information on Components, check out the [ECS Guide](../ecs/hytale-ecs-theory#components).
+
+Start by creating your custom component class. This will be extremely similar to how regular components are created, however we'll setup a custom Codec so the server can translate this data to BSON, or the server's internal json encoder.
+
+<Callout type="info">
+  Each variable you want to store in your component must have its own Codec field defined in the BuilderCodec.
+  For more information on how to create custom Codecs, check out the [ECS Codec Guide](../ecs/hytale-ecs-theory#codec).
+</Callout>
+
+```java
+public class YourPlayerData implements Component<EntityStore> {
+
+    // define some vars!
+    private int someInteger;
+    private String someString;
+    private Map<String, String> someMap;
+
+    public static final BuilderCodec<YourPlayerData> CODEC =
+            BuilderCodec.builder(YourPlayerData.class, YourPlayerData::new)
+            .append(new KeyedCodec<>("SomeInteger", Codec.INTEGER),
+                    (data, value) -> data.someInteger = value, // setter
+                    data -> data.someInteger) // getter
+            .addValidator(Validators.nonNull())
+            .add()
+            .append(new KeyedCodec<>("SomeString", Codec.STRING),
+                    (data, value) -> data.someString = value, // setter
+                    data -> data.someString) // getter
+            .add()
+            .append(new KeyedCodec<>("SomeMap",
+                            new MapCodec<>(Codec.STRING, HashMap::new, false)),
+                    (data, value) -> data.someMap = value, // setter
+                    data -> data.someMap) // getter
+            .add()
+            .build();
+
+
+
+    // Getters and Setters are for the purpose of this example omitted.
+
+    // constructor
+    public YourPlayerData() {
+        this.someInteger = 0;
+        this.someString = "";
+        this.someMap = new HashMap<>();
+    }
+
+    // copy constructor for cloning
+    public YourPlayerData(YourPlayerData clone) {
+        this.someInteger = clone.someInteger;
+        this.someString = clone.someString;
+        this.someMap = clone.someMap;
+    }
+
+    @Nonnull
+    @Override
+    public Component<EntityStore> clone() {
+        return new YourPlayerData(this);
+    }
+}
+```
+
+## Register your Component
+
+Inside your main class's `setup()` method, register your new Component.
+
+```java
+public class YourPlugin extends JavaPlugin {
+
+    private ComponentType<EntityStore, YourPlayerData> yourPlayerDataComponent;
+
+    public YourPlugin(@Nonnull JavaPluginInit init) {
+        super(init);
+    }
+
+    @Override
+    protected void setup(){
+        this.yourPlayerDataComponent = this.getEntityStoreRegistry().registerComponent(
+            YourPlayerData.class,
+            "YourPlayerDataComponent",
+            YourPlayerData.CODEC
+        );
+    }
+
+    public ComponentType<EntityStore, YourPlayerData> getYourPlayerDataComponent() {
+        return this.yourPlayerDataComponent;
+    }
+}
+```
+
+## Using your Component
+
+To use your newly created component, you can add the Component to a player using the `addComponent` method, although this only adds it temporarily, meaning when the player/entity leaves the world, the component is removed. You can use `putComponent` to ensure the component persists between sessions.
+
+```java
+// You will need the Ref and Store to apply components
+private void someEntryMethod(@Nonnull Ref<EntityStore> ref, @Nonnull Store<EntityStore> store)
+{
+       // Any entity will work, for now we will use the player
+      Player player = (Player) store.getComponent(ref, Player.getComponentType());
+
+      // since we're using putComponent, it could be useful to check if it already exists on the player in case we want to update it
+     if(store.getComponent(ref, YourPlugin.instance().getYourPlayerDataComponent()) != null)
+     {
+          // here we implement logic that updates the component
+         var comp = store.getComponent(ref, YourPlugin.instance().getYourPlayerDataComponent())
+         // declare public fields or methods in the component class
+         comp.SomeString = "An Updated Field";
+     } else {
+          // Here we put the component
+          var myCustomComp = new CustomComponent();
+          // declare public fields or methods in the component class
+          myCustomComp.SomeString = "Edited String";
+
+          // putComponent allows you to insert declared objects
+          store.putComponent(ref, YourPlugin.instance().getYourPlayerDataComponent(), myCustomComp);
+     }
+}
+```
+
+## Using your Data
+
+Your component will be stored within the `Store<EntityStore>` when added to the player. In the provided example,
+we'll fetch this data off the player using the `ensureAndGetComponent()` method, which will add the component to
+the player if it does not exist with the default values.
+
+```java
+public class IncompleteCustomCommand extends AbstractPlayerCommand {
+
+    public IncompleteCustomCommand() {
+        super("nope", "don't use this command");
+    }
+
+    @Override
+    protected void execute(
+        @NonNullDecl CommandContext commandContext,
+        @NonNullDecl Store<EntityStore> store,
+        @NonNullDecl Ref<EntityStore> ref,
+        @NonNullDecl PlayerRef playerRef,
+        @NonNullDecl World world
+    ) {
+        YourPlayerData customData = store.ensureAndGetComponent(ref, YourPlugin.instance().getYourPlayerDataComponent());
+        // ensureAndGetComponent adds the component to the ref, with the default values defined inside your component.
+ 		// use your data
+    }
+}
+```
+
+And that's it! Your data will now be saved and loaded automatically with the player.
+
+Using custom components to store persistent data on players is a powerful way to maintain state across sessions.
+By following the steps outlined above, you can easily create, register, and utilize your own data structures within the Hytale ECS framework.
+This approach ensures that your data is seamlessly integrated with the game's existing systems.
+For more information about Hytale's Entity Component System visit the [Hytale ECS Theory](https://hytalemodding.dev/en/docs/guides/ecs/hytale-ecs-theory) guide.
diff --git a/content/docs/ro-RO/guides/plugin/teleporting-players.mdx b/content/docs/ro-RO/guides/plugin/teleporting-players.mdx
index 57cee77f..32ce0435 100644
--- a/content/docs/ro-RO/guides/plugin/teleporting-players.mdx
+++ b/content/docs/ro-RO/guides/plugin/teleporting-players.mdx
@@ -1,26 +1,32 @@
 ---
 title: Teleporting the player
 description: Learn how to teleport the player.
+authors:
+  - name: oskarscot
+    url: https://oskar.scot
 ---
 
-To teleport players in Hytale, you will need to get a `World` object so we can safely run the teleport on the world thread. The world thread manages all entity updates, so modifying entities off-thread can crash the server or cause inconsistent state.
-Next, we get the entity store and make a `Teleport` object.
-We add a `Teleport` component to the player’s entity reference in the entity store. This triggers the teleportation logic for that player.
+Teleporting players in Hytale works by simply attaching a `Teleport` component to a player with the desired world and transform.
+You can only trigger teleports from a world where the player is currently present.
+Teleport itself is a component but it also provides factory methods to configure the Teleport. Just as with any entity component, an EntityStore and a Ref to the EntityStore is required
+
+We can create a simple teleport utility like this:
 
 ```java
-public static void teleportPlayer(Player player, int x, int y, int z) {
-        World world = player.getWorld();
-        if (world == null) return;
-        world.execute(() -> {
-            if (player.getReference() == null) return;
-            Store<EntityStore> store = player.getReference().getStore();
-            Teleport teleport = Teleport.createForPlayer(world,
-                new Vector3d(x ,y, z), // Target position
-                new Vector3f(0, 0, 0)  // Target rotation (pitch, yaw, roll)
-            );
+public static void teleportPlayer(Ref<EntityStore> ref, Store<EntityStore> store, World targetWorld, double x, double y, double z) {                                                                                       
+    Transform transform = new Transform(x, y, z);                                                                                                                           
+    Teleport teleport = Teleport.createForPlayer(targetWorld, transform);                                                                                                   
+    store.addComponent(ref, Teleport.getComponentType(), teleport);                                                                                                         
+}  
+```
 
-            store.addComponent(player.getReference(), Teleport.getComponentType(), teleport);
-        });
+A `Transform` is a representation of a position Vector3d and rotation Vector3f which works in the following way:
 
-}
+```java
+Transform transform = new Transform(
+    new Vector3d(x, y, z),      // Position
+    new Rotation(yaw, pitch, 0) // Rotation, last value seems to always be 0
+);
+Teleport teleport = Teleport.createForPlayer(targetWorld, transform);
+store.addComponent(ref, Teleport.getComponentType(), teleport);
 ```
diff --git a/content/docs/ro-RO/guides/plugin/tracking-mod-analytics-with-hstats.mdx b/content/docs/ro-RO/guides/plugin/tracking-mod-analytics-with-hstats.mdx
new file mode 100644
index 00000000..45c022e0
--- /dev/null
+++ b/content/docs/ro-RO/guides/plugin/tracking-mod-analytics-with-hstats.mdx
@@ -0,0 +1,65 @@
+---
+title: Tracking Mod Analytics with HStats
+description: Learn how you can track Analytics for your Hytale Mod for Free using hstats.dev
+authors:
+  - name: Al3x
+    url: https://hstats.dev
+---
+
+In this guide, you will learn how to integrate HStats into your Plugin/Mod which will allow you to track how many Servers are using it along with other stats.
+
+<Callout type="info">
+  HStats is a third-party tool and is not affiliated with HytaleModding or Hypixel Studios
+</Callout>
+
+# Step 1: Register your Mod to HStats
+
+Before you touch any code, you will need to add your mod to the HStats website which will give you a UUID for your mod.
+
+- Create or Login to an Account on https://hstats.dev
+- Navigate to the dashboard page (https://hstats.dev/dashboard)
+- On the left, type in your mod's name and click "Add Mod"
+- Keep note of the UUID generated for later.
+
+# Step 2: Add the HStats Class to Your Project
+
+To keep things simple, HStats uses a single Java class file that handles everything for you.
+
+- Download / Copy the File from the GitHub page (https://github.com/hstats-dev/HStatsExamplePlugin/blob/main/src/main/java/com/al3x/HStats.java)
+- Paste into your Project. You should now have a HStats.java file somewhere in your projects directory.
+- Update the package name from com.al3x to whatever fits your project.
+
+# Step 3: Initialize HStats in your code
+
+You only need to add one line of code to your mod's setup method in your main class to start tracking.
+
+`new HStats("YOUR-MOD-UUID", "1.0.0");`
+
+Replace `YOUR-MOD-UUID` with the Mod UUID we made note of earlier and change the `1.0.0` version to whatever version your mod is currently on.
+
+Your setup method should now look something like this:
+
+```java
+@Override
+protected void setup() {
+  super.setup();
+  new HStats("c34a2b2a-afd8-4d6a-821e-7a63e12c5ea6", "1.0.0");
+}
+```
+
+# Extras
+
+Your done! Your mod should now be listed under the Mods page (https://hstats.dev/mods) as well as under your dashboard.
+
+Servers using your mod should now post updates about every minute to HStats which you can view in the Dashboard.
+
+### Embeds
+
+HStats allows you to generate an Embed Card that you can place on your CurseForge or GitHub page. This is useful for server owners to be able to see how many other servers are using your mod.
+
+- In your dashboard, scroll down to the Embed Card section.
+- Customize the appearance (Light/Dark mode, layout, etc).
+- Copy the generated URL to display your "Active Servers" and "Players Online" live on your mod's description page
+
+Heres an example of what they look like:
+![HStats Example](https://api.hstats.dev/api/embed/d52fa672-6966-47b2-b501-1a11bddebac3/card.svg?theme=light\&layout=compact\&size=md\&show_id=true\&dark=false)
diff --git a/content/docs/ro-RO/guides/plugin/world-gen.mdx b/content/docs/ro-RO/guides/plugin/world-gen.mdx
index 4c23b0c9..7b193ffd 100644
--- a/content/docs/ro-RO/guides/plugin/world-gen.mdx
+++ b/content/docs/ro-RO/guides/plugin/world-gen.mdx
@@ -100,7 +100,7 @@ Biome biome = biomeGen.generateBiomeAt(zoneResult, seed, x, z);
 
 ### Zone & Cave Integration
 
-Each zone defines it's own cave patterns:
+Each zone defines its own cave patterns:
 
 ```java
 Zone zone = /* ... */;
diff --git a/content/docs/ro-RO/guides/prefabs.mdx b/content/docs/ro-RO/guides/prefabs.mdx
index 08404b30..b1a55109 100644
--- a/content/docs/ro-RO/guides/prefabs.mdx
+++ b/content/docs/ro-RO/guides/prefabs.mdx
@@ -14,7 +14,7 @@ Prefabs are Hytale's way of creating reusable structures.
 There are a few fundamental concepts to understand about prefabs:
 
 - Users interact with prefabs via a prefab editing world.
-- Prefabs the physical structures in the game world, and are saved as JSON files.
+- Prefabs are the physical structures in the game world, and are saved as JSON files.
 
 ## How to Create a Prefab
 
diff --git a/content/docs/ro-RO/official-documentation/custom-ui/common-styling.mdx b/content/docs/ro-RO/official-documentation/custom-ui/common-styling.mdx
new file mode 100644
index 00000000..c36e3e3a
--- /dev/null
+++ b/content/docs/ro-RO/official-documentation/custom-ui/common-styling.mdx
@@ -0,0 +1,50 @@
+---
+title: Common Styling
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# Common Styling
+
+## Common UI Styling Library
+
+This document describes the shared UI components and styles defined in `Common.ui`.
+
+---
+
+### Styles
+
+We are providing some styles that can be re-used in any custom UI that, provide a cohesive UI experience with the core game UI. These styles are available in the `Common.ui` file.
+
+You can find a list of all the styles defined with live examples by running the `/ui-gallery` command ingame.
+
+<Callout type="warning">
+  This command is not available yet, but will be in a future patch.
+</Callout>
+
+![Gallery](/assets/official-documentation/ui/gallery.png)
+
+### Importing
+
+To use these styles in your UI file:
+
+```
+$Common = "Common.ui";
+
+// Then reference styles and components:
+$Common.@TextButton { @Text = "My Button"; }
+$Common.@Container { ... }
+```
+
+<Callout type="info">
+  The `Common.ui` file is at `Common/UI/Custom/Common.ui` within the Hytale pack. If your custom ui document is in a subfolder of `Common/UI/Custom/`, reference it via relative path traversal:
+
+  ```
+  $Common = "../Common.ui";
+  ```
+
+  You can find more info about paths [here](markup#path).
+</Callout>
diff --git a/content/docs/ro-RO/official-documentation/custom-ui/index.mdx b/content/docs/ro-RO/official-documentation/custom-ui/index.mdx
new file mode 100644
index 00000000..f94c4e88
--- /dev/null
+++ b/content/docs/ro-RO/official-documentation/custom-ui/index.mdx
@@ -0,0 +1,125 @@
+---
+title: Custom UI
+icon: LayoutDashboard
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# Custom UI
+
+## What is Custom UI?
+
+Custom UI is Hytale's framework for creating **custom user interfaces** controlled by the game server. Unlike the built-in Client UI (which is part of the game client and cannot be modified), Server UI allows you to create interactive screens and HUD overlays through Java plugins and asset packs.
+
+As a modder, Custom UI gives you the power to:
+
+- **Create custom interactive pages** - Shop interfaces, quest dialogs, server settings menus, admin panels
+- **Add custom HUD overlays** - Quest trackers, status displays, custom health bars, server information
+- **Design with markup** - Use `.ui` files to define reusable UI templates
+- **Handle user interactions** - Respond to button clicks, form submissions, and other events
+- **Localize your UI** - Support multiple languages using the game's translation system
+
+## How Custom UI Fits Into Hytale's UI
+
+Hytale's user interface is divided into two main categories:
+
+### Client UI (Not Moddable)
+
+Built-in interfaces controlled by the C# game client:
+
+- Main menu and settings
+- Character creation
+- Built-in HUD (health, hotbar, chat)
+- Inventory and crafting screens
+- Development tools
+
+**You cannot modify these** - they are part of the core game client.
+
+### In-Game UI (Moddable via Server)
+
+Server-controlled interfaces that you can create and customize:
+
+#### Custom Pages
+
+Full-screen interactive overlays that appear during gameplay:
+
+- Can be dismissed by the player (ESC key)
+- Capture all input (keyboard and mouse)
+- Support loading states while waiting for server responses
+- Perfect for: shops, dialogs, menus, configuration screens
+
+#### Custom HUDs
+
+Persistent overlay elements drawn on top of the game world:
+
+- Display-only (no user interaction)
+- Always visible during gameplay
+- Lightweight and non-intrusive
+- Perfect for: quest objectives, status indicators, server info panels
+
+## Architecture Overview
+
+Server UI uses a **command-based architecture**:
+
+```
+┌─────────────────────┐         ┌──────────────────────┐
+│   Java Server       │         │    C# Client         │
+│   (Your Plugin)     │         │    (Game)            │
+├─────────────────────┤         ├──────────────────────┤
+│                     │         │                      │
+│ InteractiveCustomUI │         │   CustomPage or      │
+│ Page                │         │   CustomHud          │
+│   ↓ build()         ├────────→│     ↓ Apply          │
+│ UICommandBuilder    │         │   Element Tree       │
+│   - append()        │         │     ↓ Layout         │
+│   - set()           │         │   Rendered UI        │
+│   - clear()         │         │                      │
+│                     │         │                      │
+│ ↓ handleDataEvent() │← Events │   User Interaction   │
+│   Process input     │         │   (click, type, etc) │
+│   sendUpdate()      │         │                      │
+└─────────────────────┘         └──────────────────────┘
+```
+
+**The flow:**
+
+1. Your Java code builds UI using `UICommandBuilder`
+2. Commands are sent to the client as data
+3. Client parses `.ui` markup files and creates visual elements
+4. User interacts with the UI
+5. Events are sent back to your Java code
+6. You process events and send updates back
+
+## Key Principles
+
+### Declarative, Not Imperative
+
+You don't create UI objects directly. Instead, you send **commands** that describe what you want:
+
+- "Append this button template to that container"
+- "Set this label's text to 'Hello World'"
+- "Clear all children from this list"
+
+### Asset-Driven
+
+UI structure is defined in `.ui` markup files (assets), not hardcoded in Java. This enables:
+
+- Designers to modify layouts without touching code
+- Reusable UI components
+- Consistent visual language
+
+### Event-Driven
+
+User interactions trigger events that flow back to your server code. You register event bindings and handle them in `handleDataEvent()`.
+
+### Selector-Based
+
+You target specific UI elements using **selectors:**
+
+- `#MyButton` - Element with ID "MyButton"
+- `#List[0]` - First child of element "List"
+- `#List[0] #Title` - Element with ID "Title" in the first child of element "List"
+- `#Label.TextColor` - The TextColor property of element "Label"
diff --git a/content/docs/ro-RO/official-documentation/custom-ui/layout.mdx b/content/docs/ro-RO/official-documentation/custom-ui/layout.mdx
new file mode 100644
index 00000000..0a24ca09
--- /dev/null
+++ b/content/docs/ro-RO/official-documentation/custom-ui/layout.mdx
@@ -0,0 +1,492 @@
+---
+title: Layout
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# Layout
+
+The layout system determines how UI elements are positioned and sized on screen. Understanding layout is crucial for creating well-structured, responsive interfaces.
+
+## Layout Fundamentals
+
+Every UI element has:
+
+- **Container Rectangle** - The space allocated by the parent
+- **Anchor** - How the element positions/sizes itself within the container
+- **Padding** - Inner spacing that affects child layout
+- **LayoutMode** - How the element arranges its children (if it's a container)
+
+```
+┌─────────────────────────────────────┐
+│  Container Rectangle (from parent)  │
+│  ┌───────────────────────────────┐  │
+│  │  Anchored Rectangle           │  │
+│  │  ┌─────────────────────────┐  │  │
+│  │  │ Padding                 │  │  │
+│  │  │  ┌───────────────────┐  │  │  │
+│  │  │  │  Content Area     │  │  │  │
+│  │  │  └───────────────────┘  │  │  │
+│  │  └─────────────────────────┘  │  │
+│  └───────────────────────────────┘  │
+└─────────────────────────────────────┘
+```
+
+## Anchor
+
+`Anchor` controls how an element positions and sizes itself within its container rectangle.
+
+### Fixed Size
+
+```
+Button {
+    Anchor: (Width: 200, Height: 40);
+}
+```
+
+Creates a 200×40 pixel button.
+
+### Positioning
+
+```
+Label {
+    Anchor: (Top: 10, Left: 20, Width: 100, Height: 30);
+}
+```
+
+- **Top**: 10 pixels from container's top edge
+- **Left**: 20 pixels from container's left edge
+- **Width**: 100 pixels wide
+- **Height**: 30 pixels tall
+
+### Anchoring to Edges
+
+```
+Button {
+    Anchor: (Bottom: 10, Right: 10, Width: 100, Height: 30);
+}
+```
+
+Anchors the button to the bottom-right corner, 10 pixels from each edge.
+
+### Stretching
+
+```
+Group {
+    Anchor: (Top: 0, Bottom: 0, Left: 0, Right: 0);
+}
+```
+
+Stretches to fill the entire container (all edges at 0 pixels).
+
+**Shorthand:**
+
+```
+Group {
+    Anchor: (Full: 0);
+}
+```
+
+### Mixed Anchoring
+
+```
+Panel {
+    Anchor: (Top: 10, Bottom: 10, Left: 20, Width: 300);
+}
+```
+
+- Fixed width of 300 pixels
+- Stretches vertically between top and bottom edges
+- 10 pixels from top and bottom
+- 20 pixels from left
+
+## Padding
+
+`Padding` creates inner spacing, affecting where children are positioned.
+
+### Uniform Padding
+
+```
+Group {
+    Padding: (Full: 20);
+}
+```
+
+20 pixels of padding on all sides.
+
+### Directional Padding
+
+```
+Group {
+    Padding: (Top: 10, Bottom: 20, Left: 15, Right: 15);
+}
+```
+
+Different padding per edge.
+
+### Shorthand
+
+```
+// Horizontal and vertical
+Group {
+    Padding: (Horizontal: 20, Vertical: 10);
+}
+
+// Equivalent to:
+// Top: 10, Bottom: 10, Left: 20, Right: 20
+```
+
+### Effect on Children
+
+```
+Group {
+    Anchor: (Width: 200, Height: 100);
+    Padding: (Full: 10);
+
+    Label {
+        Anchor: (Full: 0);
+    }
+}
+```
+
+The label fills the group, but there's a 10-pixel gap on all sides due to padding.
+
+```
+┌──────────────────────┐
+│ Group (200×100)      │
+│  ┌────────────────┐  │
+│  │ Label          │  │ ← 10px padding all around
+│  │                │  │
+│  └────────────────┘  │
+└──────────────────────┘
+```
+
+## LayoutMode
+
+`LayoutMode` determines how a container arranges its children.
+
+### Top (Vertical Stack)
+
+```
+Group {
+    LayoutMode: Top;
+
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+}
+```
+
+Children stack vertically from top to bottom:
+
+```
+┌──────────┐
+│ Button 1 │
+├──────────┤
+│ Button 2 │
+├──────────┤
+│ Button 3 │
+└──────────┘
+
+
+```
+
+Each child's `Anchor.Bottom` adds spacing between elements:
+
+```
+Button { Anchor: (Height: 30, Bottom: 10); }  // 10px gap after this button
+```
+
+### Bottom (Vertical Stack)
+
+```
+Group {
+    LayoutMode: Bottom;
+
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+}
+```
+
+Children stack vertically from top to bottom but aligned to the bottom edge of the parent:
+
+```
+
+
+
+┌──────────┐
+│ Button 1 │
+├──────────┤
+│ Button 2 │
+├──────────┤
+│ Button 3 │
+└──────────┘
+```
+
+### Left (Horizontal Stack)
+
+```
+Group {
+    LayoutMode: Left;
+
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+}
+```
+
+Children arrange horizontally from left to right:
+
+```
+┌────────┬────────┬────────┐
+│ Button │ Button │ Button │
+│   1    │   2    │   3    │
+└────────┴────────┴────────┘
+```
+
+Use `Anchor.Right` for spacing between elements.
+
+### Right (Horizontal Stack)
+
+```
+Group {
+    LayoutMode: Right;
+
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+}
+```
+
+Children arrange horizontally from left to right but aligned to the right side of the parent:
+
+```
+                                                                 ┌────────┬────────┬────────┐
+                                                                 │ Button │ Button │ Button │
+                                                                 │   1    │   2    │   3    │
+                                                                 └────────┴────────┴────────┘
+```
+
+### Center
+
+```
+Group {
+    LayoutMode: Center;
+
+    Group #Dialog {
+        Anchor: (Width: 400, Height: 300);
+    }
+}
+```
+
+Centers the children horizontally.
+
+### Middle
+
+```
+Group {
+    LayoutMode: Middle;
+
+    Group #Dialog {
+        Anchor: (Width: 400, Height: 300);
+    }
+}
+```
+
+Centers the children vertically.
+
+### CenterMiddle (Horizontal Stack, Fully Centered)
+
+```
+Group {
+    LayoutMode: CenterMiddle;
+
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+}
+```
+
+Children stack horizontally from left to right, centered both horizontally and vertically within the parent:
+
+```
+┌────────────────────────────────────────────┐
+│                                            │
+│                                            │
+│         ┌──────┐ ┌──────┐ ┌──────┐         │
+│         │  B1  │ │  B2  │ │  B3  │         │
+│         └──────┘ └──────┘ └──────┘         │
+│                                            │
+│                                            │
+└────────────────────────────────────────────┘
+```
+
+---
+
+### MiddleCenter (Vertical Stack, Fully Centered)
+
+```
+Group {
+    LayoutMode: MiddleCenter;
+
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+}
+```
+
+Children stack vertically from top to bottom, centered both horizontally and vertically within the parent:
+
+```
+┌────────────────────────────────────────────┐
+│                                            │
+│              ┌──────────┐                  │
+│              │ Button 1 │                  │
+│              ├──────────┤                  │
+│              │ Button 2 │                  │
+│              ├──────────┤                  │
+│              │ Button 3 │                  │
+│              └──────────┘                  │
+│                                            │
+└────────────────────────────────────────────┘
+```
+
+---
+
+### Full
+
+```
+Group {
+    LayoutMode: Full;
+
+    Label {
+        Anchor: (Top: 20, Left: 20, Width: 100, Height: 30);
+    }
+}
+```
+
+Children use absolute positioning via their `Anchor` properties.
+
+### TopScrolling
+
+```
+Group {
+    LayoutMode: TopScrolling;
+    ScrollbarStyle: $Common.@DefaultScrollbar;
+
+    // ... many children
+}
+```
+
+Like `Top`, but adds a scrollbar if content exceeds container height.
+
+Or use `BottomScrolling` for bottom-aligned content.
+
+### LeftScrolling
+
+```
+Group {
+    LayoutMode: LeftScrolling;
+    ScrollbarStyle: $Common.@DefaultScrollbar;
+
+    // ... many children
+}
+```
+
+Like `Left`, but adds a scrollbar for horizontal scrolling.
+
+Or use `RightScrolling` for right-aligned content.
+
+### LeftCenterWrap (Wrapping Horizontal Stack, Horizontally Centered)
+
+```
+Group {
+    LayoutMode: LeftCenterWrap;
+
+    Button { Anchor: (Width: 80, Height: 30); }
+    Button { Anchor: (Width: 80, Height: 30); }
+    Button { Anchor: (Width: 80, Height: 30); }
+    Button { Anchor: (Width: 80, Height: 30); }
+    Button { Anchor: (Width: 80, Height: 30); }
+}
+```
+
+Children flow left to right. When there's no more horizontal space, they wrap to the next row. Each row is horizontally centered within the parent:
+
+```
+┌────────────────────────────────────────────┐
+│                                            │
+│       ┌──────┐ ┌──────┐ ┌──────┐           │
+│       │  B1  │ │  B2  │ │  B3  │           │
+│       └──────┘ └──────┘ └──────┘           │
+│            ┌──────┐ ┌──────┐               │
+│            │  B4  │ │  B5  │               │
+│            └──────┘ └──────┘               │
+│                                            │
+└────────────────────────────────────────────┘
+```
+
+## FlexWeight
+
+`FlexWeight` distributes remaining space among children.
+
+```
+Group {
+    LayoutMode: Left;
+    Anchor: (Width: 400);
+
+    Button {
+        Anchor: (Width: 100);
+    }
+
+    Group {
+        FlexWeight: 1;  // Takes all remaining space
+    }
+
+    Button {
+        Anchor: (Width: 100);
+    }
+}
+```
+
+Result:
+
+- First button: 100px
+- Middle group: 200px (400 - 100 - 100 = 200)
+- Last button: 100px
+
+### Multiple FlexWeights
+
+```
+Group {
+    LayoutMode: Left;
+    Anchor: (Width: 600);
+
+    Group { FlexWeight: 1; }
+    Group { FlexWeight: 2; }
+    Group { FlexWeight: 1; }
+}
+```
+
+Remaining space (600px) is split:
+
+- First group: 600 × (1/4) = 150px
+- Second group: 600 × (2/4) = 300px
+- Third group: 600 × (1/4) = 150px
+
+## Visibility
+
+```
+Button #HiddenButton {
+    Visible: false;
+}
+```
+
+**Effect:**
+
+- Element and its children are not displayed
+- Element is **not included in layout** (doesn't take up space)
diff --git a/content/docs/ro-RO/official-documentation/custom-ui/markup.mdx b/content/docs/ro-RO/official-documentation/custom-ui/markup.mdx
new file mode 100644
index 00000000..564110ed
--- /dev/null
+++ b/content/docs/ro-RO/official-documentation/custom-ui/markup.mdx
@@ -0,0 +1,226 @@
+---
+title: Markup
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# Markup
+
+## Markup
+
+An element is the basic building block of a user interface. There are various types of elements with different properties, which are documented below.
+
+Here's what the syntax looks like:
+
+```
+// Basic declaration of an element
+// with its Anchor property set to attach on all sides of its parent
+// with 10 pixels of margin
+Group { Anchor: (Left: 10, Top: 10, Right: 10, Bottom: 10); }
+
+Group { Anchor: (Full: 10); } // More concise version
+
+// Declaration of a Label with a name
+// (can be used to access the element from game code)
+Label #MyLabel {
+  Style: LabelStyle(FontSize: 16); // or just Style: (FontSize: 16), type can be inferred.
+  Text: "Hi! I am text.";
+}
+
+// Declaration of a Group containing 2 children
+// You can use FlexWeight to distribute any left-over space after explicit widths/heights have been subtracted
+Group {
+  LayoutMode: Left;
+  Label { Text: "Child 1"; FlexWeight: 2; }
+  Label { Text: "Child 2"; FlexWeight: 1; }
+}
+```
+
+### Documents
+
+A UI document (_.ui_ file) contains trees of elements. There can be multiple root elements.
+
+### Named Expressions
+
+Named expressions can be declared at any level of a document (including at the root) and will be scoped to that subtree, though they need to be declared at the top of the block.
+
+```
+// Example of named expressions, declared and used with @ prefix
+@Title = "Hytale";
+@ExtraSpacing = 5;
+
+Label {
+  Text: @Title;
+  Style: (LetterSpacing: 2 + @ExtraSpacing);
+}
+```
+
+You can use the spread operator `...` to reuse a named expression while overriding some of its fields:
+
+```
+@MyBaseStyle = LabelStyle(FontSize: 24, LetterSpacing: 2);
+
+Label {
+  Style: (...@MyBaseStyle, FontSize: 36);
+}
+```
+
+You can even layer multiple named expressions like so:
+
+```
+@TitleStyle = LabelStyle(FontSize: 24, HorizontalAlignment: Center);
+@SpacedTextStyle = LabelStyle(LetterSpacing: 2);
+
+Label {
+  Style: (...@BigTextStyle, ...@SpacedTextStyle);
+}
+```
+
+#### Document references
+
+A document can reference another document and access its named expressions.
+
+```
+// Document references are defined with $ prefix
+$Common = "../Common.ui";
+
+TextButton {
+  Style: $Common.@DefaultButtonStyle;
+}
+```
+
+### Templates
+
+You can declare a reusable bit of interface as a named expression and then instantiate it as many times as you want in the tree while customizing it.
+
+You can override local named expressions as well as insert additional children at any point in the template tree. However, local named expressions must be defined at the very top of the block, before properties and child elements.
+
+```
+// This is the template
+@Row = Group {
+  Anchor: (Height: 50);
+  Label #Label { Anchor: (Left: 0, Width: 100); Text: @LabelText; }
+  Group #Content { Anchor: (Left: 100); }
+};
+
+// Here we'll be using it twice in the document tree
+Group #Rows {
+  LayoutMode: TopScrolling;
+
+  @Row #MyFirstRow {
+    @LabelText = "First row";
+    #Content { TextInput {} }
+  }
+
+  @Row #MySecondRow {
+    @LabelText = "Second row";
+  }
+}
+```
+
+### Property Types
+
+#### Basic Types
+
+- **Boolean**
+  - `Visible: false;`
+  - `Visible: true;`
+- **Int**
+  - `Height: 20;`
+- **Float, Double, Decimal**
+  - `Min: 0.2;`
+- **String**
+  - `Text: "Hi!";`
+- **Char**
+  - `PasswordChar: "*";`
+  - _Note: The syntax is the same as a string, however a value of this type cannot contain more than one character!_
+- **Color**
+  - `Background: #ffffff;`&#x20;
+- **Objects**
+  - `Style: (Background: #ffffff)`
+- **Array**&#x20;
+  - `TextSpans: [(Text: "Hi", IsBold: true)]`
+
+#### Translations
+
+Translation keys can be referenced anywhere in markup where you can provide a string, and they are then converted to a string when an element gets instantiated.
+
+**Example:**
+
+```
+Label {
+  Text: %ui.general.cancel;
+}
+```
+
+#### Colors
+
+A color literal can be written as follows:
+
+- `#rrggbb`: 6-digit hexadecimal representation for red, green, blue (fully opaque)
+- `#rrggbb(a.a)`: 6-digit hexadecimal representation for red, green, blue with alpha between 0 and 1
+- `#rrggbbaa`: 8-digit hexadecimal representation for red, green, blue and alpha
+
+```
+Group {
+  Background: #000000(0.3);
+}
+```
+
+<Callout>
+  The `#rrggbb(a.a)` format is prefered over the `#rrggbbaa` format for
+  readability reasons.
+</Callout>
+
+#### Font Name
+
+Font names can be referenced directly by their string ID. Internally this is using a custom type called `UIFontName`, however strings will be converted automatically to this type in markup.
+
+```
+Label {
+  Text: "Hi";
+  Style: (FontName: "Secondary");
+}
+```
+
+**Available Font Names**
+
+- _Default_ - This is the default font that is used for most text and is always used unless a different option has been specified
+- _Secondary_ - This font is mostly used for headlines or elements that are supposed to stick out
+- _Mono_ - This is only used for development; For things such as profiling or error overlays.
+
+#### Path
+
+We can reference other UI assets with the `UIPath` type. Similar to `UIFontName`_,_ Strings are automatically converted to a `UIPath`. Paths are always relative to the file where they have been declared in. Looking up _MyButton.png_ in _Menu/MyAwesomeMenu.ui_ will result in _Menu/MyButton.png_. If you want to reference a file that is in a parent folder you can go back one directory by writing two dots (_../MyButton.png_).
+
+The markup syntax of a `UIPath` is the same as a String. (e.g. `Path: "Test.png"`)
+
+Here are some more examples:
+
+| UIPath             | .ui File                              | Resulting Path    |
+| ------------------ | ------------------------------------- | ----------------- |
+| MyButton.png       | Menu/MyAwesomeMenu.ui                 | Menu/MyButton.png |
+| ../MyButton.png    | Menu/MyAwesomeMenu.ui                 | MyButton.png      |
+| ../../MyButton.png | Menu/Popup/Templates/MyAwesomeMenu.ui | Menu/MyButton.png |
+
+#### Objects
+
+Objects contain a set of properties. In this example we are assigning an Anchor object to the _Anchor_ property:
+
+```
+Group {
+  Anchor: (
+   Height: 10,
+   Width: 20
+ );
+}
+```
+
+You can find all objects that can be used in markup [here](type-documentation#elements).
+
+## Visual Studio Code Extension
+
+There is an official extension for Visual Studio Code which adds syntax highlighting for .ui files. You can find it [here](https://marketplace.visualstudio.com/items?itemName=HypixelStudiosCanadaInc.vscode-hytaleui).
diff --git a/content/docs/ro-RO/official-documentation/custom-ui/type-documentation/index.mdx b/content/docs/ro-RO/official-documentation/custom-ui/type-documentation/index.mdx
new file mode 100644
index 00000000..69cea406
--- /dev/null
+++ b/content/docs/ro-RO/official-documentation/custom-ui/type-documentation/index.mdx
@@ -0,0 +1,127 @@
+---
+title: Type Documentation
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# Type Documentation
+
+This is a generated list of UI elements accessible by markup. More information about the User Interface framework can be found in the main documentation.
+
+## Elements
+
+- [ActionButton](type-documentation/elements/actionbutton)
+- [AssetImage](type-documentation/elements/assetimage)
+- [BackButton](type-documentation/elements/backbutton)
+- [BlockSelector](type-documentation/elements/blockselector)
+- [Button](type-documentation/elements/button)
+- [CharacterPreviewComponent](type-documentation/elements/characterpreviewcomponent)
+- [CheckBox](type-documentation/elements/checkbox)
+- [CheckBoxContainer](type-documentation/elements/checkboxcontainer)
+- [CircularProgressBar](type-documentation/elements/circularprogressbar)
+- [CodeEditor](type-documentation/elements/codeeditor)
+- [ColorOptionGrid](type-documentation/elements/coloroptiongrid)
+- [ColorPicker](type-documentation/lements/colorpicker)
+- [ColorPickerDropdownBox](type-documentation/elements/colorpickerdropdownbox)
+- [CompactTextField](type-documentation/elements/compacttextfield)
+- [DropdownBox](type-documentation/elements/dropdownbox)
+- [DropdownEntry](type-documentation/elements/dropdownentry)
+- [DynamicPane](type-documentation/elements/dynamicpane)
+- [DynamicPaneContainer](type-documentation/elements/dynamicpanecontainer)
+- [FloatSlider](type-documentation/elements/floatslider)
+- [FloatSliderNumberField](type-documentation/elements/floatslidernumberfield)
+- [Group](type-documentation/elements/group)
+- [HotkeyLabel](type-documentation/elements/hotkeylabel)
+- [ItemGrid](type-documentation/elements/itemgrid)
+- [ItemIcon](type-documentation/elements/itemicon)
+- [ItemPreviewComponent](type-documentation/elements/itempreviewcomponent)
+- [ItemSlot](type-documentation/elements/itemslot)
+- [ItemSlotButton](type-documentation/elements/itemslotbutton)
+- [Label](type-documentation/elements/label)
+- [LabeledCheckBox](type-documentation/elements/labeledcheckbox)
+- [MenuItem](type-documentation/elements/menuitem)
+- [MultilineTextField](type-documentation/elements/multilinetextfield)
+- [NumberField](type-documentation/elements/numberfield)
+- [Panel](type-documentation/elements/panel)
+- [ProgressBar](type-documentation/elements/progressbar)
+- [ReorderableList](type-documentation/elements/reorderablelist)
+- [ReorderableListGrip](type-documentation/elements/reorderablelistgrip)
+- [SceneBlur](type-documentation/elements/sceneblur)
+- [Slider](type-documentation/elements/slider)
+- [SliderNumberField](type-documentation/elements/slidernumberfield)
+- [Sprite](type-documentation/elements/sprite)
+- [TabButton](type-documentation/elements/tabbutton)
+- [TabNavigation](type-documentation/elements/tabnavigation)
+- [TextButton](type-documentation/elements/textbutton)
+- [TextField](type-documentation/elements/textfield)
+- [TimerLabel](type-documentation/elements/timerlabel)
+- [ToggleButton](type-documentation/elements/togglebutton)
+
+## Property Types
+
+- [Anchor](type-documentation/property-types/anchor)
+- [BlockSelectorStyle](type-documentation/property-types/blockselectorstyle)
+- [ButtonSounds](type-documentation/property-types/buttonsounds)
+- [ButtonStyle](type-documentation/property-types/buttonstyle)
+- [ButtonStyleState](type-documentation/property-types/buttonstylestate)
+- [CheckBoxStyle](type-documentation/property-types/checkboxstyle)
+- [CheckBoxStyleState](type-documentation/property-types/checkboxstylestate)
+- [ClientItemStack](type-documentation/property-types/clientitemstack)
+- [ColorOptionGridStyle](type-documentation/property-types/coloroptiongridstyle)
+- [ColorPickerDropdownBoxStateBackground](type-documentation/property-types/colorpickerdropdownboxstatebackground)
+- [ColorPickerDropdownBoxStyle](type-documentation/property-types/colorpickerdropdownboxstyle)
+- [ColorPickerStyle](type-documentation/property-types/colorpickerstyle)
+- [DropdownBoxSearchInputStyle](type-documentation/property-types/dropdownboxsearchinputstyle)
+- [DropdownBoxSounds](type-documentation/property-types/dropdownboxsounds)
+- [DropdownBoxStyle](type-documentation/property-types/dropdownboxstyle)
+- [InputFieldButtonStyle](type-documentation/property-types/inputfieldbuttonstyle)
+- [InputFieldDecorationStyle](type-documentation/property-types/inputfielddecorationstyle)
+- [InputFieldDecorationStyleState](type-documentation/property-types/inputfielddecorationstylestate)
+- [InputFieldIcon](type-documentation/property-types/inputfieldicon)
+- [InputFieldStyle](type-documentation/property-types/inputfieldstyle)
+- [ItemGridSlot](type-documentation/property-types/itemgridslot)
+- [ItemGridStyle](type-documentation/property-types/itemgridstyle)
+- [LabeledCheckBoxStyle](type-documentation/property-types/labeledcheckboxstyle)
+- [LabeledCheckBoxStyleState](type-documentation/property-types/labeledcheckboxstylestate)
+- [LabelSpan](type-documentation/property-types/labelspan)
+- [LabelStyle](type-documentation/property-types/labelstyle)
+- [NumberFieldFormat](type-documentation/property-types/numberfieldformat)
+- [Padding](type-documentation/property-types/padding)
+- [PatchStyle](type-documentation/property-types/patchstyle)
+- [PopupStyle](type-documentation/property-types/popupstyle)
+- [ScrollbarStyle](type-documentation/property-types/scrollbarstyle)
+- [SliderStyle](type-documentation/property-types/sliderstyle)
+- [SoundStyle](type-documentation/property-types/soundstyle)
+- [SpriteFrame](type-documentation/property-types/spriteframe)
+- [SubMenuItemStyle](type-documentation/property-types/submenuitemstyle)
+- [SubMenuItemStyleState](type-documentation/property-types/submenuitemstylestate)
+- [Tab](type-documentation/property-types/tab)
+- [TabNavigationStyle](type-documentation/property-types/tabnavigationstyle)
+- [TabStyle](type-documentation/property-types/tabstyle)
+- [TabStyleState](type-documentation/property-types/tabstylestate)
+- [TextButtonStyle](type-documentation/property-types/textbuttonstyle)
+- [TextButtonStyleState](type-documentation/property-types/textbuttonstylestate)
+- [TextTooltipStyle](type-documentation/property-types/texttooltipstyle)
+- [ToggleButtonStyle](type-documentation/property-types/togglebuttonstyle)
+- [ToggleButtonStyleState](type-documentation/property-types/togglebuttonstylestate)
+
+## Enums
+
+- [ActionButtonAlignment](type-documentation/enums/actionbuttonalignment)
+- [CodeEditorLanguage](type-documentation/enums/codeeditorlanguage)
+- [ColorFormat](type-documentation/enums/colorformat)
+- [DropdownBoxAlign](type-documentation/enums/dropdownboxalign)
+- [InputFieldButtonSide](type-documentation/enums/inputfieldbuttonside)
+- [InputFieldIconSide](type-documentation/enums/inputfieldiconside)
+- [ItemGridInfoDisplayMode](type-documentation/enums/itemgridinfodisplaymode)
+- [LabelAlignment](type-documentation/enums/labelalignment)
+- [LayoutMode](type-documentation/enums/layoutmode)
+- [MouseWheelScrollBehaviourType](type-documentation/enums/mousewheelscrollbehaviourtype)
+- [ProgressBarAlignment](type-documentation/enums/progressbaralignment)
+- [ProgressBarDirection](type-documentation/enums/progressbardirection)
+- [ResizeType](type-documentation/enums/resizetype)
+- [TimerDirection](type-documentation/enums/timerdirection)
+- [TooltipAlignment](type-documentation/enums/tooltipalignment)
diff --git a/content/docs/ro-RO/official-documentation/npc/2-getting-started-with-templates.mdx b/content/docs/ro-RO/official-documentation/npc/2-getting-started-with-templates.mdx
index 91081ca1..99d078e0 100644
--- a/content/docs/ro-RO/official-documentation/npc/2-getting-started-with-templates.mdx
+++ b/content/docs/ro-RO/official-documentation/npc/2-getting-started-with-templates.mdx
@@ -9,7 +9,7 @@ authors:
 
 There are no hard and fast rules for making a start on a template. I like to duplicate **BlankTemplate** and start from there because it already provides the basic structure of the file.
 
-This leaves me with the following template (`Template_Goblin_Ogre.json`): (note: the file could be looking different in the current version of the game)
+This leaves me with the following template (`Template_Goblin_Ogre.json`): (**note: the file could be looking different in the current version of the game**)
 
 ```json
 {
@@ -33,7 +33,7 @@ This leaves me with the following template (`Template_Goblin_Ogre.json`): (note:
     }
   },
   "Appearance": { "Compute": "Appearance" },
-  "DropList": { "Compute": "Droplist" },
+  "DropList": { "Compute": "DropList" },
   "MaxHealth": { "Compute": "MaxHealth" },
   "MotionControllerList": [
     {
@@ -65,10 +65,10 @@ And the following variant (`Goblin_Ogre.json`) next to the template. There's a t
   "Type": "Variant",
   "Reference": "Template_Goblin_Ogre",
   "Modify": {
-    "Appearance": "Goblin_Ogre",
+    "Appearance": "Goblin",
     "MaxHealth": 124
   }
 }
 ```
 
-Our artists have defined the `Goblin_Ogre` appearance already so I'm going to use that.
+Our artists have not yet finished animations for the `Goblin_Ogre`, for that sake of the tutorial I am going to use appearance `Goblin`, because it offers a more complete set of animations that we will need.
diff --git a/content/docs/ro-RO/official-documentation/worldgen/pack-tutorial/asset-packs.mdx b/content/docs/ro-RO/official-documentation/worldgen/pack-tutorial/asset-packs.mdx
index 38809fad..dcf1f3b9 100644
--- a/content/docs/ro-RO/official-documentation/worldgen/pack-tutorial/asset-packs.mdx
+++ b/content/docs/ro-RO/official-documentation/worldgen/pack-tutorial/asset-packs.mdx
@@ -9,13 +9,13 @@ authors:
 
 <OfficialDocumentationNotice />
 
-# How to modify Hytale
+# How to modify Hytale?
 
-## What's an Asset Pack
+## What's an Asset Pack?
 
-Hytales gameplay is driven by assets in the game that can be modified by creators. Asset Packs are our solution to let you override or add features to the base game with your own work. These can in the form of zip files of folders, which contain a custom set of assets. This is not the only way for a creator to change Hytale but this is the most accessible form.;
+Hytales gameplay is driven by assets in the game that can be modified by creators. Asset Packs are our solution to let you override or add features to the base game with your own work. These can be the form of zip files of folders, which contain a custom set of assets. This is not the only way for a creator to change Hytale but this is the most accessible form.;
 
-### How do I make an Asset Pack
+### How do I make an Asset Pack?
 
 <video controls className="my-6 aspect-video w-full rounded-lg border">
   <source src="https://cdn.internal.hytalemodding.dev/guides/official/how-to-asset-pack.mp4" type="video/mp4" />
@@ -48,7 +48,7 @@ An asset pack is typically a zip or folder, with a `manifest.json` inside. This
 }
 ```
 
-### Where are they stored
+### Where are they stored?
 
 Asset Packs are stored with other mods in the Mods folder.
 
@@ -76,7 +76,7 @@ C:\Users\<user>\AppData\Roaming\Hytale\UserData\Saves\New World 5\mods
 
 When you have Asset Packs or Mods installed, these will appear in the New World menu under the Options menu.;
 
-### How do I change an existing asset
+### How do I change an existing asset?
 
 <video controls className="my-6 aspect-video w-full rounded-lg border">
   <source src="https://cdn.internal.hytalemodding.dev/guides/official/how-to-asset.mp4" type="video/mp4" />
diff --git a/content/docs/ro-RO/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx b/content/docs/ro-RO/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx
index 44528376..24e628b5 100644
--- a/content/docs/ro-RO/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx
+++ b/content/docs/ro-RO/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx
@@ -106,7 +106,7 @@ If a BaseHeight is provided, the TopY and BottomY values are relative to the Bas
 
 Applies a Material Provider slot on a set of horizontal stripes of blocks of varying thickness and position. Below is an example image of basalt stripes into a stone cliff.
 
-{/* ![](https://540086904-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F7KAmBkOg6d13nZCkf9ku%2Fuploads%2FbcxO9LpArn8gPCaBwFg5%2Funknown.png?alt=media&token=1c72b67a-8253-4d03-8c64-1ad5f6830050) */}
+![Example of basalt stripes](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/basalt-stripes-example.png)
 
 #### Parameters:
 
diff --git a/content/docs/ro-RO/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx b/content/docs/ro-RO/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx
index 5e34acd4..a4418473 100644
--- a/content/docs/ro-RO/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx
+++ b/content/docs/ro-RO/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx
@@ -294,7 +294,7 @@ Combines all the positions into a single Positioins field.
 
 ---
 
-### SimpleHoritontal
+### SimpleHorizontal
 
 Keeps only the positions that are within the provided range.
 
diff --git a/content/docs/ro-RO/official-documentation/worldgen/worldgen-tutorial/README.mdx b/content/docs/ro-RO/official-documentation/worldgen/worldgen-tutorial/README.mdx
new file mode 100644
index 00000000..5f66d245
--- /dev/null
+++ b/content/docs/ro-RO/official-documentation/worldgen/worldgen-tutorial/README.mdx
@@ -0,0 +1,166 @@
+---
+title: How to edit and create Biomes
+description: Explores where world generation assets can be found and how to edit them.
+---
+
+### Where are the Assets
+
+World generation assets are kept in the HytaleGenerator directory within the assets.
+
+```
+/Server/HytaleGenerator/
+```
+
+<div className="flex flex-row rounded-lg border p-4">
+  <div className="flex-1/2 border-r pr-4">
+    ```
+    /Biomes
+    ```
+
+    Biome assets, with content configurations.
+  </div>
+
+  <div className="flex-1/2 pl-4">
+    ```
+    /WorldStructure
+    ```
+
+    Generator files that define which biomes spawn together.
+  </div>
+</div>
+
+<div className="flex flex-row rounded-lg border p-4">
+  <div className="flex-1/2 border-r pr-4">
+    ```
+    /Density
+    ```
+
+    Density assets that can be referenced by any other assets.
+  </div>
+
+  <div className="flex-1/2 pl-4">
+    ```
+    /Assignments
+    ```
+
+    Prop assets that can be referenced by any Biome assets.
+  </div>
+</div>
+
+***
+
+An example of this structure can be found bellow, packed in an asset pack with the instance configuration.
+
+[https://drive.google.com/file/d/1sIz_CluANIIe3n8vNiOi-4PQdeqCO0qY/view?usp=drive_link](https://drive.google.com/file/d/1sIz_CluANIIe3n8vNiOi-4PQdeqCO0qY/view?usp=drive_link)
+
+<Callout>
+  Ensure you place your asset pack in the correct directory, under Mods.
+</Callout>
+
+### How to visit our worlds
+
+https://drive.google.com/file/d/1BJurxyj-taE-PXWm04bk7Dl6X7ZHTH92/view?usp=sharing
+
+#### Requirements
+
+- You must be an **Operator** in the world.
+  - To do this, run <mark style="color:$danger;">`/op self`</mark>
+- You must be in **Creative mode**.
+  - Press the <mark style="color:$danger;">`O`</mark> key, O for Orange.&#x20;
+
+The generation assets define a set of generators but on their own you cannot visit these. Currently you require an Instance with a generator that will allow you to visit your work.
+
+```
+/Server/Instances/
+```
+
+Instances are separate worlds that players can join using the `/instances` command. Each instance has an `Instance.bson` configuration asset that specifies which generator to use, among other worldly settings.
+
+```json
+{
+  "WorldGen": {
+    "Type": "HytaleGenerator",
+    "WorldStructure": "Basic",
+    "playerSpawn" : {
+      "X" : 123,
+      "Y" : 480,
+      "Z" : 10000,
+      "Pitch" : 0,
+      "Yaw" : 0,
+      "Roll" : 0
+    }
+  }
+}
+```
+
+<Callout>
+  You can create custom instances for different world structures and biomes as you need them.
+</Callout>
+
+### How to edit Biomes
+
+<video>
+  <source src="https://cdn.internal.hytalemodding.dev/guides/official/How-to-edit-Biomes.mp4" type="video/mp4" />
+</video>
+
+We currently use the Hytale Node Editor when editing world generation assets. This can be accessed while in-game from the Content Creation menu when pressing B. The node editor is then found under the asset editor dropdown on the upper left.&#x20;
+
+![Node Editor 1](/assets/official-documentation/worldgen/worldgen-tutorial/biomes/node-editor-1.png)
+
+Once you have the Hytale Node Editor open, through the file menu you can open Biomes by navigating to the Biomes directory and selecting one from your pack.&#x20;
+
+```
+/Server/HytaleGenerator/Biomes/
+```
+
+### Biome Asset Structure
+
+Every Biome has a root Biome node, this node splits into 5 structures. This is covered briefly but more information on each field can be found on the World Generation Concepts page.
+
+![Node Editor 2](/assets/official-documentation/worldgen/worldgen-tutorial/biomes/node-editor-2.png)
+
+<Callout>
+  Each biome is for the most part self contained, meaning it has control over what appears with the biome. The only exception to this are Base Heights.
+</Callout>
+
+<Tabs>
+  <Tab value="Terrain">
+    Mathematical function nodes that calculate the physical shape of the Biome's terrain.
+  </Tab>
+
+  <Tab value="Materials">
+    Logical nodes that determine what materials (blocks) make up a Biome's terrain.
+  </Tab>
+
+  <Tab value="Props">
+    Function nodes that add objects like prefabs and decorations to the terrain.
+  </Tab>
+
+  <Tab value="Environments">
+    Logical nodes that determine the environment asset at a given coordinate within the biome. This asset determines things like weather, NPC spawns, and sounds.
+  </Tab>
+
+  <Tab value="Tints">
+    Logical function nodes that determine a colour code that can be used by certain blocks in the world. Typically this will be grasses and soils.
+  </Tab>
+</Tabs>
+
+### How to preview your work
+
+[https://drive.google.com/file/d/1mNcHn9LhFnWDF0DzWFH6_YllmKAUvUry/view?t=6](https://drive.google.com/file/d/1mNcHn9LhFnWDF0DzWFH6_YllmKAUvUry/view?t=6)
+
+Once you are in an Instance world with the Hytale Generator active you will only be able to see your work by generating new chunks. There are a few ways to do this.
+
+The viewport command selects an area around the Player that will live reload as you make changes to the generator.&#x20;
+
+```
+/viewport --radius 5 
+```
+
+You can also create a new world to show your changes.&#x20;
+
+```
+/instances spawn <instance> 
+```
+
+The last option is to simply fly south, new chunks will generate with the changes made.
diff --git a/content/docs/ro-RO/quick-start.mdx b/content/docs/ro-RO/quick-start.mdx
index 653644f4..249d803a 100644
--- a/content/docs/ro-RO/quick-start.mdx
+++ b/content/docs/ro-RO/quick-start.mdx
@@ -9,3 +9,8 @@ Welcome to the Hytale modding documentation! Here you'll find everything you nee
 * [Setting up your dev environment](./guides/plugin/setting-up-env)
 * [Entity Component System (ECS)](./guides/ecs/entity-component-system)
 * [Publishing your mod](./publishing)
+
+### Useful Links
+
+* [Kaupenjoe's Modding Videos](https://www.youtube.com/@ModdingByKaupenjoe)
+* [TroubleDEV's Modding Videos](https://www.youtube.com/@TroubleDEV)
diff --git a/content/docs/ro-RO/server/argtypes.mdx b/content/docs/ro-RO/server/argtypes.mdx
new file mode 100644
index 00000000..e54a442e
--- /dev/null
+++ b/content/docs/ro-RO/server/argtypes.mdx
@@ -0,0 +1,61 @@
+---
+title: ArgTypes
+description: Available ArgTypes
+icon: List
+full: true
+authors:
+  - name: Valeena
+---
+
+| Name                        | Target Class                           | Description                                                                                                                               |   |
+| :-------------------------- | :------------------------------------- | :---------------------------------------------------------------------------------------------------------------------------------------- | - |
+| Boolean                     | java.lang.Boolean                      | A 'true' or 'false' input                                                                                                                 |   |
+| Integer                     | java.lang.Integer                      | A whole number                                                                                                                            |   |
+| String                      | java.lang.String                       | Words, text, numbers, letters. To input more than one word at a time, you may need to wrap it with double quotes (`"my fancy sentence"`). |   |
+| Float                       | java.lang.Float                        | A floating-pointer number                                                                                                                 |   |
+| Double                      | java.lang.Double                       | A decimal number                                                                                                                          |   |
+| UUID                        | java.util.UUID                         | A UUID (Universally Unique IDentifier)                                                                                                    |   |
+| Player_UUID                 | java.util.UUID                         | A UUID or an online player username                                                                                                       |   |
+| Game_Profile_Lookup_Async   | ProfileServiceClient.PublicGameProfile | A player UUID or username. If not found locally, performs a remote lookup via the Profile Service.                                        |   |
+| Relative_Double_Coord       | Coord                                  | An x, y, or z coordinate as a decimal, optionally relative by specifying a tilde (~) in front of the number                               |   |
+| Relative_Int_Coord          | IntCoord                               | An x, y, or z coordinate as a whole number, optionally relative by specifying a tilde (~) in front of the number                          |   |
+| Relative_Integer            | RelativeInteger                        | A tilde to mark an integer relative to a base                                                                                             |   |
+| Relative_Float              | RelativeFloat                          | A tilde to mark a float relative to a base                                                                                                |   |
+| Player_Ref                  | PlayerRef                              | A UUID or an online player's username                                                                                                     |   |
+| World                       | World                                  | A world folder name                                                                                                                       |   |
+| Model_Asset                 | ModelAsset                             | A reference to an Asset of type Model                                                                                                     |   |
+| Weather_Asset               | Weather                                | A reference to an Asset of type Weather                                                                                                   |   |
+| Interaction_Asset           | Interaction                            | A reference to an Asset of type Interaction                                                                                               |   |
+| Root_Interaction_Asset      | RootInteraction                        | A reference to an Asset of type Root Interaction                                                                                          |   |
+| Effect_Asset                | EntityEffect                           | A refernece to an Asset of type EntityEffect                                                                                              |   |
+| Environment_Asset           | Environment                            | A reference to an Asset of type Environment                                                                                               |   |
+| Item_Asset                  | Item                                   | A reference to an Asset of type Item                                                                                                      |   |
+| Block_Type_Asset            | BlockType                              | A reference to an Asset of type BlockType                                                                                                 |   |
+| Particle_System             | ParticleSystem                         | A reference to an Asset of type ParticleSystem                                                                                            |   |
+| Hitbox_Collision_Config     | HitboxCollisionConfig                  | A reference to an Asset of type HitboxCollisionConfig                                                                                     |   |
+| Repulsion_Config            | RepulsionConfig                        | A reference to an Asset of type RepulsionConfig                                                                                           |   |
+| Sound_Event_Asset           | SoundEvent                             | A reference to an Asset of type SoundEvent                                                                                                |   |
+| Ambiance_Fx_Asset           | AmbianceFX                             | A reference to an Asset of type AmbianceFX                                                                                                |   |
+| Sound_Category              | SoundCategory                          | A sound category (sfx, music, ambient, ui)                                                                                                |   |
+| Entity_ID                   | `ArgWrapper<EntityWrappedArg, UUID>`   | A UUID representing an entity id                                                                                                          |   |
+| Integer_Comparison_Operator | IntegerComparisonOperator              | A mathematical sign for integer comparison                                                                                                |   |
+| Integer_Operation           | IntegerOperation                       | A mathematical sign for performing an operation                                                                                           |   |
+| Int_Range                   | `Pair<Integer, Integer>`               | Two integers representing a minimum and maximum of a range                                                                                |   |
+| Relative_Int_Range          | RelativeIntRange                       | Two integers representing a minimum and maximum of a range                                                                                |   |
+| Vector2I                    | Vector2i                               | Two integers, generally corresponding to x/z axis                                                                                         |   |
+| Vector3I                    | Vector3i                               | Three integers, generally corresponding to x/y/z axis                                                                                     |   |
+| Relative_Vector3I           | RelativeVector3i                       | Three optionally relative integers, generally corresponding to x/y/z axis                                                                 |   |
+| Relative_Block_Position     | RelativeIntPosition                    | A position with three integer coordinates, representing a block's location in world space.                                                |   |
+| Relative_Position           | Relative                               | A position with three decimal coordinates, representing a location in world space.                                                        |   |
+| Relative_Chunk_Position     | RealtiveChunkPosition                  | A position with two integer coordinates (x, z), representing a chunk's location.                                                          |   |
+| Rotation                    | Vector3f                               | A rotation with three coordinates, representing the pitch, yaw, and roll respectively                                                     |   |
+| Block_Type_Key              | String                                 | A block type                                                                                                                              |   |
+| Block_ID                    | Integer                                | A block type, converted to an int id                                                                                                      |   |
+| Color                       | Integer                                | A color value in hex format, hex integer, or decimal integer                                                                              |   |
+| Weighted_Block_Type         | `Pair<Integer, String>`                | A weight corresponding to a blocktype                                                                                                     |   |
+| Weighted_Block_Entry        | String                                 | A block with optional weight prefix                                                                                                       |   |
+| Block_Pattern               | BlockPattern                           | A list of blocks with optional weights                                                                                                    |   |
+| Individual_Block_Mask       | BlockMask                              | Create a block mask using symbols and block names                                                                                         |   |
+| Block_Mask                  | BlockMask                              | A tick rate value (e.g., 30tps, 33ms, or 30)                                                                                              |   |
+| Tick_Rate                   | Integer                                | A list of block masks that combine together                                                                                               |   |
+| Game_Mode                   | GameMode                               | GameMode                                                                                                                                  |   |
diff --git a/content/docs/ro-RO/server/interaction-reference.mdx b/content/docs/ro-RO/server/interaction-reference.mdx
new file mode 100644
index 00000000..6c0d01b3
--- /dev/null
+++ b/content/docs/ro-RO/server/interaction-reference.mdx
@@ -0,0 +1,1586 @@
+---
+title: Interactions
+description: A list of most Interaction types provided by Hypixel, along with the meaning of their fields, and how they fit together.
+icon: List
+authors:
+  - name: Stephen Baynham
+    url: https://github.com/cannibalvox
+---
+
+### The Interaction Base Type
+
+All interactions of every type below are inherited from Interaction and have these fields.
+
+**Interaction Fields**
+
+| Field Name                | Type                                                                 | Required? | Notes                                                                                                                                                                                                                       |
+| ------------------------- | -------------------------------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| ViewDistance              | `Double`<br />(Default: 96.0)                                        | **No**    | Distance in blocks at which other players can see the effects from this interaction.                                                                                                                                        |
+| Effects                   | `InteractionEffects`                                                 | **No**    | Sound, animations, and particle effects that should trigger when this interaction begins executing.                                                                                                                         |
+| HorizontalSpeedMultiplier | `Float`<br />(Default: 1.0)                                          | **No**    | Multiplier applied to the User entity's movement speed while this interaction is executing                                                                                                                                  |
+| RunTime                   | `Float`                                                              | **No**    | If provided, this interaction will continue executing for at least this long before the interaction chain moves onto the next interaction.                                                                                  |
+| CancelOnItemChange        | `Boolean`<br />(Default: true)                                       | **No**    | If true, this interaction will be cancelled if the User entity's held item changes during execution. This can happen either due to the selected hotbar slot changing or the contents of the item's inventory slot changing. |
+| Rules                     | `InteractionRules`                                                   | **Yes**   | If provided, adds additional limitations and cancellation conditions to this interaction.                                                                                                                                   |
+| Settings                  | `Map`<br />(Key Type: `GameMode`, Value Type: `InteractionSettings`) | **No**    | If provided, adds additional per-GameMode settings to the interaction.                                                                                                                                                      |
+| Camera                    | `InteractionCameraSettings`                                          | **No**    | Arrays of camera motion keyframes for cutscenes and reveals.                                                                                                                                                                |
+
+**GameMode Values**
+
+- `Creative`: The game is currently in Creative Mode
+- `Adventure`: The game is currently in Adventure Mode
+
+**InteractionEffects Fields**
+
+| Field Name               | Type                                              | Required? | Notes                                                                                                                                                 |
+| ------------------------ | ------------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Particles                | `Array`<br />(Element Type: `ModelParticle`)      | **No**    | Particle systems to activate when this interaction begins if the player is in third-person mode.                                                      |
+| FirstPersonParticles     | `Array`<br />(Element Type: `ModelParticle`)      | **No**    | Particle systems to activate when this interaction begins if the player is in first-person mode.                                                      |
+| WorldSoundEventId        | `Asset`<br />(Asset Type: `SoundEvent`)           | **No**    | A sound to play in the world at the User entity's location when this interaction begins.<br />**The SoundEvent must be single-channel (mono) sound.** |
+| LocalSoundEventId        | `Asset`<br />(Asset Type: `SoundEvent`)           | **No**    | A 2D sound to play for the User entity when this interaction begins. Ignored if the User entity is not a player.                                      |
+| Trails                   | `Array`<br />(Element Type: `ModelTrail`)         | **No**    | Trail effects to activate on the User entity when this interaction begins.                                                                            |
+| WaitForAnimationToFinish | `Boolean`<br />(Default: false)                   | **No**    | If true, this interaction will continue executing for at least the length of any animations in this InteractionEffects object.                        |
+| ItemPlayerAnimationsId   | `Asset`<br />(Asset Type: `ItemPlayerAnimations`) | **No**    | If provided, the User entity will use this ItemPlayerAnimations set while this interaction is executing.                                              |
+| ItemAnimationId          | `String`                                          | **No**    | Id of an animation to trigger when this interaction begins executing.<br />**This animation id is not validated on server start.**                    |
+| ClearAnimationOnFinish   | `Boolean`<br />(Default: false)                   | **No**    | If true, animations triggered by this interaction will be halted when the interaction completes.                                                      |
+| ClearSoundEventOnFinish  | `Boolean`<br />(Default: false)                   | **No**    | If true, sounds triggered by this interaction will be halted when the interaction completes.                                                          |
+| CameraEffect             | `Asset`<br />(Asset Type: `CameraEffect` )        | **No**    | If provided, the CameraEffect will be applied while this interaction is executing.                                                                    |
+| MovementEffects          | `MovementEffects`                                 | **No**    | If provided, apply the movement effects to the User entity while this interaction is executing.                                                       |
+| StartDelay               | `Float`<br />(Default: 0.0f)                      | **No**    | The interaction will wait this many seconds before triggering the effects in this object.                                                             |
+
+**InteractionRules Fields**
+
+| Field Name          | Type                                                                                                | Required? | Notes                                                                                                                                                                                                                                     |
+| ------------------- | --------------------------------------------------------------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| BlockedBy           | `Array`<br />(Element Type: `InteractionType`)<br />(Default: Based on the chain's InteractionType) | **No**    | If provided, this RootInteraction cannot be executed while interaction chains of the provided types are executing.<br />**This field only functions for rules attached to a RootInteraction. It has no effect on an Interaction.**        |
+| Blocking            | `Array`<br />(Element Type: `InteractionType`)                                                      | **No**    | If provided, interaction chains with the specified InteractionTypes cannot be executed while this interaction is executing.                                                                                                               |
+| InterruptedBy       | `Array`<br />(Element Type: `InteractionType`)                                                      | **No**    | If provided, interaction chains with the specified InteractionTypes will cancel this interaction chain when they execute.<br />**This field only functions for rules attached to a RootInteraction. It has no effect on an Interaction.** |
+| Interrupting        | `Array`<br />(Element Type: `InteractionType`)                                                      | **No**    | If provided, interaction chains with the specified InteractionTypes will be canceled when this interaction begins.                                                                                                                        |
+| BlockedByBypass     | `String`                                                                                            | **No**    | If provided, this RootInteraction cannot be blocked by interaction chains whose RootInteraction has this value as an asset tag.                                                                                                           |
+| BlockingBypass      | `String`                                                                                            | **No**    | If provided, this interaction will not block RootInteractions that have the this value as an asset tag.                                                                                                                                   |
+| InterruptedByBypass | `String`                                                                                            | **No**    | If provided, this RootInteraction cannot be canceled by RootInteractions that have this value as an asset tag.                                                                                                                            |
+| InterruptingBypass  | `String`                                                                                            | **No**    | If provided, this interaction will not cancel interaction chains whose RootInteraction has this value as an asset tag.                                                                                                                    |
+
+**InteractionType Values**
+
+- `Primary`
+- `Secondary`
+- `Ability1`
+- `Ability2`
+- `Ability3`
+- `Use`
+- `Pick`
+- `Pickup`
+- `CollisionEnter`
+- `CollisionLeave`
+- `Collision`
+- `EntityStatEffect`
+- `SwapTo`
+- `SwapFrom`
+- `Death`
+- `Wielding`
+- `ProjectileSpawn`
+- `ProjectileHit`
+- `ProjectileMiss`
+- `ProjectileBounce`
+- `Held`
+- `HeldOffhand`
+- `Equipped`
+- `Dodge`
+- `GameModeSwap`
+
+**InteractionSettings Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                        |
+| ---------------- | ------------------------------- | --------- | -------------------------------------------------------------------------------------------- |
+| AllowSkipOnClick | `Boolean`<br />(Default: false) | **No**    | If true, the user will be able to skip this interaction by clicking shortly after it starts. |
+
+**InteractionCameraSettings Fields**
+
+| Field Name  | Type                                             | Required? | Notes                                                                                                                                                           |
+| ----------- | ------------------------------------------------ | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| FirstPerson | `Array`<br />(Element Type: `InteractionCamera`) | **No**    | A list of camera keyframes to be played if the player is in first-person.<br />**The time of each keyframe must be after the keyframe before it in the array.** |
+| ThirdPerson | `Array`<br />(Element Type: `InteractionCamera`) | **No**    | A list of camera keyframes to be played if the player is in third-person.<br />**The time of each keyframe must be after the keyframe before it in the array.** |
+
+**InteractionCamera Fields**
+
+| Field Name | Type                         | Required? | Notes                                                                                                                                       |
+| ---------- | ---------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------- |
+| Time       | `Float`<br />(Default: 0.1f) | **No**    | How long after the interaction begins executing that the camera should arrive at this keyframe.<br />**Cannot be less than or equal to 0.** |
+| Position   | `Vector3`                    | **Yes**   | Where the camera should be located when it arrives at this keyframe.                                                                        |
+| Rotation   | `Direction`                  | **Yes**   | Where the camera should be pointing when it arrives at this keyframe.                                                                       |
+
+### SimpleInteraction
+
+Most interaction types below are inherited from SimpleInteraction and have these
+fields.  If a type does not have these fields, the documentation will mention it.
+
+The purpose of SimpleInteraction is to facilitate Interaction chaining by taking different paths
+based on whether the Interaction succeeded or failed.  The circumstances under which
+a given Interaction fails are generally type-specific (and described in the documentation
+below), but all interactions will be marked failed if they are cancelled via one of the
+many, many mechanisms for doing so.
+
+It is valid to create an interaction asset of type "Simple", which can be valuable when you want to use the
+interaction fields with no additional functionality.
+
+**SimpleInteraction Fields**
+
+| Field Name | Type                                     | Required? | Notes                                                                                          |
+| ---------- | ---------------------------------------- | --------- | ---------------------------------------------------------------------------------------------- |
+| Next       | `Asset`<br />(Asset Type: `Interaction`) | **No**    | After this Interaction has finished, "Next" will be executed if this Interaction did not fail. |
+| Failed     | `Asset`<br />(Asset Type: `Interaction`) | **No**    | After this Interaction has finished, "Failed" will be executed if this Interaction failed.     |
+
+## Flow Control
+
+These are interaction types used to control the flow of an interaction chain and allow interactions
+to be composed into more complex behaviors.  These interaction types generally do not pertain to
+the game and instead pertain to the interaction system itself.
+
+### Condition
+
+This interaction will fail if one of the fields is provided but does not match the current state.
+
+**Condition Fields**
+
+| Field Name       | Type       | Required? | Notes                                                                                                                                                                                    |
+| ---------------- | ---------- | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| RequiredGameMode | `GameMode` | **No**    | If provided, the interaction will fail if the current GameMode does not match the provided value.                                                                                        |
+| Jumping          | `Boolean`  | **No**    | If provided, the interaction will fail if the player's Jumping state does not match the provided value. (i.e. if True, the player must be jumping, if False, the player must not be)     |
+| Swimming         | `Boolean`  | **No**    | If provided, the interaction will fail if the player's Swimming state does not match the provided value. (i.e. if True, the player must be swimming, if False, the player must not be)   |
+| Crouching        | `Boolean`  | **No**    | If provided, the interaction will fail if the player's Crouching state does not match the provided value. (i.e. if True, the player must be crouching, if False, the player must not be) |
+| Running          | `Boolean`  | **No**    | If provided, the interaction will fail if the player's Running state does not match the provided value. (i.e. if True, the player must be running, if False, the player must not be)     |
+| Flying           | `Boolean`  | **No**    | If provided, the interaction will fail if the player's Flying state does not match the provided value. (i.e. if True, the player must be flying, if False, the player must not be)       |
+
+**GameMode Values**
+
+- `Creative`: The game is currently in Creative Mode
+- `Adventure`: The game is currently in Adventure Mode
+
+### FirstClick
+
+This interaction does not inherit from SimpleInteraction and therefore has no Next or Failed fields.
+
+This interaction has two fields that each contain a reference to an Interaction: Click and Hold.  If the root interaction
+of the chain was initiated by a client button/key press (or simulated NPC input) and the input was a tap, then
+the Click interaction is run. if it was a longer press, then the Hold interaction is run.
+
+As a minor implementation detail, this interaction is internally marked as failed when the Hold path is followed.
+This generally shouldn't matter.  If the interaction was not initiated by a key press at all, the Click path will be followed,
+but it seems risky to rely on that behavior.
+
+**FirstClick Fields**
+
+| Field Name | Type                                     | Required? | Notes                                                                                                                                                    |
+| ---------- | ---------------------------------------- | --------- | -------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Click      | `Asset`<br />(Asset Type: `Interaction`) | **No**    | If provided and the root interaction of the chain was initiated by button/key press, this interaction is executed next if the press was a quick tap.     |
+| Hold       | `Asset`<br />(Asset Type: `Interaction`) | **No**    | If provided and the root interaction of the chain was initiated by a button/key press, this interaction is executed next if the press was a longer hold. |
+
+### Interrupt
+
+This interaction can be used to cancel one or more running interaction chains on an entity and **all forked interaction
+chains those chains have spawned that are still currently running**.  All interaction chains canceled in this manner will be marked as
+Failed, which may have additional implications if the canceled chains are themselves forked from
+other chains that are still running.
+
+**Interrupt Fields**
+
+| Field Name     | Type                                           | Required? | Notes                                                                                                                                                                                               |
+| -------------- | ---------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Entity         | `InteractionTarget`<br />(Default: User)       | **Yes**   | The entity that is the owner of the target interaction chains.  This field can indicate the Owner, User, or Target of this interaction chain.                                                       |
+| InterruptTypes | `Array`<br />(Element Type: `InteractionType`) | **No**    | A set of InteractionTypes that are to be interrupted. Only interactions of these types are affected. If null, all types will be interrupted.<br />**(Note: An empty set will interrupt NO TYPES.)** |
+| RequiredTag    | `String`                                       | **No**    | An asset tag that, if provided, the RootInteraction of the interaction chain must have in order to be canceled.                                                                                     |
+| ExcludedTag    | `String`                                       | **No**    | An asset tag that, if provided, the RootInteraction of the interaction chain must not have in order to be canceled.                                                                                 |
+
+**InteractionTarget Values**
+
+- `User` - The user of this interaction chain. The entity whose actions caused this interaction chain to be executed. This is usually the same as the Owner.
+- `Owner` - The owner of this interaction chain. The entity upon whom this interaction chain is executing.
+- `Target` - The entity target of this interaction chain, if any.  This value is mutable (and can therefore come from many places) but most commonly, it is an entity the User was targeting when this interaction chain began executing.
+
+**InteractionType Values**
+
+- `Primary`
+- `Secondary`
+- `Ability1`
+- `Ability2`
+- `Ability3`
+- `Use`
+- `Pick`
+- `Pickup`
+- `CollisionEnter`
+- `CollisionLeave`
+- `Collision`
+- `EntityStatEffect`
+- `SwapTo`
+- `SwapFrom`
+- `Death`
+- `Wielding`
+- `ProjectileSpawn`
+- `ProjectileHit`
+- `ProjectileMiss`
+- `ProjectileBounce`
+- `Held`
+- `HeldOffhand`
+- `Equipped`
+- `Dodge`
+- `GameModeSwap`
+
+### Parallel
+
+This interaction does not inherit from SimpleInteraction and therefore has no Next or Failed fields.
+
+This interaction has a field `Interactions` that is an array of RootInteraction assets. The list must contain at least
+two RootInteractions.  This interaction will fork all of its children except for the first into their
+own interaction chains and immediately complete. After this interaction completes, this interaction chain will
+execute the first RootInteraction in the `Interactions` list.
+
+This interaction does not have any failure conditions and is indifferent to the fate of the forked interaction chains.
+
+**Parallel Fields**
+
+| Field Name   | Type                                                | Required? | Notes                                                         |
+| ------------ | --------------------------------------------------- | --------- | ------------------------------------------------------------- |
+| Interactions | `AssetArray`<br />(Element Type: `RootInteraction`) | **Yes**   | An array of RootInteractions that will be forked or executed. |
+
+### Repeat
+
+This interaction has a field `ForkInteractions` that is an asset of type RootInteraction. This interaction will fork that
+RootInteraction into its own interaction chain and then wait for it to complete. If the RootInteraction fails, this
+interaction will complete immediately and be marked failed. Otherwise, the RootInteraction will be forked and run again,
+up to a specified total number of times.
+
+**Repeat Fields**
+
+| Field Name       | Type                                                                                   | Required? | Notes                                                                                                                                                                                                              |
+| ---------------- | -------------------------------------------------------------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| ForkInteractions | `Asset`<br />(Asset Type: `RootInteraction`)                                           | **Yes**   | A RootInteraction that will be forked.                                                                                                                                                                             |
+| Repeat           | `Integer`<br />(Default: 1)<br />**Must be -1 or a positive integer. 0 is not valid.** | **No**    | The total number of times to fork ForkInteractions. If -1 is provided, ForkInteractions will continue being forked and executed indefinitely, until this interaction is cancelled or until ForkInteractions fails. |
+
+### Replace
+
+This interaction does not inherit from SimpleInteraction and therefore has no Next or Failed fields.
+
+This interaction uses the InteractionVars system that is avaiable for items. InteractionVars are RootInteractions that
+can be attached to an Item asset with a name.
+
+This interaction specifies a var name, and if this interaction chain was executed through
+an item and that item has an InteractionVar of the same name, then this interaction will immediately execute
+the RootInteraction on the var.  Otherwise, it will execute the default RootInteraction specified in this interaction.
+If no default is specified, then this interaction will be marked as failed.
+
+**Replace Fields**
+
+| Field Name   | Type                                         | Required? | Notes                                                                                                                                                                                                           |
+| ------------ | -------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Var          | `String`                                     | **Yes**   | The name of the InteractionVar to execute.                                                                                                                                                                      |
+| DefaultValue | `Asset`<br />(Asset Type: `RootInteraction`) | **No**    | The RootInteraction to execute if the owning item does not have an InteractionVar by the specified name. If not provided, the interaction will be marked as failed instead.                                     |
+| DefaultOk    | `Boolean`<br />(Default: false)              | **No**    | If false, then an angry message will be printed to the server logs if the owning item does not have an InteractionVar by the specified name.  The functioning of this interaction will be otherwise unaffected. |
+
+### RunRootInteraction
+
+This interaction immediately executes the provided RootInteraction as part of this interaction chain. This interaction
+does not have any failure conditions.
+
+**RunRootInteraction Fields**
+
+| Field Name      | Type                                         | Required? | Notes                           |
+| --------------- | -------------------------------------------- | --------- | ------------------------------- |
+| RootInteraction | `Asset`<br />(Asset Type: `RootInteraction`) | **Yes**   | The RootInteraction to execute. |
+
+### Selector
+
+This interaction will execute a Selector to find entities and/or blocks (depending on the Selector) and fork off an
+interaction chain for each located entity or block. This interaction will not wait for those interaction chains
+to complete and is indifferent to their fate. The forked interaction chains will use the located entity/block as
+their target entity/target block. Each entity or block will only fork one interaction chain over the life of this
+interaction.  The Selector is guaranteed to run once for each execution of this interaction, but some Selectors
+are intended to be run over a period of time and sweep across an area to locate targets. In order to use those Selectors
+properly, you will need to extend the execution time of this interaction using `RunTime` or `WaitForAnimationToFinish`.
+The Selector will be executed repeatedly over the lifetime of the interaction.
+
+If the Selector is configured to locate entities, you can add additional sets of entity matching rules. If a located entity
+matches one of the rules, the matching RootInteraction will be forked instead of the standard `HitEntity` RootInteraction.
+
+Entities located by the Selector will be ignored if they do not have a NetworkId, if they are dead, or if they are invulnerable.
+The only exception to this rule is that players in Creative Mode that are marked to receive hits will not be ignored.
+
+This interaction's failure conditions are configurable via the `FailOn` field. You can configure this interaction to never
+fail, to fail if the Selector does not locate any blocks before this interaction finishes executing, to fail if the
+Selector does not locate any entities before this interaction finishes executing, or to fail in either case.
+
+**Selector Fields**
+
+| Field Name     | Type                                         | Required? | Notes                                                                                                                                                                                                                                     |
+| -------------- | -------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Selector       | `Selector`                                   | **Yes**   | The Selector is executed at least once and may be executed repeatedly to locate blocks and/or entities in an area.                                                                                                                        |
+| HitEntity      | `Asset`<br />(Asset Type: `RootInteraction`) | **No**    | If included and the `Selector` locates an entity that does not match any `HitEntityRules`, this RootInteraction will be forked into a new interaction chain with the located entity as the target entity.                                 |
+| HitEntityRules | `Array`<br />(Element Type: `HitEntity`)     | **No**    | If included, these rules will be matched against any entity located by the `Selector`. If an entity matches a set of rules, the RootInteraction associated with the rules will be forked instead of the standard `HitEntity` interaction. |
+| HitBlock       | `Asset`<br />(Asset Type: `RootInteraction`) | **No**    | If included and the `Selector` locates a block, this RootInteraction will be forked into a new interaction chain with the located block as the block target.                                                                              |
+| FailOn         | `FailOnType`<br />(Default: `Neither`)       | **No**    | Defines under what circumstances this interaction will fail.  It can be marked to fail when it completes without locating any blocks, it can be marked to fail when it completes without locating any entities, both, or neither.         |
+| IgnoreOwner    | `Boolean`<br />(Default: true)               | **No**    | If true, the Selector will not locate the User entity of this interaction.                                                                                                                                                                |
+
+**HitEntity Fields**
+
+| Field Name | Type                                         | Required? | Notes                                                                                                 |
+| ---------- | -------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------- |
+| Matchers   | `Array`<br />(Element Type: `EntityMatcher`) | **Yes**   | A set of rules that an entity must match. An entity must successful match all rules to be considered. |
+| Next       | `Asset`<br />(Asset Type: `RootInteraction`) | **Yes**   | The RootInteraction to fork if an entity matches all rules.                                           |
+
+**EntityMatcher Fields**
+
+| Field Name | Type                            | Required? | Notes                                                                                                     |
+| ---------- | ------------------------------- | --------- | --------------------------------------------------------------------------------------------------------- |
+| Type       | `String`                        | **Yes**   | If provided, specifies a type of EntityMatcher to use. Each matcher type may come with additional fields. |
+| Invert     | `Boolean`<br />(Default: false) | **No**    | If true, an entity must fail this rule for it to be marked as succeeded.                                  |
+
+**EntityMatcher Type: Player**
+
+This EntityMatcher will succesfully match the entity only if they are a player.
+
+**EntityMatcher Type: Vulnerable**
+
+This Entitymatcher will successfully match the entity only if they are not marked as invulnerable.
+
+**FailOnType Values**
+
+- `Neither`
+- `Entity`
+- `Block`
+- `Either`
+
+### Serial
+
+This interaction does not inherit from SimpleInteraction and therefore has no Next or Failed fields.
+
+This interaction has a field `Interactions` which is a list of Interaction assets. This interaction immediately
+completes and the interaction chain continues by executing the interactions in the list one at a time. This
+interaction does not have any failure conditions.
+
+**Serial Fields**
+
+| Field Name   | Type                                            | Required? | Notes                                      |
+| ------------ | ----------------------------------------------- | --------- | ------------------------------------------ |
+| Interactions | `AssetArray`<br />(Element Type: `Interaction`) | **Yes**   | An array of Interaction assets to execute. |
+
+## Cooldowns
+
+RootInteractions interface with a complex cooldown system that can be used for a variety of purposes. Aside from simply
+adding an important aspect of resource management to your game design, cooldowns can be used to ensure that click-activated
+interaction chains don't repeatedly spam if the player holds down the input.
+
+By default, every RootInteraction has a cooldown timer that is keyed to the RootInteraction name, and by default, it
+will launch a cooldown of 0.35 seconds when activated by client input.  Otherwise, no cooldown will be activated.  However,
+by configuring your RootInteraction, you can change the key for the cooldown (so that multiple RootInteractions can share
+a single cooldown), set the cooldown timer to whatever you like, and configure multiple charges that can build up over time
+to allow the entity to activate the RootInteraction multiple times before being forced to pause.
+
+One important concept to keep in mind is the difference between **cooldown** and **charge time**.  The cooldown, if any,
+is activated each time a RootInteraction triggers, even if the player has more available charges. If the RootInteraction
+is configured to use charges, then they will gradually build up over time. In order for a RootInteraction to be activated,
+the cooldown (if any) must be expired, and the RootInteraction must have at least one charge (if it has been
+configured to use charges).
+
+Bear in mind that the entire Cooldown configuration is shared between different RootInteractions with the same cooldown id.
+If you activate an ability with 5 charges and a short cooldown and then another ability with a much longer cooldown and no
+charges, the second ability will use the cooldown properties of the first ability until/unless the first ability finishes
+charging and is cleared from the system.  You should generally only have multiple RootInteractions share a cooldown id
+if they have the same configuration.
+
+The interactions below interact with the cooldown system to allow you to manipulate cooldowns via the interaction system. By
+using these interactions, you can have several interaction chains with different cooldown configurations share cooldowns
+that are checked and activated as part of the interaction chain itself, or have some components of an interaction change
+use a second cooldown separate from the main one.
+
+### CooldownCondition
+
+**CooldownCondition Fields**
+
+This interaction will fail if the specified cooldown id is on cooldown for the User entity.  This interaction will only
+function for players- the interaction will always succeed for NPCs.  In order for this interaction to succeed, the
+cooldown, if any, must have expired and at least one charge, if any, must have filled.
+
+| Field Name | Type     | Required? | Notes                     |
+| ---------- | -------- | --------- | ------------------------- |
+| Id         | `String` | **Yes**   | The cooldown id to check. |
+
+### IncrementCooldown
+
+**IncrementCooldown Fields**
+
+This interaction will modify a cooldown that is currently active on the User entity, allowing charges and remaining
+cooldown to be modified.
+Despite its name, this interaction can be used to reduce a cooldown as well as increase it. If the cooldown is not
+currently active, this interaction will have no effect. The interaction has no special failure conditions.
+
+| Field Name        | Type                        | Required? | Notes                                                                                                                                                                                                                                                                                     |
+| ----------------- | --------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Id                | `String`                    | **No**    | If provided, the cooldown id of the cooldown to be manipulated. If not provided, the cooldown id of the current chain's RootInteraction will be used.                                                                                                                                     |
+| Time              | `Float`<br />(Default: 0.0) | **No**    | The amount to increase the remaining cooldown by. Can be negative. The remaining cooldown time will not be reduced below zero or increased above the maximum cooldown time.                                                                                                               |
+| ChargeTime        | `Float`<br />(Default: 0.0) | **No**    | The amount to increase the remaining time until the next charge is filled by. Can be negative. The remaining charge time cannot be reduced below zero or increased above the maximum cooldown time. **This will not work on abilities that have a maximum of 1 charge, for some reason.** |
+| Charge            | `Integer`<br />(Default: 0) | **No**    | The amount to increase the number of charges by. Can be negative. The number of charges cannot be reduced below 0 or increased above the maximum.                                                                                                                                         |
+| InterruptRecharge | `Boolean`(Default: false)   | **No**    | If true and `Charge` is not 0, will reset the remaining time to the next charge to the maximum value after changing the charge count.                                                                                                                                                     |
+
+### ResetCooldown
+
+This interaction will trigger a cooldown on the User entity with a specified configuration. The charges will be refilled
+but the cooldown will be immediately triggered.  The mechanisms for deciding on the configuration are a little bit complicated.
+You may specify a cooldown configuration via the `Cooldown` field. If you do not include an `Id` field, then the
+interaction chain's RootInteraction will be used for any field not specified in the configuration. If there is an active
+cooldown under the specified `Id` (or under the RootInteraction's cooldown id if none is specified) then the fields
+from that active cooldown will overwrite data in the RootInteraction's cooldown, but not data in your `Cooldown` field.
+
+**ResetCooldown Fields**
+
+| Field Name | Type                  | Required? | Notes                                                        |
+| ---------- | --------------------- | --------- | ------------------------------------------------------------ |
+| Cooldown   | `InteractionCooldown` | **No**    | A cooldown configuration to use for the new, reset cooldown. |
+
+**InteractionCooldown Fields**
+
+| Field Name        | Type                                 | Required? | Notes                                                                                                                                                                                                 |
+| ----------------- | ------------------------------------ | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Id                | `String`                             | **No**    | The cooldown id to use for this cooldown. If not provided, the RootInteraction's cooldown id will be used, if any.                                                                                    |
+| Cooldown          | `Float`<br />(Default: 0.0)          | **No**    | The duration of the cooldown, in seconds.                                                                                                                                                             |
+| Charges           | `Array`<br />(Element Type: `Float`) | **No**    | If provided, a list of how many charges this cooldown can build, and how long each charge takes to build, in seconds.                                                                                 |
+| InterruptRecharge | `Boolean`<br />(Default: false)      | **No**    | If true, the charge time will be reset when the number of charges changes.                                                                                                                            |
+| ClickBypass       | `Boolean`<br />(Default: false)      | **No**    | If true, RootInteractions keyed to this cooldown can still be activated when it is on cooldown provided that the RootInteraction was triggered by a distinct key or mouse button press on the client. |
+
+### TriggerCooldown
+
+This interaction is similar to ResetCooldown, except instead of refilling the cooldown's charges, one charge will be deducted
+as normal.
+
+**TriggerCooldown Fields**
+
+| Field Name | Type                  | Required? | Notes                                                        |
+| ---------- | --------------------- | --------- | ------------------------------------------------------------ |
+| Cooldown   | `InteractionCooldown` | **No**    | A cooldown configuration to use for the new, reset cooldown. |
+
+**InteractionCooldown Fields**
+
+| Field Name        | Type                                 | Required? | Notes                                                                                                                                                                                                 |
+| ----------------- | ------------------------------------ | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Id                | `String`                             | **No**    | The cooldown id to use for this cooldown. If not provided, the RootInteraction's cooldown id will be used, if any.                                                                                    |
+| Cooldown          | `Float`<br />(Default: 0.0)          | **No**    | The duration of the cooldown, in seconds.                                                                                                                                                             |
+| Charges           | `Array`<br />(Element Type: `Float`) | **No**    | If provided, a list of how many charges this cooldown can build, and how long each charge takes to build, in seconds.                                                                                 |
+| InterruptRecharge | `Boolean`<br />(Default: false)      | **No**    | If true, the charge time will be reset when the number of charges changes.                                                                                                                            |
+| ClickBypass       | `Boolean`<br />(Default: false)      | **No**    | If true, RootInteractions keyed to this cooldown can still be activated when it is on cooldown provided that the RootInteraction was triggered by a distinct key or mouse button press on the client. |
+
+## Combo Chains
+
+Hytale additionally comes with a rich "combo chaining" system, which allows several inputs in a row to result in different
+attacks and special moves.  Rather than being attached to the RootInteraction like the cooldown system, these are
+primarily driven by the `Chaining` interaction.
+
+### Chaining
+
+This interaction does not inherit from SimpleInteraction and therefore has no Failed field. Its Next field works differently
+from most interaction types.
+
+Chaining is a type of flow control interaction- each time a Chaining interaction with the same `ChainId` is called, a single
+interaction in the `Next` list is chosen and the others are ignored. The first time the `ChainId` is used, the first
+interaction in the list is chosen, the next time the second, etc. Once the end of the list is reached, the first
+interaction will be chosen again.
+
+Bear in mind: the progress through the Next list is based on the **ChainId**, not the interaction!  That means that two
+different Chaining interactions can share a single combo chain. You could have a pair of daggers that attacks with
+the left when the left mouse button is clicked and with the right when the right mouse button is clicked.  You could give
+both interaction chains a Chaining interaction with the same `ChainId` and three `Next` entries that do a light-light-heavy
+combo.  Each specific hit would occur with either the left or the right knife based on which button you clicked, but
+the combo would be otherwise identical regardless of which you chose.
+
+The Chaining interaction also has a concept called "flags".  It is possible to attach named flags to a `ChainId` by using
+the ChainFlag interaction.  Then, you specify the flag name in Chaining's `Flags` field. If a Flag is active when the
+Chaining interaction is run, the Flag's interaction will be run instead of the appropriate interaction in `Next`.
+Bear in mind: the entity's progress through the `Next` list still advances, the resulting `Next` interaction is just not
+run.  Only one flag can be active at a time.
+
+Lastly, it is possible to cancel the entity's progress through the combo chain and reset them to the first interaction in
+the list. This can be done with the CancelChain interaction, but it will also happen automatically if the player does
+not trigger an interaction with the ChainId for the specified ChainingAllowance.  When either of these happen, all flags will be
+canceled as well.
+
+All of these effects are triggered on the User entity only. Non-players can use the chaining system, but Flags do not currently
+work for non-players.  This interaction has no special failure conditions.
+
+**Chaining Fields**
+
+| Field Name        | Type                                                       | Required? | Notes                                                                                                                                                                                                                       |
+| ----------------- | ---------------------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| ChainId           | `String`                                                   | **No**    | If provided, acts as a key that multiple Chaining interactions can use to share combo chain progress and flags. If not provided, a unique ChainId will be generated for this interaction.                                   |
+| ChainingAllowance | `Double`<br />(Default: 0.0)                               | **No**    | If, at the time this interaction is triggered, it has been this long in seconds since the last time a Chaining interaction with the same ChainId was executed, all state for this ChainId will be cleared before execution. |
+| Next              | `AssetArray`<br />(Element Type: `Interaction`)            | **Yes**   | A list of interactions to cycle between each time this interaction is run.                                                                                                                                                  |
+| Flags             | `Map`<br />(Key Type: `String`, Value Type: `Interaction`) | **No**    | A map of flag names to interactions to run if the flag is active when this interaction executes.                                                                                                                            |
+
+### CancelChain
+
+This interaction resets all progress and flag data on the User entity for the provided `ChainId`.  The next time a Chaining
+interaction is called for the provided `ChainId`, it will begin at the first interaction in the `Next` list. This
+interaction has no special failure conditions.
+
+**CancelChain Fields**
+
+| Field Name | Type     | Required? | Notes                                 |
+| ---------- | -------- | --------- | ------------------------------------- |
+| ChainId    | `String` | **Yes**   | A ChainId whose data should be reset. |
+
+### ChainFlag
+
+This interaction activates a flag on the User entity for the provided `ChainId`, which can be used to change behavior the
+next time a Chaining interaction with this `ChainId` is run. This will overwrite any flag that has
+already been raised. This interaction will have no effect for non-players. This interaction has no special failure
+conditions.
+
+| Field Name | Type     | Required? | Notes                                        |
+| ---------- | -------- | --------- | -------------------------------------------- |
+| ChainId    | `String` | **Yes**   | A ChainId on whom the flag should be raised. |
+| Flag       | `String` | **Yes**   | The name of the flag to raise.               |
+
+## Charging
+
+A unique flow-control interaction that is frequently used is the Charging interaction.  It is a flow-control interaction
+that delays while the input button used to trigger the interaction chain is held.  When it is released (or the interaction
+is forced to end), the interaction chain can continue with a different interaction based on how long the input was held
+for.
+
+These interactions are all related by either being the Charging interaction, or other interaction types that inherit the
+Charging interaction's behavior.
+
+### Charging
+
+This interaction does not inherit from SimpleInteraction and therefore its Next field works different from most interactions.
+This interaction adds its own Failed field which works the same way that SimpleInteraction's does.
+
+This interaction only works properly when its interaction chain was triggered by a client key or button press (or
+NPC-simulated equivalent). This interaction will continue executing for as long as the key or button press is held (with
+some exceptions, covered below) by the User entity.  Like other interactions, it has a `Next` field indicating which interaction to execute
+after this one, but the field is a map from `Float` values to `Interaction` assets. When this interaction ends, either
+due to the input being released or the charge duration completing, this interaction will determine the largest `Float` key that is less
+than the amount of time in seconds that the interaction was executing for.  The Interaction mapped to that key will be
+executed next.
+
+The interaction includes some cancellation conditions that are specific to this interaction. For instance, the interaction
+has a `CancelOnOtherClick` field that matches the field on RootInteraction. If it is active on this interaction but not
+the RootInteraction, then clicking while charging will cancel this interaction (and execute the `Failed` interaction rather
+than any of the `Next` interactions) but otherwise continue the interaction chain.
+
+Another valuable feature Charging has is the `Forks` field.  For input-triggered interactions that are triggered while the
+Charging interaction is executing, you can add an entry for the relevant InteractionType to this field and instead of
+triggering the usual interaction chain based on held item, targeted block, etc. the RootInteraction specified in the
+`Forks` field will be triggered.  This can unlock rich attack modes and behaviors. For instance, having a shield bash attack
+triggered off left click while blocking, or a special attack that triggers when both mouse buttons are pressed at the
+same time.
+
+There are two modes of operation for the Charging interaction. One is to have the ability charge for as long
+as the input is held and only end execution when the entity releases the input.  Bows in the main Hytale game work
+that way.  That is accomplished by setting `AllowIndefiniteHold` to true.  Another mode of operation is to have the
+interaction complete execution when the execution time has surpassed the largest key value in the `Next` field and
+immediately begin executing the Interaction mapped to that key.  Food in the main Hytale game work like this.  It
+is accomplished by setting `AllowIndefiniteHold` to false.
+
+One pitfall to be careful of when setting `AllowIndefiniteHold` to false is the way it interacts with cooldowns.\
+Normally, input-initiated interaction chains start a 0.35s cooldown on the triggered RootInteraction that prevents
+holding the mouse button from immediately spamming a new interaction when the first one completes.  However, if the
+duration of a Charging interaction is longer than 0.35s, then the cooldown will have already completed when the
+interaction chain finishes, which will often result in a new execution beginning immediately before the player can
+stop pressing the mouse button.  One solution for this problem is to add a `Simple` interaction to the end of your
+interaction chain with a `RunTime` of 0.35s to simulate the cooldown.  Alternatively, you can add a longer cooldown
+(the maximum duration of your Charging interaction plus 0.35s) to the RootInteraction. However, the longer cooldown is
+not always desirable, as the interaction may have ended prematurely, resulting in an unusually long lockout between
+executions.
+
+**Charging Fields**
+
+| Field Name                         | Type                                                                    | Required? | Notes                                                                                                                                                                                                                                                                                                                                                                                       |
+| ---------------------------------- | ----------------------------------------------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| FailOnDamage                       | `Boolean`<br />(Default: false)                                         | **No**    | If true, this interaction will fail and end immediately if the User entity takes any damage while it is executing.                                                                                                                                                                                                                                                                          |
+| CancelOnOtherClick                 | `Boolean`<br />(Default: true)                                          | **No**    | If true, this interaction will fail and end immediately if the User entity sends another button or key press while it is executing.                                                                                                                                                                                                                                                         |
+| Forks                              | `Map`<br />(Key Type: `InteractionType`, Value Type: `RootInteraction`) | **No**    | A map of InteractionType to RootInteraction. If entity input triggers the InteractionType while this interaction is executing, the mapped RootInteraction will be forked into its own interaction chain. This will happen instead of the usual handling for that InteractionType.  This fork will occur even if `CancelOnOtherClick` is set to true.                                        |
+| Failed                             | `Asset`<br />(Asset Type: `Interaction`)                                | **No**    | After this Interaction has finished, "Failed" will be executed if this Interaction failed.                                                                                                                                                                                                                                                                                                  |
+| AllowIndefiniteHold                | `Boolean`<br />(Default: false)                                         | **No**    | If true, this interaction will continue executing for as long as the User entity continues to hold the input. If false, execution will end as soon as the execution time in seconds reaches the largest key value in the `Next` map.                                                                                                                                                        |
+| DisplayProgress                    | `Boolean`<br />(Default: true)                                          | **No**    | If true, players executing this interaction will see a progress bar will be displayed below their cursor indicating how close to reaching the highest key value in `Next` they are.                                                                                                                                                                                                         |
+| Next                               | `Map`<br />(Key Type: `Float`, Value Type: `Interaction`)               | **No**    | A map from `Float` to `Interaction`.  When this interaction successfully finishes executing (either because the input was released or because the maximum duration was reached), this interaction will find the `Float` value with the largest duration in seconds that is less than the amount of time this interaction executed for. That key's mapped Interaction will then be executed. |
+| MouseSensitivityAdjustmentTarget   | `Float`<br />(Default: 1.0)                                             | **No**    | While charging, this mouse sensitivity multiplier will gradually be applied.                                                                                                                                                                                                                                                                                                                |
+| MouseSensitivityAdjustmentDuration | `Float`<br />(Default: 1.0)                                             | **No**    | Duration in seconds. After this many seconds, `MouseSensitivityAdjustmentTarget` will be fully applied to the mouse sensitivity.                                                                                                                                                                                                                                                            |
+| Delay                              | `ChargingDelay`                                                         | **No**    | Settings that allow charging progress to be pushed back when the User entity takes damage.                                                                                                                                                                                                                                                                                                  |
+
+**ChargingDelay Fields**
+
+| Field Name    | Type                        | Required? | Notes                                                                                                                                                                                                                                                                     |
+| ------------- | --------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| MinHealth     | `Float`<br />(Default: 0.0) | **No**    | Damage taken as a percentage of entity health (0.0-1.0). If a hit deals less than this much damage, no pushback will be applied.  If a hit deals exactly this much damage, `MinDelay` seconds worth of pushback will be applied.                                          |
+| MaxHealth     | `Float`<br />(Default: 0.0) | **No**    | Damage taken as a percentage of entity health (0.0-1.0). If a hit deals at least this much damage, `MaxDelay` seconds worth of pushback will be applied.                                                                                                                  |
+| MinDelay      | `Float`<br />(Default: 0)   | **No**    | The amount of pushback, in seconds, to apply if the entity takes a hit that deals `MinHealth` damage. The amount of pushback applied by a hit is a gradiant between `MinDelay` and `MaxDelay` based on the amount of damage between `MinHealth` and `MaxHealth`.          |
+| MaxDelay      | `Float`<br />(Default: 0)   | **No**    | The amount of pushback, in seconds, to apply if the entity takes a hit that deals at least `MaxHealth` damage. The amount of pushback applied by a hit is a gradiant between `MinDelay` and `MaxDelay` based on the amount of damage between `MinHealth` and `MaxHealth`. |
+| MaxTotalDelay | `Float`<br />(Deault: 0)    | **No**    | The maximum amount of pushback the entity can receive over the course of a single charge, regardless of how many times they are hit.                                                                                                                                      |
+
+**InteractionType Values**
+
+- `Primary`
+- `Secondary`
+- `Ability1`
+- `Ability2`
+- `Ability3`
+- `Use`
+- `Pick`
+- `Pickup`
+- `CollisionEnter`
+- `CollisionLeave`
+- `Collision`
+- `EntityStatEffect`
+- `SwapTo`
+- `SwapFrom`
+- `Death`
+- `Wielding`
+- `ProjectileSpawn`
+- `ProjectileHit`
+- `ProjectileMiss`
+- `ProjectileBounce`
+- `Held`
+- `HeldOffhand`
+- `Equipped`
+- `Dodge`
+- `GameModeSwap`
+
+### Wielding
+
+This interaction is inherited from Charging rather than SimpleInteraction.  However, its `Failed` and `Next` fields function
+identically to SimpleInteraction.  It does not inherit all fields from Charging, so be sure to pay close attention to
+the field list below.
+
+This interaction drives most blocking behavior in the game. While this interaction is executing, attacks made against
+the Owner entity will (conditionally) trigger effects defined in this interaction.  Unlike the Charging interaction,
+this interaction can always execute indefinitely and will only end when it fails or when the input is released.
+
+One option available in Wielding is `AngledWielding`, which allows damage and knockback modifiers to only be applied
+depending on the direction the attack against the Owner entity is coming from.  The AngledWielding type has a
+field `Angle` which determines which direction the protection points relative to the player (0 is the player's
+front), and `AngleDistance` which determines how wide the cone of protection extends around the player.  Block effects
+from this interaction (such as `BlockedEffects`, `BlockedInteractions`, and `StaminaCost`) will only apply if
+the DamageCause matches `DamageModifiers` OR if the DamageCause matches `AngledWielding.DamageModifiers` and
+the source of the damage matches `Angle` and `AngleDistance`.  It is possible for damage and knockback multipliers
+specified on both this interaction's modifier fields and `AngledWielding`'s modifier fields to stack, if both
+have entries for the same DamageCause.
+
+This interaction will only have an effect on damage taken by one of the DamageCause entries in `DamageModifiers` or
+`AngledWielding.DamageModifiers`.  If a DamageCause is in `DamageModifiers`, then the block effect will be triggered
+and the damage modifier applied regardless of what direction the Owner entity is attacked from.  If a DamageCause is in
+`AngledWielding.DamageModifiers`, then the damage modifier is only applied if the
+
+\*\* Wielding Fields\*\*
+
+| Field Name          | Type                                                                    | Required? | Notes                                                                                                                                                                                                                                                                                                                                                                                                      |
+| ------------------- | ----------------------------------------------------------------------- | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| FailOnDamage        | `Boolean`<br />(Default: false)                                         | **No**    | If true, this interaction will fail and end immediately if the User entity takes any damage while it is executing.                                                                                                                                                                                                                                                                                         |
+| CancelOnOtherClick  | `Boolean`<br />(Default: true)                                          | **No**    | If true, this interaction will fail and end immediately if the User entity sends another button or key press while it is executing.                                                                                                                                                                                                                                                                        |
+| Forks               | `Map`<br />(Key Type: `InteractionType`, Value Type: `RootInteraction`) | **No**    | A map of InteractionType to RootInteraction. If entity input triggers the InteractionType while this interaction is executing, the mapped RootInteraction will be forked into its own interaction chain. This will happen instead of the usual handling for that InteractionType.  This fork will occur even if `CancelOnOtherClick` is set to true (after which this interaction chain will be canceled). |
+| Next                | `Asset`<br />(Asset Type: `Interaction`)                                | **No**    | After this interaction has finished, "Next" will be executed if this interaction did not fail.                                                                                                                                                                                                                                                                                                             |
+| Failed              | `Asset`<br />(Asset Type: `Interaction`)                                | **No**    | After this interaction has finished, "Failed" will be executed if this interaction failed.                                                                                                                                                                                                                                                                                                                 |
+| DamageModifiers     | `Map`<br />(Key Type: `DamageCause`, Value Type: `Float`)               | **No**    | A map from DamageCause to Float, where the Float is multiplied against any damage received from the mapped DamageCause while this interaction is executing.                                                                                                                                                                                                                                                |
+| KnockbackModifiers  | `Map`<br />(Key Type: `DamageCause`, Value Type: `Float`)               | **No**    | A map from DamageCause to Float, where the Float is multiplied against any knockback force received from the mapped DamageCause while this interaction is executing.                                                                                                                                                                                                                                       |
+| AngledWielding      | `AngledWielding`                                                        | **No**    | Configuration to only trigger block effects from certain angles.                                                                                                                                                                                                                                                                                                                                           |
+| StaminaCost         | `StaminaCost`                                                           | **No**    | If the Owner entity receives damage that matches `DamageModifiers` or `AngledWielding` while this interaction is executing, then the entity's stamina will be deducted according to this configuration.                                                                                                                                                                                                    |
+| BlockedEffects      | `DamageEffects`                                                         | **No**    | If the Owner entity receives damage that matches `DamageModifiers` or `AngledWielding` while this interaction is executing, then these effects will be applied to the instance of damage.                                                                                                                                                                                                                  |
+| BlockedInteractions | `Asset`<br />(Asset Type: `RootInteraction`)                            | **No**    | If the Owner entity receives damage that matches `DamageModifiers` or `AngledWielding` while this interaction is executing, then this RootInteraction will be launched as a brand new interaction chain with the Owner entity as both Owner and User, and the attacker as the Target entity.  This new interaction chain is, notably, brand new, **not** forked from the current one.                      |
+
+**AngledWielding Fields**
+
+| Field Name         | Type                                                      | Required? | Notes                                                                                                                                                                                                            |
+| ------------------ | --------------------------------------------------------- | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Angle              | `Float`<br />(Default: 0.0)                               | **No**    | Angle in degrees relative to the Owner entity where the angled protection is centered. 0.0 means pointed towards the front of the Owner entity.                                                                  |
+| AngleDistance      | `Float`<br />(Default: 0.0)                               | **No**    | Angle in degrees indicating how wide the cone of protection is.                                                                                                                                                  |
+| DamageModifiers    | `Map`<br />(Key Type: `DamageCause`, Value Type: `Float`) | **No**    | A map from DamageCause to Float, where the Float is multiplied against any damage received from the mapped DamageCause received from within the cone of protection while this interaction is executing.          |
+| KnockbackModifiers | `Map`<br />(Key Type: `DamageCause`, Value Type: `Float`) | **No**    | A map from DamageCause to Float, where the Float is multiplied against any knockback force received from the mapped DamageCause received from within the cone of protection while this interaction is executing. |
+
+**StaminaCost Fields**
+
+| Field Name | Type                                             | Required? | Notes                                                                                                                                                                                                                                                |
+| ---------- | ------------------------------------------------ | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| CostType   | `CostType`<br />(Default: `MaxHealthPercentage`) | **No**    | How to calculate stamina consumed by blocking from the raw pre-block damage. If `Damage`, then the stamina consumed will be `rawDamage / Value`. If `MaxHealthPercentage`, then the stamina consumed will be `rawDamage / (EntityMaxHealth * Value)` |
+| Value      | `Float`<br />(Default: 0.04)                     | **No**    | The value to use in the `CostType` formula.                                                                                                                                                                                                          |
+
+**DamageEffects Fields**
+
+| Field Name             | Type                                         | Required? | Notes                                                                           |
+| ---------------------- | -------------------------------------------- | --------- | ------------------------------------------------------------------------------- |
+| ModelParticles         | `Array`<br />(Element Type: `ModelParticle`) | **No**    | Particle systems to trigger in the first-person view.                           |
+| WorldParticles         | `Array`<br />(Element Type: `WorldParticle`) | **No**    | Particle systems to trigger in the third-person view.                           |
+| LocalSoundEventId      | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | 2D sound to play locally to the attacking entity if they are a player.          |
+| WorldSoundEventId      | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | Sound to play in the world at the Owner entity's location.                      |
+| PlayerSoundEventId     | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | 2D sound to play locally to the Owner entity if they are a player.              |
+| ViewDistance           | `Double`<br />(Default: 75.0)                | **No**    | Distance at which these effects should play for other players.                  |
+| Knockback              | `Knockback`                                  | **No**    | The properties of the knockback that will be applied.                           |
+| CameraEffect           | `Asset`<br />(Asset Type: `CameraEffect`)    | **No**    | CameraEffect to briefly apply locally to the Owner entity if they are a player. |
+| StaminaDrainMultiplier | `Float`<br />(Default: 1.0)                  | **No**    | This multiplier is applied to the `StaminaCost`, if any.                        |
+
+**Knockback Fields**
+
+| Field Name     | Type                                       | Required? | Notes                                                                                                                      |
+| -------------- | ------------------------------------------ | --------- | -------------------------------------------------------------------------------------------------------------------------- |
+| Type           | `String`                                   | **No**    | If provided, specifies a type of knockback to use. Each knockback type may come with additional fields.                    |
+| Force          | `Double`<br />(Default: 0.0)               | **No**    | The amount of force to apply to the Owner entity.                                                                          |
+| Duration       | `Double`<br />(Default: 0.0)               | **No**    | If 0.0, apply the force as a single impulse.  If more, continuously apply the force over a period of time.                 |
+| VelocityType   | `ChangeVelocityType`<br />(Default: `Add`) | **No**    | How to apply the force, either adding it to the entity's current velocity, or setting the velocity to the knockback force. |
+| VelocityConfig | `VelocityConfig`                           | **No**    | Characteristics of friction as the Owner entity is thrown by this knockback.                                               |
+
+**Knockback Type: Force**
+
+Apply the calculated knockback force along the provided direction.
+
+| Field Name | Type                         | Required? | Notes                                                                                |
+| ---------- | ---------------------------- | --------- | ------------------------------------------------------------------------------------ |
+| Direction  | `Vector3`<br />(Default: Up) | **No**    | Which direction the player should be flung, relative to the direction of the attack. |
+
+**Knockback Type: Point**
+
+Apply the calculated knockback force laterally along the XZ plane, plus provided Y velocity.
+
+| Field Name | Type                        | Required? | Notes                                                                                                   |
+| ---------- | --------------------------- | --------- | ------------------------------------------------------------------------------------------------------- |
+| OffsetX    | `Integer`<br />(Default: 0) | **No**    | Offset the source position of the knockback left or right perpendicular to the direction of the attack. |
+| OffsetZ    | `Integer`<br />(Default: 0) | **No**    | Offset the source position of the knockback, forward or backward along the directon of the attack.      |
+| RotateY    | `Integer`<br />(Default: 0) | **No**    | Rotate the knockback direction around the Y axis, where 0 is the default attack direction.              |
+| VelocityY  | `Float`<br />(Default: 0.0) | **No**    | Add vertical velocity to the knockback force after the direction and force has been calculated.         |
+
+**Knockback Type: Directional**
+
+Apply the calculated knockback force along the attack direction, removing any vertical component and replacing it with a provided Y velocity.
+
+| Field Name | Type                      | Required? | Notes                                                                                                                                            |
+| ---------- | ------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------ |
+| RelativeX  | `Float`<br />(Default: 0) | **No**    | Apply additional force left or right perpendicular to the direction of the attack. The additional force is multiplied by the knockback strength. |
+| RelativeZ  | `Float`<br />(Default: 0) | **No**    | Apply additional force forward or backward along the attack direction. The additional force is multiplied by the knockback strength.             |
+| VelocityY  | `Float`<br />(Default: 0) | **No**    | Replace the vertical velocity of the knockback with this value.  This value is not multiplied by knockback strength.                             |
+
+**VelocityConfig Fields**
+
+| Field Name          | Type                                              | Required? | Notes                                                                                                                                                                                           |
+| ------------------- | ------------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| GroundResistance    | `Float`<br />(Default: 0.82)                      | **No**    | The minimum amount of friction applied when the entity is in contact with the ground.  1.0 = no friction, 0.0 = total friction                                                                  |
+| GroundResistanceMax | `Float`<br />(Default: 0.0)                       | **No**    | The maximum amount of friction applied when the entity is in contact with the ground.  1.0 = no friction, 0.0 = total friction                                                                  |
+| AirResistance       | `Float`<br />(Default: 0.96)                      | **No**    | The minimum amount of friction applied when the entity is in the air. 1.0 = no friction, 0.0 = total friction                                                                                   |
+| AirResistanceMax    | `Float`<br />(Default: 0.0)                       | **No**    | The maximum amount of friction applied when the entity is in the air. 1.0 = no friction, 0.0 = total friction                                                                                   |
+| Threshold           | `Float`<br />(Default: 1.0)                       | **No**    | The speed at which the maximum amount of friction will be applied to the entity. The amount of friction applied will increase from minimum to maximum as the entity moves from 0 to this speed. |
+| Style               | `VelocityThresholdStyle`<br />(Default: `Linear`) | **No**    | The curve that friction follows as the entity's speed increases toward the `Threshold`.                                                                                                         |
+
+**CostType Values**
+
+- `MaxHealthPercentage`
+- `Damage`
+
+**ChangeVelocityType Values**
+
+- `Add`
+- `Set`
+
+**VelocityThresholdStyle Values**
+
+- `Linear`
+- `Exp`
+
+## Blocks
+
+These are interaction types meant to reason about and modify blocks in the world.  The most important concept unique
+to these interactions is the Block Target.  Like the Entity Target, it is mutable and can come from many places.
+However, for interaction chains initiated by the client, the block target will initially be the block that the player's cursor was
+over, if any.
+
+Additionally, for interaction chains initiated by the client, the client will send along which face of the block is targeted,
+which is used by a few block-related interactions.
+It is left up to each interaction type that cares about block faces as to how to handle this behavior for simulated input
+(i.e. NPCs initiating chains that are normally initated by the client).  At the time of this writing, all block-related
+interactions choose the top face where relevant in simulated input.
+
+### BlockCondition
+
+This interaction has a field `Matchers` which specifies certain conditions, such as block type, state, etc.  This
+interaction fails if the current target block does not match all of them.
+
+**BlockCondition Fields**
+
+| Field Name       | Type                                        | Required? | Notes                                                                                                                                                                                                                                                                                                                                   |
+| ---------------- | ------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false)             | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction.                                                                                                                                                                                                       |
+| Matchers         | `Array`<br />(Element Type: `BlockMatcher`) | **Yes**   | A list of conditions that the target block must match or this condition will fail.<br />**Note: This field is technically not required but there is a bug that makes it dangerous to not provide at the time of this writing.**<br />**Note: If no conditions are added to this array, the interaction will fail, counterintuitively.** |
+
+**BlockMatcher Fields**
+
+| Field Name | Type                       | Required? | Notes                                                                          |
+| ---------- | -------------------------- | --------- | ------------------------------------------------------------------------------ |
+| Block      | `BlockIdMatcher`           | **No**    | If provided, requires the block itself match some set of conditions.           |
+| Face       | `BlockFace`                | **No**    | If provided and not 'None', requires a specific block face be targeted.        |
+| StaticFace | `Boolean` (Default: false) | **No**    | If false, the face condition will be adjusted by the block's current rotation. |
+
+**BlockFace Values**
+
+- `Up`
+- `Down`
+- `North`
+- `South`
+- `East`
+- `West`
+- `None`
+
+**BlockIdMatcher Fields**
+
+| Field Name | Type                                   | Required? | Notes                                                                      |
+| ---------- | -------------------------------------- | --------- | -------------------------------------------------------------------------- |
+| Id         | `Asset`<br />(Asset Type: `BlockType`) | **No**    | If provided, the block must match the specified `BlockType`.               |
+| State      | `String`                               | **No**    | If provided, the block's current state must match the provided state name. |
+| Tag        | `String`                               | **No**    | If provided, the block type's asset tags must contain the provided tag.    |
+
+### DestroyCondition
+
+This interaction fails if the current User entity cannot destroy the current target blcok.
+
+**DestroyCondition Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+
+### PlacementCountCondition
+
+This interaction accepts the name of a BlockType that has the TrackedPlacement BlockEntity. The interaction will fail if the number of
+blocks of the provided BlockType in the world do not match the provided condition.
+
+**PlacementCountCondition Fields**
+
+| Field Name | Type                           | Required? | Notes                                                                                                                                                                                                                                                           |
+| ---------- | ------------------------------ | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Block      | `String`                       | **Yes**   | The BlockType to examine. The number of instances of the BlockType in the world will be compared to Value.<br />**Note: The specified BlockType must have the TrackedPlacement BlockEntity. Otherwise, the number of blocks in the world will always be zero.** |
+| Value      | `Integer`<br />(Default: 0)    | **No**    | The value to compare the number of blocks in the world with.                                                                                                                                                                                                    |
+| LessThan   | \`Boolean<br />(Default: true) | **No**    | If true, the interaction will fail if the number of blocks in the world is greater than or equal to Value. If false, the interaction will fail if the number of blocks in the world is less than or equal to Value.                                             |
+
+### BreakBlock
+
+This interaction attempts to break the target block while acting as the User entity. The User entity must be a player. It
+is not guaranteed to work, depending on world settings and the User entity's current state, it may not work.  If it
+fails, it will fail the interaction under some circumstances, but not others.
+
+**Note: In particular, if `Harvest`=false and the player is in Survival mode, the player will simply execute a damage operation
+against the block. Even when the Tool field is specified, the player's currently-held item can impact the results in unintuitive
+ways.**
+
+This interaction will fail if there is no block target, if `Harvest`=true and the
+block is not harvestable, or if the world settings prevent the Harvest/Break operation.
+It will generally not fail otherwise, even if the block was not broken or damaged.
+The block will generally break every time if `Harvest`=true or the player is in
+Creative mode.
+
+**BreakBlock Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                                                                                                                                                                                                  |
+| ---------------- | ------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction.                                                                                                                                                                      |
+| Harvest          | `Boolean` (Default: false)      | **No**    | If true, harvest the block and deposit the drops in the player's inventory. This operation will generally always succeed.  If false, this interaction will effectively perform whatever action would have occurred if the player had left-clicked the block.                                           |
+| Tool             | `String`                        | **No**    | If `Harvest`=true, the player is in Survival mode, and this field is provided, then the break operation will be performed as though with this tool type.<br />**This field mostly doesn't work.  Your held item will be used for most block damage calculations regardless of this field's contents.** |
+| MatchTool        | `Boolean` (Default: false)      | **No**    | If true, `Harvest`=true, the player is in Survival mode, and `Tool` is provided, block breaking will be prevented unless `Tool` is a valid gathering tool for the target block. The interaction will not be failed, even if block breaking is prevented in this manner.                                |
+
+### ChangeBlock
+
+This interaction requires a mapping from one or more current BlockTypes to one or more target BlockTypes.  If the
+target block is one of the key BlockTypes, then it will be changed to the mapped target BlockType.  If the current
+BlockType of the target block does not appear as a key in the Changes field, then this interaction fails.
+
+**ChangeBlock Fields**
+
+| Field Name        | Type                                                        | Required? | Notes                                                                                                                             |
+| ----------------- | ----------------------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget  | `Boolean`<br />(Default: false)                             | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+| Changes           | `Map`<br />(Key Type: `BlockType`, Value Type: `BlockType`) | **No**    | A list of potential block type changes, with each entry having a current and new BlockType id.                                    |
+| WorldSoundEventId | `Asset`<br />(Asset Type: `SoundEvent`)                     | **No**    | If provided, this SoundEvent is played in the world at the position of the block if the block successfully changes.               |
+| RequireNotBroken  | `Boolean`<br />(Default: false)                             | **No**    | If true, this interaction will fail if the player's held item is broken (durability 0), and the block change will not take place. |
+
+### ChangeState
+
+This interaction requires a mapping from one or more current block state names to one or more state names. If the
+target block is in one of the key block states, then it will be changed to the mapped target blocks tate. If the
+current block state of the target block does nto appear as a key in the Changes field, then this interaction fails.
+
+All blocks start out with a null state by default.  This null state can be referenced by the key "default" and the block
+can be returned to that state with the value "default".
+
+**ChangeState Fields**
+
+| Field Name       | Type                                                  | Required? | Notes                                                                                                                                          |
+| ---------------- | ----------------------------------------------------- | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false)                       | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction.              |
+| Changes          | `Map`<br />(Key Type: `String`, Value Type: `String`) | **No**    | A list of potential block state changes, with each entry having a current and new state name.                                                  |
+| UpdateBlockState | `Boolean`<br />(Default: false)                       | **No**    | If true, performs a full refresh of the block's BlockEntity component and notifies nearby players as though a full block type change occurred. |
+
+### CycleBlockGroup
+
+This interaction will attempt to change the target block to the next block type in one of the BlockGroups it belongs to.
+If the block type belongs to multiple BlockGroups, which one is used is effectively arbitrary. The User entity must be
+a player. If the block cannot be changed for any reason (entity not a player, no block target, block does not belong
+to a BlockGroup, etc.). If the block is the only entry in the BlockGroup, this interaction will succeed and the block
+will be considered changed despite nothing happening.  Unlike most other block-changing interactions, this one will
+fail if the world settings prevent players from breaking blocks.
+
+**This interaction always reduces the player's held item's durability by a single 'hit' worth of damage if the block
+changes. There is no way to prevent it. The block type will change and the interaction will succeed even if the player's
+held item is broken, however.**
+
+**CycleBlockGroup Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+
+### DestroyBlock
+
+This interaction destroys the target block without dropping anything.  It will successfully destroy the block if the
+target block exists and this interaction has no failure conditions.
+
+**This interaction has no additional fields.**
+
+### PickBlock
+
+This interaction is effectively equivalent to using the middle mouse button in creative mode. In survival mode, the
+block's item will be moved to the user's current active hotbar slot if it is in the player's inventory.  This
+interaction is performed entirely on the client and cannot be performed by non-players.  It is unclear if this
+interaction has failure conditions.
+
+**PickBlock Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+
+### PlaceBlock
+
+This interaction is effectively identical to a right clicking while holding a block in their hand, with some
+additional options. For one, it can be executed with any LivingEntity as the User entity. For another, it has some
+useful fields.  For the most part, though, it follows the same behaviors and rules as any ordinary block placement
+by a player.
+
+It's not clear under what circumstances this interaction can fail. The server will not fail the interaction under any
+special circumstances (including when there is no target block, or when `BlockTypeToPlace` is not provided and the
+LivingEntity is not holding a block). However, the client is very involved with the function of this interaction and
+its behavior is unknown.
+
+**PlaceBlock Fields**
+
+| Field Name         | Type                                   | Required? | Notes                                                                                                                                                                                                                                                                                                                                                           |
+| ------------------ | -------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| BlockTypeToPlace   | `Asset`<br />(Asset Type: `BlockType`) | **No**    | If provided, the block placed by this interaction will be the specified BlockType. If not provided, the User entity's held item will be used, instead, if it is a block.                                                                                                                                                                                        |
+| RemoveItemInHand   | `Boolean`<br />(Default: True)         | **No**    | If true and the User entity is not a player in Creative mode, the item in the player's hand must match the block being placed and one quantity will be removed for each block placed. If the item does not match, the block cannot be placed.  If false, the player's hand item is ignored entirely.\*\*                                                        |
+| AllowDragPlacement | `Boolean`<br />(Default: True)         | **No**    | If true and the interaction was triggered on the client by a player, then the player can hold the input that was used to activate this interaction chain and move the mouse around in order to execute this interaction repeatedly and place several blocks. The interaction chain will not move onto the next interaction until the player releases the input. |
+
+### RunOnBlockTypes
+
+This interaction retrieves all blocks within a provided radius of the User entity. For each block that matches any of
+the provided BlockSets, a new interaction chain will be forked that uses the matching block as the target block.
+This interaction will continue executing until all forked interaction chains have completed.  The interaction will fail if no
+blocks within the radius match the provided BlockSets or if all of the forked interaction chains fail.
+
+**RunOnBlockTypes Fields**
+
+| Field Name   | Type                                         | Required?        | Notes                                                                                                                                                                                                                                                                                      |
+| ------------ | -------------------------------------------- | ---------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| Range        | `Integer`                                    | **Yes**          | The spherical radius around the User entity to search for blocks. Must be at least 1.                                                                                                                                                                                                      |
+| BlockSets    | `AssetArray`<br />(Element Type: `BlockSet`) | **No**           | A list of BlockSets to match nearby blocks again. Only blocks that match any of the BlockSets will have interaction chains forked for them.                                                                                                                                                |
+| MaxCount     | `Integer`                                    | **Yes**          | The maximum number of blocks that will be located with the search. Further blocks will be ignored. If there are more matching blocks within the radius than this number, the specific set of blocks that will be found is completely arbitrary and may change from execution to execution. |
+| Interactions | `Asset`<br />(Asset Type: `RootInteraction`) | **No, but yes.** | The RootInteraction that will be forked for each matching block.  This interaction will not fail to validate if it is missing, but every execution of this interaction will fail.                                                                                                          |
+
+### UseBlock
+
+If the target block has an interaction for this interaction chain's interaction type, execute it immediately as part of
+this interaction chain. The execution will be wrapped in UseBlockEvent.Pre and UseBlockEvent.Post events, and cancellations
+of the UserBlockEvent.Pre event are respected. The User entity is considered the triggering entity for both events.
+
+If the target block does not have an interaction for this interaction chain's interaction type, this interaction fails.
+
+**This interaction has no additional fields.**
+
+## Items
+
+These are interactions intended to interface with an entity's inventory. There is no concept of an "item target",
+unfortunately, so these generally either interact with the entity's held item or the entity's inventory at a high level.
+
+### AddItem
+
+Adds a specified quantity of a specified item to the User entity's inventory, preferring to add it to the
+entity's hotbar where possible. This interaction will have no effect on User entities that are not LivingEntities.
+This interaction has no failure states.
+
+**Note: This interaction has a bug in its field validators that will cause interactions that reference items declared
+in the same mod to fail validation on startup.  Additionally, this interaction has a bug that will cause it to
+fail and have no effect if the User entity has no block target. Use ModifyInventory instead.**
+
+**AddItem Fields**
+
+| Field Name       | Type                              | Required? | Notes                                                                                                                             |
+| ---------------- | --------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false)   | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+| ItemId           | `Asset`<br />(Asset Type: `Item`) | **Yes**   | The item id of the item to add to the player's inventory.                                                                         |
+| Quantity         | `Integer`<br />(Default: 0)       | **No**    | The quantity of the item to add to the player's inventory.                                                                        |
+
+### CheckUniqueItemUsage
+
+This interaction will check whether it has run once for the User entity with their currently-held item before. If it hasn't,
+it will succeed. If it has, it will fail. It will also fail if the User entity is not a player. The interaction will record
+the item id of the User entity's currently-held item on success, ensuring it cannot be successfully run with that player
+and item id combination again.
+
+**This interaction has no additional fields.**
+
+### ChangeActiveSlot
+
+This interaction does not inherit from SimpleInteraction and therefore has no Next or Failed fields.  The `CancelOnItemChange`
+field is ignored for this interaction and is always treated as false. This interaction will set the User entity's currently-
+active hotbar slot to the specified slot index. If none is specified, the interaction chain's target slot will be used,
+if any. Otherwise, slot 0 will be used.  If a slot is specified and it is already active, then this interaction will
+have no effect, but if no slot is specified and the interaction chain's target slot is already active, the logic in
+the next paragraph will still be executed. This interaction will also have no effect if the User entity is not a
+LivingEntity.
+
+Once the slot has changed, a new SwapTo interaction chain will be forked off for the selected slot.
+If a target slot was specified, then the interaction chain's current target slot will be set to the specified slot, as will
+the forked SwapTo interaction chain. If this interaction chain was initiated by a player swapping an item into or out of
+an occupied active hotbar slot, then the swap will be executed after the slot is changed and before the SwapTo
+interaction is forked. Not running this interaction in the resulting SwapFrom interaction chain is a way for the server
+to cancel players performing these sorts of swap interactions. The default behavior for these swap interactions is that
+the SwapFrom interaction chain will be initiated with the currently-active-slot as the target slot. As a result, the
+target slot will usually not change when this interaction runs, it merely exists as a signal for the server to continue the
+item swap.
+
+**ChangeActiveSlot Fields**
+
+| Field Name | Type      | Required? | Notes                                                                                                                                                                                                     |
+| ---------- | --------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| TargetSlot | `Integer` | **No**    | If not provided, indicates the slot the player's active hotbar slot should be changed to.  Otherwise, the interaction chain's target slot will be used (which is usually the already-active hotbar slot). |
+
+### EquipItem
+
+This interaction will equip the User entity's currently-held item into the appropriate armor slot, if it is armor. The
+interaction will fail if the item is armor but it cannot be equipped for some reason. The interaction will succeed but
+take no action if the User entity cannot equip armor or if the item is not armor.
+
+**This interaction has no additional fields.**
+
+### IncreaseBackpackCapacity
+
+This interaction will increase the User entity's backpack size by the provided amount.  **It will additionally remove one
+quantity from the player's currently-held item. There is no way to prevent this.**  This interaction will have no effect
+if the User entity is not a player.  This interaction has no special failure conditions, even if the User entity
+is not a player, or the player is not currently holding an item.
+
+| Field Name | Type                        | Required? | Notes                                                                                   |
+| ---------- | --------------------------- | --------- | --------------------------------------------------------------------------------------- |
+| Capacity   | `Integer`<br />(Default: 1) | **No**    | The additional backpack capacity to add to the player. **Must be between 1 and 32767.** |
+
+### ModifyInventory
+
+This interaction attempts to perform one or more inventory-modifying actions against the User entity. The User entity must
+be a player. If they are not, no actions will be performed, but the interaction will not fail. Any item removals performed
+by this interaction, either as a result of `ItemToRemove` or `AdjustHeldItemQuantity`, are both atomic (meaning the entire
+quantity must be removed, or none) and required (meaning that the interaction will fail and no further actions taken if
+the removal fails for any reason).  Item additions performed by this interaction, either as a result of `ItemToAdd` or
+`AdjustHeldItemQuantity` will drop excess items on the ground near the player if necesary and continue on.
+
+This interaction first executes the item removal in `ItemToRemove`, if any, then adjusts the held item as specified by
+`AdjustHeldItemQuantity`, if provided, then executes the item addition in `ItemToAdd`, if any, and then finally executes
+the damage/healing of the held item in `AdjustHeldItemDurability`, if provided.
+
+**ModifyDurability Fields**
+
+| Field Name               | Type                            | Required? | Notes                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
+| ------------------------ | ------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| RequiredGameMode         | `GameMode`                      | **No**    | If provided, only execute the inventory-modifying actions if the player is in the provided GameMode. The interaction will not fail if the GameMode doesn't match.                                                                                                                                                                                                                                                                                                                                                                               |
+| ItemToRemove             | `ItemStack`                     | **No**    | If provided, a matching item will be removed in the provided quantity. If there is no matching item in the player inventory in the required quantity, then the interaction will fail and further actions will not be executed.                                                                                                                                                                                                                                                                                                                  |
+| AdjustHeldItemQuantity   | `Integer`<br />(Default: 0)     | **No**    | The player's held item, if any, will have its quantity will be modified by the provided amount- subtracted from if this number is negative or added to if this item is positive.  If the player has no held item, then this field will have no effect regardless of its value and the interaction will NOT fail.  If the player's inventory does not have sufficient quantity of items to support the removal, this interaction will fail and further actions will not be executed. Excess items will be dropped on the ground near the player. |
+| ItemToAdd                | `ItemStack`                     | **No**    | If provided, the ItemStack will be added to the player's inventory. Excess items will be dropped on the ground near the player.                                                                                                                                                                                                                                                                                                                                                                                                                 |
+| AdjustHeldItemDurability | `Double`<br />(Default: 0.0)    | **No**    | The player's held item, if any, will have its durability adjusted by the specified amount.  The durability cannot go below 0 or raise above the item's maximum durability. Invalid durability values in this field will not cause the interaction to fail. Neither will it fail if the player has no held item.                                                                                                                                                                                                                                 |
+| BrokenItem               | `String`                        | **No**    | This field should contain an ItemId, but it is not validated by the server on startup, so be careful.  This field can have the value of "Empty" to specify no item, or an empty hand. If specified and the `AdjustHeldItemDurability` operation reduces the player's held item to 0 durability, the player's held item is changed to this ItemId. If the inventory replacement fails, this interaction will fail.                                                                                                                               |
+| NotifyOnBreak            | `Boolean`<br />(Default: false) | **No**    | If true and the `AdjustHeldItemDurability` operation reduces the player's held item to 0 durability, this interaction will perform the usual audiovisual feedback of a broken tool. It will play the usual tool breaking sound and send the player a text message in chat that their item has broken.                                                                                                                                                                                                                                           |
+| NotifyOnBreakMessage     | `String`                        | **No**    | If provided, and `NotifyOnBreak` is true, when the player is notified of a broken tool by this interaction, the message sent to their chat will instead be the translation key specified by this field. The translation key supports the templating parameter `{itemName}`. See the translation key `server.general.repair.itemBroken_Hoe` for an example.                                                                                                                                                                                      |
+
+**GameMode Values**
+
+- `Creative`: The game is currently in Creative Mode
+- `Adventure`: The game is currently in Adventure Mode
+
+**ItemStack Fields**
+
+| Field Name                   | Type                              | Required? | Notes                                                                                |
+| ---------------------------- | --------------------------------- | --------- | ------------------------------------------------------------------------------------ |
+| Id                           | `Asset`<br />(Asset Type: `Item`) | **Yes**   | The id of the Item asset this stack contains.                                        |
+| Quantity                     | `Integer`<br />(Default: 1)       | **No**    | The number of items in this stack.<br />**Must be greater than 0.**                  |
+| Durability                   | `Double`<br />(Default: 0.0)      | **No**    | The durability of the item stack.<br />**Cannot be negative.**                       |
+| MaxDurability                | `Double`<br />(Default: 0.0)      | **No**    | The maximum durability of the item this stack contains.<br />**Cannot be negative.** |
+| Metadata                     | `Bson Document`                   | **No**    | If provided, applies the bson to the item stack metadata.                            |
+| OverrideDroppedItemAnimation | `Boolean`\*(Default: false)       | **No**    | ???                                                                                  |
+
+### PickupItem
+
+This interaction will attempt to pick up the User entity's current target entity and add it to their inventory. It will
+fail if the User entity is not a player, if they do not have a target entity, or if the target entity is not an item
+located in the world.  It will not fail if the player simply cannot pick up the item.
+
+**This interaction has no additional fields.**
+
+### RefillContainer
+
+This interaction will fail if the User entity is not a player. The interaction will draw a ray from the player's head
+down their look direction until the edge of the player's held item's interaction range or until the first solid block.
+The nearest fluid block of a type listed in this interaction's `States` map will result in the one of the player's
+currently-held items being converted to the fluid's related item state.  If the `States` map indicates a durability
+for the new item state, then the converted item will use that durability. If the item is already in the fluid's related
+item state, then this interaction will fail if the player's held item is already at maximum durability (unless the
+`States` map indicates a durability value greater than the item's maximum, in which case the interaction will succeed
+but the item will not change).  Otherwise, the durability listed for the fluid in the `States` map will be added to the
+item's current durability.
+
+If the interaction has not failed by this point, the fluid block in the world may be transformed to a different type if one is listed
+in the `States` map.
+
+If any part of this process does not proceed for any reason (for instance, if the player is not holding an item),
+then this interaction will fail.
+
+**RefillContainer Fields**
+
+| Field Name | Type                                                       | Required? | Notes                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| ---------- | ---------------------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| States     | `Map`<br />(Key Type: `String`, Value Type: `RefillState`) | **Yes**   | A map from item state names to `RefillState` objects, which contain information such as acceptable fluid block types, durability increases, and what fluid type to convert the targeted fluid block to after refill, if any. If the player targets a fluid block that matches one of the fluid types in the `RefillState`, the item will be converted to the keyed item state and the `RefillState` will be used to decide what happens next. |
+
+**RefillState Fields**
+
+| Field Name     | Type                                  | Required? | Notes                                                                                                                                                                                                                                                                                                                           |
+| -------------- | ------------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| AllowedFluids  | `Array`<br />(Element Type: `String`) | **Yes**   | If any of these fluids are targeted by the player, the player's held item will be converted to the keyed item state and `Durability` and `TransformFluid` will be used.                                                                                                                                                         |
+| Durability     | `Double`<br />(Default: -1.0)         | **No**    | If the player's held item changes item states, this value is the new item's durability, unless it is negative, in which case the item will begin at full durability. If the player's held item is already in the item state, and the item is not already at full durability, this value will be added to the item's durability. |
+| TransformFluid | `String`                              | **No**    | If provided, this field is a fluid id that the targeted fluid block should be transformed to if the player's held item is successfully updated.                                                                                                                                                                                 |
+
+## Entities
+
+### DamageEntity
+
+This interaction does not inherit from SimpleInteraction, but adds its own Next and Failed fields that
+work similarly.
+
+This interaction will cause the User entity to damage the Target entity.  It has the capability to apply different
+damage based on the direction of the attack or what body part was targeted by the User entity, with each possibility
+providing different damage calculations, effects, and Next interaction. If multiple entires match the attack, `TargetedDamage`
+(body part damage) takes highest priority, then the first matching `AngledDamage` in the list, then the default
+damage in the base interaction fields.  It is possible for elements of these different damage priorities to be taken peacemeal if higher-priority
+damage fields do not overwrite lower-priority damage fields. For instance,
+damage calculation could be taken from `TargetedDamage`, the damage effects could be taken from the first matching
+`AngledDamage`, and the Next interaction coming from the default damage field.
+
+If all damage dealt by this interaction is cancelled, then this interaction will fail, and the `Failed` interaction
+will be executed next in the chain. If any damage dealt by this interaction is blocked, then this interaction will
+succeed, but the `Blocked` interaction wil lbe executed next in the chain. Otherwise, the highest-precedent matching
+`Next` interaction that you provide will be executed.  For instance, if you provide `Next` interactions for all
+`TargetedDamage` and `AngledDamage` entries, and one in the interaction's `Next` field, then a headshot could result
+in a unique `Next` interaction being executed, even if there is a matching `AngledDamage` entry. However, if you leave
+the `Next` interaction out of your `TargetedDamage` entries, a special `Next` interaction for backstabs could be
+executed.  Otherwise, the `Next` field in the root of the interaction will be executed instead.
+
+DamageEntity has an unusual relationship with `RunTime`. This interaction always ends immediately after its first tick,
+regardless of the status of `RunTime` or `WaitForAnimationToFinish`.  However, if damage dealt by this interaction is
+calculated as `DamageCalculatorType` `Dps`, then the `RunTime` will be used to determine the precise amount of damage to
+deal. If `RunTime` is 0, then no damage will be dealt.
+
+**DamageEntity Fields**
+
+| Field Name       | Type                                                          | Required?                                                                                                                    | Notes                                                                                                                                                                                                                                                                                                                                                                         |
+| ---------------- | ------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| DamageCalculator | `DamageCalculator`                                            | **No**                                                                                                                       | If provided, describes the damage amounts and types to apply to the Target entity.                                                                                                                                                                                                                                                                                            |
+| DamageEffects    | `DamageEffects`                                               | **No**                                                                                                                       | If provided, describes particles, sounds, knockback, etc. to apply to the target entity on damage.                                                                                                                                                                                                                                                                            |
+| Next             | `Asset`<br />(Asset Type: `Interaction`)                      | **No**  After this interaction has finished, "Next" will be executed if damage was dealt to the target and none was blocked. |                                                                                                                                                                                                                                                                                                                                                                               |
+| AngledDamage     | `Array`<br />(Element Type: `AngledDamage`)                   | **No**                                                                                                                       | If provided, allows alternative `DamageCalculator`, `DamageEffects`, and `Next` entries for attacks that approach the target from certain angles.                                                                                                                                                                                                                             |
+| TargetedDamage   | `Map`<br />(Key Type: `String`, Value Type: `TargetedDamage`) | **Yes**                                                                                                                      | This field must be provided, but is not required to have any entries.  This is a map from body part names to `TargetedDamage` values. Hypixel only uses one body part name: `Head`, and it is not clear whether there are others.  If provided, allows alternative `DamageCalculator`, `DamageEffects`, and `Next` entries for attacks that damage specific enemy body parts. |
+| EntityStatsOnHit | `Array`<br />(Element Type: `EntityStatOnHit`)                | **No**                                                                                                                       | If provided, allows this attack to reduce enemy stats other than health.  Each individual damage application dealt by the same ability will apply stat reductions, at diminishing returns. All damage dealt in interaction chains forked by a Selector interaction will share the number of hits across all targets.                                                          |
+| Failed           | `Asset`<br />(Asset Type: `Interaction`)                      | **No**                                                                                                                       | After this interaction has finished, "Failed" will be executed if no damage hits were applied to the player, or if all damage hits were cancelled.                                                                                                                                                                                                                            |
+| Blocked          | `Asset`<br />(Asset Type: `Interaction`)                      | **No**                                                                                                                       | After this interaction has finished, "Blocked" will be executed if any damage hits were blocked by the target.                                                                                                                                                                                                                                                                |
+
+**DamageCalculator Fields**
+
+| Field Name                | Type                                                      | Required? | Notes                                                                                                                                                                                                                                                 |
+| ------------------------- | --------------------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Type                      | `DamageCalculatorType`<br />(Default: Absolute)           | **No**    | Whether the damage being applied is `Absolute` or \`Dps'.                                                                                                                                                                                             |
+| Class                     | `DamageClass`<br />(Default: Unknown)                     | **No**    | The type of attack producing the damage. Some weapon systems apply equipment modifiers based on this value.                                                                                                                                           |
+| BaseDamage                | `Map`<br />(Key Type: `DamageCause`, Value Type: `Float`) | **No**    | A set of DamageCauses and how much base damage is dealt for each.                                                                                                                                                                                     |
+| SequentialModifierStep    | `Float`<br />(Default: 0.0)                               | **No**    | Value between 0.0-1.0. Each additional hit from a single ability will have its damage reduced by this much as a percentage. All damage dealt in interaction chains forked by a Selector interaction will share the number of hits across all targets. |
+| SequentialModifierMinimum | `Float`<br />(Default: 0.0)                               | **No**    | Value between 0.0-1.0. `SequentialModifierStep` cannot reduce damage below this percentage regardless of the number of hits.                                                                                                                          |
+| RandomPercentageModifier  | `Float`<br />(Default: 0.0)                               | **No**    | A random value between +/- this amount multiplied by the base damage will be added to the base damage.                                                                                                                                                |
+
+**DamageEffects Fields**
+
+| Field Name             | Type                                         | Required? | Notes                                                                                   |
+| ---------------------- | -------------------------------------------- | --------- | --------------------------------------------------------------------------------------- |
+| ModelParticles         | `Array`<br />(Element Type: `ModelParticle`) | **No**    | Particle systems to trigger in the first-person view.                                   |
+| WorldParticles         | `Array`<br />(Element Type: `WorldParticle`) | **No**    | Particle systems to trigger in the third-person view.                                   |
+| LocalSoundEventId      | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | 2D sound to play locally to the attacking entity if they are a player.                  |
+| WorldSoundEventId      | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | Sound to play in the world at the Target entity's location.                             |
+| PlayerSoundEventId     | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | 2D sound to play locally to the Target entity if they are a player.                     |
+| ViewDistance           | `Double`<br />(Default: 75.0)                | **No**    | Distance at which these effects should play for other players.                          |
+| Knockback              | `Knockback`                                  | **No**    | The properties of the knockback that will be applied.                                   |
+| CameraEffect           | `Asset`<br />(Asset Type: `CameraEffect`)    | **No**    | CameraEffect to briefly apply locally to the Target entity if they are a player.        |
+| StaminaDrainMultiplier | `Float`<br />(Default: 1.0)                  | **No**    | This multiplier is applied to the stamina cost incurred by the target blocking, if any. |
+
+**AngledDamage Fields**
+
+| Field Name       | Type                                     | Required? | Notes                                                                                                                                                                                                     |
+| ---------------- | ---------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| AngleDistance    | `Float`<br />(Default: 0)                | **No**    | The width in degrees of the matching arc around the Target entity. If the attack against the Target originates from within the arc, then the properties below will be applied to the attack, if provided. |
+| Angle            | `Float`<br />(Default: 0.0)              | **No**    | The angle in degrees around the Target entity at which the matching arc is centered.                                                                                                                      |
+| DamageCalculator | `DamageCalculator`                       | **No**    | If provided and the attack against the Target entity originates from within the provided arc, this DamageCalculator will override the interaction's `DamageCalculator` field.                             |
+| DamageEffects    | `DamageEffects`                          | **No**    | If provided and the attack against the Target entity originates from within the provided arc, this DamageEffects will override the interaction's `DamageEffects` field.                                   |
+| Next             | `Asset`<br />(Asset Type: `Interaction`) | **No**    | If provided and the attack against the Target entity originates from within the provided arc, this Interaction will override the interaction's `Next` field.                                              |
+
+**TargetedDamage Fields**
+
+| Field Name       | Type                                     | Required? | Notes                                                                                                                                                                                            |
+| ---------------- | ---------------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| DamageCalculator | `DamageCalculator`                       | **No**    | If provided and this TargetedDamage was matched, this DamageCalculator will override the interaction's `DamageCalculator` field and the `DamageCalculator` field of any matching `AngledDamage`. |
+| DamageEffects    | `DamageEffects`                          | **No**    | If provided and this TargetedDamage was matched, this DamageEffects will override the interaction's `DamageEffects` field and the `DamageEffects` field of any matching `AngledDamage`.          |
+| Next             | `Asset`<br />(Asset Type: `Interaction`) | **No**    | If provided and this TargetedDamage was matched, this Interaction will override the interaction's `Next` field and the `Next` field of any matching `AngledDamage`.                              |
+
+**EntityStatOnHit Fields**
+
+| Field Name                  | Type                                                                       | Required? | Notes                                                                                                                                                                                                                                                                                        |
+| --------------------------- | -------------------------------------------------------------------------- | --------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| EntityStatId                | `Asset`<br />(AssetType: `EntityStatType`)                                 | **Yes**   | Which entity stat to affect.                                                                                                                                                                                                                                                                 |
+| Amount                      | `Float`<br />(Default: 0.0)                                                | **No**    | How much of the stat to apply for each damage application. Use negative numbers to reduce stats.                                                                                                                                                                                             |
+| MultipliersPerEntitiesHit   | `Array`<br />(Element Type: `Float`, Default: `[1.0, 0.6, 0.4, 0.2, 0.1]`) | **No**    | The diminishing returns curve to be applied for multiple damage applications by the same ability. Each hit's stat impact will be multiplied by the next value in the list.  If there are more hits than array elements, subsequent hits will be multiplied by `MultiplierPerExtraEntityHit`. |
+| MultiplierPerExtraEntityHit | `Float`<br />(Default: 0.05)                                               | **No**    | If an ability carries out more damage applications than there are elements in the `MultipliersPerEntitiesHit` array, then subsequent stat values will be multiplied by this number.                                                                                                          |
+
+**Knockback Fields**
+
+| Field Name     | Type                                       | Required? | Notes                                                                                                                      |
+| -------------- | ------------------------------------------ | --------- | -------------------------------------------------------------------------------------------------------------------------- |
+| Type           | `String`                                   | **No**    | If provided, specifies a type of knockback to use. Each Target type may come with additional fields.                       |
+| Force          | `Double`<br />(Default: 0.0)               | **No**    | The amount of force to apply to the Owner entity.                                                                          |
+| Duration       | `Double`<br />(Default: 0.0)               | **No**    | If 0.0, apply the force as a single impulse.  If more, continuously apply the force over a period of time.                 |
+| VelocityType   | `ChangeVelocityType`<br />(Default: `Add`) | **No**    | How to apply the force, either adding it to the entity's current velocity, or setting the velocity to the knockback force. |
+| VelocityConfig | `VelocityConfig`                           | **No**    | Characteristics of friction as the Owner entity is thrown by this knockback.                                               |
+
+**Knockback Type: Force**
+
+Apply the calculated knockback force along the provided direction.
+
+| Field Name | Type                         | Required? | Notes                                                                                |
+| ---------- | ---------------------------- | --------- | ------------------------------------------------------------------------------------ |
+| Direction  | `Vector3`<br />(Default: Up) | **No**    | Which direction the entity should be flung, relative to the direction of the attack. |
+
+**Knockback Type: Point**
+
+Apply the calculated knockback force laterally along the XZ plane, plus provided Y velocity.
+
+| Field Name | Type                        | Required? | Notes                                                                                                   |
+| ---------- | --------------------------- | --------- | ------------------------------------------------------------------------------------------------------- |
+| OffsetX    | `Integer`<br />(Default: 0) | **No**    | Offset the source position of the knockback left or right perpendicular to the direction of the attack. |
+| OffsetZ    | `Integer`<br />(Default: 0) | **No**    | Offset the source position of the knockback, forward or backward along the directon of the attack.      |
+| RotateY    | `Integer`<br />(Default: 0) | **No**    | Rotate the knockback direction around the Y axis, where 0 is the default attack direction.              |
+| VelocityY  | `Float`<br />(Default: 0.0) | **No**    | Add vertical velocity to the knockback force after the direction and force has been calculated.         |
+
+**Knockback Type: Directional**
+
+Apply the calculated knockback force along the attack direction, removing any vertical component and replacing it with a provided Y velocity.
+
+| Field Name | Type                      | Required? | Notes                                                                                                                                            |
+| ---------- | ------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------ |
+| RelativeX  | `Float`<br />(Default: 0) | **No**    | Apply additional force left or right perpendicular to the direction of the attack. The additional force is multiplied by the knockback strength. |
+| RelativeZ  | `Float`<br />(Default: 0) | **No**    | Apply additional force forward or backward along the attack direction. The additional force is multiplied by the knockback strength.             |
+| VelocityY  | `Float`<br />(Default: 0) | **No**    | Replace the vertical velocity of the knockback with this value.  This value is not multiplied by knockback strength.                             |
+
+**VelocityConfig Fields**
+
+| Field Name          | Type                                              | Required? | Notes                                                                                                                                                                                           |
+| ------------------- | ------------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| GroundResistance    | `Float`<br />(Default: 0.82)                      | **No**    | The minimum amount of friction applied when the entity is in contact with the ground.  1.0 = no friction, 0.0 = total friction                                                                  |
+| GroundResistanceMax | `Float`<br />(Default: 0.0)                       | **No**    | The maximum amount of friction applied when the entity is in contact with the ground.  1.0 = no friction, 0.0 = total friction                                                                  |
+| AirResistance       | `Float`<br />(Default: 0.96)                      | **No**    | The minimum amount of friction applied when the entity is in the air. 1.0 = no friction, 0.0 = total friction                                                                                   |
+| AirResistanceMax    | `Float`<br />(Default: 0.0)                       | **No**    | The maximum amount of friction applied when the entity is in the air. 1.0 = no friction, 0.0 = total friction                                                                                   |
+| Threshold           | `Float`<br />(Default: 1.0)                       | **No**    | The speed at which the maximum amount of friction will be applied to the entity. The amount of friction applied will increase from minimum to maximum as the entity moves from 0 to this speed. |
+| Style               | `VelocityThresholdStyle`<br />(Default: `Linear`) | **No**    | The curve that friction follows as the entity's speed increases toward the `Threshold`.                                                                                                         |
+
+**DamageCalculatorType Values**
+
+- `Absolute`
+- `Dps`
+
+**DamageClass Values**
+
+- `Unknown`
+- `Light`
+- `Charged`
+- `Signature`
+
+**ChangeVelocityType Values**
+
+- `Add`
+- `Set`
+
+**VelocityThresholdStyle Values**
+
+- `Linear`
+- `Exp`
+
+### LaunchProjectile
+
+This is just a worse version of Projectile and is slated to be removed.  Use Projectile.
+
+### Projectile
+
+This interaction will spawn a new projectile at the User entity's eye position that will travel in its look direction.
+
+| Field Name | Type                                          | Required? | Notes                                                  |
+| ---------- | --------------------------------------------- | --------- | ------------------------------------------------------ |
+| Config     | `Asset`<br />(Asset Type: `ProjectileConfig`) | **No**    | Configuration describing the projectile to be spawned. |
+
+### RemoveEntity
+
+Despawns the specified entity from the world. This interaction will have no effect if the specified entity is a player. This
+interaction has no special failure conditions.
+
+| Field Name | Type                                     | Required? | Notes                  |
+| ---------- | ---------------------------------------- | --------- | ---------------------- |
+| Entity     | `InteractionTarget`<br />(Default: User) | **No**    | The entity to despawn. |
+
+**InteractionTarget Values**
+
+- `User` - The user of this interaction chain. The entity whose actions caused this interaction chain to be executed. This is usually the same as the Owner.
+- `Owner` - The owner of this interaction chain. The entity upon whom this interaction chain is executing.
+- `Target` - The entity target of this interaction chain, if any.  This value is mutable (and can therefore come from many places) but most commonly, it is an entity the User was targeting when this interaction chain began executing.
+
+### SendMessage
+
+This interaction sends a message to the Owner entity if that entity can receive messages.  Otherwise, the message
+is written to the server logs.  If the entity is a player, the message will appear in the player's chat window.
+
+\*\*SendMessage
+
+| Field Name | Type     | Required? | Notes                                                                                                                 |
+| ---------- | -------- | --------- | --------------------------------------------------------------------------------------------------------------------- |
+| Message    | `String` | **No**    | A text message to be sent to the Owner entity.  If this field is not provided, `Key` is used instead.                 |
+| Key        | `String` | **No**    | A translation key for a message to be sent to the Owner entity. If `Message` is provided, then this field is ignored. |
+
+### UseEntity
+
+This interaction is not in use by Hypixel and has some unusual qualities that mean it probably won't do what you want it
+to.  Do not use it.
+
+This interaction will retrieve the entity currently targeted by the client (NOT the interaction chain's current Target
+entity) and execute that entity's RootInteraction for this interaction chain's current interaction type. The
+RootInteraction will be executed as part of this current interaction chain. None of the properties of this interaction
+chain will be modified.
+
+This interaction will fail if the client is not currently targeting an entity, or if no interaction for the current
+interaction type exists on the entity.
+
+## Stats
+
+Hytale's resource system has been written about fairly extensively.  You can use these interactions to modify stats in
+response to actions or use stats as a cost for abilities.
+
+### ChangeStat
+
+This interaction applies a set of raw stat changes to the User entity. It has no special failure conditions.
+
+| Field Name    | Type                                                         | Required? | Notes                                                                                                                                                                                                                      |
+| ------------- | ------------------------------------------------------------ | --------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| StatModifiers | `Map`<br />(Key Type: `EntityStatType`, Value Type: `Float`) | **Yes**   | A set of stats to modify and what value to apply to them.                                                                                                                                                                  |
+| ValueType     | `ValueType`<br />(Default: Absolute)                         | **No**    | Whether the values in the `StatModifiers` map represent flat values to apply to the stat total, or percentages (0.0-100.0). Percentage values are percentage of the difference between the maximum and minimum stat value. |
+| Behaviour     | `ChangeStatBehavior`<br />(Default: Add)                     | **No**    | Whether the values in the `StatModifiers` map represent deltas to add into the User entity's current stat values, or fixed values to set the entity's stats to.                                                            |
+
+**ValueType Values**
+
+- `Absolute`
+- `Percent`
+
+**ChangeStatBehaviour Values**
+
+- `Add`
+- `Set`
+
+### ChangeStatWithModifier
+
+This interaction is like ChangeStat, except an armor stat modifier can be chosen which will apply bonuses and penalties
+to a stat from the User entity's equipped armor before it is applied.
+
+| Field Name            | Type                                                         | Required? | Notes                                                                                                                                                                                                                      |
+| --------------------- | ------------------------------------------------------------ | --------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| StatModifiers         | `Map`<br />(Key Type: `EntityStatType`, Value Type: `Float`) | **Yes**   | A set of stats to modify and what value to apply to them.                                                                                                                                                                  |
+| ValueType             | `ValueType`<br />(Default: Absolute)                         | **No**    | Whether the values in the `StatModifiers` map represent flat values to apply to the stat total, or percentages (0.0-100.0). Percentage values are percentage of the difference between the maximum and minimum stat value. |
+| Behaviour             | `ChangeStatBehavior`<br />(Default: Add)                     | **No**    | Whether the values in the `StatModifiers` map represent deltas to add into the User entity's current stat values, or fixed values to set the entity's stats to.                                                            |
+| InteractionModifierId | `InteractionModifierId`                                      | **Yes**   | The armor interaction modifier to apply bonuses and penalties for.                                                                                                                                                         |
+
+**ValueType Values**
+
+- `Absolute`
+- `Percent`
+
+**ChangeStatBehaviour Values**
+
+- `Add`
+- `Set`
+
+**InteractionModifierId Values**
+
+- `Dodge`
+
+### StatsCondition
+
+This interaction will fail if the User entity cannot afford the specified stats costs, or if it does not have the
+requested stats.
+
+| Field Name | Type                                                         | Required? | Notes                                                                                                                                                                                    |
+| ---------- | ------------------------------------------------------------ | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Costs      | `Map`<br />(Key Type:` EntityStatType`, Value Type: `Float`) | **Yes**   | A set of costs that the User entity needs to be able to afford for this interaction to succeed.                                                                                          |
+| ValueType  | `ValueType`<br />(Default: Absolute)                         | **No**    | Whether the values in the `Costs` map represetn flat values or percentages (0.0-100.0).  Percentage values are percentage of the difference between the maximum and minimum value.       |
+| LessThan   | `Boolean`<br />(Default: false)                              | **No**    | If true, this interaction will fail unless the User entity's current stat values are at or **below** the specified levels.  If false, they must be at or **above** the specified levels. |
+| Lenient    | `Boolean`<br />(Default: false)                              | **No**    | If true and `LessThan` is true, and a player's minimum stat value is below zero, then the player can afford a stat cost if the current value of a stat if above 0.                       |
+
+**ValueType Values**
+
+- `Absolute`
+- `Percent`
+
+### StatsConditionWithModifier
+
+This interaction is like StatsCondition, except an armor stat modifier can be chosen which will apply bonuses and penalties
+to a stat's cost from the User entity's equipped armor before it is compared.
+
+| Field Name            | Type                                                         | Required? | Notes                                                                                                                                                                                    |
+| --------------------- | ------------------------------------------------------------ | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Costs                 | `Map`<br />(Key Type:` EntityStatType`, Value Type: `Float`) | **Yes**   | A set of costs that the User entity needs to be able to afford for this interaction to succeed.                                                                                          |
+| ValueType             | `ValueType`<br />(Default: Absolute)                         | **No**    | Whether the values in the `Costs` map represetn flat values or percentages (0.0-100.0).  Percentage values are percentage of the difference between the maximum and minimum value.       |
+| LessThan              | `Boolean`<br />(Default: false)                              | **No**    | If true, this interaction will fail unless the User entity's current stat values are at or **below** the specified levels.  If false, they must be at or **above** the specified levels. |
+| Lenient               | `Boolean`<br />(Default: false)                              | **No**    | If true and `LessThan` is true, and a player's minimum stat value is below zero, then the player can afford a stat cost if the current value of a stat if above 0.                       |
+| InteractionModifierId | `InteractionModifierId`                                      | **Yes**   | The armor interaction modifier to apply bonuses and penalties for.                                                                                                                       |
+
+**ValueType Values**
+
+- `Absolute`
+- `Percent`
+
+**InteractionModifierId Values**
+
+- `Dodge`
+
+## EntityEffects
+
+EntityEffects are buff or debuff effects that can be applied to a LivingEntity.  These can have a variety of effects from
+movement speed changes to periodic damage.
+
+### EffectCondition
+
+This interaction will fail if the specified entity's EntityEffects do not match the provided conditions.
+
+**EffectCondition Fields**
+
+| Field Name      | Type                                             | Required? | Notes                                                                                                                                                                                                             |
+| --------------- | ------------------------------------------------ | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Entity          | `InteractionTarget`<br />(Default: User)         | **Yes**   | The entity to examine for EntityEffects. This field can indicate the Owner, User, or Target of this interaction chain.                                                                                            |
+| Match           | `Match`<br />(Default: All)                      | **No**    | If `All`, then this interaction will fail if any EntityEffect in the `EntityEffectIds` is not on the specified entity. If `None`, then this interaction will fail if any EntityEffect IS on the specified entity. |
+| EntityEffectIds | `AssetArray`<br />(Element Type: `EntityEffect`) | **Yes**   | The set of EntityEffects to check against the specified entity and `Match`.                                                                                                                                       |
+
+**InteractionTarget Values**
+
+- `User` - The user of this interaction chain. The entity whose actions caused this interaction chain to be executed. This is usually the same as the Owner.
+- `Owner` - The owner of this interaction chain. The entity upon whom this interaction chain is executing.
+- `Target` - The entity target of this interaction chain, if any.  This value is mutable (and can therefore come from many places) but most commonly, it is an entity the User was targeting when this interaction chain began executing.
+
+**Match Values**
+
+- `All` - All EntityEffects must be on the specified entity for this interaction to succeed.
+- `None` - None of the EntityEffects must be on the specified entity for this interaction to succeed.
+
+### ApplyEffect
+
+This interaction will apply the specified EntityEffect to the specified Entity.  It has no special failure conditions.
+
+**ApplyEffect Fields**
+
+| Field Name | Type                                      | Required? | Notes                                                                                                                  |
+| ---------- | ----------------------------------------- | --------- | ---------------------------------------------------------------------------------------------------------------------- |
+| Entity     | `InteractionTarget`<br />(Default: User)  | **Yes**   | The entity to apply the EntityEffect to. This field can indicate the Owner, User, or Target of this interaction chain. |
+| EffectId   | `Asset`<br />(Asset Type: `EntityEffect`) | **Yes**   | The effect to apply.                                                                                                   |
+
+**InteractionTarget Values**
+
+- `User` - The user of this interaction chain. The entity whose actions caused this interaction chain to be executed. This is usually the same as the Owner.
+- `Owner` - The owner of this interaction chain. The entity upon whom this interaction chain is executing.
+- `Target` - The entity target of this interaction chain, if any.  This value is mutable (and can therefore come from many places) but most commonly, it is an entity the User was targeting when this interaction chain began executing.
+
+### ClearEntityEffect
+
+This interaction will remove the specified EntityEffect from the specified Entity. It has no special failure conditions.
+It will not fail if the Entity does not have the EntityEffect.
+
+**ClearEntityEffect Fields**
+
+| Field Name | Type                                      | Required? | Notes                                                                                                                     |
+| ---------- | ----------------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------- |
+| Entity     | `InteractionTarget`<br />(Default: User)  | **Yes**   | The entity to remove the EntityEffect from. This field can indicate the Owner, User, or Target of this interaction chain. |
+| EffectId   | `Asset`<br />(Asset Type: `EntityEffect`) | **Yes**   | The effect to remove.                                                                                                     |
+
+**InteractionTarget Values**
+
+- `User` - The user of this interaction chain. The entity whose actions caused this interaction chain to be executed. This is usually the same as the Owner.
+- `Owner` - The owner of this interaction chain. The entity upon whom this interaction chain is executing.
+- `Target` - The entity target of this interaction chain, if any.  This value is mutable (and can therefore come from many places) but most commonly, it is an entity the User was targeting when this interaction chain began executing.
+
+## Farming
+
+These are interaction types built to support the in-game farming system in Hytale. They are mostly block-related interactions
+with a few exceptions.
+
+### ChangeFarmingStage
+
+If the target block is a farming block, this interaction will attempt to modify the current farming stage in one of
+three ways.  The interaction can optionally specify which StageSet to use for the new stage. If it is not specified,
+the current StageSet will be used. If any part of the the process of changing the growth stage fails, this interaction
+will fail, with the one exception that attempting to set the stage to the crop's existing stage will have no effect but
+still succeed.
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                                                                                                                                                                          |
+| ---------------- | ------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction.                                                                                                                                              |
+| StageSet         | `String`                        | **No**    | If provided, set the block's current stage to one in the provided StageSet. Otherwise, use the crop's current StageSet.                                                                                                                                                        |
+| Increase         | `Integer`                       | **No**    | If provided, increase the current stage by the specified amount. If the specified stage does not exist, the block will be set to the closest extant stage.                                                                                                                     |
+| Decrease         | `Integer`                       | **No**    | If provided and `Increase` is not provided, decrease the current stage by the specified amount. If the specified stage does not exist, the block will be set to the closest extant stage.                                                                                      |
+| Stage            | `Integer`<br />(Default: -1)    | **No**    | If provided and `Increase`/`Decrease` are not provided, set the current stage to the specified stage. If this value is less than 0, set the current stage to the final growth stage. If the specified stage does not exist, the block will be set to the closest extant stage. |
+
+### FertilizeSoil
+
+If the target block is unfertilized tilled soil or a farming block on top of unfertilized tilled soil, fertilizes the soil.
+The interaction will fail otherwise.
+
+**FertilizeSoil Fields**
+
+| Field Name       | Type                                  | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false)       | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+| RefreshModifiers | `Array`<br />(Element Type: `String`) | **No**    | Does nothing.                                                                                                                     |
+
+### HarvestCrop
+
+This interaction will attempt to execute the harvest action on the current block target and add the crop's drops to the User entity's
+inventory.  The block will either be destroyed or set to its post-harvest growth stage, depending on the farming
+configuration of the block.  This will happen (and the player will receive the full harvest drops) regardless of the
+block's current growth stage. This interaction has no special failure conditions, even if the block target isn't a
+farming block or gathering isn't permitted in the current world, but nothing will occur in those cases.
+
+**HarvestCrop Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+
+### UseWateringCan
+
+If the target block is tilled soil or a farming block on top of tilled soil, waters the soil for the specified duration.
+The interaction will fail otherwise.
+
+**UseWateringCan Fields**
+
+| Field Name       | Type                                  | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false)       | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+| Duration         | `Integer`<br />(Default: 0)           | **No**    | The duration in seconds to water the soil for.                                                                                    |
+| RefreshModifiers | `Array`<br />(Element Type: `String`) | **No**    | Does nothing.                                                                                                                     |
diff --git a/content/docs/ru-RU/contributing/pr-guidelines.mdx b/content/docs/ru-RU/contributing/pr-guidelines.mdx
index 7a251032..c226da04 100644
--- a/content/docs/ru-RU/contributing/pr-guidelines.mdx
+++ b/content/docs/ru-RU/contributing/pr-guidelines.mdx
@@ -19,6 +19,8 @@ To ensure a smooth and efficient review process, both contributors and reviewers
 4. **Code Quality**
    - Ensure your code follows the project's coding standards and best practices.
    - Include comments where necessary to explain complex logic.
+   - Always test your changes locally before submitting the PR to catch any issues early.
+   - Format your code using `bun format` to maintain consistency across the codebase.
 5. **Testing**
    - Test your changes thoroughly before submitting the PR.
    - If applicable, include unit tests or integration tests to verify your changes.
diff --git a/content/docs/ru-RU/contributing/translate.mdx b/content/docs/ru-RU/contributing/translate.mdx
new file mode 100644
index 00000000..c62ffdde
--- /dev/null
+++ b/content/docs/ru-RU/contributing/translate.mdx
@@ -0,0 +1,74 @@
+---
+title: Translate
+description: How to translate HytaleModding to your language
+---
+
+# Translating HytaleModding
+
+HytaleModding is translated with the help of the community using **Crowdin**. If you want to help translate or improve existing translations, this is the right place.
+
+## Steps to Translate
+
+All translations are managed **via Crowdin**.
+
+1. Visit [our Crowdin project](https://crowdin.com/project/hytalemodding) and log in if required.
+2. Click on your language.
+3. Click on the file/article you wish to translate. We recommend starting with Official Documentation, and then Server Plugin Documentation.
+4. Start translating!
+5. Approved translations will appear on the website.
+
+### Video Guide
+
+<iframe src="https://www.youtube.com/embed/NHiG1rDRgks" allowFullScreen />
+
+## How to discuss
+
+You can always report issues or discuss specific topics directly on Crowdin, but we recommend using Discord instead of the Crowdin comment system to keep everything organized in one place.
+
+1. Join [our Discord](https://discord.gg/hytalemodding)
+2. Open `#translations` channel. Here you can discuss or ask questions that are not related to a specific language.
+3. If you want to join a thread, you are required to run `/translator <your-language>` command here. The bot will add you to the thread for your language.
+
+## Translation Guidelines
+
+- You need to be confident in what you are translating. You should be able to read the text you just translated and understand the meaning of it very easily.
+- It should use the simplest form of language possible. Use English words if the translation is unknown to the majority in your country.
+- Use your imagination, trust yourself. Feel free to change any context as you wish as long as it can still get the same point across and is understandable.
+- These guidelines are more important than language-specific guidelines, but less important than Hytale terminology and rules.
+
+## What not to translate
+
+We request you all to not translate these specific sections of the website:
+
+### Callout types
+
+Callouts are the boxes that contain important information. We request you to not translate the types as they only work in English.
+
+**Example:**
+
+```mdx
+<Callout type="warning" title="Translate this title!">
+Translate the text inside the callout!
+</Callout>
+```
+
+In this example, please don't translate the word warning, the rest you can translate.
+
+### Icons
+
+Icon names must not be translated.
+They are technical identifiers mapped directly to existing icons. Translating them will break the icon rendering.
+
+```mdx
+icon: Globe
+```
+
+---
+
+{/* 
+For translators who will edit this page:
+
+- You are required to translate the Guidelines as they change.
+- General guidelines should be translated but not edited.
+- Learn how to use Markdown from writing_guides.mdx
+*/}
diff --git a/content/docs/ru-RU/established-information/server/content-categories/art-assets.mdx b/content/docs/ru-RU/established-information/server/content-categories/art-assets.mdx
index e4fa05d7..bddd19ea 100644
--- a/content/docs/ru-RU/established-information/server/content-categories/art-assets.mdx
+++ b/content/docs/ru-RU/established-information/server/content-categories/art-assets.mdx
@@ -14,7 +14,7 @@ Hytale обеспечивает полную поддержку для 3D мод
 Hytale использует **Blockbench** в качестве основного инструмента для 3D моделирования и анимации:
 
 * **Официальная поддержка**: используется для «создания моделей, текстур и анимаций»
-* **Специальный плагин**: Hytale будет выделен плагин Blockbench, который будет выпущен в ASAP
+* **Special plugin**: Hytale has a dedicated [Blockbench Plugin](https://www.blockbench.net/plugins/hytale_plugin).
 * **Прямая совместимость**: Плагин позволяет создателям "создавать совместимые с Hytale-модели, текстуры и анимации прямо в Blockbench"
 * **Заменяет устаревшие инструменты**: Полностью заменяет старый разработчик моделей Hytale Model Maker, чтобы соответствовать нынешним творческим процессам в нашем комьюнити
 * **Безопасность**: Позволяет добавлять только те вещи, которые совместимы с движком, так что не нужно беспокоиться о том, что ваша модификация что-то сломает
diff --git a/content/docs/ru-RU/guides/ecs/block-components.mdx b/content/docs/ru-RU/guides/ecs/block-components.mdx
new file mode 100644
index 00000000..ca68b38a
--- /dev/null
+++ b/content/docs/ru-RU/guides/ecs/block-components.mdx
@@ -0,0 +1,247 @@
+---
+title: Block Components
+description: Learn how to use the block components.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+  - name: oskarscot
+    link: https://oskar.scot
+---
+
+# Overview
+
+In this guide, you'll learn how to use block components to create a ticking block.
+
+<Callout>
+  For a more complete reference, you may also want to review FarmingSystems.Ticking, as much of the underlying logic is based on its implementation.
+</Callout>
+
+## Steps
+
+### 1. ExampleBlock - holds block behavior
+
+```java
+public class ExampleBlock implements Component<ChunkStore> {
+
+    public static final BuilderCodec CODEC = BuilderCodec.builder(ExampleBlock.class, ExampleBlock::new).build();
+
+    // Components usually require a copy constructor as well but since we don't actually hold any data in this component this is not neccessary
+    public ExampleBlock() { }
+
+    public static ComponentType getComponentType() {
+        return ExamplePlugin.get().getExampleBlockComponentType();
+    }
+
+    @Nullable
+    public Component<ChunkStore> clone() {
+        return new ExampleBlock();
+    }
+}
+```
+
+ExampleBlock is a custom component that stores the behavior and data for your ticking block. Here, it simply places an Ice Block at x + 1 relative to its current position when it ticks.
+
+---
+
+### 2. ExampleInitializer - marks blocks as ticking when placed
+
+```java
+public class ExampleInitializer extends RefSystem {
+
+    @Override
+    public void onEntityAdded(@Nonnull Ref ref, @Nonnull AddReason reason, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+        BlockModule.BlockStateInfo info = (BlockModule.BlockStateInfo) commandBuffer.getComponent(ref, BlockModule.BlockStateInfo.getComponentType());
+        if (info == null) return;
+
+        ExampleBlock generator = (ExampleBlock) commandBuffer.getComponent(ref, ExamplePlugin.get().getExampleBlockComponentType());
+        if (generator != null) {
+            int x = ChunkUtil.xFromBlockInColumn(info.getIndex());
+            int y = ChunkUtil.yFromBlockInColumn(info.getIndex());
+            int z = ChunkUtil.zFromBlockInColumn(info.getIndex());
+
+            WorldChunk worldChunk = (WorldChunk) commandBuffer.getComponent(info.getChunkRef(), WorldChunk.getComponentType());
+            if (worldChunk != null) {
+				worldChunk.setTicking(x, y, z, true);
+            }
+        }
+    }
+
+    @Override
+    public void onEntityRemove(@Nonnull Ref ref, @Nonnull RemoveReason reason, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+    }
+
+    @Override
+    public Query getQuery() {
+        return Query.and(BlockModule.BlockStateInfo.getComponentType(), ExamplePlugin.get().getExampleBlockComponentType());
+    }
+}
+```
+
+ExampleInitializer is a RefSystem that reacts when block entities with the ExampleBlock component are added or removed. This is crucial for marking blocks as ticking when they're first placed.
+
+**Key Points:**
+
+- Tells the game that this block should tick, allowing `ExampleSystem` to process it.
+
+```java
+worldChunk.setTicking(x, y, z, true);
+```
+
+---
+
+### 3. ExampleSystem - handles ticking
+
+```java
+public class ExampleSystem extends EntityTickingSystem {
+
+    public void tick(float dt, int index, @Nonnull ArchetypeChunk archetypeChunk, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+        BlockSection blocks = (BlockSection) archetypeChunk.getComponent(index, BlockSection.getComponentType());
+
+        assert blocks != null;
+
+        if (blocks.getTickingBlocksCountCopy() != 0) {
+            ChunkSection section = (ChunkSection) archetypeChunk.getComponent(index, ChunkSection.getComponentType());
+
+            assert section != null;
+
+            BlockComponentChunk blockComponentChunk = (BlockComponentChunk) commandBuffer.getComponent(section.getChunkColumnReference(), BlockComponentChunk.getComponentType());
+
+            assert blockComponentChunk != null;
+
+            blocks.forEachTicking(blockComponentChunk, commandBuffer, section.getY(), (blockComponentChunk1, commandBuffer1, localX, localY, localZ, blockId) -> {
+                Ref<ChunkStore> blockRef = blockComponentChunk.getEntityReference(ChunkUtil.indexBlockInColumn(localX, localY, localZ));
+                if (blockRef == null) {
+                    return BlockTickStrategy.IGNORED;
+                } else {
+                    ExampleBlock exampleBlock = (ExampleBlock) commandBuffer1.getComponent(blockRef, ExampleBlock.getComponentType());
+                    if (exampleBlock != null) {
+                        WorldChunk worldChunk = (WorldChunk) commandBuffer.getComponent(section.getChunkColumnReference(), WorldChunk.getComponentType());
+                        World world = worldChunk.getWorld();
+
+                        int globalX = localX + (worldChunk.getX() * 32);
+                        int globalZ = localZ + (worldChunk.getZ() * 32);
+
+                        // We need to execute setBlock on the world thread as you cannot call store functions from a system
+                        // This is because of the architecture of the server, depending on your needs you can also use the CommandBuffer
+                        world.execute(() -> {
+                            world.setBlock(globalX + 1, localY, globalZ, "Rock_Ice");
+                        });
+
+                        return BlockTickStrategy.CONTINUE;
+
+                    } else {
+                        return BlockTickStrategy.IGNORED;
+                    }
+                }
+            });
+        }
+    }
+
+    @Nullable
+    public Query getQuery() {
+        return Query.and(BlockSection.getComponentType(), ChunkSection.getComponentType());;
+    }
+}
+```
+
+ExampleSystem is an EntityTickingSystem that runs every tick to execute the logic for all ticking blocks with the ExampleBlock component.
+
+**Key Points:**
+
+- **Get the block component**
+
+```java
+ExampleBlock exampleBlock = (ExampleBlock) commandBuffer.getComponent(blockRef, ExampleBlock.getComponentType());
+```
+
+- **Convert local chunk coordinates to world coordinates**
+
+```java
+int globalX = localX + (worldChunk.getX() * 32);
+int globalZ = localZ + (worldChunk.getZ() * 32);
+```
+
+- **Run the block logic**
+
+```java
+exampleBlock.runBlockAction(globalX, localY, globalZ, worldChunk.getWorld());
+```
+
+- **Keep the block ticking in the next tick**
+
+```java
+return BlockTickStrategy.CONTINUE;
+```
+
+---
+
+### 4. ExamplePlugin - registers components and systems
+
+```java
+public class ExamplePlugin extends JavaPlugin {
+    protected static ExamplePlugin instance;
+    private static final HytaleLogger LOGGER = HytaleLogger.forEnclosingClass();
+    private ComponentType exampleBlockComponentType;
+
+    public static ExamplePlugin get() {
+        return instance;
+    }
+
+    public ExamplePlugin(@Nonnull JavaPluginInit init) {
+        super(init);
+        LOGGER.atInfo().log("Hello from " + this.getName() + " version " + this.getManifest().getVersion().toString());
+    }
+
+    @Override
+    protected void setup() {
+        instance = this;
+        LOGGER.atInfo().log("Setting up plugin " + this.getName());
+        this.exampleBlockComponentType = this.getChunkStoreRegistry().registerComponent(ExampleBlock.class, "ExampleBlock", ExampleBlock.CODEC);
+    }
+	
+	@Override
+	protected void start() {
+		this.getChunkStoreRegistry().registerSystem(new ExampleSystem());
+		this.getChunkStoreRegistry().registerSystem(new ExampleInitializer());
+	}
+
+    public ComponentType getExampleBlockComponentType() {
+        return this.exampleBlockComponentType;
+    }
+}
+```
+
+---
+
+### 5. Configure In-Game
+
+![block-component-1](/assets/guides/block-component-1.png)
+
+![block-component-2](/assets/guides/block-component-2.png)
+
+With this logic, the block will now continuously place an Ice Block at the coordinates x + 1 relative to its current position every time it ticks.
+
+---
+
+## Common Issues
+
+### NullPointerException on Startup
+
+**Error message:**
+
+```java
+java.lang.NullPointerException: Cannot invoke "com.hypixel.hytale.component.query.Query.validateRegistry(com.hypixel.hytale.component.ComponentRegistry)" because "query" is null
+```
+
+**Cause:**
+This error occurs when your module is loaded **before** the required Hytale modules.
+
+**Fix:**
+Add `EntityModule` and `BlockModule` as dependencies in your `manifest.json` to ensure proper load order.
+
+```json
+"Dependencies": {
+  "Hytale:EntityModule": "*",
+  "Hytale:BlockModule": "*"
+}
+```
diff --git a/content/docs/ru-RU/guides/ecs/hytale-ecs-theory.mdx b/content/docs/ru-RU/guides/ecs/hytale-ecs-theory.mdx
index db300136..7b774427 100644
--- a/content/docs/ru-RU/guides/ecs/hytale-ecs-theory.mdx
+++ b/content/docs/ru-RU/guides/ecs/hytale-ecs-theory.mdx
@@ -28,7 +28,7 @@ authors:
 
 ## Holder
 
-Holder - это по сути чертёж (шаблон) сущности. Прежде чем сущность появится в Store (и, соответственно, в мире), она существует как `Holder`. Он собирает и хранит все необходимые компоненты (данные). Можно сравнить это с корзиной для покупок. Вы берёте все нужные компоненты, и когда всё собрано, "оформляете покупку" в Store: он принимает ваш "корзину", создаёт корректный ID сущности и выдаёт вам "чек" (Ref).
+Holder - это по сути чертёж (шаблон) сущности. Before an entity exists in the Store (and thus in the world), it exists as a `Holder`. Он собирает и хранит все необходимые компоненты (данные). Можно сравнить это с корзиной для покупок. Вы берёте все нужные компоненты, и когда всё собрано, "оформляете покупку" в Store: он принимает ваш "корзину", создаёт корректный ID сущности и выдаёт вам "чек" (Ref).
 
 Давайте рассмотрим пример: инициализация игроков. В `Universe` метод `addPlayer` демонстрирует это идеально.
 Когда игрок подключается, мы не сразу бросаем его в ECS. Сначала мы создаем их данные в Holder.
@@ -74,6 +74,7 @@ protected void execute(@Nonnull CommandContext commandContext, @Nonnull Store<En
   player.sendMessage(Message.raw("UUIDComponent : " + component.getUuid()));
   player.sendMessage(Message.raw("Transform : " + transform.getPosition()));
 }
+
 ```
 
 Здесь мы используем `Store<EntityStore>`, чтобы получить компонент `Player` через `Ref<EntityStore>`. То же самое можно сделать и с другими компонентами, например `UUIDComponent` или `TransformComponent`, чтобы получить трансформ сущности - позицию и положение (поворот).
@@ -162,11 +163,11 @@ commandBuffer.removeComponent(ref, componentType);
 MyComponent comp = commandBuffer.getComponent(ref, componentType);
 ```
 
-## Codec
+## Кодек
 
-Codecs handle serialization and deserialization of components. Hytale uses them to save and load entity data to and from disk as well as sending component data over the network. When creating a custom component, you must also create a corresponding Codec.
+Кодеки обрабатывают сериализацию и десериализацию компонентов. Hytale использует их для сохранения и загрузки данных сущностей на диск и с диска, а также для отправки данных компонентов по сети. При создании пользовательского компонента необходимо также создать соответствующий кодек.
 
-There are mutliple Codec types already implemented in the default Codec Interface:
+There are multiple Codec types already implemented in the default Codec Interface:
 
 - Codec.STRING
 - Codec.BOOLEAN
@@ -186,16 +187,16 @@ There are mutliple Codec types already implemented in the default Codec Interfac
 - Codec.DURATION
 - Codec.DURATION_SECONDS
 - Codec.LOG_LEVEL
-- Codec.UUID_BINARY
+- Codec.LOG_LEVEL
 - Codec.UUID_STRING
 
-Aside from the basic types, there are also more complex Codec implementations like `CodecMap`, `ObjectMapCodec` or `EnumCodec`.
+Помимо базовых типов, существуют также более сложные реализации кодеков, такие как `CodecMap`, `ObjectMapCodec` или `EnumCodec`.
 
-### Builder Codec
+### BuilderCodec
 
-The `BuilderCodec` is a powerful utility for creating your custom codecs. It allows you to define how each field in your component is serialized and deserialized. Each Field needs to have the following information:
+BuilderCodec — это мощная утилита для создания пользовательских кодеков. Он позволяет определить, как каждое поле в вашем компоненте будет сериализовано и десериализовано. Каждое поле должно содержать следующую информацию:
 
-- The KeyedCodec to use for serialization/deserialization of the field. This can be one of the built-in codecs or a custom codec if your field is a complex type. To initialize a KeyedCodec you need to provide a unique string identifier for the codec and the actual Codec instance to use for the field.
+- KeyedCodec, который будет использоваться для сериализации/десериализации поля. Им может быть один из встроенных кодеков или пользовательский кодек, если ваше поле имеет сложный тип. Для инициализации KeyedCodec необходимо предоставить уникальный строковый идентификатор кодека и фактический экземпляр Codec, который будет использоваться для самого поля.
 
 <Callout type="warning">
   Keep in mind that every KeyedCodec identifier string must start Uppercase and be unique across your entire mod. This means that if you have multiple components, each field's KeyedCodec identifier must not clash with any other field's identifier in any other component within your mod. Otherwise you may run into serialization issues.
@@ -214,7 +215,7 @@ This might seem tedious at first but it ensures that your component can be corre
   KeyedCodec<Integer> exampleInt = new KeyedCodec<Integer>("ExampleIntIdForCodec", Codec.INTEGER);
   ```
 
-- **Setter Function**: This is a lambda function that takes an instance of your component and returns the value of the field you want to serialize. For example, if you have a field called `myCustomField` in your custom component, your getter function would look like this:
+- **Setter Function**: This is a lambda function that takes an instance of your component + the value to set and sets the field value on the component. For example, if you have a field called `myCustomField` in your custom component, your setter function would look like this:
   ```java
   (data, value) -> data.myCustomField = value
   ```
@@ -275,7 +276,7 @@ public class PoisonComponent implements Component<EntityStore> {
 
 You can also add validators to your Codec fields to ensure that the data being serialized/deserialized meets certain criteria. For example, if you want to ensure that the `damagePerTick` field is always non-negative or the poison name is never null, you can add a validator like this:
 
-````java
+```java
 .append(
     new KeyedCodec<Float>("DamagePerTick", Codec.FLOAT),
     (data, value) -> data.damagePerTick = value,
@@ -291,15 +292,16 @@ You can also add validators to your Codec fields to ensure that the data being s
 )
 .addValidator(Validators.nonNull())
 .add()
+```
 
 ### Complex Codec Examples
 
-If you want to have a map inside your component, you can use the MapCodec class to build a KeyedCoded for it. Here's an example of how to create a Codec for a Map field:
+If you want to have a map inside your component, you can use the MapCodec class to build a KeyedCodec for it. Here's an example of how to create a Codec for a Map field:
 
 ```java
 var damagePerTick = new KeyedCodec<>("DamagePerTick", new MapCodec<>(Codec.FLOAT, HashMap<String, Float>::new));
-````
+```
 
 <Callout type="info">
-  This also works with custom Objects as long as you have a Codec defined for the Object type.
+  Это также работает с пользовательскими объектами, если для типа объекта определен кодек.
 </Callout>
diff --git a/content/docs/ru-RU/guides/ecs/systems.mdx b/content/docs/ru-RU/guides/ecs/systems.mdx
index eec8e494..f7da5d63 100644
--- a/content/docs/ru-RU/guides/ecs/systems.mdx
+++ b/content/docs/ru-RU/guides/ecs/systems.mdx
@@ -1,16 +1,16 @@
 ---
-title: Systems
-description: In this guide you will learn about how systems work inside of Hytale.
+title: Системы
+description: В этом руководстве вы узнаете, как системы работают внутри Hytale.
 authors:
   - name: oskarscot
     url: https://oskar.scot
 ---
 
-Systems are where the logic lives. While components are pure data containers, systems operate on entities that match specific component queries. The ECS scheduler runs systems each tick, passing in only the entities that have the components the system cares about.
+Системы - это место, где находится логика. Если компоненты являются просто хранилищами данных, то системы работают на сущностях с определёнными компонентами. Планировщик ECS запускает системы каждый тик, передавая им только те сущности, которые имеют компоненты, необходимые системе.
 
 ### EntityTickingSystem
 
-The most common system type. It runs every tick and processes each entity matching its query individually.
+Наиболее распространенный тип системы. Он запускается при каждом тике и обрабатывает каждую сущность, соответствующую его запросу, индивидуально.
 
 ```java
 public class PoisonSystem extends EntityTickingSystem<EntityStore> {
@@ -58,11 +58,11 @@ public class PoisonSystem extends EntityTickingSystem<EntityStore> {
 }
 ```
 
-The `tick` method receives `dt` which is delta time since the last tick. This lets you accumulate time for interval-based logic rather than counting ticks. The `ArchetypeChunk` gives you access to the entity's components via the index, and `getReferenceTo` returns the `Ref` you need for issuing commands.
+Метод `tick` получает `dt` - время, прошедшее с последнего тика. Это позволяет накапливать время для логики, основанной на интервалах, вместо подсчёта тиков. `ArchetypeChunk` даёт доступ к компонентам сущностей по индексу, а `getReferenceTo` возвращает `Ref`, который нужен для выполнения команд.
 
 ### TickingSystem
 
-Runs once per tick globally, not per-entity. Use this for world-wide updates or logic that doesn't target specific entities.
+Выполняется один раз за тик глобально, а не для каждой сущности. Используйте это для глобальных обновлений мира или логики, которая не относится к конкретным сущностям.
 
 ```java
 public class GlobalUpdateSystem extends TickingSystem<EntityStore> {
@@ -76,7 +76,7 @@ public class GlobalUpdateSystem extends TickingSystem<EntityStore> {
 
 ### DelayedEntitySystem
 
-Like `EntityTickingSystem` but with a built-in delay. The constructor takes a float representing seconds between executions.
+Похоже на `EntityTickingSystem`, но со встроенной задержкой. Конструктор принимает число с плавающей точкой — количество секунд между выполнениями.
 
 ```java
 public class HealthRegenSystem extends DelayedEntitySystem<EntityStore> {
@@ -88,7 +88,7 @@ public class HealthRegenSystem extends DelayedEntitySystem<EntityStore> {
   @Override
   public void tick(float dt, int index, @Nonnull ArchetypeChunk<EntityStore> archetypeChunk,
       @Nonnull Store<EntityStore> store, @Nonnull CommandBuffer<EntityStore> commandBuffer) {
-    // Runs every 1 second per matching entity
+    // Выполняется каждую секунду для каждой совпадающей сущности
   }
 
   @Nonnull
@@ -101,8 +101,8 @@ public class HealthRegenSystem extends DelayedEntitySystem<EntityStore> {
 
 ### RefSystem
 
-We can also create systems to listen for changes on entities themselves. This is done through a `RefSystem`, for example let's say we want to perform an action whenever we add a component to an entity, update it or remove it.
-This can be done via the `RefChangeSystem<ECS_STORE, COMPONENT>`. Let's break down the example below:
+Мы также можем создавать системы для проверки изменений связанных с самими сущностями. Это делается с помощью `RefSystem`. Например, мы хотим выполнять определенные действия каждый раз, когда мы добавляем компонент к сущности, обновляем или удаляем его.
+Это можно сделать с помощью `RefChangeSystem<ECS_STORE, COMPONENT>`. Давайте разберём следующий пример:
 
 ```java
 public class PermissionAttachmentSystem extends RefChangeSystem<EntityStore, PermissionAttachment> {
@@ -120,7 +120,7 @@ public class PermissionAttachmentSystem extends RefChangeSystem<EntityStore, Per
     UUIDComponent component = store.getComponent(ref, UUIDComponent.getComponentType());
     UUID playerUuid = component.getUuid();
 
-    // PermissionAttachment component was added to a new entity
+    // Компонент PermissionAttachment был удален
   }
 
   @Override
@@ -128,7 +128,7 @@ public class PermissionAttachmentSystem extends RefChangeSystem<EntityStore, Per
     UUIDComponent component = store.getComponent(ref, UUIDComponent.getComponentType());
     UUID playerUuid = component.getUuid();
 
-    // PermissionAttachment component was updated using replaceComponent or putComponent
+    // Компонент был PermissionAttachment с использованием replaceComponent или putComponent
   }
 
   @Override
@@ -136,7 +136,7 @@ public class PermissionAttachmentSystem extends RefChangeSystem<EntityStore, Per
     UUIDComponent component = store.getComponent(ref, UUIDComponent.getComponentType());
     UUID playerUuid = component.getUuid();
 
-    // PermissionAttachment component was removed from an entity
+    // Компонент PermissionAttachment был удален из сущности
   }
 
   @Nullable
@@ -147,27 +147,29 @@ public class PermissionAttachmentSystem extends RefChangeSystem<EntityStore, Per
 }
 ```
 
-In this system we listen for changes on the `PermissionAttachment` component inside of the `EntityStore`. This gives us access to `onComponentAdded`, `onComponentSet` and `onComponentRemoved` which in this example caches and persists permission data
-which is stored on a player inside of a custom `PermissionAttachment` component.
+В этой системе мы проверяем изменения компонента `PermissionAttachment` внутри `EntityStore`. Это дает нам доступ к `onComponentAdded`, `onComponentSet` и `onComponentRemoved`, которые в данном примере сохраняют и кэшируют данные о правах
+которые хранятся в игроке внутри пользовательского компонента `PermissionAttachment`.
 
-## Queries
+## Запросы (Queries)
 
-Queries filter which entities a system processes. The ECS only passes entities to your system's `tick` method if they have all the components specified in the query.
+Запросы (Queries) фильтруют то, какие сущности будут обрабатываться системой. ECS передаёт сущности в метод `tick` вашей системы **только если у них есть все компоненты**, указанные в запросе.
 
 ```java
-// Single component - any entity with PoisonComponent
+// Один компонент — любые сущности с PoisonComponent
 Query.and(poisonComponentType)
 
-// Multiple components - entities with both
+// Несколько компонентов — сущности, у которых есть оба компонента
 Query.and(poisonComponentType, Player.getComponentType())
 
-// Exclusion - players that aren't dead
-Query.and(Player.getComponentType(), Query.not(DeathComponent.getComponentType()))
+// Исключение — игроки, которые не мертвы
+Query.and(
+    Player.getComponentType(),
+    Query.not(DeathComponent.getComponentType()))
 ```
 
-## SystemGroups and Dependencies
+## Группы систем и зависимости
 
-Systems can declare which group they belong to and what dependencies they have. This controls execution order which is critical for systems that interact.
+Системы могут указывать, к какой группе они принадлежат, и какие у них есть зависимости. Это контролирует порядок выполнения имеющий решающее значение для взаимодействующих систем.
 
 ```java
 @Nullable
@@ -177,7 +179,7 @@ public SystemGroup<EntityStore> getGroup() {
 }
 ```
 
-For more complex ordering you can override `getDependencies`:
+Для более комплексного порядка выполнения кода вы можете перезаписать `getDependencies`:
 
 ```java
 @Nonnull
@@ -189,11 +191,11 @@ public Set<Dependency<EntityStore>> getDependencies() {
 }
 ```
 
-The damage system is a good example of why ordering matters. Hytale's damage pipeline has four stages: GatherDamageGroup collects damage sources, FilterDamageGroup applies reductions and cancellations, then damage is applied to health, and finally InspectDamageGroup handles side effects like particles and sounds. If these ran in the wrong order you'd play death animations before the entity dies or apply armor reduction after health is already subtracted.
+Система урона — хороший пример того, почему порядок выполнения важен. Пайплайн урона в Hytale имеет четыре этапа: GatherDamageGroup собирает источники урона, FilterDamageGroup применяет уменьшения и отмены, затем урон применяется к здоровью, и наконец InspectDamageGroup обрабатывает побочные эффекты, такие как частицы и звуки. Если бы эти этапы выполнялись в неправильном порядке, анимация смерти проигрывалась до того, как сущность умерла, или значение параметра брони уменьшилось уже после получения урона.
 
-## Registering Components and Systems
+## Регистрация компонентов и систем
 
-Components and systems must be registered during plugin setup. The `EntityStoreRegistry` handles this.
+Компоненты и системы должны регистрироваться во время настройки плагина. Этим занимается `EntityStoreRegistry`.
 
 ```java
 public final class ExamplePlugin extends JavaPlugin {
@@ -227,4 +229,4 @@ public final class ExamplePlugin extends JavaPlugin {
 }
 ```
 
-The `registerComponent` method returns a `ComponentType` which acts as a key for accessing that component type throughout your plugin. Store it as a field and pass it to any systems that need it. The second argument is a factory for creating default instances.
+Метод `registerComponent` возвращает `ComponentType`, который действует как ключ для доступа к этому типу компонента во всем вашем плагине. Сохраните его как поле и передайте в любые системы, которым он нужен. Второй аргумент - это фабрика (функция или объект, который создаёт и возвращает другие объекты) для создания экземпляров по умолчанию.
diff --git a/content/docs/ru-RU/guides/java-basics/00-introduction.mdx b/content/docs/ru-RU/guides/java-basics/00-introduction.mdx
index ff213ef2..9552c38e 100644
--- a/content/docs/ru-RU/guides/java-basics/00-introduction.mdx
+++ b/content/docs/ru-RU/guides/java-basics/00-introduction.mdx
@@ -7,7 +7,7 @@ description: Руководство для новичков по изучени
 
 ## Почему именно Java?
 
-Java - мощный, объектно-ориентированный язык программирования, созданный в 1995 году. Это один из самых популярных языков программирования в мире и используется для всего, от мобильных приложений до корпоративного программного обеспечения. Наиболее важно для нас то, что это язык, который Hytale использует для своих серверов & моддинг API.
+Java - мощный, объектно-ориентированный язык программирования, созданный в 1995 году. Это один из самых популярных языков программирования в мире и используется для всего, от мобильных приложений до корпоративного программного обеспечения. Most importantly for us, it's the language Hytale uses for its servers & modding API.
 
 ## Чему Вы Научитесь
 
diff --git a/content/docs/ru-RU/guides/java-basics/02-operators.mdx b/content/docs/ru-RU/guides/java-basics/02-operators.mdx
index ab19a217..9e555024 100644
--- a/content/docs/ru-RU/guides/java-basics/02-operators.mdx
+++ b/content/docs/ru-RU/guides/java-basics/02-operators.mdx
@@ -119,7 +119,7 @@ String greetingWithName = "Hello, " + name + "!"; // "Hello, Alice!"
 
 ## Приоритет операторов
 
-Приоритет операторов означает, какой оператор учитывается первым в строке кода. Думайте об этом как о BODMAS/PEMDAS (правило порядка выполнения математических операций) в математике!
+Operator Precedence means which operator gets evaluated first in an line of code. Думайте об этом как о BODMAS/PEMDAS (правило порядка выполнения математических операций) в математике!
 
 ```java
 int result = 10 + 5 * 2; // результат 20, не 30
diff --git a/content/docs/ru-RU/guides/java-basics/03-control-flow-if.mdx b/content/docs/ru-RU/guides/java-basics/03-control-flow-if.mdx
index 040353e2..2abd1074 100644
--- a/content/docs/ru-RU/guides/java-basics/03-control-flow-if.mdx
+++ b/content/docs/ru-RU/guides/java-basics/03-control-flow-if.mdx
@@ -7,7 +7,7 @@ description: Вы узнаете, как управлять потоками в
 
 ## Базовый оператор if
 
-Самая простая форма проверяет одно условие;
+The simplest form checks one condition:
 
 ```java
 int health = 20;
diff --git a/content/docs/ru-RU/guides/java-basics/08-access-modifiers.mdx b/content/docs/ru-RU/guides/java-basics/08-access-modifiers.mdx
index af560932..da2bf33b 100644
--- a/content/docs/ru-RU/guides/java-basics/08-access-modifiers.mdx
+++ b/content/docs/ru-RU/guides/java-basics/08-access-modifiers.mdx
@@ -484,7 +484,7 @@ class Data {
     // Static member:
     // cannot access to non-static variables
     public static void bar() {
-        x = 100; // Error: non-static variable x cannot be renference from a static context
+        x = 100; // Error: non-static variable x cannot be referenced from a static context
         y = 100; // OK
     }
 }
@@ -504,7 +504,7 @@ Data.x = 1000; // Error: cannot access instanced variables in a static context
 
 ### Static Fields
 
-A static field represents a data member owned by the class type rather then the object. Static fields are also stored in a specific memory location that's been shared between all the object instances that are created.
+A static field represents a data member owned by the class type rather than the object. Static fields are also stored in a specific memory location that's been shared between all the object instances that are created.
 
 It is declared as following:
 
diff --git a/content/docs/ru-RU/guides/plugin/animated-block-textures.mdx b/content/docs/ru-RU/guides/plugin/animated-block-textures.mdx
new file mode 100644
index 00000000..42bfa51f
--- /dev/null
+++ b/content/docs/ru-RU/guides/plugin/animated-block-textures.mdx
@@ -0,0 +1,101 @@
+---
+title: Animated Block Textures
+description: Learn how to attach a .blockyanim to a block
+authors:
+  - name: Burkino
+---
+
+import { File, Folder, Files } from 'fumadocs-ui/components/files';
+
+So, you want to make your blocks feel more alive through animations, do you?\
+Now for the most part this is the exact same as [Creating custom blocks](./creating-block).
+![blue fire gif](/assets/guides/blue_fire.gif)
+
+## Prerequisites
+
+This is NOT a guide on animating or texturing or even using BlockBench, why? Because I don't know how to do that.\
+The only thing we will be doing is taking the fire texture, changing the color, and applying it to our new fire block.
+
+## Setup
+
+To start, you're obviously going to want to grab the `Common/VFX/Fire/Fire.png` file. How you do it is up to you, in the Asset Editor you'll need to switch to the Common tab.\
+I'll assume you know how colorize or change the hue of an image, so go ahead and do that now and save it as `Blue_Fire.png`.
+
+The other assets used in this guide are `Common/VFX/Fire/Fire.blockymodel` and `Common/Blocks/Animations/Fire/Fire_Burn.blockyanim` (both renamed to `Blue_Fire`) but since we won't be changing them it's probably fine to leave them. I will reference the `Blue_Fire` versions as a way to point out what should be custom assets.\
+I will also duplicate `Server/Item/Item/Deco/Deco_Fire.json` and call it `Deco_Blue_Fire.json`.
+
+## Applying the changes
+
+The `Deco_Blue_Fire` block is actually just a particle emitter, however we will not be using particles, so lets start by removing them in `Block > Particles`.\
+Next we want to set the Block Model (called `CustomModel` in JSON) to `VFX/Blue_Fire/Blue_Fire.blockymodel` and Block Model Textures (`CustomModelTexture` in JSON) to
+
+```json
+[
+    {
+        "Texture": "VFX/Blue_Fire/Blue_Fire.png",
+        "Weight": 1
+    }
+]
+```
+
+Finally, we will apply the .blockyanim to our model, this is done through the Block Model Animation property (`CustomModelAnimation` in JSON) and the value should be `Blocks/Animations/Blue_Fire/Blue_Fire_Burn.blockyanim`.
+
+## Final Code
+
+With that your new blue fire should be done. Here is the minimal JSON for our blue fire.\
+There is an additional `Looping` and `RequiresAlphaBlending` property that I have not gone over, however I hope it is self-explanatory.
+
+```json
+{
+  "BlockType": {
+    "DrawType": "Model",
+    "CustomModel": "VFX/Blue_Fire/Blue_Fire.blockymodel",
+    "CustomModelAnimation": "Blocks/Animations/Blue_Fire/Blue_Fire_Burn.blockyanim",
+    "CustomModelTexture": [
+      {
+        "Texture": "VFX/Blue_Fire/Blue_Fire.png",
+        "Weight": 1
+      }
+    ],
+    "Looping": true,
+    "RequiresAlphaBlending": false
+  },
+  "PlayerAnimationsId": "Block"
+}
+```
+
+<Files>
+  <Folder name="resources" defaultOpen>
+    <Folder name="Server" defaultOpen>
+      <Folder name="Item" defaultOpen>
+        <Folder name="Items" defaultOpen>
+          <Folder name="Deco" defaultOpen>
+            <File name="Deco_Blue_Fire.json" />
+          </Folder>
+        </Folder>
+      </Folder>
+    </Folder>
+
+    <Folder name="Common" defaultOpen>
+      <Folder name="Blocks" defaultOpen>
+        <Folder name="Animations" defaultOpen>
+          <Folder name="Blue_Fire" defaultOpen>
+            <File name="Blue_Fire_Burn.blockyanim" />
+          </Folder>
+        </Folder>
+      </Folder>
+
+      <Folder name="VFX" defaultOpen>
+        <Folder name="Blue_Fire" defaultOpen>
+          <File name="Blue_Fire.blockymodel" />
+
+          <File name="Blue_Fire.png" />
+        </Folder>
+      </Folder>
+    </Folder>
+  </Folder>
+</Files>
+
+## Next steps
+
+Now that you know how to attach an animation to a block, try adding it to a block state.
diff --git a/content/docs/ru-RU/guides/plugin/build-and-test.mdx b/content/docs/ru-RU/guides/plugin/build-and-test.mdx
index 0e7fe7eb..f37534c3 100644
--- a/content/docs/ru-RU/guides/plugin/build-and-test.mdx
+++ b/content/docs/ru-RU/guides/plugin/build-and-test.mdx
@@ -9,18 +9,18 @@ If you followed along with the [Setting Up Your Development Environment](./setti
 
 ## Building Your Mod
 
-In our case, we've **Maven** as the build system. Maven is a powerful build automation tool that manages dependencies, compiles your code, and packages everything into a distributable JAR file.
+In our case, we've **Gradle** as the build system. Gradle is a powerful build automation tool that manages dependencies, compiles your code, and packages everything into a distributable JAR file.
 
-### Understanding Maven
+### Understanding Gradle
 
-Maven uses a `pom.xml` file (Project Object Model) to define your project's configuration, dependencies, and build settings. You can learn more about Maven at the [official Apache Maven website](https://maven.apache.org/).
+Gradle can use a `build.gradle.kts` file (Kotlin DSL) to define your project's configuration, dependencies, and build settings. You can learn more about Gradle at the [official Gradle website](https://gradle.org/).
 
-### Building with Maven
+### Building with Gradle
 
 To build your mod, open a terminal in your project directory and run:
 
 ```bash
-mvn package
+./gradlew build
 ```
 
 This command will:
@@ -29,16 +29,35 @@ This command will:
 2. Run any tests (if present)
 3. Package everything into a JAR file
 
+<Callout type="info">
+  If you are using the plugin template from the [Setting Up Your Development Environment](./setting-up-env) guide, then the build script is already set up for you. It includes paths to your Hytale game library and handles the packaging of your mod, managing hytale dependencies and manifest changes.
+
+  If you have a different path to your Hytale installation, you may receive the following error:
+
+  ```bash
+  FAILURE: Build failed with an exception.
+
+  * What went wrong:
+  Failed to find Hytale at the expected location. Please make sure you have installed the game. The expected location can be changed using the hytale.home_path property. Currently looking in 'C:\Path\To\Hytale'
+  ```
+
+  You can change the path by adding a property to your `gradle.properties` file (if it doesn't exist, create it in the root of your project):
+
+  ```properties
+  hytale.home_path=C:\Correct\Path\To\Hytale
+  ```
+</Callout>
+
 ### Build Output
 
-Once the build completes successfully, your mod will be located in the `target` directory and named:
+Once the build completes successfully, your mod will be located in the `build/libs` directory and named:
 
 ```
-ExamplePlugin-1.0-SNAPSHOT.jar
+ExamplePlugin-1.0.jar
 ```
 
 <Callout type="info">
-  The exact name may vary depending on what you configured in your `pom.xml` file. Check the `artifactId` and `version` fields to see what your JAR will be named.
+  The exact name may vary depending on what you configured in your `build.gradle.kts` and `settings.gradle.kts` file. Check the `rootProject.name` and `version` fields to see what your JAR will be named.
 </Callout>
 
 ## Testing Your Mod
@@ -49,11 +68,11 @@ Now that you've built your mod, it's time to test it in Hytale!
 
 First, you need to find Hytale's mods directory:
 
-1. Press **Win + R** on your keyboard
-2. Type `%appdata%` and press Enter
-3. Navigate to: `Hytale\UserData\Mods`
+1. Go to your Hytale installation directory (The default location is usually in your AppData folder)
+   > On Windows, you can access it by clicking `windows + R` and typing `%appdata%`.
+2. Navigate to: `/UserData/Mods`
 
-The full path should look like:
+The default path would look like:
 
 ```
 C:\Users\YourUsername\AppData\Roaming\Hytale\UserData\Mods
@@ -65,7 +84,7 @@ C:\Users\YourUsername\AppData\Roaming\Hytale\UserData\Mods
 
 ### 2. Copy Your Mod
 
-Copy the `ExamplePlugin-1.0-SNAPSHOT.jar` file from your project's `target` directory into the `Mods` folder you just located.
+Copy the `ExamplePlugin-1.0.jar` file from your project's `build/libs` directory into the `Mods` folder you just located.
 
 ### 3. Launch Hytale and Verify
 
@@ -84,7 +103,7 @@ If your mod doesn't appear in the mods list:
 - Make sure the JAR file is in the correct `Mods` folder
 - Check that your `manifest.json` file is properly configured
 - Look for any error messages in the Hytale logs
-- Verify that you're using the correct version of Java and Maven
+- Verify that you're using the correct version of Java and Gradle
 
 ## Next Steps
 
diff --git a/content/docs/ru-RU/guides/plugin/creating-commands.mdx b/content/docs/ru-RU/guides/plugin/creating-commands.mdx
index d33597f3..08572f16 100644
--- a/content/docs/ru-RU/guides/plugin/creating-commands.mdx
+++ b/content/docs/ru-RU/guides/plugin/creating-commands.mdx
@@ -8,6 +8,8 @@ authors:
     url: https://oskar.scot
   - name: jacobwojoski
     url: https://github.com/jacobwojoski
+  - name: Marcel-TO
+    url: https://marcel-to.net
 ---
 
 In this guide, you will learn how to create custom commands for your Hytale mod.
@@ -36,7 +38,7 @@ The most basic command is an `AbstractAsyncCommand`. It has very minimal data av
   `AbstractAsyncCommand` runs on its own background thread. This means its execute is not tied to any world instance and because of this it can not edit any **Stores** or **Refs** without getting the desired world first. To access this data any of the other command types would be preferred and are likely what you will want to use instead.
 </Callout>
 
-The main purpose for a command like this would be for something that can happen everywhere and is not tied to a specific world. For example a `serverRules` command to tell the user thats running the command in chat what the servers rules are nomatter what world they are in.
+The main purpose for a command like this would be for something that can happen everywhere and is not tied to a specific world. For example a `serverRules` command to tell the user that's running the command in chat what the server's rules are no matter what world they are in.
 
 ```java
 // Command that can be run that lists the server rules in chat to the player
@@ -49,7 +51,7 @@ public class ServerRulesCommand extends AbstractAsyncCommand {
     }
 
     // Run the command
-    // conetext - info about who ran the command. Server console?, Some player?
+    // context - info about who ran the command. Server console?, Some player?
     @Override
     protected CompletableFuture<Void> executeAsync(@Nonnull CommandContext context) {
         context.sendMessage(Message.raw("The only rule is there are no rules."));
@@ -134,7 +136,7 @@ Uses a Ray to see what the player is looking at and tries to run the command on
 
 ## Adding Arguments
 
-Arguments are additional fields that the user can input when running a command. The different types of arguments along with small snipits and a large example can be seen below.
+Arguments are additional fields that the user can input when running a command. The different types of arguments along with small snippets and a large example can be seen below.
 
 ### Command Argument Types
 
@@ -163,14 +165,14 @@ this.messageArg = this.withOptionalArg("message", "Message to print while healin
 
 ### Default Arguments
 
-Adding a default argument has two additional arguemnt for the default value and default value description. You need to use `withDefaultArg` method.
+Adding a default argument has two additional argument for the default value and default value description. You need to use `withDefaultArg` method.
 
 ```java
 // args <Command String> <Description> <Default Value> <Desc of default value>
 this.healthArg = this.withDefaultArg("health", "Amount to heal player", ArgTypes.FLOAT, (float)100, "Desc of Default: 100");
 ```
 
-### Flag Arguemnts
+### Flag Arguments
 
 Similar as above but the flags return is either true if it exists or false if it does not. You need to use `withFlagArg` method.
 
@@ -181,20 +183,13 @@ this.debugArg = this.withFlagArg("debug", "Add debug logs");
 
 ### ArgTypes
 
-The following ArgTypes are available (only lists common types):
-
-- `ArgTypes.STRING`
-- `ArgTypes.INTEGER`
-- `ArgTypes.BOOLEAN`
-- `ArgTypes.FLOAT`
-- `ArgTypes.DOUBLE`
-- `ArgTypes.UUID`
+You can find all the available argument types on the [ArgTypes](../../argtypes) page.
 
 ### Example Command Arg Types
 
-Shows all Command arguemnt types with different various input types.
+Shows all Command argument types with different various input types.
 
-**NOTE:** When getting the value of an argument during execute you need to pass the context with `someArg.get(commandContext)`. Where `commandContext` is the first variable in the execute funtion.
+**NOTE:** When getting the value of an argument during execute you need to pass the context with `someArg.get(commandContext)`. Where `commandContext` is the first variable in the execute function.
 
 ```java
 // Example usage: /healplayer --health 50 --message "Feels Good" --debug
@@ -204,7 +199,7 @@ public class HealPlayerCommand extends AbstractTargetPlayerCommand {
     private final FlagArg debugArg;
 
     public HealPlayerCommand() {
-        super("healplayer", "Healing a player for an <input> ammount of HP (default: 100)");
+        super("healplayer", "Healing a player for an <input> amount of HP (default: 100)");
 
         // Abstract TargetPlayerCommand passes the player that ran the command by default and implements
         // the use of `--player <value>` to specify someone else
@@ -213,10 +208,10 @@ public class HealPlayerCommand extends AbstractTargetPlayerCommand {
         this.healthArg = this.withDefaultArg("health", "Amount to heal player", ArgTypes.FLOAT, (float)100, "Desc of Default: 100");
 
         // Or you could do the following making the health value required instead of with a default.
-        //    You would need to change the decleration to RequiredArg<Float>
+        //    You would need to change the declaration to RequiredArg<Float>
         // this.healthArg = this.withRequiredArg("health", "Amount to heal player", ArgTypes.FLOAT);
 
-        // Optional args reguare the user the input `--<key> <value>` so the following would require `--message "Good Luck"`
+// Optional args require the user the input `--<key> <value>` so the following would require `--message "Good Luck"`
         this.messageArg = this.withOptionalArg("message", "Message to print while healing", ArgTypes.STRING);
 
         // No type needed due to being a bool
@@ -230,7 +225,7 @@ public class HealPlayerCommand extends AbstractTargetPlayerCommand {
             commandContext.sendMessage(Message.raw("We are debugging"));
         }
 
-        // Health is stored in a generic stat map to allowing mods/future contect to easily add more stats if desired.
+        // Health is stored in a generic stat map to allowing mods/future content to easily add more stats if desired.
         EntityStatMap stats = store.getComponent(ref, EntityStatMap.getComponentType());
         int healthIdx = DefaultEntityStatTypes.getHealth();
         EntityStatValue health = stats.get(healthIdx);
@@ -252,7 +247,7 @@ public class HealPlayerCommand extends AbstractTargetPlayerCommand {
 
 ## Argument Validators
 
-Argument validators are a way to check the command before the command gets executed. They are added with the `addValidator` method on an argument when calling `withXxxArg`. They provide a nice output to the user when an input value is invalid.
+Argument validators are a way to check the command before the command gets executed. They are added with the `addValidator` method on an argument when calling `withXxxArg`. They provide a nice output to the user when an input value is invalid. There are some common validators provided in the `Validators` class such as `greaterThan`, `lessThan`, and `or`, `max`, `range`, etc.
 
 ```java
 ...
@@ -260,18 +255,59 @@ Argument validators are a way to check the command before the command gets execu
     OptionalArg<Integer> healAmount = withOptionalArg("amount", "Heal Amount", ArgTypes.INTEGER)
         .addValidator(Validators.greaterThan(0))
         .addValidator(Validators.lessThan(1000));
-
-    // Custom check example
-    OptionalArg<Integer> healAmount = withOptionalArg("amount", "Heal Amount", ArgTypes.INTEGER)
-            .addValidator( value -> {
-                if (value != null && value <= 0) {
-                    return ValidationResult.error("ammount argument must be a positive number");
-                }
-                return ValidationResult.success();
-            });
 ...
 ```
 
+### Custom Validators
+
+You can also create custom validators by implementing the `com.hypixel.hytale.codec.validation.Validator` interface. The interfaces forces you to implement the `accept` and `updateSchema` method. The `accept` method takes in the argument value and validates it. If the validation fails, you can use the `fail` method of the `com.hypixel.hytale.codec.validation.ValidationResults` class to return an error message.
+The `updateSchema` method is used to update the schema of the command argument. This is used for commands that have dynamic schemas based on the input value. For example, if you have a command that takes in a player name as an argument, you can use the `updateSchema` method to update the schema to include a list of online players for validation.
+
+Here is an example of a custom validator that checks if a string value is equal to a banned word. In this example, the banned word is "badword". If the input value is "badword", the validator will fail and return an error message.
+
+```java
+import com.hypixel.hytale.codec.schema.SchemaContext;
+import com.hypixel.hytale.codec.schema.config.Schema;
+import com.hypixel.hytale.codec.validation.ValidationResults;
+import com.hypixel.hytale.codec.validation.Validator;
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+
+public class MyCustomValidator implements Validator<String> {
+    @Nonnull
+    private final String value;
+
+    public MyCustomValidator(@Nonnull String value) {
+        this.value = value;
+    }
+
+    @Override
+    public void accept(@Nullable String input, @Nonnull ValidationResults results) {
+        if (this.value.equalsIgnoreCase(input)) {
+            results.fail("The given role has been banned.");
+        }
+    }
+
+    @Override
+    public void updateSchema(SchemaContext context, @Nonnull Schema target) {
+        // This method can be used to update the schema of the command argument. This is useful for commands that have dynamic schemas based on the input value. For example, if you have a command that takes in a player name as an argument, you can use the `updateSchema` method to update the schema to include a list of online players for validation.
+        throw new UnsupportedOperationException("Not implemented yet.");
+    }
+}
+```
+
+After the custom validator is created, you can add it to an argument like the following example. In this example, we add the `MyCustomValidator` to a string argument called "role". If the user inputs "badword" as the role, the command will fail and return the error message defined in the `MyCustomValidator`.
+
+```java
+    ...
+    // Custom validator example
+    String bannedRole = "badword";
+
+    OptionalArg<String> roleArg = withOptionalArg("role", "Role to assign", ArgTypes.STRING)
+        .addValidator(new MyCustomValidator(bannedRole));
+    ...
+```
+
 ---
 
 ## Permissions
@@ -312,7 +348,7 @@ This allows the server to control who has access to specific commands. You add t
 
 If you want variants of the same command without doing argument parsing you can instead use `addUsageVariant(new OtherCommandClass())` in the original commands constructor.
 
-The only difference is in the `OtherCommandClass()` constrcutor you don't pass the command name to the super class.
+The only difference is in the `OtherCommandClass()` constructor you don't pass the command name to the super class.
 
 <Callout type="info">
   You can also use `addAliases("some_alias", "some_other_alias")` as a way to add shorthand or other ways to write the same command.
@@ -387,7 +423,7 @@ public class AdminCommand extends AbstractCommandCollection {
     public AdminCommand () {
         super("admin", "Admin commands");
         addSubCommand(new UserCommandCollection());
-        addSybCommand(new ServerCommandCollection);
+        addSubCommand(new ServerCommandCollection);
     }
 }
 ```
@@ -417,5 +453,5 @@ public class MyPlugin extends JavaPlugin {
 
 ## Video Link
 
-_Special Thanks to [TroubleDev](https://www.youtube.com/@TroubleDEV) for his excelent video guide on all of these features._
+_Special Thanks to [TroubleDev](https://www.youtube.com/@TroubleDEV) for his excellent video guide on all of these features._
 _Video Link: [TroubleDev - Hytale's Command API Explained](https://www.youtube.com/watch?v=KnmhG9MDMgo)_
diff --git a/content/docs/ru-RU/guides/plugin/creating-events.mdx b/content/docs/ru-RU/guides/plugin/creating-events.mdx
index 95863990..d3f0925d 100644
--- a/content/docs/ru-RU/guides/plugin/creating-events.mdx
+++ b/content/docs/ru-RU/guides/plugin/creating-events.mdx
@@ -1,6 +1,6 @@
 ---
-title: Creating Events
-description: Learn how to create custom events for your Hytale mod.
+title: Creating Events Listeners
+description: Learn how to create event listeners for your Hytale mod.
 authors:
   - name: Neil Revin
     url: https://itsneil.dev
@@ -10,7 +10,7 @@ authors:
 
 ## Event Class
 
-You can import a Event class and create a function with the Event as a argument. [Click here](../../server/events) to look at all available events.
+You can import an Event class and create a function with the Event as an argument. [Click here](../../server/events) to look at all available events.
 
 Example plugin when a player is ready (joins a server):
 
diff --git a/content/docs/ru-RU/guides/plugin/item-registry.mdx b/content/docs/ru-RU/guides/plugin/item-registry.mdx
new file mode 100644
index 00000000..9a0fd53a
--- /dev/null
+++ b/content/docs/ru-RU/guides/plugin/item-registry.mdx
@@ -0,0 +1,95 @@
+---
+title: Working with the Item Registry
+description: Learn how to access and query the game's item registry to list all items, check if items exist, and retrieve item properties.
+authors:
+  - name: Denis
+---
+
+In this guide, you'll learn how to work with Hytale's Item Registry system. This is useful when you need to programmatically list all available items, validate item IDs, or retrieve item properties at runtime.
+
+## Prerequisites
+
+Before diving in, you should be familiar with:
+
+- [Setting up your development environment](./setting-up-env)
+- [Creating commands](./creating-commands) (optional, for testing)
+
+## Required Imports
+
+To work with the Item Registry, you'll need the following imports:
+
+```java
+import com.hypixel.hytale.assetstore.map.DefaultAssetMap;
+import com.hypixel.hytale.server.core.asset.type.item.config.Item;
+```
+
+## Getting the Item Registry
+
+The Item Registry is accessed through the `Item.getAssetMap()` method, which returns a `DefaultAssetMap<String, Item>` containing all registered items in the game:
+
+```java
+DefaultAssetMap<String, Item> itemMap = Item.getAssetMap();
+```
+
+## Listing All Items
+
+To iterate through all items in the registry, you can get the underlying map and loop through its entries:
+
+```java
+DefaultAssetMap<String, Item> itemMap = Item.getAssetMap();
+var map = itemMap.getAssetMap();
+
+for (var entry : map.entrySet()) {
+    String itemId = String.valueOf(entry.getKey());
+    Item item = entry.getValue();
+    
+    // Do something with the item
+    LOGGER.atInfo().log("Item ID: " + itemId);
+}
+```
+
+You can also get the total count of registered items:
+
+```java
+int totalItems = map.size();
+```
+
+## Checking if an Item Exists
+
+To check if a specific item exists in the registry, use `getAsset()` and verify the result:
+
+```java
+public boolean itemExists(String itemId) {
+    var assetMap = Item.getAssetMap();
+    if (assetMap != null) {
+        Item item = assetMap.getAsset(itemId);
+        return item != null && item != Item.UNKNOWN;
+    }
+    return false;
+}
+```
+
+<Callout type="info">
+  The `Item.UNKNOWN` constant represents an invalid or unrecognized item. Always check for both `null` and `Item.UNKNOWN` when validating items.
+</Callout>
+
+## Accessing Item Properties
+
+Once you have an `Item` instance, you can access various properties:
+
+```java
+var assetMap = Item.getAssetMap();
+Item item = assetMap.getAsset("Soil_Grass");
+
+if (item != null && item != Item.UNKNOWN) {
+    String id = item.getId(); // Soil_Grass
+    int maxStack = item.getMaxStack(); // 100
+    boolean isBlock = item.hasBlockType(); // true
+    boolean isConsumable = item.isConsumable(); // false
+}
+```
+
+## Related Guides
+
+- [Inventory Management](./inventory-management) - Learn how to add and remove items from player inventories
+- [Create Custom Item and Interaction](./item-interaction) - Learn how to create your own custom items
diff --git a/content/docs/ru-RU/guides/plugin/permission-management.mdx b/content/docs/ru-RU/guides/plugin/permission-management.mdx
index 6b7cfd46..55f06101 100644
--- a/content/docs/ru-RU/guides/plugin/permission-management.mdx
+++ b/content/docs/ru-RU/guides/plugin/permission-management.mdx
@@ -10,132 +10,569 @@ authors:
     link: https://discord.com/users/292656109939064833
   - name: Ivan
     link: https://discord.com/users/505770451218333717
+  - name: ZenithDevHQ
+    link: https://github.com/ZenithDevHQ
 ---
 
-In this guide, you'll learn how to manage permission nodes and groups in your Hytale plugin.
+In this guide, you'll learn how to manage permission nodes and groups in your Hytale plugin. Permissions control what actions players can perform on your server, from basic commands to advanced administrative functions.
 
-## The `PermissionsModule` class
+## What Are Permissions?
 
-The `PermissionsModule` class is responsible for managing permission nodes and groups in your plugin. It provides methods to check, grant and revoke permissions and groups for players. It allows the following operations
+Permissions are string identifiers that control access to features and commands. When a player tries to perform an action (like using a command), the server checks if they have the required permission.
 
-- Add permissions to user
-- Remove permissions from user
-- Add permissions to group (this also creates the group if it doesn't exist)
-- Remove permissions from group
-- Add user to group
-- Remove user from group
-- List all groups for a user
-- Check if a user has a permission (it checks both user and group permissions for the given player UUID)
+**Example permission nodes:**
 
-With this class you cannot:
+- `hytale.command.gamemode` - Permission to use the gamemode command
+- `hytale.editor.brush.use` - Permission to use brush tools
+- `myplugin.teleport.home` - A custom permission for your plugin
 
-- List all defined groups
-- Remove a group
+Permissions follow a hierarchical naming pattern: `namespace.category.action`
 
-### Adding Permission Nodes
+## Key Concepts
 
-You need a `Set<String>` containing all the permission nodes you want to add, these are added on top of the already existing permission nodes the user may have, it is not a replacement.
+Before diving into code, let's understand the core concepts:
+
+| Concept             | Description                                                                |
+| ------------------- | -------------------------------------------------------------------------- |
+| **Permission Node** | A string like `myplugin.feature.use` that represents a specific permission |
+| **Group**           | A named collection of permissions (e.g., "Admin", "VIP", "Default")        |
+| **Provider**        | The backend that stores and retrieves permissions                          |
+| **Wildcard**        | A pattern like `*` or `myplugin.*` that matches multiple permissions       |
+
+### How Permissions Are Checked
+
+When checking if a player has a permission, Hytale follows this order:
+
+1. **User's direct permissions** - Permissions granted directly to the player
+2. **Group permissions** - Permissions from groups the player belongs to
+3. **Virtual groups** - Game-mode-based permissions (e.g., Creative mode grants builder tools)
+4. **Default value** - Falls back to `false` if no match found
+
+<Callout type="info">
+  The first definitive match wins. If a player has a permission granted at the user level, group permissions won't override it.
+</Callout>
+
+---
+
+## The `PermissionsModule` Class
+
+The `PermissionsModule` class is the central hub for managing permissions. Access it using the singleton pattern:
 
 ```java
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.addUserPermission(playerUUID, permissions);
 ```
 
-### Removing Permission Nodes
+### Available Operations
+
+The module supports these operations:
+
+| Operation                     | Method                                          |
+| ----------------------------- | ----------------------------------------------- |
+| Add permissions to user       | `addUserPermission(uuid, permissions)`          |
+| Remove permissions from user  | `removeUserPermission(uuid, permissions)`       |
+| Add permissions to group      | `addGroupPermission(groupName, permissions)`    |
+| Remove permissions from group | `removeGroupPermission(groupName, permissions)` |
+| Add user to group             | `addUserToGroup(uuid, groupName)`               |
+| Remove user from group        | `removeUserFromGroup(uuid, groupName)`          |
+| Get user's groups             | `getGroupsForUser(uuid)`                        |
+| Check permission              | `hasPermission(uuid, permissionNode)`           |
+
+<Callout type="warning">
+  The module does **not** support:
+
+  - Listing all defined groups
+  - Deleting a group entirely
+
+  Groups are implicitly created when you first add permissions to them.
+</Callout>
+
+---
 
-Same as above, we just use the `removeUserPermission` method instead to remove permission nodes.
+## Checking Permissions
+
+The most common operation is checking if a player has a permission.
+
+### Basic Permission Check
+
+```java
+// Returns true if player has the permission, false otherwise
+boolean canUse = PermissionsModule.get().hasPermission(playerUUID, "myplugin.feature.use");
+
+if (canUse) {
+    // Player has permission, allow the action
+} else {
+    // Player lacks permission, deny or show error
+}
+```
+
+### Permission Check with Default Value
+
+You can specify what to return when no permission is explicitly set:
+
+```java
+// Returns true by default if no explicit permission is found
+boolean canUse = PermissionsModule.get().hasPermission(playerUUID, "myplugin.feature.use", true);
+```
+
+This is useful for features that should be enabled by default but can be revoked.
+
+### Using PermissionHolder Interface
+
+Players and command senders implement `PermissionHolder`, allowing direct checks:
+
+```java
+// In a command or event handler where you have access to the player
+if (player.hasPermission("myplugin.admin.manage")) {
+    // Player has admin permission
+}
+```
+
+---
+
+## Managing User Permissions
+
+### Adding Permissions to a User
+
+Permissions are additive - new permissions are added on top of existing ones, not replaced.
+
+```java
+PermissionsModule perms = PermissionsModule.get();
+
+// Add a single permission
+perms.addUserPermission(playerUUID, Set.of("myplugin.vip.chat"));
+
+// Add multiple permissions at once
+Set<String> newPerms = Set.of(
+    "myplugin.vip.chat",
+    "myplugin.vip.fly",
+    "myplugin.vip.kit"
+);
+perms.addUserPermission(playerUUID, newPerms);
+```
+
+### Removing Permissions from a User
 
 ```java
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.removeUserPermission(playerUUID, permissions);
+
+// Remove specific permissions
+Set<String> toRemove = Set.of("myplugin.vip.fly");
+perms.removeUserPermission(playerUUID, toRemove);
 ```
 
-### Add permissions to group
+---
+
+## Managing Groups
+
+Groups let you assign a collection of permissions to multiple players. This is more manageable than assigning permissions individually.
+
+### Adding Permissions to a Group
+
+If the group doesn't exist, it will be created automatically.
 
 ```java
-String groupName = "testGroup";
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.addGroupPermission(groupName, permissions);
+
+// Create/update the "VIP" group with permissions
+Set<String> vipPerms = Set.of(
+    "myplugin.vip.chat",
+    "myplugin.vip.fly",
+    "myplugin.vip.kit"
+);
+perms.addGroupPermission("VIP", vipPerms);
 ```
 
-### Remove permissions from group
+### Removing Permissions from a Group
 
 ```java
-String groupName = "testGroup";
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.removeGroupPermission(groupName, permissions);
+
+// Remove specific permissions from the group
+Set<String> toRemove = Set.of("myplugin.vip.fly");
+perms.removeGroupPermission("VIP", toRemove);
 ```
 
-### Add user to group
+### Adding a User to a Group
 
 ```java
-String groupName = "testGroup";
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.addUserToGroup(playerUUID, groupName);
+
+// Add player to the VIP group - they now have all VIP permissions
+perms.addUserToGroup(playerUUID, "VIP");
 ```
 
-### Remove user from group
+### Removing a User from a Group
 
 ```java
-String groupName = "testGroup";
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.removeUserFromGroup(playerUUID, groupName);
+
+// Remove player from VIP group
+perms.removeUserFromGroup(playerUUID, "VIP");
 ```
 
-### List all groups for a user
+### Getting a User's Groups
 
 ```java
 PermissionsModule perms = PermissionsModule.get();
-perms.getGroupsForUser(playerUUID);
+
+// Get all groups the player belongs to
+Set<String> groups = perms.getGroupsForUser(playerUUID);
+
+for (String group : groups) {
+    System.out.println("Player is in group: " + group);
+}
 ```
 
-### Check Permission Nodes
+---
+
+## Built-in Groups
+
+Hytale includes two default groups:
+
+| Group     | Default Permissions   | Purpose                           |
+| --------- | --------------------- | --------------------------------- |
+| `OP`      | `*` (all permissions) | Server operators with full access |
+| `Default` | None                  | Base group for all players        |
+
+Players without any explicit group assignment are automatically part of the `Default` group.
 
-To check if a player has a specific permission node, you can use the `hasPermission` method.
+---
+
+## Wildcards
+
+Wildcards let you grant or deny multiple permissions with a single pattern.
+
+### Wildcard Patterns
+
+| Pattern             | Meaning                                          |
+| ------------------- | ------------------------------------------------ |
+| `*`                 | Grants **all** permissions                       |
+| `myplugin.*`        | Grants all permissions starting with `myplugin.` |
+| `-*`                | Denies **all** permissions                       |
+| `-myplugin.admin.*` | Denies all admin permissions in your plugin      |
+
+### Example: Admin Group with Wildcards
 
 ```java
-boolean hasPermission = PermissionsModule.hasPermission(playerUUID, "permission.node");
+// Grant all permissions to admins
+perms.addGroupPermission("Admin", Set.of("*"));
+
+// Grant all plugin permissions to moderators
+perms.addGroupPermission("Moderator", Set.of("myplugin.*"));
+
+// Grant all permissions except admin commands
+perms.addGroupPermission("Helper", Set.of(
+    "*",
+    "-myplugin.admin.*"  // Deny admin permissions
+));
 ```
 
-## Additional: Defining your own provider for permissions and groups
+<Callout type="warning">
+  Negation permissions (starting with `-`) take precedence at each level. Use them carefully to avoid accidentally blocking permissions.
+</Callout>
+
+---
+
+## Built-in Permission Nodes
+
+Hytale provides constants for common permissions in the `HytalePermissions` class:
+
+### Command Permissions
+
+```java
+// Generate permission for a command
+String perm = HytalePermissions.fromCommand("gamemode");
+// Result: "hytale.command.gamemode"
+
+// Generate permission for a subcommand
+String perm = HytalePermissions.fromCommand("gamemode", "creative");
+// Result: "hytale.command.gamemode.creative"
+```
+
+### Common Permission Nodes
+
+| Permission                    | Description                  |
+| ----------------------------- | ---------------------------- |
+| `hytale.command.op.add`       | Add players to OP group      |
+| `hytale.command.op.remove`    | Remove players from OP group |
+| `hytale.editor.brush.use`     | Use brush tools              |
+| `hytale.editor.prefab.use`    | Use prefabs                  |
+| `hytale.editor.selection.use` | Use selection tools          |
+| `hytale.editor.history`       | Undo/redo operations         |
+| `hytale.camera.flycam`        | Use fly camera mode          |
+
+---
+
+## Listening to Permission Events
+
+You can react to permission changes using Hytale's event system.
+
+### Available Events
+
+| Event                                            | Triggered When                   |
+| ------------------------------------------------ | -------------------------------- |
+| `PlayerPermissionChangeEvent.PermissionsAdded`   | Permissions added to a user      |
+| `PlayerPermissionChangeEvent.PermissionsRemoved` | Permissions removed from a user  |
+| `PlayerGroupEvent.Added`                         | User added to a group            |
+| `PlayerGroupEvent.Removed`                       | User removed from a group        |
+| `GroupPermissionChangeEvent.Added`               | Permissions added to a group     |
+| `GroupPermissionChangeEvent.Removed`             | Permissions removed from a group |
 
-The PermissionsModule also enables us to define our own PermissionProvider's, this can be useful for:
+### Example: Reacting to Permission Changes
 
-- Cross server permission systems
-- Implementing features missing in the `HytalePermissionsProvider` like permission expiry
+```java
+public class PermissionListener {
+
+    public static void onPermissionsAdded(PlayerPermissionChangeEvent.PermissionsAdded event) {
+        UUID playerUUID = event.getPlayerUuid();
+        Set<String> added = event.getAddedPermissions();
+
+        System.out.println("Permissions added to " + playerUUID + ": " + added);
 
-To implement our PermissionProvider, first we need to define a provider class that implements PermissionProvider:
+        // Maybe notify the player or update cached data
+    }
+
+    public static void onGroupAdded(PlayerGroupEvent.Added event) {
+        UUID playerUUID = event.getPlayerUuid();
+        String groupName = event.getGroupName();
+
+        System.out.println("Player " + playerUUID + " joined group: " + groupName);
+    }
+}
+```
+
+### Registering the Events
 
 ```java
-public class DatabasePermissionProvider implements PermissionProvider
+public class MyPlugin extends JavaPlugin {
+
+    @Override
+    public void setup() {
+        EventRegistry events = this.getEventRegistry();
+
+        events.registerGlobal(
+            PlayerPermissionChangeEvent.PermissionsAdded.class,
+            PermissionListener::onPermissionsAdded
+        );
+
+        events.registerGlobal(
+            PlayerGroupEvent.Added.class,
+            PermissionListener::onGroupAdded
+        );
+    }
+}
 ```
 
-Then we just implement the required methods using a database implementation.
+---
+
+## Creating a Custom Permission Provider
+
+For advanced use cases, you can create your own permission provider. This is useful for:
+
+- Database-backed permissions (MySQL, MongoDB, etc.)
+- Cross-server permission synchronization
+- Custom features like permission expiry or contexts
+
+### Implementing PermissionProvider
+
+```java
+public class DatabasePermissionProvider implements PermissionProvider {
+
+    @Nonnull
+    @Override
+    public String getName() {
+        return "DatabasePermissionProvider";
+    }
+
+    // User permission methods
+    @Override
+    public void addUserPermissions(@Nonnull UUID uuid, @Nonnull Set<String> permissions) {
+        // Save to your database
+    }
+
+    @Override
+    public void removeUserPermissions(@Nonnull UUID uuid, @Nonnull Set<String> permissions) {
+        // Remove from your database
+    }
+
+    @Override
+    public Set<String> getUserPermissions(@Nonnull UUID uuid) {
+        // Query your database
+        return Set.of();
+    }
+
+    // Group permission methods
+    @Override
+    public void addGroupPermissions(@Nonnull String group, @Nonnull Set<String> permissions) {
+        // Save to your database
+    }
+
+    @Override
+    public void removeGroupPermissions(@Nonnull String group, @Nonnull Set<String> permissions) {
+        // Remove from your database
+    }
+
+    @Override
+    public Set<String> getGroupPermissions(@Nonnull String group) {
+        // Query your database
+        return Set.of();
+    }
+
+    // User-group membership methods
+    @Override
+    public void addUserToGroup(@Nonnull UUID uuid, @Nonnull String group) {
+        // Save to your database
+    }
+
+    @Override
+    public void removeUserFromGroup(@Nonnull UUID uuid, @Nonnull String group) {
+        // Remove from your database
+    }
+
+    @Override
+    public Set<String> getGroupsForUser(@Nonnull UUID uuid) {
+        // Query your database
+        return Set.of("Default");
+    }
+}
+```
 
 <Callout type="warning">
-  Hytale will try to use the first available permissions provider to add/remove gamemode groups (i.e. `Creative`, `Adventure`).
+  Hytale automatically assigns players to game-mode groups (like `Creative` or `Adventure`) using the first available provider.
+
+  If your provider throws an error when the group doesn't exist, the player will be disconnected! Always handle missing groups gracefully.
+</Callout>
+
+### Registering Your Provider
 
-  If your provider throws an error (for instance, if the group does not exist) when the server is preparing the player, the player will be disconnected.
+```java
+public class MyPlugin extends JavaPlugin {
+
+    @Override
+    public void setup() {
+        // Add your provider alongside the default one
+        PermissionsModule.get().addProvider(new DatabasePermissionProvider());
+    }
+}
+```
+
+The `PermissionsModule` aggregates permissions from all registered providers. This means:
+
+- Permission checks query all providers
+- Write operations (add/remove) use the **first** provider
+
+### Replacing the Default Provider
+
+If you want full control, you can remove the default provider:
+
+```java
+public class MyPlugin extends JavaPlugin {
+
+    @Override
+    public void setup() {
+        PermissionsModule perms = PermissionsModule.get();
+
+        // Remove the default provider FIRST
+        perms.removeProvider(perms.getFirstPermissionProvider());
+
+        // Then add your provider
+        perms.addProvider(new DatabasePermissionProvider());
+    }
+}
+```
+
+<Callout type="info">
+  When you remove the default provider, the `/op self` command will stop working since it checks for provider tampering.
 </Callout>
 
-We can then register the provider using the built-in permission module:
+---
+
+## Best Practices
+
+### Permission Naming Conventions
+
+Follow the pattern: `namespace.category.action`
 
 ```java
-PermissionsModule.get().addProvider(new DatabasePermissionProvider());
+// Good - clear hierarchy
+"myplugin.admin.ban"
+"myplugin.user.teleport.home"
+"myplugin.vip.chat.color"
+
+// Bad - unclear structure
+"myplugin_ban"
+"teleport"
+"vipChatColor"
 ```
 
-Please note that the `HytalePermissionsProvider` will still be enabled alongside your provider.
-The `PermissionsModule` will aggregate groups and permissions from all available providers.
+### Use Constants for Permissions
 
-If you want to disable the default `HytalePermissionsProvider`, you can use:
+Define your permissions as constants to avoid typos:
 
 ```java
-// put this **before** you add your provider
-PermissionsModule.get().removeProvider(PermissionsModule.get().getFirstPermissionProvider());
+public final class MyPermissions {
+    public static final String ADMIN_BAN = "myplugin.admin.ban";
+    public static final String ADMIN_KICK = "myplugin.admin.kick";
+    public static final String USER_HOME = "myplugin.user.home";
+    public static final String VIP_FLY = "myplugin.vip.fly";
+}
+
+// Usage
+if (player.hasPermission(MyPermissions.ADMIN_BAN)) {
+    // ...
+}
 ```
+
+### Don't Over-Permission
+
+Only create permissions for actions that genuinely need access control. Not everything needs a permission check.
+
+### Thread Safety
+
+If you create a custom provider, ensure it's thread-safe. Permission checks can occur from multiple threads simultaneously. Use `ReadWriteLock` or `ConcurrentHashMap` for your data structures.
+
+---
+
+## In-Game Commands
+
+Hytale provides built-in commands for managing permissions:
+
+### `/op` Command
+
+| Command               | Description                                                        |
+| --------------------- | ------------------------------------------------------------------ |
+| `/op self`            | Toggle your own OP status (singleplayer or with `--allow-op` flag) |
+| `/op add <player>`    | Add a player to the OP group                                       |
+| `/op remove <player>` | Remove a player from the OP group                                  |
+
+### `/perm` Command
+
+Use `/perm --help` in-game for full usage. Common operations:
+
+| Command                                  | Description                   |
+| ---------------------------------------- | ----------------------------- |
+| `/perm user list <uuid>`                 | List user's permissions       |
+| `/perm user add <uuid> <perm>`           | Add permission to user        |
+| `/perm user remove <uuid> <perm>`        | Remove permission from user   |
+| `/perm user group list <uuid>`           | List user's groups            |
+| `/perm user group add <uuid> <group>`    | Add user to group             |
+| `/perm user group remove <uuid> <group>` | Remove user from group        |
+| `/perm group list <group>`               | List group's permissions      |
+| `/perm group add <group> <perm>`         | Add permission to group       |
+| `/perm group remove <group> <perm>`      | Remove permission from group  |
+| `/perm test <perm>`                      | Test if you have a permission |
+
+---
+
+## Summary
+
+You've learned how to:
+
+- **Check permissions** using `PermissionsModule.hasPermission()`
+- **Manage user permissions** with `addUserPermission()` and `removeUserPermission()`
+- **Work with groups** using `addGroupPermission()`, `addUserToGroup()`, etc.
+- **Use wildcards** like `*` and `myplugin.*` for bulk permissions
+- **Listen to events** for permission changes
+- **Create custom providers** for database-backed permissions
+
+For more advanced permission systems with features like inheritance, expiry, and contexts, we're looking into expanding this guide with advanced permission management techniques in the future.
diff --git a/content/docs/ru-RU/guides/plugin/setting-up-env.mdx b/content/docs/ru-RU/guides/plugin/setting-up-env.mdx
index d2718098..5be5e9e0 100644
--- a/content/docs/ru-RU/guides/plugin/setting-up-env.mdx
+++ b/content/docs/ru-RU/guides/plugin/setting-up-env.mdx
@@ -4,6 +4,10 @@ description: Learn how to set up your development environment for modding Hytale
 authors:
   - name: Neil Revin
     link: https://itsneil.dev
+  - name: Marcel-TO
+    url: https://marcel-to.net
+  - name: Ádám Liszkai
+    link: https://adaliszk.dev
 ---
 
 This guide will walk you through setting up a complete development environment for Hytale modding, including all necessary tools and dependencies.
@@ -19,24 +23,73 @@ Before we begin, make sure you have:
 
 ## Required Software
 
-### 1. Java Development Kit (JDK)
+### Integrated Development Environment (IDE)
 
+We recommend IntelliJ IDEA Community Edition for Hytale modding. If you use IntelliJ IDEA, **almost everything is built-in**. You can clone a template, open a new project, and start working right away!
+
+1. Download from [JetBrains website](https://www.jetbrains.com/idea/download/)
+2. Install with default settings
+3. Launch and complete the initial setup wizard
+
+When opening a project, wait for indexing to finish, then start coding.
+Now, IDEA may say "No JDK configured" at the top of the source file you have.
+In that case, you can click Download JDK and choose JetBrains JDK 25.
+
+<Callout type="success">
+  If IDEA opened the project without errors, your environment is ready.
+</Callout>
+
+More details by [JetBrains](https://www.jetbrains.com/help/idea/2026.1/run-for-the-first-time.html)
+help page, where we recommend that you also check the
+[SDK configuration](https://www.jetbrains.com/help/idea/2026.1/sdk.html) guide.
+
+<Callout type="info">
+  We recommened following
+  [TheNullicorn's](https://gist.github.com/TheNullicorn/90a619796c40f20ae1fcf13094c1a57d) guide to ensure
+  you are using the correct `Nonnull` in your projects.
+</Callout>
+
+#### What the IDE Does for You
+
+When opened in IntelliJ IDEA, the project automatically:
+
+- Detects and configures Gradle or Maven
+- Downloads all dependencies
+- Sets up project structure and classpaths
+- Configures run/build tasks
+
+You do **not** need to manually install or configure Maven or Gradle if you stay inside the IDE.
+
+Skip to the [Setting Up Your Workspace](#setting-up-your-workspace).
+
+### Manual Setup: Java Development Kit (JDK)
+
+For any other setup, you will need to install and configure your system to have and load Java.
 Hytale modding requires Java 25 or later. We recommend using OpenJDK.
 
-#### Windows
+#### Windows via Installer
 
 1. Download OpenJDK 25 from [Adoptium](https://adoptium.net/)
 2. Run the installer with default settings
+   - Optionally enable feature `Set or Override JAVA_HOME variable` to resolve version related build issues with your project.
 3. Verify installation by opening Command Prompt and running:
 
+#### Windows via Scoop
+
+1. Install Scoop via PowerShell using [scoop.sh](https://scoop.sh/)
+2. Install OpenJDK 25:
+
 ```bash
-java -version
+scoop bucket add java
+scoop install java/openjdk25
 ```
 
 #### macOS
 
+1. Install Brew via Terminal using [brew.sh](https://brew.sh)
+2. Install JDK via Homebrew:
+
 ```bash
-# Using Homebrew
 brew install openjdk@25
 ```
 
@@ -51,22 +104,41 @@ brew install openjdk@25
 
 #### Linux (Ubuntu/Debian)
 
+1. Install JDK via the built-in package repository:
+
 ```bash
 sudo apt update
 sudo apt install openjdk-25-jdk
 ```
 
-### 2. Integrated Development Environment (IDE)
+### Verify installation:
 
-We recommend IntelliJ IDEA Community Edition for Hytale modding.
+Run the following command to see what version of Java you have:
 
-1. Download from [JetBrains website](https://www.jetbrains.com/idea/download/)
-2. Install with default settings
-3. Launch and complete the initial setup wizard
+```bash
+java -version
+```
+
+### Java Build Tool (Optional)
+
+We recommend using a Gradle Wrapper for managing dependencies and building your Hytale plugins. It provides benefits by eliminating the need for a system-wide Gradle installation and ensuring consistent Gradle versions across different environments. (Alternatively you can use Maven, but this guide focuses on Gradle since it is the default for our plugin template.)
+
+The plugin template in the following sections includes a Gradle Wrapper, so you can skip this step if you plan to use the template.
+
+#### Choosing Gradle (if not using the template)
+
+If you prefer to install Gradle manually, follow these steps:
 
-### 3) Java Build Tool
+1. Visit the official website: https://gradle.org/releases/
+2. Download the newest gradle binary: `gradle-9.3.1-bin.zip` (Binary zip archive)
+3. Unzip it
+4. Add the `gradle-9.3.1/bin/` folder to your PATH
+
+You can now try the command `gradle -version` to verify Gradle is installed correctly. Make sure to do this in a fresh new terminal instead of one you had opened from before!
+
+#### Choosing Maven (if not using the template)
 
-We recommend using Apache Maven for managing dependencies and building your Hytale plugins. (Alternatively you can use Gradle, but this guide focuses on Maven.)
+If you prefer to use Maven instead of Gradle, follow these steps to install Maven:
 
 1. Visit the official website: https://maven.apache.org/download.cgi
 2. Download this file: `apache-maven-3.9.12-bin.zip` (Binary zip archive)
@@ -89,22 +161,61 @@ cd MyFirstMod
 
 If you don't have Git installed, you can download the ZIP file from the repository page and extract it to a folder named `MyFirstMod`.
 
-### 2. Open Plugin in your IDEA
+### 2. Open Plugin in your IDE
 
-1. Open IntelliJ IDEA
+1. Open Your IDE (e.g., IntelliJ IDEA)
 2. Click "Open" and navigate to your `MyFirstMod` directory
-3. IntelliJ will automatically detect it as a Maven project
+3. Most IDEs like IntelliJ will automatically detect it as a Gradle project
 4. Wait for the project to index and dependencies to download
 
-<Callout type="info">
-  We recommened following [this](https://gist.github.com/TheNullicorn/90a619796c40f20ae1fcf13094c1a57d) guide to ensure you are using the correct `Nonnull` in your projects.
-</Callout>
+## Alternate Approach: Hytale Dependency
+
+If you prefer to set up your project from scratch without using the template and importing the hytale dependencies manually, ensure your build configuration includes the Hytale repositories and dependencies:
+
+For Gradle, add the following to your `build.gradle.kts`:
+
+```kotlin
+repositories {
+    mavenCentral()
+    maven {
+        name = "hytale"
+        url = uri("https://maven.hytale.com/release") // Or "hytale-pre-release" for pre-release versions
+    }
+}
+dependencies {
+    // + here means the latest version, but you can hard-wire any known version!
+    implementation("com.hypixel.hytale:Server:+")
+}
+```
+
+For Maven, add the following to your `pom.xml`:
+
+```xml
+<project>
+    <repositories>
+        <repository>
+            <id>hytale-release</id> <!-- Or "hytale-pre-release" for pre-release versions -->
+            <url>https://maven.hytale.com/release</url> <!-- Or "https://maven.hytale.com/pre-release" -->
+        </repository>
+    </repositories>
+
+    <dependencies>
+        <dependency>
+            <groupId>com.hypixel.hytale</groupId>
+            <artifactId>Server</artifactId>
+            <!-- Replace with latest version, Hytale provides jars for the last five releases -->
+            <version>LATEST_VERSION_HERE</version>
+            <scope>provided</scope>
+        </dependency>
+    </dependencies>
+</project>
+```
 
 ## Next Steps
 
 Now that you have your development environment set up with the plugin template:
 
-1. **Customize the template** - Edit the `pom.xml` and `manifest.json` file to change your mod's name and details
+1. **Customize the template** - Edit the `settings.gradle.kts`, `build.gradle.kts` and `manifest.json` file to change your mod's name and details
 2. **Explore the code structure** - Familiarize yourself with the template's organization
 3. **Start modding** - Begin writing your first Hytale plugin!
 
diff --git a/content/docs/ru-RU/guides/plugin/spawning-entities.mdx b/content/docs/ru-RU/guides/plugin/spawning-entities.mdx
index e12c0aea..15be2fb3 100644
--- a/content/docs/ru-RU/guides/plugin/spawning-entities.mdx
+++ b/content/docs/ru-RU/guides/plugin/spawning-entities.mdx
@@ -36,7 +36,7 @@ Store<EntityStore> store = world.getEntityStore().getStore();
 
 ## Creating Entities
 
-Once you have the `EntityStore` instance, you can start to create a entity and give it components. Entities are just instances of `Holder<EntityStore>` with several components attached to them.
+Once you have the `EntityStore` instance, you can start to create an entity and give it components. Entities are just instances of `Holder<EntityStore>` with several components attached to them.
 
 <Callout type="warning">
   To interact with the `World` instance, some methods require you to run the code inside the world's execution context.
@@ -118,3 +118,48 @@ Finally, we can add the entity to the world by calling the `addEntity` method on
 ```java
 store.addEntity(holder, AddReason.SPAWN);
 ```
+
+## Making the entity persist
+
+Hytale automatically saves all entities, but the `NetworkId` component (required for players to be able to see the entity) needs to be manually added every time the entity is loaded.
+
+### Using a system
+
+If you have a component that is unique to your entities, this can be done by creating and registering a custom system as follows:
+
+```java
+public class AddNetworkIdToMyEntitySystem extends HolderSystem<EntityStore> {
+    private final ComponentType<EntityStore, MyEntityComponent> myEntityComponentType = MyEntityComponent.getComponentType();
+    private final ComponentType<EntityStore, NetworkId> networkIdComponentType = NetworkId.getComponentType();
+    private final Query<EntityStore> query = Query.and(this.myEntityComponentType, Query.not(this.networkIdComponentType));
+
+    @Override
+    public void onEntityAdd(@NotNull Holder<EntityStore> holder, @NotNull AddReason reason, @NotNull Store<EntityStore> store) {
+        if (!holder.getArchetype().contains(NetworkId.getComponentType())) {
+            holder.addComponent(NetworkId.getComponentType(), new NetworkId(store.getExternalData().takeNextNetworkId()));
+        }
+    }
+
+    @Override
+    public void onEntityRemoved(@NotNull Holder<EntityStore> holder, @NotNull RemoveReason reason, @NotNull Store<EntityStore> store) {}
+
+    @Override
+    public @Nullable Query<EntityStore> getQuery() {
+        return query;
+    }
+}
+```
+
+In your plugin's `setup()` function
+
+```java
+this.getEntityStoreRegistry().registerSystem(new AddNetworkIdToMyEntitySystem())
+```
+
+### Using PropComponent
+
+Alternatively you can add `PropComponent` to your entity. Hytale adds `PropComponent` to entities spawned with the Entity Tool, and such entities automatically get `NetworkId` and `PrefabCopyableComponent` (which makes the entity work with prefabs).
+
+<Callout type="warning">
+  There is no guarantee, that Hytale will not add some other behavior to this component in the future, which may break your entity, so be careful if you decide to rely on it.
+</Callout>
diff --git a/content/docs/ru-RU/guides/plugin/store-persistent-data.mdx b/content/docs/ru-RU/guides/plugin/store-persistent-data.mdx
new file mode 100644
index 00000000..1071dff3
--- /dev/null
+++ b/content/docs/ru-RU/guides/plugin/store-persistent-data.mdx
@@ -0,0 +1,171 @@
+---
+title: Storing Persistent Data on the Player
+description: Learn how to save and load persistent data using Components
+authors:
+  - name: Neil Revin
+    url: https://itsneil.dev/
+  - name: ArcticDev
+    url: https://github.com/ArcticRaven
+  - name: oskarscot
+    url: https://oskar.scot
+  - name: JammingEng
+    url: https://github.com/JammingEnd
+---
+
+Here is how to store persistent data using a custom component on a Player.
+
+## Build your Component Class
+
+Creating a custom component class leverages the Component system made with the ECS architecture in mind. For more information on Components, check out the [ECS Guide](../ecs/hytale-ecs-theory#components).
+
+Start by creating your custom component class. This will be extremely similar to how regular components are created, however we'll setup a custom Codec so the server can translate this data to BSON, or the server's internal json encoder.
+
+<Callout type="info">
+  Each variable you want to store in your component must have its own Codec field defined in the BuilderCodec.
+  For more information on how to create custom Codecs, check out the [ECS Codec Guide](../ecs/hytale-ecs-theory#codec).
+</Callout>
+
+```java
+public class YourPlayerData implements Component<EntityStore> {
+
+    // define some vars!
+    private int someInteger;
+    private String someString;
+    private Map<String, String> someMap;
+
+    public static final BuilderCodec<YourPlayerData> CODEC =
+            BuilderCodec.builder(YourPlayerData.class, YourPlayerData::new)
+            .append(new KeyedCodec<>("SomeInteger", Codec.INTEGER),
+                    (data, value) -> data.someInteger = value, // setter
+                    data -> data.someInteger) // getter
+            .addValidator(Validators.nonNull())
+            .add()
+            .append(new KeyedCodec<>("SomeString", Codec.STRING),
+                    (data, value) -> data.someString = value, // setter
+                    data -> data.someString) // getter
+            .add()
+            .append(new KeyedCodec<>("SomeMap",
+                            new MapCodec<>(Codec.STRING, HashMap::new, false)),
+                    (data, value) -> data.someMap = value, // setter
+                    data -> data.someMap) // getter
+            .add()
+            .build();
+
+
+
+    // Getters and Setters are for the purpose of this example omitted.
+
+    // constructor
+    public YourPlayerData() {
+        this.someInteger = 0;
+        this.someString = "";
+        this.someMap = new HashMap<>();
+    }
+
+    // copy constructor for cloning
+    public YourPlayerData(YourPlayerData clone) {
+        this.someInteger = clone.someInteger;
+        this.someString = clone.someString;
+        this.someMap = clone.someMap;
+    }
+
+    @Nonnull
+    @Override
+    public Component<EntityStore> clone() {
+        return new YourPlayerData(this);
+    }
+}
+```
+
+## Register your Component
+
+Inside your main class's `setup()` method, register your new Component.
+
+```java
+public class YourPlugin extends JavaPlugin {
+
+    private ComponentType<EntityStore, YourPlayerData> yourPlayerDataComponent;
+
+    public YourPlugin(@Nonnull JavaPluginInit init) {
+        super(init);
+    }
+
+    @Override
+    protected void setup(){
+        this.yourPlayerDataComponent = this.getEntityStoreRegistry().registerComponent(
+            YourPlayerData.class,
+            "YourPlayerDataComponent",
+            YourPlayerData.CODEC
+        );
+    }
+
+    public ComponentType<EntityStore, YourPlayerData> getYourPlayerDataComponent() {
+        return this.yourPlayerDataComponent;
+    }
+}
+```
+
+## Using your Component
+
+To use your newly created component, you can add the Component to a player using the `addComponent` method, although this only adds it temporarily, meaning when the player/entity leaves the world, the component is removed. You can use `putComponent` to ensure the component persists between sessions.
+
+```java
+// You will need the Ref and Store to apply components
+private void someEntryMethod(@Nonnull Ref<EntityStore> ref, @Nonnull Store<EntityStore> store)
+{
+       // Any entity will work, for now we will use the player
+      Player player = (Player) store.getComponent(ref, Player.getComponentType());
+
+      // since we're using putComponent, it could be useful to check if it already exists on the player in case we want to update it
+     if(store.getComponent(ref, YourPlugin.instance().getYourPlayerDataComponent()) != null)
+     {
+          // here we implement logic that updates the component
+         var comp = store.getComponent(ref, YourPlugin.instance().getYourPlayerDataComponent())
+         // declare public fields or methods in the component class
+         comp.SomeString = "An Updated Field";
+     } else {
+          // Here we put the component
+          var myCustomComp = new CustomComponent();
+          // declare public fields or methods in the component class
+          myCustomComp.SomeString = "Edited String";
+
+          // putComponent allows you to insert declared objects
+          store.putComponent(ref, YourPlugin.instance().getYourPlayerDataComponent(), myCustomComp);
+     }
+}
+```
+
+## Using your Data
+
+Your component will be stored within the `Store<EntityStore>` when added to the player. In the provided example,
+we'll fetch this data off the player using the `ensureAndGetComponent()` method, which will add the component to
+the player if it does not exist with the default values.
+
+```java
+public class IncompleteCustomCommand extends AbstractPlayerCommand {
+
+    public IncompleteCustomCommand() {
+        super("nope", "don't use this command");
+    }
+
+    @Override
+    protected void execute(
+        @NonNullDecl CommandContext commandContext,
+        @NonNullDecl Store<EntityStore> store,
+        @NonNullDecl Ref<EntityStore> ref,
+        @NonNullDecl PlayerRef playerRef,
+        @NonNullDecl World world
+    ) {
+        YourPlayerData customData = store.ensureAndGetComponent(ref, YourPlugin.instance().getYourPlayerDataComponent());
+        // ensureAndGetComponent adds the component to the ref, with the default values defined inside your component.
+ 		// use your data
+    }
+}
+```
+
+And that's it! Your data will now be saved and loaded automatically with the player.
+
+Using custom components to store persistent data on players is a powerful way to maintain state across sessions.
+By following the steps outlined above, you can easily create, register, and utilize your own data structures within the Hytale ECS framework.
+This approach ensures that your data is seamlessly integrated with the game's existing systems.
+For more information about Hytale's Entity Component System visit the [Hytale ECS Theory](https://hytalemodding.dev/en/docs/guides/ecs/hytale-ecs-theory) guide.
diff --git a/content/docs/ru-RU/guides/plugin/teleporting-players.mdx b/content/docs/ru-RU/guides/plugin/teleporting-players.mdx
index 57cee77f..32ce0435 100644
--- a/content/docs/ru-RU/guides/plugin/teleporting-players.mdx
+++ b/content/docs/ru-RU/guides/plugin/teleporting-players.mdx
@@ -1,26 +1,32 @@
 ---
 title: Teleporting the player
 description: Learn how to teleport the player.
+authors:
+  - name: oskarscot
+    url: https://oskar.scot
 ---
 
-To teleport players in Hytale, you will need to get a `World` object so we can safely run the teleport on the world thread. The world thread manages all entity updates, so modifying entities off-thread can crash the server or cause inconsistent state.
-Next, we get the entity store and make a `Teleport` object.
-We add a `Teleport` component to the player’s entity reference in the entity store. This triggers the teleportation logic for that player.
+Teleporting players in Hytale works by simply attaching a `Teleport` component to a player with the desired world and transform.
+You can only trigger teleports from a world where the player is currently present.
+Teleport itself is a component but it also provides factory methods to configure the Teleport. Just as with any entity component, an EntityStore and a Ref to the EntityStore is required
+
+We can create a simple teleport utility like this:
 
 ```java
-public static void teleportPlayer(Player player, int x, int y, int z) {
-        World world = player.getWorld();
-        if (world == null) return;
-        world.execute(() -> {
-            if (player.getReference() == null) return;
-            Store<EntityStore> store = player.getReference().getStore();
-            Teleport teleport = Teleport.createForPlayer(world,
-                new Vector3d(x ,y, z), // Target position
-                new Vector3f(0, 0, 0)  // Target rotation (pitch, yaw, roll)
-            );
+public static void teleportPlayer(Ref<EntityStore> ref, Store<EntityStore> store, World targetWorld, double x, double y, double z) {                                                                                       
+    Transform transform = new Transform(x, y, z);                                                                                                                           
+    Teleport teleport = Teleport.createForPlayer(targetWorld, transform);                                                                                                   
+    store.addComponent(ref, Teleport.getComponentType(), teleport);                                                                                                         
+}  
+```
 
-            store.addComponent(player.getReference(), Teleport.getComponentType(), teleport);
-        });
+A `Transform` is a representation of a position Vector3d and rotation Vector3f which works in the following way:
 
-}
+```java
+Transform transform = new Transform(
+    new Vector3d(x, y, z),      // Position
+    new Rotation(yaw, pitch, 0) // Rotation, last value seems to always be 0
+);
+Teleport teleport = Teleport.createForPlayer(targetWorld, transform);
+store.addComponent(ref, Teleport.getComponentType(), teleport);
 ```
diff --git a/content/docs/ru-RU/guides/plugin/tracking-mod-analytics-with-hstats.mdx b/content/docs/ru-RU/guides/plugin/tracking-mod-analytics-with-hstats.mdx
new file mode 100644
index 00000000..45c022e0
--- /dev/null
+++ b/content/docs/ru-RU/guides/plugin/tracking-mod-analytics-with-hstats.mdx
@@ -0,0 +1,65 @@
+---
+title: Tracking Mod Analytics with HStats
+description: Learn how you can track Analytics for your Hytale Mod for Free using hstats.dev
+authors:
+  - name: Al3x
+    url: https://hstats.dev
+---
+
+In this guide, you will learn how to integrate HStats into your Plugin/Mod which will allow you to track how many Servers are using it along with other stats.
+
+<Callout type="info">
+  HStats is a third-party tool and is not affiliated with HytaleModding or Hypixel Studios
+</Callout>
+
+# Step 1: Register your Mod to HStats
+
+Before you touch any code, you will need to add your mod to the HStats website which will give you a UUID for your mod.
+
+- Create or Login to an Account on https://hstats.dev
+- Navigate to the dashboard page (https://hstats.dev/dashboard)
+- On the left, type in your mod's name and click "Add Mod"
+- Keep note of the UUID generated for later.
+
+# Step 2: Add the HStats Class to Your Project
+
+To keep things simple, HStats uses a single Java class file that handles everything for you.
+
+- Download / Copy the File from the GitHub page (https://github.com/hstats-dev/HStatsExamplePlugin/blob/main/src/main/java/com/al3x/HStats.java)
+- Paste into your Project. You should now have a HStats.java file somewhere in your projects directory.
+- Update the package name from com.al3x to whatever fits your project.
+
+# Step 3: Initialize HStats in your code
+
+You only need to add one line of code to your mod's setup method in your main class to start tracking.
+
+`new HStats("YOUR-MOD-UUID", "1.0.0");`
+
+Replace `YOUR-MOD-UUID` with the Mod UUID we made note of earlier and change the `1.0.0` version to whatever version your mod is currently on.
+
+Your setup method should now look something like this:
+
+```java
+@Override
+protected void setup() {
+  super.setup();
+  new HStats("c34a2b2a-afd8-4d6a-821e-7a63e12c5ea6", "1.0.0");
+}
+```
+
+# Extras
+
+Your done! Your mod should now be listed under the Mods page (https://hstats.dev/mods) as well as under your dashboard.
+
+Servers using your mod should now post updates about every minute to HStats which you can view in the Dashboard.
+
+### Embeds
+
+HStats allows you to generate an Embed Card that you can place on your CurseForge or GitHub page. This is useful for server owners to be able to see how many other servers are using your mod.
+
+- In your dashboard, scroll down to the Embed Card section.
+- Customize the appearance (Light/Dark mode, layout, etc).
+- Copy the generated URL to display your "Active Servers" and "Players Online" live on your mod's description page
+
+Heres an example of what they look like:
+![HStats Example](https://api.hstats.dev/api/embed/d52fa672-6966-47b2-b501-1a11bddebac3/card.svg?theme=light\&layout=compact\&size=md\&show_id=true\&dark=false)
diff --git a/content/docs/ru-RU/guides/plugin/world-gen.mdx b/content/docs/ru-RU/guides/plugin/world-gen.mdx
index 4c23b0c9..7b193ffd 100644
--- a/content/docs/ru-RU/guides/plugin/world-gen.mdx
+++ b/content/docs/ru-RU/guides/plugin/world-gen.mdx
@@ -100,7 +100,7 @@ Biome biome = biomeGen.generateBiomeAt(zoneResult, seed, x, z);
 
 ### Zone & Cave Integration
 
-Each zone defines it's own cave patterns:
+Each zone defines its own cave patterns:
 
 ```java
 Zone zone = /* ... */;
diff --git a/content/docs/ru-RU/guides/prefabs.mdx b/content/docs/ru-RU/guides/prefabs.mdx
index 08404b30..b1a55109 100644
--- a/content/docs/ru-RU/guides/prefabs.mdx
+++ b/content/docs/ru-RU/guides/prefabs.mdx
@@ -14,7 +14,7 @@ Prefabs are Hytale's way of creating reusable structures.
 There are a few fundamental concepts to understand about prefabs:
 
 - Users interact with prefabs via a prefab editing world.
-- Prefabs the physical structures in the game world, and are saved as JSON files.
+- Prefabs are the physical structures in the game world, and are saved as JSON files.
 
 ## How to Create a Prefab
 
diff --git a/content/docs/ru-RU/official-documentation/custom-ui/common-styling.mdx b/content/docs/ru-RU/official-documentation/custom-ui/common-styling.mdx
new file mode 100644
index 00000000..c36e3e3a
--- /dev/null
+++ b/content/docs/ru-RU/official-documentation/custom-ui/common-styling.mdx
@@ -0,0 +1,50 @@
+---
+title: Common Styling
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# Common Styling
+
+## Common UI Styling Library
+
+This document describes the shared UI components and styles defined in `Common.ui`.
+
+---
+
+### Styles
+
+We are providing some styles that can be re-used in any custom UI that, provide a cohesive UI experience with the core game UI. These styles are available in the `Common.ui` file.
+
+You can find a list of all the styles defined with live examples by running the `/ui-gallery` command ingame.
+
+<Callout type="warning">
+  This command is not available yet, but will be in a future patch.
+</Callout>
+
+![Gallery](/assets/official-documentation/ui/gallery.png)
+
+### Importing
+
+To use these styles in your UI file:
+
+```
+$Common = "Common.ui";
+
+// Then reference styles and components:
+$Common.@TextButton { @Text = "My Button"; }
+$Common.@Container { ... }
+```
+
+<Callout type="info">
+  The `Common.ui` file is at `Common/UI/Custom/Common.ui` within the Hytale pack. If your custom ui document is in a subfolder of `Common/UI/Custom/`, reference it via relative path traversal:
+
+  ```
+  $Common = "../Common.ui";
+  ```
+
+  You can find more info about paths [here](markup#path).
+</Callout>
diff --git a/content/docs/ru-RU/official-documentation/custom-ui/index.mdx b/content/docs/ru-RU/official-documentation/custom-ui/index.mdx
new file mode 100644
index 00000000..f94c4e88
--- /dev/null
+++ b/content/docs/ru-RU/official-documentation/custom-ui/index.mdx
@@ -0,0 +1,125 @@
+---
+title: Custom UI
+icon: LayoutDashboard
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# Custom UI
+
+## What is Custom UI?
+
+Custom UI is Hytale's framework for creating **custom user interfaces** controlled by the game server. Unlike the built-in Client UI (which is part of the game client and cannot be modified), Server UI allows you to create interactive screens and HUD overlays through Java plugins and asset packs.
+
+As a modder, Custom UI gives you the power to:
+
+- **Create custom interactive pages** - Shop interfaces, quest dialogs, server settings menus, admin panels
+- **Add custom HUD overlays** - Quest trackers, status displays, custom health bars, server information
+- **Design with markup** - Use `.ui` files to define reusable UI templates
+- **Handle user interactions** - Respond to button clicks, form submissions, and other events
+- **Localize your UI** - Support multiple languages using the game's translation system
+
+## How Custom UI Fits Into Hytale's UI
+
+Hytale's user interface is divided into two main categories:
+
+### Client UI (Not Moddable)
+
+Built-in interfaces controlled by the C# game client:
+
+- Main menu and settings
+- Character creation
+- Built-in HUD (health, hotbar, chat)
+- Inventory and crafting screens
+- Development tools
+
+**You cannot modify these** - they are part of the core game client.
+
+### In-Game UI (Moddable via Server)
+
+Server-controlled interfaces that you can create and customize:
+
+#### Custom Pages
+
+Full-screen interactive overlays that appear during gameplay:
+
+- Can be dismissed by the player (ESC key)
+- Capture all input (keyboard and mouse)
+- Support loading states while waiting for server responses
+- Perfect for: shops, dialogs, menus, configuration screens
+
+#### Custom HUDs
+
+Persistent overlay elements drawn on top of the game world:
+
+- Display-only (no user interaction)
+- Always visible during gameplay
+- Lightweight and non-intrusive
+- Perfect for: quest objectives, status indicators, server info panels
+
+## Architecture Overview
+
+Server UI uses a **command-based architecture**:
+
+```
+┌─────────────────────┐         ┌──────────────────────┐
+│   Java Server       │         │    C# Client         │
+│   (Your Plugin)     │         │    (Game)            │
+├─────────────────────┤         ├──────────────────────┤
+│                     │         │                      │
+│ InteractiveCustomUI │         │   CustomPage or      │
+│ Page                │         │   CustomHud          │
+│   ↓ build()         ├────────→│     ↓ Apply          │
+│ UICommandBuilder    │         │   Element Tree       │
+│   - append()        │         │     ↓ Layout         │
+│   - set()           │         │   Rendered UI        │
+│   - clear()         │         │                      │
+│                     │         │                      │
+│ ↓ handleDataEvent() │← Events │   User Interaction   │
+│   Process input     │         │   (click, type, etc) │
+│   sendUpdate()      │         │                      │
+└─────────────────────┘         └──────────────────────┘
+```
+
+**The flow:**
+
+1. Your Java code builds UI using `UICommandBuilder`
+2. Commands are sent to the client as data
+3. Client parses `.ui` markup files and creates visual elements
+4. User interacts with the UI
+5. Events are sent back to your Java code
+6. You process events and send updates back
+
+## Key Principles
+
+### Declarative, Not Imperative
+
+You don't create UI objects directly. Instead, you send **commands** that describe what you want:
+
+- "Append this button template to that container"
+- "Set this label's text to 'Hello World'"
+- "Clear all children from this list"
+
+### Asset-Driven
+
+UI structure is defined in `.ui` markup files (assets), not hardcoded in Java. This enables:
+
+- Designers to modify layouts without touching code
+- Reusable UI components
+- Consistent visual language
+
+### Event-Driven
+
+User interactions trigger events that flow back to your server code. You register event bindings and handle them in `handleDataEvent()`.
+
+### Selector-Based
+
+You target specific UI elements using **selectors:**
+
+- `#MyButton` - Element with ID "MyButton"
+- `#List[0]` - First child of element "List"
+- `#List[0] #Title` - Element with ID "Title" in the first child of element "List"
+- `#Label.TextColor` - The TextColor property of element "Label"
diff --git a/content/docs/ru-RU/official-documentation/custom-ui/layout.mdx b/content/docs/ru-RU/official-documentation/custom-ui/layout.mdx
new file mode 100644
index 00000000..0a24ca09
--- /dev/null
+++ b/content/docs/ru-RU/official-documentation/custom-ui/layout.mdx
@@ -0,0 +1,492 @@
+---
+title: Layout
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# Layout
+
+The layout system determines how UI elements are positioned and sized on screen. Understanding layout is crucial for creating well-structured, responsive interfaces.
+
+## Layout Fundamentals
+
+Every UI element has:
+
+- **Container Rectangle** - The space allocated by the parent
+- **Anchor** - How the element positions/sizes itself within the container
+- **Padding** - Inner spacing that affects child layout
+- **LayoutMode** - How the element arranges its children (if it's a container)
+
+```
+┌─────────────────────────────────────┐
+│  Container Rectangle (from parent)  │
+│  ┌───────────────────────────────┐  │
+│  │  Anchored Rectangle           │  │
+│  │  ┌─────────────────────────┐  │  │
+│  │  │ Padding                 │  │  │
+│  │  │  ┌───────────────────┐  │  │  │
+│  │  │  │  Content Area     │  │  │  │
+│  │  │  └───────────────────┘  │  │  │
+│  │  └─────────────────────────┘  │  │
+│  └───────────────────────────────┘  │
+└─────────────────────────────────────┘
+```
+
+## Anchor
+
+`Anchor` controls how an element positions and sizes itself within its container rectangle.
+
+### Fixed Size
+
+```
+Button {
+    Anchor: (Width: 200, Height: 40);
+}
+```
+
+Creates a 200×40 pixel button.
+
+### Positioning
+
+```
+Label {
+    Anchor: (Top: 10, Left: 20, Width: 100, Height: 30);
+}
+```
+
+- **Top**: 10 pixels from container's top edge
+- **Left**: 20 pixels from container's left edge
+- **Width**: 100 pixels wide
+- **Height**: 30 pixels tall
+
+### Anchoring to Edges
+
+```
+Button {
+    Anchor: (Bottom: 10, Right: 10, Width: 100, Height: 30);
+}
+```
+
+Anchors the button to the bottom-right corner, 10 pixels from each edge.
+
+### Stretching
+
+```
+Group {
+    Anchor: (Top: 0, Bottom: 0, Left: 0, Right: 0);
+}
+```
+
+Stretches to fill the entire container (all edges at 0 pixels).
+
+**Shorthand:**
+
+```
+Group {
+    Anchor: (Full: 0);
+}
+```
+
+### Mixed Anchoring
+
+```
+Panel {
+    Anchor: (Top: 10, Bottom: 10, Left: 20, Width: 300);
+}
+```
+
+- Fixed width of 300 pixels
+- Stretches vertically between top and bottom edges
+- 10 pixels from top and bottom
+- 20 pixels from left
+
+## Padding
+
+`Padding` creates inner spacing, affecting where children are positioned.
+
+### Uniform Padding
+
+```
+Group {
+    Padding: (Full: 20);
+}
+```
+
+20 pixels of padding on all sides.
+
+### Directional Padding
+
+```
+Group {
+    Padding: (Top: 10, Bottom: 20, Left: 15, Right: 15);
+}
+```
+
+Different padding per edge.
+
+### Shorthand
+
+```
+// Horizontal and vertical
+Group {
+    Padding: (Horizontal: 20, Vertical: 10);
+}
+
+// Equivalent to:
+// Top: 10, Bottom: 10, Left: 20, Right: 20
+```
+
+### Effect on Children
+
+```
+Group {
+    Anchor: (Width: 200, Height: 100);
+    Padding: (Full: 10);
+
+    Label {
+        Anchor: (Full: 0);
+    }
+}
+```
+
+The label fills the group, but there's a 10-pixel gap on all sides due to padding.
+
+```
+┌──────────────────────┐
+│ Group (200×100)      │
+│  ┌────────────────┐  │
+│  │ Label          │  │ ← 10px padding all around
+│  │                │  │
+│  └────────────────┘  │
+└──────────────────────┘
+```
+
+## LayoutMode
+
+`LayoutMode` determines how a container arranges its children.
+
+### Top (Vertical Stack)
+
+```
+Group {
+    LayoutMode: Top;
+
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+}
+```
+
+Children stack vertically from top to bottom:
+
+```
+┌──────────┐
+│ Button 1 │
+├──────────┤
+│ Button 2 │
+├──────────┤
+│ Button 3 │
+└──────────┘
+
+
+```
+
+Each child's `Anchor.Bottom` adds spacing between elements:
+
+```
+Button { Anchor: (Height: 30, Bottom: 10); }  // 10px gap after this button
+```
+
+### Bottom (Vertical Stack)
+
+```
+Group {
+    LayoutMode: Bottom;
+
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+}
+```
+
+Children stack vertically from top to bottom but aligned to the bottom edge of the parent:
+
+```
+
+
+
+┌──────────┐
+│ Button 1 │
+├──────────┤
+│ Button 2 │
+├──────────┤
+│ Button 3 │
+└──────────┘
+```
+
+### Left (Horizontal Stack)
+
+```
+Group {
+    LayoutMode: Left;
+
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+}
+```
+
+Children arrange horizontally from left to right:
+
+```
+┌────────┬────────┬────────┐
+│ Button │ Button │ Button │
+│   1    │   2    │   3    │
+└────────┴────────┴────────┘
+```
+
+Use `Anchor.Right` for spacing between elements.
+
+### Right (Horizontal Stack)
+
+```
+Group {
+    LayoutMode: Right;
+
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+}
+```
+
+Children arrange horizontally from left to right but aligned to the right side of the parent:
+
+```
+                                                                 ┌────────┬────────┬────────┐
+                                                                 │ Button │ Button │ Button │
+                                                                 │   1    │   2    │   3    │
+                                                                 └────────┴────────┴────────┘
+```
+
+### Center
+
+```
+Group {
+    LayoutMode: Center;
+
+    Group #Dialog {
+        Anchor: (Width: 400, Height: 300);
+    }
+}
+```
+
+Centers the children horizontally.
+
+### Middle
+
+```
+Group {
+    LayoutMode: Middle;
+
+    Group #Dialog {
+        Anchor: (Width: 400, Height: 300);
+    }
+}
+```
+
+Centers the children vertically.
+
+### CenterMiddle (Horizontal Stack, Fully Centered)
+
+```
+Group {
+    LayoutMode: CenterMiddle;
+
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+}
+```
+
+Children stack horizontally from left to right, centered both horizontally and vertically within the parent:
+
+```
+┌────────────────────────────────────────────┐
+│                                            │
+│                                            │
+│         ┌──────┐ ┌──────┐ ┌──────┐         │
+│         │  B1  │ │  B2  │ │  B3  │         │
+│         └──────┘ └──────┘ └──────┘         │
+│                                            │
+│                                            │
+└────────────────────────────────────────────┘
+```
+
+---
+
+### MiddleCenter (Vertical Stack, Fully Centered)
+
+```
+Group {
+    LayoutMode: MiddleCenter;
+
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+}
+```
+
+Children stack vertically from top to bottom, centered both horizontally and vertically within the parent:
+
+```
+┌────────────────────────────────────────────┐
+│                                            │
+│              ┌──────────┐                  │
+│              │ Button 1 │                  │
+│              ├──────────┤                  │
+│              │ Button 2 │                  │
+│              ├──────────┤                  │
+│              │ Button 3 │                  │
+│              └──────────┘                  │
+│                                            │
+└────────────────────────────────────────────┘
+```
+
+---
+
+### Full
+
+```
+Group {
+    LayoutMode: Full;
+
+    Label {
+        Anchor: (Top: 20, Left: 20, Width: 100, Height: 30);
+    }
+}
+```
+
+Children use absolute positioning via their `Anchor` properties.
+
+### TopScrolling
+
+```
+Group {
+    LayoutMode: TopScrolling;
+    ScrollbarStyle: $Common.@DefaultScrollbar;
+
+    // ... many children
+}
+```
+
+Like `Top`, but adds a scrollbar if content exceeds container height.
+
+Or use `BottomScrolling` for bottom-aligned content.
+
+### LeftScrolling
+
+```
+Group {
+    LayoutMode: LeftScrolling;
+    ScrollbarStyle: $Common.@DefaultScrollbar;
+
+    // ... many children
+}
+```
+
+Like `Left`, but adds a scrollbar for horizontal scrolling.
+
+Or use `RightScrolling` for right-aligned content.
+
+### LeftCenterWrap (Wrapping Horizontal Stack, Horizontally Centered)
+
+```
+Group {
+    LayoutMode: LeftCenterWrap;
+
+    Button { Anchor: (Width: 80, Height: 30); }
+    Button { Anchor: (Width: 80, Height: 30); }
+    Button { Anchor: (Width: 80, Height: 30); }
+    Button { Anchor: (Width: 80, Height: 30); }
+    Button { Anchor: (Width: 80, Height: 30); }
+}
+```
+
+Children flow left to right. When there's no more horizontal space, they wrap to the next row. Each row is horizontally centered within the parent:
+
+```
+┌────────────────────────────────────────────┐
+│                                            │
+│       ┌──────┐ ┌──────┐ ┌──────┐           │
+│       │  B1  │ │  B2  │ │  B3  │           │
+│       └──────┘ └──────┘ └──────┘           │
+│            ┌──────┐ ┌──────┐               │
+│            │  B4  │ │  B5  │               │
+│            └──────┘ └──────┘               │
+│                                            │
+└────────────────────────────────────────────┘
+```
+
+## FlexWeight
+
+`FlexWeight` distributes remaining space among children.
+
+```
+Group {
+    LayoutMode: Left;
+    Anchor: (Width: 400);
+
+    Button {
+        Anchor: (Width: 100);
+    }
+
+    Group {
+        FlexWeight: 1;  // Takes all remaining space
+    }
+
+    Button {
+        Anchor: (Width: 100);
+    }
+}
+```
+
+Result:
+
+- First button: 100px
+- Middle group: 200px (400 - 100 - 100 = 200)
+- Last button: 100px
+
+### Multiple FlexWeights
+
+```
+Group {
+    LayoutMode: Left;
+    Anchor: (Width: 600);
+
+    Group { FlexWeight: 1; }
+    Group { FlexWeight: 2; }
+    Group { FlexWeight: 1; }
+}
+```
+
+Remaining space (600px) is split:
+
+- First group: 600 × (1/4) = 150px
+- Second group: 600 × (2/4) = 300px
+- Third group: 600 × (1/4) = 150px
+
+## Visibility
+
+```
+Button #HiddenButton {
+    Visible: false;
+}
+```
+
+**Effect:**
+
+- Element and its children are not displayed
+- Element is **not included in layout** (doesn't take up space)
diff --git a/content/docs/ru-RU/official-documentation/custom-ui/markup.mdx b/content/docs/ru-RU/official-documentation/custom-ui/markup.mdx
new file mode 100644
index 00000000..564110ed
--- /dev/null
+++ b/content/docs/ru-RU/official-documentation/custom-ui/markup.mdx
@@ -0,0 +1,226 @@
+---
+title: Markup
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# Markup
+
+## Markup
+
+An element is the basic building block of a user interface. There are various types of elements with different properties, which are documented below.
+
+Here's what the syntax looks like:
+
+```
+// Basic declaration of an element
+// with its Anchor property set to attach on all sides of its parent
+// with 10 pixels of margin
+Group { Anchor: (Left: 10, Top: 10, Right: 10, Bottom: 10); }
+
+Group { Anchor: (Full: 10); } // More concise version
+
+// Declaration of a Label with a name
+// (can be used to access the element from game code)
+Label #MyLabel {
+  Style: LabelStyle(FontSize: 16); // or just Style: (FontSize: 16), type can be inferred.
+  Text: "Hi! I am text.";
+}
+
+// Declaration of a Group containing 2 children
+// You can use FlexWeight to distribute any left-over space after explicit widths/heights have been subtracted
+Group {
+  LayoutMode: Left;
+  Label { Text: "Child 1"; FlexWeight: 2; }
+  Label { Text: "Child 2"; FlexWeight: 1; }
+}
+```
+
+### Documents
+
+A UI document (_.ui_ file) contains trees of elements. There can be multiple root elements.
+
+### Named Expressions
+
+Named expressions can be declared at any level of a document (including at the root) and will be scoped to that subtree, though they need to be declared at the top of the block.
+
+```
+// Example of named expressions, declared and used with @ prefix
+@Title = "Hytale";
+@ExtraSpacing = 5;
+
+Label {
+  Text: @Title;
+  Style: (LetterSpacing: 2 + @ExtraSpacing);
+}
+```
+
+You can use the spread operator `...` to reuse a named expression while overriding some of its fields:
+
+```
+@MyBaseStyle = LabelStyle(FontSize: 24, LetterSpacing: 2);
+
+Label {
+  Style: (...@MyBaseStyle, FontSize: 36);
+}
+```
+
+You can even layer multiple named expressions like so:
+
+```
+@TitleStyle = LabelStyle(FontSize: 24, HorizontalAlignment: Center);
+@SpacedTextStyle = LabelStyle(LetterSpacing: 2);
+
+Label {
+  Style: (...@BigTextStyle, ...@SpacedTextStyle);
+}
+```
+
+#### Document references
+
+A document can reference another document and access its named expressions.
+
+```
+// Document references are defined with $ prefix
+$Common = "../Common.ui";
+
+TextButton {
+  Style: $Common.@DefaultButtonStyle;
+}
+```
+
+### Templates
+
+You can declare a reusable bit of interface as a named expression and then instantiate it as many times as you want in the tree while customizing it.
+
+You can override local named expressions as well as insert additional children at any point in the template tree. However, local named expressions must be defined at the very top of the block, before properties and child elements.
+
+```
+// This is the template
+@Row = Group {
+  Anchor: (Height: 50);
+  Label #Label { Anchor: (Left: 0, Width: 100); Text: @LabelText; }
+  Group #Content { Anchor: (Left: 100); }
+};
+
+// Here we'll be using it twice in the document tree
+Group #Rows {
+  LayoutMode: TopScrolling;
+
+  @Row #MyFirstRow {
+    @LabelText = "First row";
+    #Content { TextInput {} }
+  }
+
+  @Row #MySecondRow {
+    @LabelText = "Second row";
+  }
+}
+```
+
+### Property Types
+
+#### Basic Types
+
+- **Boolean**
+  - `Visible: false;`
+  - `Visible: true;`
+- **Int**
+  - `Height: 20;`
+- **Float, Double, Decimal**
+  - `Min: 0.2;`
+- **String**
+  - `Text: "Hi!";`
+- **Char**
+  - `PasswordChar: "*";`
+  - _Note: The syntax is the same as a string, however a value of this type cannot contain more than one character!_
+- **Color**
+  - `Background: #ffffff;`&#x20;
+- **Objects**
+  - `Style: (Background: #ffffff)`
+- **Array**&#x20;
+  - `TextSpans: [(Text: "Hi", IsBold: true)]`
+
+#### Translations
+
+Translation keys can be referenced anywhere in markup where you can provide a string, and they are then converted to a string when an element gets instantiated.
+
+**Example:**
+
+```
+Label {
+  Text: %ui.general.cancel;
+}
+```
+
+#### Colors
+
+A color literal can be written as follows:
+
+- `#rrggbb`: 6-digit hexadecimal representation for red, green, blue (fully opaque)
+- `#rrggbb(a.a)`: 6-digit hexadecimal representation for red, green, blue with alpha between 0 and 1
+- `#rrggbbaa`: 8-digit hexadecimal representation for red, green, blue and alpha
+
+```
+Group {
+  Background: #000000(0.3);
+}
+```
+
+<Callout>
+  The `#rrggbb(a.a)` format is prefered over the `#rrggbbaa` format for
+  readability reasons.
+</Callout>
+
+#### Font Name
+
+Font names can be referenced directly by their string ID. Internally this is using a custom type called `UIFontName`, however strings will be converted automatically to this type in markup.
+
+```
+Label {
+  Text: "Hi";
+  Style: (FontName: "Secondary");
+}
+```
+
+**Available Font Names**
+
+- _Default_ - This is the default font that is used for most text and is always used unless a different option has been specified
+- _Secondary_ - This font is mostly used for headlines or elements that are supposed to stick out
+- _Mono_ - This is only used for development; For things such as profiling or error overlays.
+
+#### Path
+
+We can reference other UI assets with the `UIPath` type. Similar to `UIFontName`_,_ Strings are automatically converted to a `UIPath`. Paths are always relative to the file where they have been declared in. Looking up _MyButton.png_ in _Menu/MyAwesomeMenu.ui_ will result in _Menu/MyButton.png_. If you want to reference a file that is in a parent folder you can go back one directory by writing two dots (_../MyButton.png_).
+
+The markup syntax of a `UIPath` is the same as a String. (e.g. `Path: "Test.png"`)
+
+Here are some more examples:
+
+| UIPath             | .ui File                              | Resulting Path    |
+| ------------------ | ------------------------------------- | ----------------- |
+| MyButton.png       | Menu/MyAwesomeMenu.ui                 | Menu/MyButton.png |
+| ../MyButton.png    | Menu/MyAwesomeMenu.ui                 | MyButton.png      |
+| ../../MyButton.png | Menu/Popup/Templates/MyAwesomeMenu.ui | Menu/MyButton.png |
+
+#### Objects
+
+Objects contain a set of properties. In this example we are assigning an Anchor object to the _Anchor_ property:
+
+```
+Group {
+  Anchor: (
+   Height: 10,
+   Width: 20
+ );
+}
+```
+
+You can find all objects that can be used in markup [here](type-documentation#elements).
+
+## Visual Studio Code Extension
+
+There is an official extension for Visual Studio Code which adds syntax highlighting for .ui files. You can find it [here](https://marketplace.visualstudio.com/items?itemName=HypixelStudiosCanadaInc.vscode-hytaleui).
diff --git a/content/docs/ru-RU/official-documentation/custom-ui/type-documentation/index.mdx b/content/docs/ru-RU/official-documentation/custom-ui/type-documentation/index.mdx
new file mode 100644
index 00000000..69cea406
--- /dev/null
+++ b/content/docs/ru-RU/official-documentation/custom-ui/type-documentation/index.mdx
@@ -0,0 +1,127 @@
+---
+title: Type Documentation
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# Type Documentation
+
+This is a generated list of UI elements accessible by markup. More information about the User Interface framework can be found in the main documentation.
+
+## Elements
+
+- [ActionButton](type-documentation/elements/actionbutton)
+- [AssetImage](type-documentation/elements/assetimage)
+- [BackButton](type-documentation/elements/backbutton)
+- [BlockSelector](type-documentation/elements/blockselector)
+- [Button](type-documentation/elements/button)
+- [CharacterPreviewComponent](type-documentation/elements/characterpreviewcomponent)
+- [CheckBox](type-documentation/elements/checkbox)
+- [CheckBoxContainer](type-documentation/elements/checkboxcontainer)
+- [CircularProgressBar](type-documentation/elements/circularprogressbar)
+- [CodeEditor](type-documentation/elements/codeeditor)
+- [ColorOptionGrid](type-documentation/elements/coloroptiongrid)
+- [ColorPicker](type-documentation/lements/colorpicker)
+- [ColorPickerDropdownBox](type-documentation/elements/colorpickerdropdownbox)
+- [CompactTextField](type-documentation/elements/compacttextfield)
+- [DropdownBox](type-documentation/elements/dropdownbox)
+- [DropdownEntry](type-documentation/elements/dropdownentry)
+- [DynamicPane](type-documentation/elements/dynamicpane)
+- [DynamicPaneContainer](type-documentation/elements/dynamicpanecontainer)
+- [FloatSlider](type-documentation/elements/floatslider)
+- [FloatSliderNumberField](type-documentation/elements/floatslidernumberfield)
+- [Group](type-documentation/elements/group)
+- [HotkeyLabel](type-documentation/elements/hotkeylabel)
+- [ItemGrid](type-documentation/elements/itemgrid)
+- [ItemIcon](type-documentation/elements/itemicon)
+- [ItemPreviewComponent](type-documentation/elements/itempreviewcomponent)
+- [ItemSlot](type-documentation/elements/itemslot)
+- [ItemSlotButton](type-documentation/elements/itemslotbutton)
+- [Label](type-documentation/elements/label)
+- [LabeledCheckBox](type-documentation/elements/labeledcheckbox)
+- [MenuItem](type-documentation/elements/menuitem)
+- [MultilineTextField](type-documentation/elements/multilinetextfield)
+- [NumberField](type-documentation/elements/numberfield)
+- [Panel](type-documentation/elements/panel)
+- [ProgressBar](type-documentation/elements/progressbar)
+- [ReorderableList](type-documentation/elements/reorderablelist)
+- [ReorderableListGrip](type-documentation/elements/reorderablelistgrip)
+- [SceneBlur](type-documentation/elements/sceneblur)
+- [Slider](type-documentation/elements/slider)
+- [SliderNumberField](type-documentation/elements/slidernumberfield)
+- [Sprite](type-documentation/elements/sprite)
+- [TabButton](type-documentation/elements/tabbutton)
+- [TabNavigation](type-documentation/elements/tabnavigation)
+- [TextButton](type-documentation/elements/textbutton)
+- [TextField](type-documentation/elements/textfield)
+- [TimerLabel](type-documentation/elements/timerlabel)
+- [ToggleButton](type-documentation/elements/togglebutton)
+
+## Property Types
+
+- [Anchor](type-documentation/property-types/anchor)
+- [BlockSelectorStyle](type-documentation/property-types/blockselectorstyle)
+- [ButtonSounds](type-documentation/property-types/buttonsounds)
+- [ButtonStyle](type-documentation/property-types/buttonstyle)
+- [ButtonStyleState](type-documentation/property-types/buttonstylestate)
+- [CheckBoxStyle](type-documentation/property-types/checkboxstyle)
+- [CheckBoxStyleState](type-documentation/property-types/checkboxstylestate)
+- [ClientItemStack](type-documentation/property-types/clientitemstack)
+- [ColorOptionGridStyle](type-documentation/property-types/coloroptiongridstyle)
+- [ColorPickerDropdownBoxStateBackground](type-documentation/property-types/colorpickerdropdownboxstatebackground)
+- [ColorPickerDropdownBoxStyle](type-documentation/property-types/colorpickerdropdownboxstyle)
+- [ColorPickerStyle](type-documentation/property-types/colorpickerstyle)
+- [DropdownBoxSearchInputStyle](type-documentation/property-types/dropdownboxsearchinputstyle)
+- [DropdownBoxSounds](type-documentation/property-types/dropdownboxsounds)
+- [DropdownBoxStyle](type-documentation/property-types/dropdownboxstyle)
+- [InputFieldButtonStyle](type-documentation/property-types/inputfieldbuttonstyle)
+- [InputFieldDecorationStyle](type-documentation/property-types/inputfielddecorationstyle)
+- [InputFieldDecorationStyleState](type-documentation/property-types/inputfielddecorationstylestate)
+- [InputFieldIcon](type-documentation/property-types/inputfieldicon)
+- [InputFieldStyle](type-documentation/property-types/inputfieldstyle)
+- [ItemGridSlot](type-documentation/property-types/itemgridslot)
+- [ItemGridStyle](type-documentation/property-types/itemgridstyle)
+- [LabeledCheckBoxStyle](type-documentation/property-types/labeledcheckboxstyle)
+- [LabeledCheckBoxStyleState](type-documentation/property-types/labeledcheckboxstylestate)
+- [LabelSpan](type-documentation/property-types/labelspan)
+- [LabelStyle](type-documentation/property-types/labelstyle)
+- [NumberFieldFormat](type-documentation/property-types/numberfieldformat)
+- [Padding](type-documentation/property-types/padding)
+- [PatchStyle](type-documentation/property-types/patchstyle)
+- [PopupStyle](type-documentation/property-types/popupstyle)
+- [ScrollbarStyle](type-documentation/property-types/scrollbarstyle)
+- [SliderStyle](type-documentation/property-types/sliderstyle)
+- [SoundStyle](type-documentation/property-types/soundstyle)
+- [SpriteFrame](type-documentation/property-types/spriteframe)
+- [SubMenuItemStyle](type-documentation/property-types/submenuitemstyle)
+- [SubMenuItemStyleState](type-documentation/property-types/submenuitemstylestate)
+- [Tab](type-documentation/property-types/tab)
+- [TabNavigationStyle](type-documentation/property-types/tabnavigationstyle)
+- [TabStyle](type-documentation/property-types/tabstyle)
+- [TabStyleState](type-documentation/property-types/tabstylestate)
+- [TextButtonStyle](type-documentation/property-types/textbuttonstyle)
+- [TextButtonStyleState](type-documentation/property-types/textbuttonstylestate)
+- [TextTooltipStyle](type-documentation/property-types/texttooltipstyle)
+- [ToggleButtonStyle](type-documentation/property-types/togglebuttonstyle)
+- [ToggleButtonStyleState](type-documentation/property-types/togglebuttonstylestate)
+
+## Enums
+
+- [ActionButtonAlignment](type-documentation/enums/actionbuttonalignment)
+- [CodeEditorLanguage](type-documentation/enums/codeeditorlanguage)
+- [ColorFormat](type-documentation/enums/colorformat)
+- [DropdownBoxAlign](type-documentation/enums/dropdownboxalign)
+- [InputFieldButtonSide](type-documentation/enums/inputfieldbuttonside)
+- [InputFieldIconSide](type-documentation/enums/inputfieldiconside)
+- [ItemGridInfoDisplayMode](type-documentation/enums/itemgridinfodisplaymode)
+- [LabelAlignment](type-documentation/enums/labelalignment)
+- [LayoutMode](type-documentation/enums/layoutmode)
+- [MouseWheelScrollBehaviourType](type-documentation/enums/mousewheelscrollbehaviourtype)
+- [ProgressBarAlignment](type-documentation/enums/progressbaralignment)
+- [ProgressBarDirection](type-documentation/enums/progressbardirection)
+- [ResizeType](type-documentation/enums/resizetype)
+- [TimerDirection](type-documentation/enums/timerdirection)
+- [TooltipAlignment](type-documentation/enums/tooltipalignment)
diff --git a/content/docs/ru-RU/official-documentation/npc/2-getting-started-with-templates.mdx b/content/docs/ru-RU/official-documentation/npc/2-getting-started-with-templates.mdx
index 91081ca1..99d078e0 100644
--- a/content/docs/ru-RU/official-documentation/npc/2-getting-started-with-templates.mdx
+++ b/content/docs/ru-RU/official-documentation/npc/2-getting-started-with-templates.mdx
@@ -9,7 +9,7 @@ authors:
 
 There are no hard and fast rules for making a start on a template. I like to duplicate **BlankTemplate** and start from there because it already provides the basic structure of the file.
 
-This leaves me with the following template (`Template_Goblin_Ogre.json`): (note: the file could be looking different in the current version of the game)
+This leaves me with the following template (`Template_Goblin_Ogre.json`): (**note: the file could be looking different in the current version of the game**)
 
 ```json
 {
@@ -33,7 +33,7 @@ This leaves me with the following template (`Template_Goblin_Ogre.json`): (note:
     }
   },
   "Appearance": { "Compute": "Appearance" },
-  "DropList": { "Compute": "Droplist" },
+  "DropList": { "Compute": "DropList" },
   "MaxHealth": { "Compute": "MaxHealth" },
   "MotionControllerList": [
     {
@@ -65,10 +65,10 @@ And the following variant (`Goblin_Ogre.json`) next to the template. There's a t
   "Type": "Variant",
   "Reference": "Template_Goblin_Ogre",
   "Modify": {
-    "Appearance": "Goblin_Ogre",
+    "Appearance": "Goblin",
     "MaxHealth": 124
   }
 }
 ```
 
-Our artists have defined the `Goblin_Ogre` appearance already so I'm going to use that.
+Our artists have not yet finished animations for the `Goblin_Ogre`, for that sake of the tutorial I am going to use appearance `Goblin`, because it offers a more complete set of animations that we will need.
diff --git a/content/docs/ru-RU/official-documentation/worldgen/pack-tutorial/asset-packs.mdx b/content/docs/ru-RU/official-documentation/worldgen/pack-tutorial/asset-packs.mdx
index 38809fad..dcf1f3b9 100644
--- a/content/docs/ru-RU/official-documentation/worldgen/pack-tutorial/asset-packs.mdx
+++ b/content/docs/ru-RU/official-documentation/worldgen/pack-tutorial/asset-packs.mdx
@@ -9,13 +9,13 @@ authors:
 
 <OfficialDocumentationNotice />
 
-# How to modify Hytale
+# How to modify Hytale?
 
-## What's an Asset Pack
+## What's an Asset Pack?
 
-Hytales gameplay is driven by assets in the game that can be modified by creators. Asset Packs are our solution to let you override or add features to the base game with your own work. These can in the form of zip files of folders, which contain a custom set of assets. This is not the only way for a creator to change Hytale but this is the most accessible form.;
+Hytales gameplay is driven by assets in the game that can be modified by creators. Asset Packs are our solution to let you override or add features to the base game with your own work. These can be the form of zip files of folders, which contain a custom set of assets. This is not the only way for a creator to change Hytale but this is the most accessible form.;
 
-### How do I make an Asset Pack
+### How do I make an Asset Pack?
 
 <video controls className="my-6 aspect-video w-full rounded-lg border">
   <source src="https://cdn.internal.hytalemodding.dev/guides/official/how-to-asset-pack.mp4" type="video/mp4" />
@@ -48,7 +48,7 @@ An asset pack is typically a zip or folder, with a `manifest.json` inside. This
 }
 ```
 
-### Where are they stored
+### Where are they stored?
 
 Asset Packs are stored with other mods in the Mods folder.
 
@@ -76,7 +76,7 @@ C:\Users\<user>\AppData\Roaming\Hytale\UserData\Saves\New World 5\mods
 
 When you have Asset Packs or Mods installed, these will appear in the New World menu under the Options menu.;
 
-### How do I change an existing asset
+### How do I change an existing asset?
 
 <video controls className="my-6 aspect-video w-full rounded-lg border">
   <source src="https://cdn.internal.hytalemodding.dev/guides/official/how-to-asset.mp4" type="video/mp4" />
diff --git a/content/docs/ru-RU/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx b/content/docs/ru-RU/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx
index 44528376..24e628b5 100644
--- a/content/docs/ru-RU/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx
+++ b/content/docs/ru-RU/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx
@@ -106,7 +106,7 @@ If a BaseHeight is provided, the TopY and BottomY values are relative to the Bas
 
 Applies a Material Provider slot on a set of horizontal stripes of blocks of varying thickness and position. Below is an example image of basalt stripes into a stone cliff.
 
-{/* ![](https://540086904-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F7KAmBkOg6d13nZCkf9ku%2Fuploads%2FbcxO9LpArn8gPCaBwFg5%2Funknown.png?alt=media&token=1c72b67a-8253-4d03-8c64-1ad5f6830050) */}
+![Example of basalt stripes](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/basalt-stripes-example.png)
 
 #### Parameters:
 
diff --git a/content/docs/ru-RU/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx b/content/docs/ru-RU/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx
index 5e34acd4..a4418473 100644
--- a/content/docs/ru-RU/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx
+++ b/content/docs/ru-RU/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx
@@ -294,7 +294,7 @@ Combines all the positions into a single Positioins field.
 
 ---
 
-### SimpleHoritontal
+### SimpleHorizontal
 
 Keeps only the positions that are within the provided range.
 
diff --git a/content/docs/ru-RU/official-documentation/worldgen/worldgen-tutorial/README.mdx b/content/docs/ru-RU/official-documentation/worldgen/worldgen-tutorial/README.mdx
new file mode 100644
index 00000000..5f66d245
--- /dev/null
+++ b/content/docs/ru-RU/official-documentation/worldgen/worldgen-tutorial/README.mdx
@@ -0,0 +1,166 @@
+---
+title: How to edit and create Biomes
+description: Explores where world generation assets can be found and how to edit them.
+---
+
+### Where are the Assets
+
+World generation assets are kept in the HytaleGenerator directory within the assets.
+
+```
+/Server/HytaleGenerator/
+```
+
+<div className="flex flex-row rounded-lg border p-4">
+  <div className="flex-1/2 border-r pr-4">
+    ```
+    /Biomes
+    ```
+
+    Biome assets, with content configurations.
+  </div>
+
+  <div className="flex-1/2 pl-4">
+    ```
+    /WorldStructure
+    ```
+
+    Generator files that define which biomes spawn together.
+  </div>
+</div>
+
+<div className="flex flex-row rounded-lg border p-4">
+  <div className="flex-1/2 border-r pr-4">
+    ```
+    /Density
+    ```
+
+    Density assets that can be referenced by any other assets.
+  </div>
+
+  <div className="flex-1/2 pl-4">
+    ```
+    /Assignments
+    ```
+
+    Prop assets that can be referenced by any Biome assets.
+  </div>
+</div>
+
+***
+
+An example of this structure can be found bellow, packed in an asset pack with the instance configuration.
+
+[https://drive.google.com/file/d/1sIz_CluANIIe3n8vNiOi-4PQdeqCO0qY/view?usp=drive_link](https://drive.google.com/file/d/1sIz_CluANIIe3n8vNiOi-4PQdeqCO0qY/view?usp=drive_link)
+
+<Callout>
+  Ensure you place your asset pack in the correct directory, under Mods.
+</Callout>
+
+### How to visit our worlds
+
+https://drive.google.com/file/d/1BJurxyj-taE-PXWm04bk7Dl6X7ZHTH92/view?usp=sharing
+
+#### Requirements
+
+- You must be an **Operator** in the world.
+  - To do this, run <mark style="color:$danger;">`/op self`</mark>
+- You must be in **Creative mode**.
+  - Press the <mark style="color:$danger;">`O`</mark> key, O for Orange.&#x20;
+
+The generation assets define a set of generators but on their own you cannot visit these. Currently you require an Instance with a generator that will allow you to visit your work.
+
+```
+/Server/Instances/
+```
+
+Instances are separate worlds that players can join using the `/instances` command. Each instance has an `Instance.bson` configuration asset that specifies which generator to use, among other worldly settings.
+
+```json
+{
+  "WorldGen": {
+    "Type": "HytaleGenerator",
+    "WorldStructure": "Basic",
+    "playerSpawn" : {
+      "X" : 123,
+      "Y" : 480,
+      "Z" : 10000,
+      "Pitch" : 0,
+      "Yaw" : 0,
+      "Roll" : 0
+    }
+  }
+}
+```
+
+<Callout>
+  You can create custom instances for different world structures and biomes as you need them.
+</Callout>
+
+### How to edit Biomes
+
+<video>
+  <source src="https://cdn.internal.hytalemodding.dev/guides/official/How-to-edit-Biomes.mp4" type="video/mp4" />
+</video>
+
+We currently use the Hytale Node Editor when editing world generation assets. This can be accessed while in-game from the Content Creation menu when pressing B. The node editor is then found under the asset editor dropdown on the upper left.&#x20;
+
+![Node Editor 1](/assets/official-documentation/worldgen/worldgen-tutorial/biomes/node-editor-1.png)
+
+Once you have the Hytale Node Editor open, through the file menu you can open Biomes by navigating to the Biomes directory and selecting one from your pack.&#x20;
+
+```
+/Server/HytaleGenerator/Biomes/
+```
+
+### Biome Asset Structure
+
+Every Biome has a root Biome node, this node splits into 5 structures. This is covered briefly but more information on each field can be found on the World Generation Concepts page.
+
+![Node Editor 2](/assets/official-documentation/worldgen/worldgen-tutorial/biomes/node-editor-2.png)
+
+<Callout>
+  Each biome is for the most part self contained, meaning it has control over what appears with the biome. The only exception to this are Base Heights.
+</Callout>
+
+<Tabs>
+  <Tab value="Terrain">
+    Mathematical function nodes that calculate the physical shape of the Biome's terrain.
+  </Tab>
+
+  <Tab value="Materials">
+    Logical nodes that determine what materials (blocks) make up a Biome's terrain.
+  </Tab>
+
+  <Tab value="Props">
+    Function nodes that add objects like prefabs and decorations to the terrain.
+  </Tab>
+
+  <Tab value="Environments">
+    Logical nodes that determine the environment asset at a given coordinate within the biome. This asset determines things like weather, NPC spawns, and sounds.
+  </Tab>
+
+  <Tab value="Tints">
+    Logical function nodes that determine a colour code that can be used by certain blocks in the world. Typically this will be grasses and soils.
+  </Tab>
+</Tabs>
+
+### How to preview your work
+
+[https://drive.google.com/file/d/1mNcHn9LhFnWDF0DzWFH6_YllmKAUvUry/view?t=6](https://drive.google.com/file/d/1mNcHn9LhFnWDF0DzWFH6_YllmKAUvUry/view?t=6)
+
+Once you are in an Instance world with the Hytale Generator active you will only be able to see your work by generating new chunks. There are a few ways to do this.
+
+The viewport command selects an area around the Player that will live reload as you make changes to the generator.&#x20;
+
+```
+/viewport --radius 5 
+```
+
+You can also create a new world to show your changes.&#x20;
+
+```
+/instances spawn <instance> 
+```
+
+The last option is to simply fly south, new chunks will generate with the changes made.
diff --git a/content/docs/ru-RU/quick-start.mdx b/content/docs/ru-RU/quick-start.mdx
index 653644f4..249d803a 100644
--- a/content/docs/ru-RU/quick-start.mdx
+++ b/content/docs/ru-RU/quick-start.mdx
@@ -9,3 +9,8 @@ Welcome to the Hytale modding documentation! Here you'll find everything you nee
 * [Setting up your dev environment](./guides/plugin/setting-up-env)
 * [Entity Component System (ECS)](./guides/ecs/entity-component-system)
 * [Publishing your mod](./publishing)
+
+### Useful Links
+
+* [Kaupenjoe's Modding Videos](https://www.youtube.com/@ModdingByKaupenjoe)
+* [TroubleDEV's Modding Videos](https://www.youtube.com/@TroubleDEV)
diff --git a/content/docs/ru-RU/server/argtypes.mdx b/content/docs/ru-RU/server/argtypes.mdx
new file mode 100644
index 00000000..e54a442e
--- /dev/null
+++ b/content/docs/ru-RU/server/argtypes.mdx
@@ -0,0 +1,61 @@
+---
+title: ArgTypes
+description: Available ArgTypes
+icon: List
+full: true
+authors:
+  - name: Valeena
+---
+
+| Name                        | Target Class                           | Description                                                                                                                               |   |
+| :-------------------------- | :------------------------------------- | :---------------------------------------------------------------------------------------------------------------------------------------- | - |
+| Boolean                     | java.lang.Boolean                      | A 'true' or 'false' input                                                                                                                 |   |
+| Integer                     | java.lang.Integer                      | A whole number                                                                                                                            |   |
+| String                      | java.lang.String                       | Words, text, numbers, letters. To input more than one word at a time, you may need to wrap it with double quotes (`"my fancy sentence"`). |   |
+| Float                       | java.lang.Float                        | A floating-pointer number                                                                                                                 |   |
+| Double                      | java.lang.Double                       | A decimal number                                                                                                                          |   |
+| UUID                        | java.util.UUID                         | A UUID (Universally Unique IDentifier)                                                                                                    |   |
+| Player_UUID                 | java.util.UUID                         | A UUID or an online player username                                                                                                       |   |
+| Game_Profile_Lookup_Async   | ProfileServiceClient.PublicGameProfile | A player UUID or username. If not found locally, performs a remote lookup via the Profile Service.                                        |   |
+| Relative_Double_Coord       | Coord                                  | An x, y, or z coordinate as a decimal, optionally relative by specifying a tilde (~) in front of the number                               |   |
+| Relative_Int_Coord          | IntCoord                               | An x, y, or z coordinate as a whole number, optionally relative by specifying a tilde (~) in front of the number                          |   |
+| Relative_Integer            | RelativeInteger                        | A tilde to mark an integer relative to a base                                                                                             |   |
+| Relative_Float              | RelativeFloat                          | A tilde to mark a float relative to a base                                                                                                |   |
+| Player_Ref                  | PlayerRef                              | A UUID or an online player's username                                                                                                     |   |
+| World                       | World                                  | A world folder name                                                                                                                       |   |
+| Model_Asset                 | ModelAsset                             | A reference to an Asset of type Model                                                                                                     |   |
+| Weather_Asset               | Weather                                | A reference to an Asset of type Weather                                                                                                   |   |
+| Interaction_Asset           | Interaction                            | A reference to an Asset of type Interaction                                                                                               |   |
+| Root_Interaction_Asset      | RootInteraction                        | A reference to an Asset of type Root Interaction                                                                                          |   |
+| Effect_Asset                | EntityEffect                           | A refernece to an Asset of type EntityEffect                                                                                              |   |
+| Environment_Asset           | Environment                            | A reference to an Asset of type Environment                                                                                               |   |
+| Item_Asset                  | Item                                   | A reference to an Asset of type Item                                                                                                      |   |
+| Block_Type_Asset            | BlockType                              | A reference to an Asset of type BlockType                                                                                                 |   |
+| Particle_System             | ParticleSystem                         | A reference to an Asset of type ParticleSystem                                                                                            |   |
+| Hitbox_Collision_Config     | HitboxCollisionConfig                  | A reference to an Asset of type HitboxCollisionConfig                                                                                     |   |
+| Repulsion_Config            | RepulsionConfig                        | A reference to an Asset of type RepulsionConfig                                                                                           |   |
+| Sound_Event_Asset           | SoundEvent                             | A reference to an Asset of type SoundEvent                                                                                                |   |
+| Ambiance_Fx_Asset           | AmbianceFX                             | A reference to an Asset of type AmbianceFX                                                                                                |   |
+| Sound_Category              | SoundCategory                          | A sound category (sfx, music, ambient, ui)                                                                                                |   |
+| Entity_ID                   | `ArgWrapper<EntityWrappedArg, UUID>`   | A UUID representing an entity id                                                                                                          |   |
+| Integer_Comparison_Operator | IntegerComparisonOperator              | A mathematical sign for integer comparison                                                                                                |   |
+| Integer_Operation           | IntegerOperation                       | A mathematical sign for performing an operation                                                                                           |   |
+| Int_Range                   | `Pair<Integer, Integer>`               | Two integers representing a minimum and maximum of a range                                                                                |   |
+| Relative_Int_Range          | RelativeIntRange                       | Two integers representing a minimum and maximum of a range                                                                                |   |
+| Vector2I                    | Vector2i                               | Two integers, generally corresponding to x/z axis                                                                                         |   |
+| Vector3I                    | Vector3i                               | Three integers, generally corresponding to x/y/z axis                                                                                     |   |
+| Relative_Vector3I           | RelativeVector3i                       | Three optionally relative integers, generally corresponding to x/y/z axis                                                                 |   |
+| Relative_Block_Position     | RelativeIntPosition                    | A position with three integer coordinates, representing a block's location in world space.                                                |   |
+| Relative_Position           | Relative                               | A position with three decimal coordinates, representing a location in world space.                                                        |   |
+| Relative_Chunk_Position     | RealtiveChunkPosition                  | A position with two integer coordinates (x, z), representing a chunk's location.                                                          |   |
+| Rotation                    | Vector3f                               | A rotation with three coordinates, representing the pitch, yaw, and roll respectively                                                     |   |
+| Block_Type_Key              | String                                 | A block type                                                                                                                              |   |
+| Block_ID                    | Integer                                | A block type, converted to an int id                                                                                                      |   |
+| Color                       | Integer                                | A color value in hex format, hex integer, or decimal integer                                                                              |   |
+| Weighted_Block_Type         | `Pair<Integer, String>`                | A weight corresponding to a blocktype                                                                                                     |   |
+| Weighted_Block_Entry        | String                                 | A block with optional weight prefix                                                                                                       |   |
+| Block_Pattern               | BlockPattern                           | A list of blocks with optional weights                                                                                                    |   |
+| Individual_Block_Mask       | BlockMask                              | Create a block mask using symbols and block names                                                                                         |   |
+| Block_Mask                  | BlockMask                              | A tick rate value (e.g., 30tps, 33ms, or 30)                                                                                              |   |
+| Tick_Rate                   | Integer                                | A list of block masks that combine together                                                                                               |   |
+| Game_Mode                   | GameMode                               | GameMode                                                                                                                                  |   |
diff --git a/content/docs/ru-RU/server/interaction-reference.mdx b/content/docs/ru-RU/server/interaction-reference.mdx
new file mode 100644
index 00000000..6c0d01b3
--- /dev/null
+++ b/content/docs/ru-RU/server/interaction-reference.mdx
@@ -0,0 +1,1586 @@
+---
+title: Interactions
+description: A list of most Interaction types provided by Hypixel, along with the meaning of their fields, and how they fit together.
+icon: List
+authors:
+  - name: Stephen Baynham
+    url: https://github.com/cannibalvox
+---
+
+### The Interaction Base Type
+
+All interactions of every type below are inherited from Interaction and have these fields.
+
+**Interaction Fields**
+
+| Field Name                | Type                                                                 | Required? | Notes                                                                                                                                                                                                                       |
+| ------------------------- | -------------------------------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| ViewDistance              | `Double`<br />(Default: 96.0)                                        | **No**    | Distance in blocks at which other players can see the effects from this interaction.                                                                                                                                        |
+| Effects                   | `InteractionEffects`                                                 | **No**    | Sound, animations, and particle effects that should trigger when this interaction begins executing.                                                                                                                         |
+| HorizontalSpeedMultiplier | `Float`<br />(Default: 1.0)                                          | **No**    | Multiplier applied to the User entity's movement speed while this interaction is executing                                                                                                                                  |
+| RunTime                   | `Float`                                                              | **No**    | If provided, this interaction will continue executing for at least this long before the interaction chain moves onto the next interaction.                                                                                  |
+| CancelOnItemChange        | `Boolean`<br />(Default: true)                                       | **No**    | If true, this interaction will be cancelled if the User entity's held item changes during execution. This can happen either due to the selected hotbar slot changing or the contents of the item's inventory slot changing. |
+| Rules                     | `InteractionRules`                                                   | **Yes**   | If provided, adds additional limitations and cancellation conditions to this interaction.                                                                                                                                   |
+| Settings                  | `Map`<br />(Key Type: `GameMode`, Value Type: `InteractionSettings`) | **No**    | If provided, adds additional per-GameMode settings to the interaction.                                                                                                                                                      |
+| Camera                    | `InteractionCameraSettings`                                          | **No**    | Arrays of camera motion keyframes for cutscenes and reveals.                                                                                                                                                                |
+
+**GameMode Values**
+
+- `Creative`: The game is currently in Creative Mode
+- `Adventure`: The game is currently in Adventure Mode
+
+**InteractionEffects Fields**
+
+| Field Name               | Type                                              | Required? | Notes                                                                                                                                                 |
+| ------------------------ | ------------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Particles                | `Array`<br />(Element Type: `ModelParticle`)      | **No**    | Particle systems to activate when this interaction begins if the player is in third-person mode.                                                      |
+| FirstPersonParticles     | `Array`<br />(Element Type: `ModelParticle`)      | **No**    | Particle systems to activate when this interaction begins if the player is in first-person mode.                                                      |
+| WorldSoundEventId        | `Asset`<br />(Asset Type: `SoundEvent`)           | **No**    | A sound to play in the world at the User entity's location when this interaction begins.<br />**The SoundEvent must be single-channel (mono) sound.** |
+| LocalSoundEventId        | `Asset`<br />(Asset Type: `SoundEvent`)           | **No**    | A 2D sound to play for the User entity when this interaction begins. Ignored if the User entity is not a player.                                      |
+| Trails                   | `Array`<br />(Element Type: `ModelTrail`)         | **No**    | Trail effects to activate on the User entity when this interaction begins.                                                                            |
+| WaitForAnimationToFinish | `Boolean`<br />(Default: false)                   | **No**    | If true, this interaction will continue executing for at least the length of any animations in this InteractionEffects object.                        |
+| ItemPlayerAnimationsId   | `Asset`<br />(Asset Type: `ItemPlayerAnimations`) | **No**    | If provided, the User entity will use this ItemPlayerAnimations set while this interaction is executing.                                              |
+| ItemAnimationId          | `String`                                          | **No**    | Id of an animation to trigger when this interaction begins executing.<br />**This animation id is not validated on server start.**                    |
+| ClearAnimationOnFinish   | `Boolean`<br />(Default: false)                   | **No**    | If true, animations triggered by this interaction will be halted when the interaction completes.                                                      |
+| ClearSoundEventOnFinish  | `Boolean`<br />(Default: false)                   | **No**    | If true, sounds triggered by this interaction will be halted when the interaction completes.                                                          |
+| CameraEffect             | `Asset`<br />(Asset Type: `CameraEffect` )        | **No**    | If provided, the CameraEffect will be applied while this interaction is executing.                                                                    |
+| MovementEffects          | `MovementEffects`                                 | **No**    | If provided, apply the movement effects to the User entity while this interaction is executing.                                                       |
+| StartDelay               | `Float`<br />(Default: 0.0f)                      | **No**    | The interaction will wait this many seconds before triggering the effects in this object.                                                             |
+
+**InteractionRules Fields**
+
+| Field Name          | Type                                                                                                | Required? | Notes                                                                                                                                                                                                                                     |
+| ------------------- | --------------------------------------------------------------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| BlockedBy           | `Array`<br />(Element Type: `InteractionType`)<br />(Default: Based on the chain's InteractionType) | **No**    | If provided, this RootInteraction cannot be executed while interaction chains of the provided types are executing.<br />**This field only functions for rules attached to a RootInteraction. It has no effect on an Interaction.**        |
+| Blocking            | `Array`<br />(Element Type: `InteractionType`)                                                      | **No**    | If provided, interaction chains with the specified InteractionTypes cannot be executed while this interaction is executing.                                                                                                               |
+| InterruptedBy       | `Array`<br />(Element Type: `InteractionType`)                                                      | **No**    | If provided, interaction chains with the specified InteractionTypes will cancel this interaction chain when they execute.<br />**This field only functions for rules attached to a RootInteraction. It has no effect on an Interaction.** |
+| Interrupting        | `Array`<br />(Element Type: `InteractionType`)                                                      | **No**    | If provided, interaction chains with the specified InteractionTypes will be canceled when this interaction begins.                                                                                                                        |
+| BlockedByBypass     | `String`                                                                                            | **No**    | If provided, this RootInteraction cannot be blocked by interaction chains whose RootInteraction has this value as an asset tag.                                                                                                           |
+| BlockingBypass      | `String`                                                                                            | **No**    | If provided, this interaction will not block RootInteractions that have the this value as an asset tag.                                                                                                                                   |
+| InterruptedByBypass | `String`                                                                                            | **No**    | If provided, this RootInteraction cannot be canceled by RootInteractions that have this value as an asset tag.                                                                                                                            |
+| InterruptingBypass  | `String`                                                                                            | **No**    | If provided, this interaction will not cancel interaction chains whose RootInteraction has this value as an asset tag.                                                                                                                    |
+
+**InteractionType Values**
+
+- `Primary`
+- `Secondary`
+- `Ability1`
+- `Ability2`
+- `Ability3`
+- `Use`
+- `Pick`
+- `Pickup`
+- `CollisionEnter`
+- `CollisionLeave`
+- `Collision`
+- `EntityStatEffect`
+- `SwapTo`
+- `SwapFrom`
+- `Death`
+- `Wielding`
+- `ProjectileSpawn`
+- `ProjectileHit`
+- `ProjectileMiss`
+- `ProjectileBounce`
+- `Held`
+- `HeldOffhand`
+- `Equipped`
+- `Dodge`
+- `GameModeSwap`
+
+**InteractionSettings Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                        |
+| ---------------- | ------------------------------- | --------- | -------------------------------------------------------------------------------------------- |
+| AllowSkipOnClick | `Boolean`<br />(Default: false) | **No**    | If true, the user will be able to skip this interaction by clicking shortly after it starts. |
+
+**InteractionCameraSettings Fields**
+
+| Field Name  | Type                                             | Required? | Notes                                                                                                                                                           |
+| ----------- | ------------------------------------------------ | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| FirstPerson | `Array`<br />(Element Type: `InteractionCamera`) | **No**    | A list of camera keyframes to be played if the player is in first-person.<br />**The time of each keyframe must be after the keyframe before it in the array.** |
+| ThirdPerson | `Array`<br />(Element Type: `InteractionCamera`) | **No**    | A list of camera keyframes to be played if the player is in third-person.<br />**The time of each keyframe must be after the keyframe before it in the array.** |
+
+**InteractionCamera Fields**
+
+| Field Name | Type                         | Required? | Notes                                                                                                                                       |
+| ---------- | ---------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------- |
+| Time       | `Float`<br />(Default: 0.1f) | **No**    | How long after the interaction begins executing that the camera should arrive at this keyframe.<br />**Cannot be less than or equal to 0.** |
+| Position   | `Vector3`                    | **Yes**   | Where the camera should be located when it arrives at this keyframe.                                                                        |
+| Rotation   | `Direction`                  | **Yes**   | Where the camera should be pointing when it arrives at this keyframe.                                                                       |
+
+### SimpleInteraction
+
+Most interaction types below are inherited from SimpleInteraction and have these
+fields.  If a type does not have these fields, the documentation will mention it.
+
+The purpose of SimpleInteraction is to facilitate Interaction chaining by taking different paths
+based on whether the Interaction succeeded or failed.  The circumstances under which
+a given Interaction fails are generally type-specific (and described in the documentation
+below), but all interactions will be marked failed if they are cancelled via one of the
+many, many mechanisms for doing so.
+
+It is valid to create an interaction asset of type "Simple", which can be valuable when you want to use the
+interaction fields with no additional functionality.
+
+**SimpleInteraction Fields**
+
+| Field Name | Type                                     | Required? | Notes                                                                                          |
+| ---------- | ---------------------------------------- | --------- | ---------------------------------------------------------------------------------------------- |
+| Next       | `Asset`<br />(Asset Type: `Interaction`) | **No**    | After this Interaction has finished, "Next" will be executed if this Interaction did not fail. |
+| Failed     | `Asset`<br />(Asset Type: `Interaction`) | **No**    | After this Interaction has finished, "Failed" will be executed if this Interaction failed.     |
+
+## Flow Control
+
+These are interaction types used to control the flow of an interaction chain and allow interactions
+to be composed into more complex behaviors.  These interaction types generally do not pertain to
+the game and instead pertain to the interaction system itself.
+
+### Condition
+
+This interaction will fail if one of the fields is provided but does not match the current state.
+
+**Condition Fields**
+
+| Field Name       | Type       | Required? | Notes                                                                                                                                                                                    |
+| ---------------- | ---------- | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| RequiredGameMode | `GameMode` | **No**    | If provided, the interaction will fail if the current GameMode does not match the provided value.                                                                                        |
+| Jumping          | `Boolean`  | **No**    | If provided, the interaction will fail if the player's Jumping state does not match the provided value. (i.e. if True, the player must be jumping, if False, the player must not be)     |
+| Swimming         | `Boolean`  | **No**    | If provided, the interaction will fail if the player's Swimming state does not match the provided value. (i.e. if True, the player must be swimming, if False, the player must not be)   |
+| Crouching        | `Boolean`  | **No**    | If provided, the interaction will fail if the player's Crouching state does not match the provided value. (i.e. if True, the player must be crouching, if False, the player must not be) |
+| Running          | `Boolean`  | **No**    | If provided, the interaction will fail if the player's Running state does not match the provided value. (i.e. if True, the player must be running, if False, the player must not be)     |
+| Flying           | `Boolean`  | **No**    | If provided, the interaction will fail if the player's Flying state does not match the provided value. (i.e. if True, the player must be flying, if False, the player must not be)       |
+
+**GameMode Values**
+
+- `Creative`: The game is currently in Creative Mode
+- `Adventure`: The game is currently in Adventure Mode
+
+### FirstClick
+
+This interaction does not inherit from SimpleInteraction and therefore has no Next or Failed fields.
+
+This interaction has two fields that each contain a reference to an Interaction: Click and Hold.  If the root interaction
+of the chain was initiated by a client button/key press (or simulated NPC input) and the input was a tap, then
+the Click interaction is run. if it was a longer press, then the Hold interaction is run.
+
+As a minor implementation detail, this interaction is internally marked as failed when the Hold path is followed.
+This generally shouldn't matter.  If the interaction was not initiated by a key press at all, the Click path will be followed,
+but it seems risky to rely on that behavior.
+
+**FirstClick Fields**
+
+| Field Name | Type                                     | Required? | Notes                                                                                                                                                    |
+| ---------- | ---------------------------------------- | --------- | -------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Click      | `Asset`<br />(Asset Type: `Interaction`) | **No**    | If provided and the root interaction of the chain was initiated by button/key press, this interaction is executed next if the press was a quick tap.     |
+| Hold       | `Asset`<br />(Asset Type: `Interaction`) | **No**    | If provided and the root interaction of the chain was initiated by a button/key press, this interaction is executed next if the press was a longer hold. |
+
+### Interrupt
+
+This interaction can be used to cancel one or more running interaction chains on an entity and **all forked interaction
+chains those chains have spawned that are still currently running**.  All interaction chains canceled in this manner will be marked as
+Failed, which may have additional implications if the canceled chains are themselves forked from
+other chains that are still running.
+
+**Interrupt Fields**
+
+| Field Name     | Type                                           | Required? | Notes                                                                                                                                                                                               |
+| -------------- | ---------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Entity         | `InteractionTarget`<br />(Default: User)       | **Yes**   | The entity that is the owner of the target interaction chains.  This field can indicate the Owner, User, or Target of this interaction chain.                                                       |
+| InterruptTypes | `Array`<br />(Element Type: `InteractionType`) | **No**    | A set of InteractionTypes that are to be interrupted. Only interactions of these types are affected. If null, all types will be interrupted.<br />**(Note: An empty set will interrupt NO TYPES.)** |
+| RequiredTag    | `String`                                       | **No**    | An asset tag that, if provided, the RootInteraction of the interaction chain must have in order to be canceled.                                                                                     |
+| ExcludedTag    | `String`                                       | **No**    | An asset tag that, if provided, the RootInteraction of the interaction chain must not have in order to be canceled.                                                                                 |
+
+**InteractionTarget Values**
+
+- `User` - The user of this interaction chain. The entity whose actions caused this interaction chain to be executed. This is usually the same as the Owner.
+- `Owner` - The owner of this interaction chain. The entity upon whom this interaction chain is executing.
+- `Target` - The entity target of this interaction chain, if any.  This value is mutable (and can therefore come from many places) but most commonly, it is an entity the User was targeting when this interaction chain began executing.
+
+**InteractionType Values**
+
+- `Primary`
+- `Secondary`
+- `Ability1`
+- `Ability2`
+- `Ability3`
+- `Use`
+- `Pick`
+- `Pickup`
+- `CollisionEnter`
+- `CollisionLeave`
+- `Collision`
+- `EntityStatEffect`
+- `SwapTo`
+- `SwapFrom`
+- `Death`
+- `Wielding`
+- `ProjectileSpawn`
+- `ProjectileHit`
+- `ProjectileMiss`
+- `ProjectileBounce`
+- `Held`
+- `HeldOffhand`
+- `Equipped`
+- `Dodge`
+- `GameModeSwap`
+
+### Parallel
+
+This interaction does not inherit from SimpleInteraction and therefore has no Next or Failed fields.
+
+This interaction has a field `Interactions` that is an array of RootInteraction assets. The list must contain at least
+two RootInteractions.  This interaction will fork all of its children except for the first into their
+own interaction chains and immediately complete. After this interaction completes, this interaction chain will
+execute the first RootInteraction in the `Interactions` list.
+
+This interaction does not have any failure conditions and is indifferent to the fate of the forked interaction chains.
+
+**Parallel Fields**
+
+| Field Name   | Type                                                | Required? | Notes                                                         |
+| ------------ | --------------------------------------------------- | --------- | ------------------------------------------------------------- |
+| Interactions | `AssetArray`<br />(Element Type: `RootInteraction`) | **Yes**   | An array of RootInteractions that will be forked or executed. |
+
+### Repeat
+
+This interaction has a field `ForkInteractions` that is an asset of type RootInteraction. This interaction will fork that
+RootInteraction into its own interaction chain and then wait for it to complete. If the RootInteraction fails, this
+interaction will complete immediately and be marked failed. Otherwise, the RootInteraction will be forked and run again,
+up to a specified total number of times.
+
+**Repeat Fields**
+
+| Field Name       | Type                                                                                   | Required? | Notes                                                                                                                                                                                                              |
+| ---------------- | -------------------------------------------------------------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| ForkInteractions | `Asset`<br />(Asset Type: `RootInteraction`)                                           | **Yes**   | A RootInteraction that will be forked.                                                                                                                                                                             |
+| Repeat           | `Integer`<br />(Default: 1)<br />**Must be -1 or a positive integer. 0 is not valid.** | **No**    | The total number of times to fork ForkInteractions. If -1 is provided, ForkInteractions will continue being forked and executed indefinitely, until this interaction is cancelled or until ForkInteractions fails. |
+
+### Replace
+
+This interaction does not inherit from SimpleInteraction and therefore has no Next or Failed fields.
+
+This interaction uses the InteractionVars system that is avaiable for items. InteractionVars are RootInteractions that
+can be attached to an Item asset with a name.
+
+This interaction specifies a var name, and if this interaction chain was executed through
+an item and that item has an InteractionVar of the same name, then this interaction will immediately execute
+the RootInteraction on the var.  Otherwise, it will execute the default RootInteraction specified in this interaction.
+If no default is specified, then this interaction will be marked as failed.
+
+**Replace Fields**
+
+| Field Name   | Type                                         | Required? | Notes                                                                                                                                                                                                           |
+| ------------ | -------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Var          | `String`                                     | **Yes**   | The name of the InteractionVar to execute.                                                                                                                                                                      |
+| DefaultValue | `Asset`<br />(Asset Type: `RootInteraction`) | **No**    | The RootInteraction to execute if the owning item does not have an InteractionVar by the specified name. If not provided, the interaction will be marked as failed instead.                                     |
+| DefaultOk    | `Boolean`<br />(Default: false)              | **No**    | If false, then an angry message will be printed to the server logs if the owning item does not have an InteractionVar by the specified name.  The functioning of this interaction will be otherwise unaffected. |
+
+### RunRootInteraction
+
+This interaction immediately executes the provided RootInteraction as part of this interaction chain. This interaction
+does not have any failure conditions.
+
+**RunRootInteraction Fields**
+
+| Field Name      | Type                                         | Required? | Notes                           |
+| --------------- | -------------------------------------------- | --------- | ------------------------------- |
+| RootInteraction | `Asset`<br />(Asset Type: `RootInteraction`) | **Yes**   | The RootInteraction to execute. |
+
+### Selector
+
+This interaction will execute a Selector to find entities and/or blocks (depending on the Selector) and fork off an
+interaction chain for each located entity or block. This interaction will not wait for those interaction chains
+to complete and is indifferent to their fate. The forked interaction chains will use the located entity/block as
+their target entity/target block. Each entity or block will only fork one interaction chain over the life of this
+interaction.  The Selector is guaranteed to run once for each execution of this interaction, but some Selectors
+are intended to be run over a period of time and sweep across an area to locate targets. In order to use those Selectors
+properly, you will need to extend the execution time of this interaction using `RunTime` or `WaitForAnimationToFinish`.
+The Selector will be executed repeatedly over the lifetime of the interaction.
+
+If the Selector is configured to locate entities, you can add additional sets of entity matching rules. If a located entity
+matches one of the rules, the matching RootInteraction will be forked instead of the standard `HitEntity` RootInteraction.
+
+Entities located by the Selector will be ignored if they do not have a NetworkId, if they are dead, or if they are invulnerable.
+The only exception to this rule is that players in Creative Mode that are marked to receive hits will not be ignored.
+
+This interaction's failure conditions are configurable via the `FailOn` field. You can configure this interaction to never
+fail, to fail if the Selector does not locate any blocks before this interaction finishes executing, to fail if the
+Selector does not locate any entities before this interaction finishes executing, or to fail in either case.
+
+**Selector Fields**
+
+| Field Name     | Type                                         | Required? | Notes                                                                                                                                                                                                                                     |
+| -------------- | -------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Selector       | `Selector`                                   | **Yes**   | The Selector is executed at least once and may be executed repeatedly to locate blocks and/or entities in an area.                                                                                                                        |
+| HitEntity      | `Asset`<br />(Asset Type: `RootInteraction`) | **No**    | If included and the `Selector` locates an entity that does not match any `HitEntityRules`, this RootInteraction will be forked into a new interaction chain with the located entity as the target entity.                                 |
+| HitEntityRules | `Array`<br />(Element Type: `HitEntity`)     | **No**    | If included, these rules will be matched against any entity located by the `Selector`. If an entity matches a set of rules, the RootInteraction associated with the rules will be forked instead of the standard `HitEntity` interaction. |
+| HitBlock       | `Asset`<br />(Asset Type: `RootInteraction`) | **No**    | If included and the `Selector` locates a block, this RootInteraction will be forked into a new interaction chain with the located block as the block target.                                                                              |
+| FailOn         | `FailOnType`<br />(Default: `Neither`)       | **No**    | Defines under what circumstances this interaction will fail.  It can be marked to fail when it completes without locating any blocks, it can be marked to fail when it completes without locating any entities, both, or neither.         |
+| IgnoreOwner    | `Boolean`<br />(Default: true)               | **No**    | If true, the Selector will not locate the User entity of this interaction.                                                                                                                                                                |
+
+**HitEntity Fields**
+
+| Field Name | Type                                         | Required? | Notes                                                                                                 |
+| ---------- | -------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------- |
+| Matchers   | `Array`<br />(Element Type: `EntityMatcher`) | **Yes**   | A set of rules that an entity must match. An entity must successful match all rules to be considered. |
+| Next       | `Asset`<br />(Asset Type: `RootInteraction`) | **Yes**   | The RootInteraction to fork if an entity matches all rules.                                           |
+
+**EntityMatcher Fields**
+
+| Field Name | Type                            | Required? | Notes                                                                                                     |
+| ---------- | ------------------------------- | --------- | --------------------------------------------------------------------------------------------------------- |
+| Type       | `String`                        | **Yes**   | If provided, specifies a type of EntityMatcher to use. Each matcher type may come with additional fields. |
+| Invert     | `Boolean`<br />(Default: false) | **No**    | If true, an entity must fail this rule for it to be marked as succeeded.                                  |
+
+**EntityMatcher Type: Player**
+
+This EntityMatcher will succesfully match the entity only if they are a player.
+
+**EntityMatcher Type: Vulnerable**
+
+This Entitymatcher will successfully match the entity only if they are not marked as invulnerable.
+
+**FailOnType Values**
+
+- `Neither`
+- `Entity`
+- `Block`
+- `Either`
+
+### Serial
+
+This interaction does not inherit from SimpleInteraction and therefore has no Next or Failed fields.
+
+This interaction has a field `Interactions` which is a list of Interaction assets. This interaction immediately
+completes and the interaction chain continues by executing the interactions in the list one at a time. This
+interaction does not have any failure conditions.
+
+**Serial Fields**
+
+| Field Name   | Type                                            | Required? | Notes                                      |
+| ------------ | ----------------------------------------------- | --------- | ------------------------------------------ |
+| Interactions | `AssetArray`<br />(Element Type: `Interaction`) | **Yes**   | An array of Interaction assets to execute. |
+
+## Cooldowns
+
+RootInteractions interface with a complex cooldown system that can be used for a variety of purposes. Aside from simply
+adding an important aspect of resource management to your game design, cooldowns can be used to ensure that click-activated
+interaction chains don't repeatedly spam if the player holds down the input.
+
+By default, every RootInteraction has a cooldown timer that is keyed to the RootInteraction name, and by default, it
+will launch a cooldown of 0.35 seconds when activated by client input.  Otherwise, no cooldown will be activated.  However,
+by configuring your RootInteraction, you can change the key for the cooldown (so that multiple RootInteractions can share
+a single cooldown), set the cooldown timer to whatever you like, and configure multiple charges that can build up over time
+to allow the entity to activate the RootInteraction multiple times before being forced to pause.
+
+One important concept to keep in mind is the difference between **cooldown** and **charge time**.  The cooldown, if any,
+is activated each time a RootInteraction triggers, even if the player has more available charges. If the RootInteraction
+is configured to use charges, then they will gradually build up over time. In order for a RootInteraction to be activated,
+the cooldown (if any) must be expired, and the RootInteraction must have at least one charge (if it has been
+configured to use charges).
+
+Bear in mind that the entire Cooldown configuration is shared between different RootInteractions with the same cooldown id.
+If you activate an ability with 5 charges and a short cooldown and then another ability with a much longer cooldown and no
+charges, the second ability will use the cooldown properties of the first ability until/unless the first ability finishes
+charging and is cleared from the system.  You should generally only have multiple RootInteractions share a cooldown id
+if they have the same configuration.
+
+The interactions below interact with the cooldown system to allow you to manipulate cooldowns via the interaction system. By
+using these interactions, you can have several interaction chains with different cooldown configurations share cooldowns
+that are checked and activated as part of the interaction chain itself, or have some components of an interaction change
+use a second cooldown separate from the main one.
+
+### CooldownCondition
+
+**CooldownCondition Fields**
+
+This interaction will fail if the specified cooldown id is on cooldown for the User entity.  This interaction will only
+function for players- the interaction will always succeed for NPCs.  In order for this interaction to succeed, the
+cooldown, if any, must have expired and at least one charge, if any, must have filled.
+
+| Field Name | Type     | Required? | Notes                     |
+| ---------- | -------- | --------- | ------------------------- |
+| Id         | `String` | **Yes**   | The cooldown id to check. |
+
+### IncrementCooldown
+
+**IncrementCooldown Fields**
+
+This interaction will modify a cooldown that is currently active on the User entity, allowing charges and remaining
+cooldown to be modified.
+Despite its name, this interaction can be used to reduce a cooldown as well as increase it. If the cooldown is not
+currently active, this interaction will have no effect. The interaction has no special failure conditions.
+
+| Field Name        | Type                        | Required? | Notes                                                                                                                                                                                                                                                                                     |
+| ----------------- | --------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Id                | `String`                    | **No**    | If provided, the cooldown id of the cooldown to be manipulated. If not provided, the cooldown id of the current chain's RootInteraction will be used.                                                                                                                                     |
+| Time              | `Float`<br />(Default: 0.0) | **No**    | The amount to increase the remaining cooldown by. Can be negative. The remaining cooldown time will not be reduced below zero or increased above the maximum cooldown time.                                                                                                               |
+| ChargeTime        | `Float`<br />(Default: 0.0) | **No**    | The amount to increase the remaining time until the next charge is filled by. Can be negative. The remaining charge time cannot be reduced below zero or increased above the maximum cooldown time. **This will not work on abilities that have a maximum of 1 charge, for some reason.** |
+| Charge            | `Integer`<br />(Default: 0) | **No**    | The amount to increase the number of charges by. Can be negative. The number of charges cannot be reduced below 0 or increased above the maximum.                                                                                                                                         |
+| InterruptRecharge | `Boolean`(Default: false)   | **No**    | If true and `Charge` is not 0, will reset the remaining time to the next charge to the maximum value after changing the charge count.                                                                                                                                                     |
+
+### ResetCooldown
+
+This interaction will trigger a cooldown on the User entity with a specified configuration. The charges will be refilled
+but the cooldown will be immediately triggered.  The mechanisms for deciding on the configuration are a little bit complicated.
+You may specify a cooldown configuration via the `Cooldown` field. If you do not include an `Id` field, then the
+interaction chain's RootInteraction will be used for any field not specified in the configuration. If there is an active
+cooldown under the specified `Id` (or under the RootInteraction's cooldown id if none is specified) then the fields
+from that active cooldown will overwrite data in the RootInteraction's cooldown, but not data in your `Cooldown` field.
+
+**ResetCooldown Fields**
+
+| Field Name | Type                  | Required? | Notes                                                        |
+| ---------- | --------------------- | --------- | ------------------------------------------------------------ |
+| Cooldown   | `InteractionCooldown` | **No**    | A cooldown configuration to use for the new, reset cooldown. |
+
+**InteractionCooldown Fields**
+
+| Field Name        | Type                                 | Required? | Notes                                                                                                                                                                                                 |
+| ----------------- | ------------------------------------ | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Id                | `String`                             | **No**    | The cooldown id to use for this cooldown. If not provided, the RootInteraction's cooldown id will be used, if any.                                                                                    |
+| Cooldown          | `Float`<br />(Default: 0.0)          | **No**    | The duration of the cooldown, in seconds.                                                                                                                                                             |
+| Charges           | `Array`<br />(Element Type: `Float`) | **No**    | If provided, a list of how many charges this cooldown can build, and how long each charge takes to build, in seconds.                                                                                 |
+| InterruptRecharge | `Boolean`<br />(Default: false)      | **No**    | If true, the charge time will be reset when the number of charges changes.                                                                                                                            |
+| ClickBypass       | `Boolean`<br />(Default: false)      | **No**    | If true, RootInteractions keyed to this cooldown can still be activated when it is on cooldown provided that the RootInteraction was triggered by a distinct key or mouse button press on the client. |
+
+### TriggerCooldown
+
+This interaction is similar to ResetCooldown, except instead of refilling the cooldown's charges, one charge will be deducted
+as normal.
+
+**TriggerCooldown Fields**
+
+| Field Name | Type                  | Required? | Notes                                                        |
+| ---------- | --------------------- | --------- | ------------------------------------------------------------ |
+| Cooldown   | `InteractionCooldown` | **No**    | A cooldown configuration to use for the new, reset cooldown. |
+
+**InteractionCooldown Fields**
+
+| Field Name        | Type                                 | Required? | Notes                                                                                                                                                                                                 |
+| ----------------- | ------------------------------------ | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Id                | `String`                             | **No**    | The cooldown id to use for this cooldown. If not provided, the RootInteraction's cooldown id will be used, if any.                                                                                    |
+| Cooldown          | `Float`<br />(Default: 0.0)          | **No**    | The duration of the cooldown, in seconds.                                                                                                                                                             |
+| Charges           | `Array`<br />(Element Type: `Float`) | **No**    | If provided, a list of how many charges this cooldown can build, and how long each charge takes to build, in seconds.                                                                                 |
+| InterruptRecharge | `Boolean`<br />(Default: false)      | **No**    | If true, the charge time will be reset when the number of charges changes.                                                                                                                            |
+| ClickBypass       | `Boolean`<br />(Default: false)      | **No**    | If true, RootInteractions keyed to this cooldown can still be activated when it is on cooldown provided that the RootInteraction was triggered by a distinct key or mouse button press on the client. |
+
+## Combo Chains
+
+Hytale additionally comes with a rich "combo chaining" system, which allows several inputs in a row to result in different
+attacks and special moves.  Rather than being attached to the RootInteraction like the cooldown system, these are
+primarily driven by the `Chaining` interaction.
+
+### Chaining
+
+This interaction does not inherit from SimpleInteraction and therefore has no Failed field. Its Next field works differently
+from most interaction types.
+
+Chaining is a type of flow control interaction- each time a Chaining interaction with the same `ChainId` is called, a single
+interaction in the `Next` list is chosen and the others are ignored. The first time the `ChainId` is used, the first
+interaction in the list is chosen, the next time the second, etc. Once the end of the list is reached, the first
+interaction will be chosen again.
+
+Bear in mind: the progress through the Next list is based on the **ChainId**, not the interaction!  That means that two
+different Chaining interactions can share a single combo chain. You could have a pair of daggers that attacks with
+the left when the left mouse button is clicked and with the right when the right mouse button is clicked.  You could give
+both interaction chains a Chaining interaction with the same `ChainId` and three `Next` entries that do a light-light-heavy
+combo.  Each specific hit would occur with either the left or the right knife based on which button you clicked, but
+the combo would be otherwise identical regardless of which you chose.
+
+The Chaining interaction also has a concept called "flags".  It is possible to attach named flags to a `ChainId` by using
+the ChainFlag interaction.  Then, you specify the flag name in Chaining's `Flags` field. If a Flag is active when the
+Chaining interaction is run, the Flag's interaction will be run instead of the appropriate interaction in `Next`.
+Bear in mind: the entity's progress through the `Next` list still advances, the resulting `Next` interaction is just not
+run.  Only one flag can be active at a time.
+
+Lastly, it is possible to cancel the entity's progress through the combo chain and reset them to the first interaction in
+the list. This can be done with the CancelChain interaction, but it will also happen automatically if the player does
+not trigger an interaction with the ChainId for the specified ChainingAllowance.  When either of these happen, all flags will be
+canceled as well.
+
+All of these effects are triggered on the User entity only. Non-players can use the chaining system, but Flags do not currently
+work for non-players.  This interaction has no special failure conditions.
+
+**Chaining Fields**
+
+| Field Name        | Type                                                       | Required? | Notes                                                                                                                                                                                                                       |
+| ----------------- | ---------------------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| ChainId           | `String`                                                   | **No**    | If provided, acts as a key that multiple Chaining interactions can use to share combo chain progress and flags. If not provided, a unique ChainId will be generated for this interaction.                                   |
+| ChainingAllowance | `Double`<br />(Default: 0.0)                               | **No**    | If, at the time this interaction is triggered, it has been this long in seconds since the last time a Chaining interaction with the same ChainId was executed, all state for this ChainId will be cleared before execution. |
+| Next              | `AssetArray`<br />(Element Type: `Interaction`)            | **Yes**   | A list of interactions to cycle between each time this interaction is run.                                                                                                                                                  |
+| Flags             | `Map`<br />(Key Type: `String`, Value Type: `Interaction`) | **No**    | A map of flag names to interactions to run if the flag is active when this interaction executes.                                                                                                                            |
+
+### CancelChain
+
+This interaction resets all progress and flag data on the User entity for the provided `ChainId`.  The next time a Chaining
+interaction is called for the provided `ChainId`, it will begin at the first interaction in the `Next` list. This
+interaction has no special failure conditions.
+
+**CancelChain Fields**
+
+| Field Name | Type     | Required? | Notes                                 |
+| ---------- | -------- | --------- | ------------------------------------- |
+| ChainId    | `String` | **Yes**   | A ChainId whose data should be reset. |
+
+### ChainFlag
+
+This interaction activates a flag on the User entity for the provided `ChainId`, which can be used to change behavior the
+next time a Chaining interaction with this `ChainId` is run. This will overwrite any flag that has
+already been raised. This interaction will have no effect for non-players. This interaction has no special failure
+conditions.
+
+| Field Name | Type     | Required? | Notes                                        |
+| ---------- | -------- | --------- | -------------------------------------------- |
+| ChainId    | `String` | **Yes**   | A ChainId on whom the flag should be raised. |
+| Flag       | `String` | **Yes**   | The name of the flag to raise.               |
+
+## Charging
+
+A unique flow-control interaction that is frequently used is the Charging interaction.  It is a flow-control interaction
+that delays while the input button used to trigger the interaction chain is held.  When it is released (or the interaction
+is forced to end), the interaction chain can continue with a different interaction based on how long the input was held
+for.
+
+These interactions are all related by either being the Charging interaction, or other interaction types that inherit the
+Charging interaction's behavior.
+
+### Charging
+
+This interaction does not inherit from SimpleInteraction and therefore its Next field works different from most interactions.
+This interaction adds its own Failed field which works the same way that SimpleInteraction's does.
+
+This interaction only works properly when its interaction chain was triggered by a client key or button press (or
+NPC-simulated equivalent). This interaction will continue executing for as long as the key or button press is held (with
+some exceptions, covered below) by the User entity.  Like other interactions, it has a `Next` field indicating which interaction to execute
+after this one, but the field is a map from `Float` values to `Interaction` assets. When this interaction ends, either
+due to the input being released or the charge duration completing, this interaction will determine the largest `Float` key that is less
+than the amount of time in seconds that the interaction was executing for.  The Interaction mapped to that key will be
+executed next.
+
+The interaction includes some cancellation conditions that are specific to this interaction. For instance, the interaction
+has a `CancelOnOtherClick` field that matches the field on RootInteraction. If it is active on this interaction but not
+the RootInteraction, then clicking while charging will cancel this interaction (and execute the `Failed` interaction rather
+than any of the `Next` interactions) but otherwise continue the interaction chain.
+
+Another valuable feature Charging has is the `Forks` field.  For input-triggered interactions that are triggered while the
+Charging interaction is executing, you can add an entry for the relevant InteractionType to this field and instead of
+triggering the usual interaction chain based on held item, targeted block, etc. the RootInteraction specified in the
+`Forks` field will be triggered.  This can unlock rich attack modes and behaviors. For instance, having a shield bash attack
+triggered off left click while blocking, or a special attack that triggers when both mouse buttons are pressed at the
+same time.
+
+There are two modes of operation for the Charging interaction. One is to have the ability charge for as long
+as the input is held and only end execution when the entity releases the input.  Bows in the main Hytale game work
+that way.  That is accomplished by setting `AllowIndefiniteHold` to true.  Another mode of operation is to have the
+interaction complete execution when the execution time has surpassed the largest key value in the `Next` field and
+immediately begin executing the Interaction mapped to that key.  Food in the main Hytale game work like this.  It
+is accomplished by setting `AllowIndefiniteHold` to false.
+
+One pitfall to be careful of when setting `AllowIndefiniteHold` to false is the way it interacts with cooldowns.\
+Normally, input-initiated interaction chains start a 0.35s cooldown on the triggered RootInteraction that prevents
+holding the mouse button from immediately spamming a new interaction when the first one completes.  However, if the
+duration of a Charging interaction is longer than 0.35s, then the cooldown will have already completed when the
+interaction chain finishes, which will often result in a new execution beginning immediately before the player can
+stop pressing the mouse button.  One solution for this problem is to add a `Simple` interaction to the end of your
+interaction chain with a `RunTime` of 0.35s to simulate the cooldown.  Alternatively, you can add a longer cooldown
+(the maximum duration of your Charging interaction plus 0.35s) to the RootInteraction. However, the longer cooldown is
+not always desirable, as the interaction may have ended prematurely, resulting in an unusually long lockout between
+executions.
+
+**Charging Fields**
+
+| Field Name                         | Type                                                                    | Required? | Notes                                                                                                                                                                                                                                                                                                                                                                                       |
+| ---------------------------------- | ----------------------------------------------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| FailOnDamage                       | `Boolean`<br />(Default: false)                                         | **No**    | If true, this interaction will fail and end immediately if the User entity takes any damage while it is executing.                                                                                                                                                                                                                                                                          |
+| CancelOnOtherClick                 | `Boolean`<br />(Default: true)                                          | **No**    | If true, this interaction will fail and end immediately if the User entity sends another button or key press while it is executing.                                                                                                                                                                                                                                                         |
+| Forks                              | `Map`<br />(Key Type: `InteractionType`, Value Type: `RootInteraction`) | **No**    | A map of InteractionType to RootInteraction. If entity input triggers the InteractionType while this interaction is executing, the mapped RootInteraction will be forked into its own interaction chain. This will happen instead of the usual handling for that InteractionType.  This fork will occur even if `CancelOnOtherClick` is set to true.                                        |
+| Failed                             | `Asset`<br />(Asset Type: `Interaction`)                                | **No**    | After this Interaction has finished, "Failed" will be executed if this Interaction failed.                                                                                                                                                                                                                                                                                                  |
+| AllowIndefiniteHold                | `Boolean`<br />(Default: false)                                         | **No**    | If true, this interaction will continue executing for as long as the User entity continues to hold the input. If false, execution will end as soon as the execution time in seconds reaches the largest key value in the `Next` map.                                                                                                                                                        |
+| DisplayProgress                    | `Boolean`<br />(Default: true)                                          | **No**    | If true, players executing this interaction will see a progress bar will be displayed below their cursor indicating how close to reaching the highest key value in `Next` they are.                                                                                                                                                                                                         |
+| Next                               | `Map`<br />(Key Type: `Float`, Value Type: `Interaction`)               | **No**    | A map from `Float` to `Interaction`.  When this interaction successfully finishes executing (either because the input was released or because the maximum duration was reached), this interaction will find the `Float` value with the largest duration in seconds that is less than the amount of time this interaction executed for. That key's mapped Interaction will then be executed. |
+| MouseSensitivityAdjustmentTarget   | `Float`<br />(Default: 1.0)                                             | **No**    | While charging, this mouse sensitivity multiplier will gradually be applied.                                                                                                                                                                                                                                                                                                                |
+| MouseSensitivityAdjustmentDuration | `Float`<br />(Default: 1.0)                                             | **No**    | Duration in seconds. After this many seconds, `MouseSensitivityAdjustmentTarget` will be fully applied to the mouse sensitivity.                                                                                                                                                                                                                                                            |
+| Delay                              | `ChargingDelay`                                                         | **No**    | Settings that allow charging progress to be pushed back when the User entity takes damage.                                                                                                                                                                                                                                                                                                  |
+
+**ChargingDelay Fields**
+
+| Field Name    | Type                        | Required? | Notes                                                                                                                                                                                                                                                                     |
+| ------------- | --------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| MinHealth     | `Float`<br />(Default: 0.0) | **No**    | Damage taken as a percentage of entity health (0.0-1.0). If a hit deals less than this much damage, no pushback will be applied.  If a hit deals exactly this much damage, `MinDelay` seconds worth of pushback will be applied.                                          |
+| MaxHealth     | `Float`<br />(Default: 0.0) | **No**    | Damage taken as a percentage of entity health (0.0-1.0). If a hit deals at least this much damage, `MaxDelay` seconds worth of pushback will be applied.                                                                                                                  |
+| MinDelay      | `Float`<br />(Default: 0)   | **No**    | The amount of pushback, in seconds, to apply if the entity takes a hit that deals `MinHealth` damage. The amount of pushback applied by a hit is a gradiant between `MinDelay` and `MaxDelay` based on the amount of damage between `MinHealth` and `MaxHealth`.          |
+| MaxDelay      | `Float`<br />(Default: 0)   | **No**    | The amount of pushback, in seconds, to apply if the entity takes a hit that deals at least `MaxHealth` damage. The amount of pushback applied by a hit is a gradiant between `MinDelay` and `MaxDelay` based on the amount of damage between `MinHealth` and `MaxHealth`. |
+| MaxTotalDelay | `Float`<br />(Deault: 0)    | **No**    | The maximum amount of pushback the entity can receive over the course of a single charge, regardless of how many times they are hit.                                                                                                                                      |
+
+**InteractionType Values**
+
+- `Primary`
+- `Secondary`
+- `Ability1`
+- `Ability2`
+- `Ability3`
+- `Use`
+- `Pick`
+- `Pickup`
+- `CollisionEnter`
+- `CollisionLeave`
+- `Collision`
+- `EntityStatEffect`
+- `SwapTo`
+- `SwapFrom`
+- `Death`
+- `Wielding`
+- `ProjectileSpawn`
+- `ProjectileHit`
+- `ProjectileMiss`
+- `ProjectileBounce`
+- `Held`
+- `HeldOffhand`
+- `Equipped`
+- `Dodge`
+- `GameModeSwap`
+
+### Wielding
+
+This interaction is inherited from Charging rather than SimpleInteraction.  However, its `Failed` and `Next` fields function
+identically to SimpleInteraction.  It does not inherit all fields from Charging, so be sure to pay close attention to
+the field list below.
+
+This interaction drives most blocking behavior in the game. While this interaction is executing, attacks made against
+the Owner entity will (conditionally) trigger effects defined in this interaction.  Unlike the Charging interaction,
+this interaction can always execute indefinitely and will only end when it fails or when the input is released.
+
+One option available in Wielding is `AngledWielding`, which allows damage and knockback modifiers to only be applied
+depending on the direction the attack against the Owner entity is coming from.  The AngledWielding type has a
+field `Angle` which determines which direction the protection points relative to the player (0 is the player's
+front), and `AngleDistance` which determines how wide the cone of protection extends around the player.  Block effects
+from this interaction (such as `BlockedEffects`, `BlockedInteractions`, and `StaminaCost`) will only apply if
+the DamageCause matches `DamageModifiers` OR if the DamageCause matches `AngledWielding.DamageModifiers` and
+the source of the damage matches `Angle` and `AngleDistance`.  It is possible for damage and knockback multipliers
+specified on both this interaction's modifier fields and `AngledWielding`'s modifier fields to stack, if both
+have entries for the same DamageCause.
+
+This interaction will only have an effect on damage taken by one of the DamageCause entries in `DamageModifiers` or
+`AngledWielding.DamageModifiers`.  If a DamageCause is in `DamageModifiers`, then the block effect will be triggered
+and the damage modifier applied regardless of what direction the Owner entity is attacked from.  If a DamageCause is in
+`AngledWielding.DamageModifiers`, then the damage modifier is only applied if the
+
+\*\* Wielding Fields\*\*
+
+| Field Name          | Type                                                                    | Required? | Notes                                                                                                                                                                                                                                                                                                                                                                                                      |
+| ------------------- | ----------------------------------------------------------------------- | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| FailOnDamage        | `Boolean`<br />(Default: false)                                         | **No**    | If true, this interaction will fail and end immediately if the User entity takes any damage while it is executing.                                                                                                                                                                                                                                                                                         |
+| CancelOnOtherClick  | `Boolean`<br />(Default: true)                                          | **No**    | If true, this interaction will fail and end immediately if the User entity sends another button or key press while it is executing.                                                                                                                                                                                                                                                                        |
+| Forks               | `Map`<br />(Key Type: `InteractionType`, Value Type: `RootInteraction`) | **No**    | A map of InteractionType to RootInteraction. If entity input triggers the InteractionType while this interaction is executing, the mapped RootInteraction will be forked into its own interaction chain. This will happen instead of the usual handling for that InteractionType.  This fork will occur even if `CancelOnOtherClick` is set to true (after which this interaction chain will be canceled). |
+| Next                | `Asset`<br />(Asset Type: `Interaction`)                                | **No**    | After this interaction has finished, "Next" will be executed if this interaction did not fail.                                                                                                                                                                                                                                                                                                             |
+| Failed              | `Asset`<br />(Asset Type: `Interaction`)                                | **No**    | After this interaction has finished, "Failed" will be executed if this interaction failed.                                                                                                                                                                                                                                                                                                                 |
+| DamageModifiers     | `Map`<br />(Key Type: `DamageCause`, Value Type: `Float`)               | **No**    | A map from DamageCause to Float, where the Float is multiplied against any damage received from the mapped DamageCause while this interaction is executing.                                                                                                                                                                                                                                                |
+| KnockbackModifiers  | `Map`<br />(Key Type: `DamageCause`, Value Type: `Float`)               | **No**    | A map from DamageCause to Float, where the Float is multiplied against any knockback force received from the mapped DamageCause while this interaction is executing.                                                                                                                                                                                                                                       |
+| AngledWielding      | `AngledWielding`                                                        | **No**    | Configuration to only trigger block effects from certain angles.                                                                                                                                                                                                                                                                                                                                           |
+| StaminaCost         | `StaminaCost`                                                           | **No**    | If the Owner entity receives damage that matches `DamageModifiers` or `AngledWielding` while this interaction is executing, then the entity's stamina will be deducted according to this configuration.                                                                                                                                                                                                    |
+| BlockedEffects      | `DamageEffects`                                                         | **No**    | If the Owner entity receives damage that matches `DamageModifiers` or `AngledWielding` while this interaction is executing, then these effects will be applied to the instance of damage.                                                                                                                                                                                                                  |
+| BlockedInteractions | `Asset`<br />(Asset Type: `RootInteraction`)                            | **No**    | If the Owner entity receives damage that matches `DamageModifiers` or `AngledWielding` while this interaction is executing, then this RootInteraction will be launched as a brand new interaction chain with the Owner entity as both Owner and User, and the attacker as the Target entity.  This new interaction chain is, notably, brand new, **not** forked from the current one.                      |
+
+**AngledWielding Fields**
+
+| Field Name         | Type                                                      | Required? | Notes                                                                                                                                                                                                            |
+| ------------------ | --------------------------------------------------------- | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Angle              | `Float`<br />(Default: 0.0)                               | **No**    | Angle in degrees relative to the Owner entity where the angled protection is centered. 0.0 means pointed towards the front of the Owner entity.                                                                  |
+| AngleDistance      | `Float`<br />(Default: 0.0)                               | **No**    | Angle in degrees indicating how wide the cone of protection is.                                                                                                                                                  |
+| DamageModifiers    | `Map`<br />(Key Type: `DamageCause`, Value Type: `Float`) | **No**    | A map from DamageCause to Float, where the Float is multiplied against any damage received from the mapped DamageCause received from within the cone of protection while this interaction is executing.          |
+| KnockbackModifiers | `Map`<br />(Key Type: `DamageCause`, Value Type: `Float`) | **No**    | A map from DamageCause to Float, where the Float is multiplied against any knockback force received from the mapped DamageCause received from within the cone of protection while this interaction is executing. |
+
+**StaminaCost Fields**
+
+| Field Name | Type                                             | Required? | Notes                                                                                                                                                                                                                                                |
+| ---------- | ------------------------------------------------ | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| CostType   | `CostType`<br />(Default: `MaxHealthPercentage`) | **No**    | How to calculate stamina consumed by blocking from the raw pre-block damage. If `Damage`, then the stamina consumed will be `rawDamage / Value`. If `MaxHealthPercentage`, then the stamina consumed will be `rawDamage / (EntityMaxHealth * Value)` |
+| Value      | `Float`<br />(Default: 0.04)                     | **No**    | The value to use in the `CostType` formula.                                                                                                                                                                                                          |
+
+**DamageEffects Fields**
+
+| Field Name             | Type                                         | Required? | Notes                                                                           |
+| ---------------------- | -------------------------------------------- | --------- | ------------------------------------------------------------------------------- |
+| ModelParticles         | `Array`<br />(Element Type: `ModelParticle`) | **No**    | Particle systems to trigger in the first-person view.                           |
+| WorldParticles         | `Array`<br />(Element Type: `WorldParticle`) | **No**    | Particle systems to trigger in the third-person view.                           |
+| LocalSoundEventId      | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | 2D sound to play locally to the attacking entity if they are a player.          |
+| WorldSoundEventId      | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | Sound to play in the world at the Owner entity's location.                      |
+| PlayerSoundEventId     | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | 2D sound to play locally to the Owner entity if they are a player.              |
+| ViewDistance           | `Double`<br />(Default: 75.0)                | **No**    | Distance at which these effects should play for other players.                  |
+| Knockback              | `Knockback`                                  | **No**    | The properties of the knockback that will be applied.                           |
+| CameraEffect           | `Asset`<br />(Asset Type: `CameraEffect`)    | **No**    | CameraEffect to briefly apply locally to the Owner entity if they are a player. |
+| StaminaDrainMultiplier | `Float`<br />(Default: 1.0)                  | **No**    | This multiplier is applied to the `StaminaCost`, if any.                        |
+
+**Knockback Fields**
+
+| Field Name     | Type                                       | Required? | Notes                                                                                                                      |
+| -------------- | ------------------------------------------ | --------- | -------------------------------------------------------------------------------------------------------------------------- |
+| Type           | `String`                                   | **No**    | If provided, specifies a type of knockback to use. Each knockback type may come with additional fields.                    |
+| Force          | `Double`<br />(Default: 0.0)               | **No**    | The amount of force to apply to the Owner entity.                                                                          |
+| Duration       | `Double`<br />(Default: 0.0)               | **No**    | If 0.0, apply the force as a single impulse.  If more, continuously apply the force over a period of time.                 |
+| VelocityType   | `ChangeVelocityType`<br />(Default: `Add`) | **No**    | How to apply the force, either adding it to the entity's current velocity, or setting the velocity to the knockback force. |
+| VelocityConfig | `VelocityConfig`                           | **No**    | Characteristics of friction as the Owner entity is thrown by this knockback.                                               |
+
+**Knockback Type: Force**
+
+Apply the calculated knockback force along the provided direction.
+
+| Field Name | Type                         | Required? | Notes                                                                                |
+| ---------- | ---------------------------- | --------- | ------------------------------------------------------------------------------------ |
+| Direction  | `Vector3`<br />(Default: Up) | **No**    | Which direction the player should be flung, relative to the direction of the attack. |
+
+**Knockback Type: Point**
+
+Apply the calculated knockback force laterally along the XZ plane, plus provided Y velocity.
+
+| Field Name | Type                        | Required? | Notes                                                                                                   |
+| ---------- | --------------------------- | --------- | ------------------------------------------------------------------------------------------------------- |
+| OffsetX    | `Integer`<br />(Default: 0) | **No**    | Offset the source position of the knockback left or right perpendicular to the direction of the attack. |
+| OffsetZ    | `Integer`<br />(Default: 0) | **No**    | Offset the source position of the knockback, forward or backward along the directon of the attack.      |
+| RotateY    | `Integer`<br />(Default: 0) | **No**    | Rotate the knockback direction around the Y axis, where 0 is the default attack direction.              |
+| VelocityY  | `Float`<br />(Default: 0.0) | **No**    | Add vertical velocity to the knockback force after the direction and force has been calculated.         |
+
+**Knockback Type: Directional**
+
+Apply the calculated knockback force along the attack direction, removing any vertical component and replacing it with a provided Y velocity.
+
+| Field Name | Type                      | Required? | Notes                                                                                                                                            |
+| ---------- | ------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------ |
+| RelativeX  | `Float`<br />(Default: 0) | **No**    | Apply additional force left or right perpendicular to the direction of the attack. The additional force is multiplied by the knockback strength. |
+| RelativeZ  | `Float`<br />(Default: 0) | **No**    | Apply additional force forward or backward along the attack direction. The additional force is multiplied by the knockback strength.             |
+| VelocityY  | `Float`<br />(Default: 0) | **No**    | Replace the vertical velocity of the knockback with this value.  This value is not multiplied by knockback strength.                             |
+
+**VelocityConfig Fields**
+
+| Field Name          | Type                                              | Required? | Notes                                                                                                                                                                                           |
+| ------------------- | ------------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| GroundResistance    | `Float`<br />(Default: 0.82)                      | **No**    | The minimum amount of friction applied when the entity is in contact with the ground.  1.0 = no friction, 0.0 = total friction                                                                  |
+| GroundResistanceMax | `Float`<br />(Default: 0.0)                       | **No**    | The maximum amount of friction applied when the entity is in contact with the ground.  1.0 = no friction, 0.0 = total friction                                                                  |
+| AirResistance       | `Float`<br />(Default: 0.96)                      | **No**    | The minimum amount of friction applied when the entity is in the air. 1.0 = no friction, 0.0 = total friction                                                                                   |
+| AirResistanceMax    | `Float`<br />(Default: 0.0)                       | **No**    | The maximum amount of friction applied when the entity is in the air. 1.0 = no friction, 0.0 = total friction                                                                                   |
+| Threshold           | `Float`<br />(Default: 1.0)                       | **No**    | The speed at which the maximum amount of friction will be applied to the entity. The amount of friction applied will increase from minimum to maximum as the entity moves from 0 to this speed. |
+| Style               | `VelocityThresholdStyle`<br />(Default: `Linear`) | **No**    | The curve that friction follows as the entity's speed increases toward the `Threshold`.                                                                                                         |
+
+**CostType Values**
+
+- `MaxHealthPercentage`
+- `Damage`
+
+**ChangeVelocityType Values**
+
+- `Add`
+- `Set`
+
+**VelocityThresholdStyle Values**
+
+- `Linear`
+- `Exp`
+
+## Blocks
+
+These are interaction types meant to reason about and modify blocks in the world.  The most important concept unique
+to these interactions is the Block Target.  Like the Entity Target, it is mutable and can come from many places.
+However, for interaction chains initiated by the client, the block target will initially be the block that the player's cursor was
+over, if any.
+
+Additionally, for interaction chains initiated by the client, the client will send along which face of the block is targeted,
+which is used by a few block-related interactions.
+It is left up to each interaction type that cares about block faces as to how to handle this behavior for simulated input
+(i.e. NPCs initiating chains that are normally initated by the client).  At the time of this writing, all block-related
+interactions choose the top face where relevant in simulated input.
+
+### BlockCondition
+
+This interaction has a field `Matchers` which specifies certain conditions, such as block type, state, etc.  This
+interaction fails if the current target block does not match all of them.
+
+**BlockCondition Fields**
+
+| Field Name       | Type                                        | Required? | Notes                                                                                                                                                                                                                                                                                                                                   |
+| ---------------- | ------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false)             | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction.                                                                                                                                                                                                       |
+| Matchers         | `Array`<br />(Element Type: `BlockMatcher`) | **Yes**   | A list of conditions that the target block must match or this condition will fail.<br />**Note: This field is technically not required but there is a bug that makes it dangerous to not provide at the time of this writing.**<br />**Note: If no conditions are added to this array, the interaction will fail, counterintuitively.** |
+
+**BlockMatcher Fields**
+
+| Field Name | Type                       | Required? | Notes                                                                          |
+| ---------- | -------------------------- | --------- | ------------------------------------------------------------------------------ |
+| Block      | `BlockIdMatcher`           | **No**    | If provided, requires the block itself match some set of conditions.           |
+| Face       | `BlockFace`                | **No**    | If provided and not 'None', requires a specific block face be targeted.        |
+| StaticFace | `Boolean` (Default: false) | **No**    | If false, the face condition will be adjusted by the block's current rotation. |
+
+**BlockFace Values**
+
+- `Up`
+- `Down`
+- `North`
+- `South`
+- `East`
+- `West`
+- `None`
+
+**BlockIdMatcher Fields**
+
+| Field Name | Type                                   | Required? | Notes                                                                      |
+| ---------- | -------------------------------------- | --------- | -------------------------------------------------------------------------- |
+| Id         | `Asset`<br />(Asset Type: `BlockType`) | **No**    | If provided, the block must match the specified `BlockType`.               |
+| State      | `String`                               | **No**    | If provided, the block's current state must match the provided state name. |
+| Tag        | `String`                               | **No**    | If provided, the block type's asset tags must contain the provided tag.    |
+
+### DestroyCondition
+
+This interaction fails if the current User entity cannot destroy the current target blcok.
+
+**DestroyCondition Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+
+### PlacementCountCondition
+
+This interaction accepts the name of a BlockType that has the TrackedPlacement BlockEntity. The interaction will fail if the number of
+blocks of the provided BlockType in the world do not match the provided condition.
+
+**PlacementCountCondition Fields**
+
+| Field Name | Type                           | Required? | Notes                                                                                                                                                                                                                                                           |
+| ---------- | ------------------------------ | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Block      | `String`                       | **Yes**   | The BlockType to examine. The number of instances of the BlockType in the world will be compared to Value.<br />**Note: The specified BlockType must have the TrackedPlacement BlockEntity. Otherwise, the number of blocks in the world will always be zero.** |
+| Value      | `Integer`<br />(Default: 0)    | **No**    | The value to compare the number of blocks in the world with.                                                                                                                                                                                                    |
+| LessThan   | \`Boolean<br />(Default: true) | **No**    | If true, the interaction will fail if the number of blocks in the world is greater than or equal to Value. If false, the interaction will fail if the number of blocks in the world is less than or equal to Value.                                             |
+
+### BreakBlock
+
+This interaction attempts to break the target block while acting as the User entity. The User entity must be a player. It
+is not guaranteed to work, depending on world settings and the User entity's current state, it may not work.  If it
+fails, it will fail the interaction under some circumstances, but not others.
+
+**Note: In particular, if `Harvest`=false and the player is in Survival mode, the player will simply execute a damage operation
+against the block. Even when the Tool field is specified, the player's currently-held item can impact the results in unintuitive
+ways.**
+
+This interaction will fail if there is no block target, if `Harvest`=true and the
+block is not harvestable, or if the world settings prevent the Harvest/Break operation.
+It will generally not fail otherwise, even if the block was not broken or damaged.
+The block will generally break every time if `Harvest`=true or the player is in
+Creative mode.
+
+**BreakBlock Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                                                                                                                                                                                                  |
+| ---------------- | ------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction.                                                                                                                                                                      |
+| Harvest          | `Boolean` (Default: false)      | **No**    | If true, harvest the block and deposit the drops in the player's inventory. This operation will generally always succeed.  If false, this interaction will effectively perform whatever action would have occurred if the player had left-clicked the block.                                           |
+| Tool             | `String`                        | **No**    | If `Harvest`=true, the player is in Survival mode, and this field is provided, then the break operation will be performed as though with this tool type.<br />**This field mostly doesn't work.  Your held item will be used for most block damage calculations regardless of this field's contents.** |
+| MatchTool        | `Boolean` (Default: false)      | **No**    | If true, `Harvest`=true, the player is in Survival mode, and `Tool` is provided, block breaking will be prevented unless `Tool` is a valid gathering tool for the target block. The interaction will not be failed, even if block breaking is prevented in this manner.                                |
+
+### ChangeBlock
+
+This interaction requires a mapping from one or more current BlockTypes to one or more target BlockTypes.  If the
+target block is one of the key BlockTypes, then it will be changed to the mapped target BlockType.  If the current
+BlockType of the target block does not appear as a key in the Changes field, then this interaction fails.
+
+**ChangeBlock Fields**
+
+| Field Name        | Type                                                        | Required? | Notes                                                                                                                             |
+| ----------------- | ----------------------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget  | `Boolean`<br />(Default: false)                             | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+| Changes           | `Map`<br />(Key Type: `BlockType`, Value Type: `BlockType`) | **No**    | A list of potential block type changes, with each entry having a current and new BlockType id.                                    |
+| WorldSoundEventId | `Asset`<br />(Asset Type: `SoundEvent`)                     | **No**    | If provided, this SoundEvent is played in the world at the position of the block if the block successfully changes.               |
+| RequireNotBroken  | `Boolean`<br />(Default: false)                             | **No**    | If true, this interaction will fail if the player's held item is broken (durability 0), and the block change will not take place. |
+
+### ChangeState
+
+This interaction requires a mapping from one or more current block state names to one or more state names. If the
+target block is in one of the key block states, then it will be changed to the mapped target blocks tate. If the
+current block state of the target block does nto appear as a key in the Changes field, then this interaction fails.
+
+All blocks start out with a null state by default.  This null state can be referenced by the key "default" and the block
+can be returned to that state with the value "default".
+
+**ChangeState Fields**
+
+| Field Name       | Type                                                  | Required? | Notes                                                                                                                                          |
+| ---------------- | ----------------------------------------------------- | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false)                       | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction.              |
+| Changes          | `Map`<br />(Key Type: `String`, Value Type: `String`) | **No**    | A list of potential block state changes, with each entry having a current and new state name.                                                  |
+| UpdateBlockState | `Boolean`<br />(Default: false)                       | **No**    | If true, performs a full refresh of the block's BlockEntity component and notifies nearby players as though a full block type change occurred. |
+
+### CycleBlockGroup
+
+This interaction will attempt to change the target block to the next block type in one of the BlockGroups it belongs to.
+If the block type belongs to multiple BlockGroups, which one is used is effectively arbitrary. The User entity must be
+a player. If the block cannot be changed for any reason (entity not a player, no block target, block does not belong
+to a BlockGroup, etc.). If the block is the only entry in the BlockGroup, this interaction will succeed and the block
+will be considered changed despite nothing happening.  Unlike most other block-changing interactions, this one will
+fail if the world settings prevent players from breaking blocks.
+
+**This interaction always reduces the player's held item's durability by a single 'hit' worth of damage if the block
+changes. There is no way to prevent it. The block type will change and the interaction will succeed even if the player's
+held item is broken, however.**
+
+**CycleBlockGroup Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+
+### DestroyBlock
+
+This interaction destroys the target block without dropping anything.  It will successfully destroy the block if the
+target block exists and this interaction has no failure conditions.
+
+**This interaction has no additional fields.**
+
+### PickBlock
+
+This interaction is effectively equivalent to using the middle mouse button in creative mode. In survival mode, the
+block's item will be moved to the user's current active hotbar slot if it is in the player's inventory.  This
+interaction is performed entirely on the client and cannot be performed by non-players.  It is unclear if this
+interaction has failure conditions.
+
+**PickBlock Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+
+### PlaceBlock
+
+This interaction is effectively identical to a right clicking while holding a block in their hand, with some
+additional options. For one, it can be executed with any LivingEntity as the User entity. For another, it has some
+useful fields.  For the most part, though, it follows the same behaviors and rules as any ordinary block placement
+by a player.
+
+It's not clear under what circumstances this interaction can fail. The server will not fail the interaction under any
+special circumstances (including when there is no target block, or when `BlockTypeToPlace` is not provided and the
+LivingEntity is not holding a block). However, the client is very involved with the function of this interaction and
+its behavior is unknown.
+
+**PlaceBlock Fields**
+
+| Field Name         | Type                                   | Required? | Notes                                                                                                                                                                                                                                                                                                                                                           |
+| ------------------ | -------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| BlockTypeToPlace   | `Asset`<br />(Asset Type: `BlockType`) | **No**    | If provided, the block placed by this interaction will be the specified BlockType. If not provided, the User entity's held item will be used, instead, if it is a block.                                                                                                                                                                                        |
+| RemoveItemInHand   | `Boolean`<br />(Default: True)         | **No**    | If true and the User entity is not a player in Creative mode, the item in the player's hand must match the block being placed and one quantity will be removed for each block placed. If the item does not match, the block cannot be placed.  If false, the player's hand item is ignored entirely.\*\*                                                        |
+| AllowDragPlacement | `Boolean`<br />(Default: True)         | **No**    | If true and the interaction was triggered on the client by a player, then the player can hold the input that was used to activate this interaction chain and move the mouse around in order to execute this interaction repeatedly and place several blocks. The interaction chain will not move onto the next interaction until the player releases the input. |
+
+### RunOnBlockTypes
+
+This interaction retrieves all blocks within a provided radius of the User entity. For each block that matches any of
+the provided BlockSets, a new interaction chain will be forked that uses the matching block as the target block.
+This interaction will continue executing until all forked interaction chains have completed.  The interaction will fail if no
+blocks within the radius match the provided BlockSets or if all of the forked interaction chains fail.
+
+**RunOnBlockTypes Fields**
+
+| Field Name   | Type                                         | Required?        | Notes                                                                                                                                                                                                                                                                                      |
+| ------------ | -------------------------------------------- | ---------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| Range        | `Integer`                                    | **Yes**          | The spherical radius around the User entity to search for blocks. Must be at least 1.                                                                                                                                                                                                      |
+| BlockSets    | `AssetArray`<br />(Element Type: `BlockSet`) | **No**           | A list of BlockSets to match nearby blocks again. Only blocks that match any of the BlockSets will have interaction chains forked for them.                                                                                                                                                |
+| MaxCount     | `Integer`                                    | **Yes**          | The maximum number of blocks that will be located with the search. Further blocks will be ignored. If there are more matching blocks within the radius than this number, the specific set of blocks that will be found is completely arbitrary and may change from execution to execution. |
+| Interactions | `Asset`<br />(Asset Type: `RootInteraction`) | **No, but yes.** | The RootInteraction that will be forked for each matching block.  This interaction will not fail to validate if it is missing, but every execution of this interaction will fail.                                                                                                          |
+
+### UseBlock
+
+If the target block has an interaction for this interaction chain's interaction type, execute it immediately as part of
+this interaction chain. The execution will be wrapped in UseBlockEvent.Pre and UseBlockEvent.Post events, and cancellations
+of the UserBlockEvent.Pre event are respected. The User entity is considered the triggering entity for both events.
+
+If the target block does not have an interaction for this interaction chain's interaction type, this interaction fails.
+
+**This interaction has no additional fields.**
+
+## Items
+
+These are interactions intended to interface with an entity's inventory. There is no concept of an "item target",
+unfortunately, so these generally either interact with the entity's held item or the entity's inventory at a high level.
+
+### AddItem
+
+Adds a specified quantity of a specified item to the User entity's inventory, preferring to add it to the
+entity's hotbar where possible. This interaction will have no effect on User entities that are not LivingEntities.
+This interaction has no failure states.
+
+**Note: This interaction has a bug in its field validators that will cause interactions that reference items declared
+in the same mod to fail validation on startup.  Additionally, this interaction has a bug that will cause it to
+fail and have no effect if the User entity has no block target. Use ModifyInventory instead.**
+
+**AddItem Fields**
+
+| Field Name       | Type                              | Required? | Notes                                                                                                                             |
+| ---------------- | --------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false)   | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+| ItemId           | `Asset`<br />(Asset Type: `Item`) | **Yes**   | The item id of the item to add to the player's inventory.                                                                         |
+| Quantity         | `Integer`<br />(Default: 0)       | **No**    | The quantity of the item to add to the player's inventory.                                                                        |
+
+### CheckUniqueItemUsage
+
+This interaction will check whether it has run once for the User entity with their currently-held item before. If it hasn't,
+it will succeed. If it has, it will fail. It will also fail if the User entity is not a player. The interaction will record
+the item id of the User entity's currently-held item on success, ensuring it cannot be successfully run with that player
+and item id combination again.
+
+**This interaction has no additional fields.**
+
+### ChangeActiveSlot
+
+This interaction does not inherit from SimpleInteraction and therefore has no Next or Failed fields.  The `CancelOnItemChange`
+field is ignored for this interaction and is always treated as false. This interaction will set the User entity's currently-
+active hotbar slot to the specified slot index. If none is specified, the interaction chain's target slot will be used,
+if any. Otherwise, slot 0 will be used.  If a slot is specified and it is already active, then this interaction will
+have no effect, but if no slot is specified and the interaction chain's target slot is already active, the logic in
+the next paragraph will still be executed. This interaction will also have no effect if the User entity is not a
+LivingEntity.
+
+Once the slot has changed, a new SwapTo interaction chain will be forked off for the selected slot.
+If a target slot was specified, then the interaction chain's current target slot will be set to the specified slot, as will
+the forked SwapTo interaction chain. If this interaction chain was initiated by a player swapping an item into or out of
+an occupied active hotbar slot, then the swap will be executed after the slot is changed and before the SwapTo
+interaction is forked. Not running this interaction in the resulting SwapFrom interaction chain is a way for the server
+to cancel players performing these sorts of swap interactions. The default behavior for these swap interactions is that
+the SwapFrom interaction chain will be initiated with the currently-active-slot as the target slot. As a result, the
+target slot will usually not change when this interaction runs, it merely exists as a signal for the server to continue the
+item swap.
+
+**ChangeActiveSlot Fields**
+
+| Field Name | Type      | Required? | Notes                                                                                                                                                                                                     |
+| ---------- | --------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| TargetSlot | `Integer` | **No**    | If not provided, indicates the slot the player's active hotbar slot should be changed to.  Otherwise, the interaction chain's target slot will be used (which is usually the already-active hotbar slot). |
+
+### EquipItem
+
+This interaction will equip the User entity's currently-held item into the appropriate armor slot, if it is armor. The
+interaction will fail if the item is armor but it cannot be equipped for some reason. The interaction will succeed but
+take no action if the User entity cannot equip armor or if the item is not armor.
+
+**This interaction has no additional fields.**
+
+### IncreaseBackpackCapacity
+
+This interaction will increase the User entity's backpack size by the provided amount.  **It will additionally remove one
+quantity from the player's currently-held item. There is no way to prevent this.**  This interaction will have no effect
+if the User entity is not a player.  This interaction has no special failure conditions, even if the User entity
+is not a player, or the player is not currently holding an item.
+
+| Field Name | Type                        | Required? | Notes                                                                                   |
+| ---------- | --------------------------- | --------- | --------------------------------------------------------------------------------------- |
+| Capacity   | `Integer`<br />(Default: 1) | **No**    | The additional backpack capacity to add to the player. **Must be between 1 and 32767.** |
+
+### ModifyInventory
+
+This interaction attempts to perform one or more inventory-modifying actions against the User entity. The User entity must
+be a player. If they are not, no actions will be performed, but the interaction will not fail. Any item removals performed
+by this interaction, either as a result of `ItemToRemove` or `AdjustHeldItemQuantity`, are both atomic (meaning the entire
+quantity must be removed, or none) and required (meaning that the interaction will fail and no further actions taken if
+the removal fails for any reason).  Item additions performed by this interaction, either as a result of `ItemToAdd` or
+`AdjustHeldItemQuantity` will drop excess items on the ground near the player if necesary and continue on.
+
+This interaction first executes the item removal in `ItemToRemove`, if any, then adjusts the held item as specified by
+`AdjustHeldItemQuantity`, if provided, then executes the item addition in `ItemToAdd`, if any, and then finally executes
+the damage/healing of the held item in `AdjustHeldItemDurability`, if provided.
+
+**ModifyDurability Fields**
+
+| Field Name               | Type                            | Required? | Notes                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
+| ------------------------ | ------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| RequiredGameMode         | `GameMode`                      | **No**    | If provided, only execute the inventory-modifying actions if the player is in the provided GameMode. The interaction will not fail if the GameMode doesn't match.                                                                                                                                                                                                                                                                                                                                                                               |
+| ItemToRemove             | `ItemStack`                     | **No**    | If provided, a matching item will be removed in the provided quantity. If there is no matching item in the player inventory in the required quantity, then the interaction will fail and further actions will not be executed.                                                                                                                                                                                                                                                                                                                  |
+| AdjustHeldItemQuantity   | `Integer`<br />(Default: 0)     | **No**    | The player's held item, if any, will have its quantity will be modified by the provided amount- subtracted from if this number is negative or added to if this item is positive.  If the player has no held item, then this field will have no effect regardless of its value and the interaction will NOT fail.  If the player's inventory does not have sufficient quantity of items to support the removal, this interaction will fail and further actions will not be executed. Excess items will be dropped on the ground near the player. |
+| ItemToAdd                | `ItemStack`                     | **No**    | If provided, the ItemStack will be added to the player's inventory. Excess items will be dropped on the ground near the player.                                                                                                                                                                                                                                                                                                                                                                                                                 |
+| AdjustHeldItemDurability | `Double`<br />(Default: 0.0)    | **No**    | The player's held item, if any, will have its durability adjusted by the specified amount.  The durability cannot go below 0 or raise above the item's maximum durability. Invalid durability values in this field will not cause the interaction to fail. Neither will it fail if the player has no held item.                                                                                                                                                                                                                                 |
+| BrokenItem               | `String`                        | **No**    | This field should contain an ItemId, but it is not validated by the server on startup, so be careful.  This field can have the value of "Empty" to specify no item, or an empty hand. If specified and the `AdjustHeldItemDurability` operation reduces the player's held item to 0 durability, the player's held item is changed to this ItemId. If the inventory replacement fails, this interaction will fail.                                                                                                                               |
+| NotifyOnBreak            | `Boolean`<br />(Default: false) | **No**    | If true and the `AdjustHeldItemDurability` operation reduces the player's held item to 0 durability, this interaction will perform the usual audiovisual feedback of a broken tool. It will play the usual tool breaking sound and send the player a text message in chat that their item has broken.                                                                                                                                                                                                                                           |
+| NotifyOnBreakMessage     | `String`                        | **No**    | If provided, and `NotifyOnBreak` is true, when the player is notified of a broken tool by this interaction, the message sent to their chat will instead be the translation key specified by this field. The translation key supports the templating parameter `{itemName}`. See the translation key `server.general.repair.itemBroken_Hoe` for an example.                                                                                                                                                                                      |
+
+**GameMode Values**
+
+- `Creative`: The game is currently in Creative Mode
+- `Adventure`: The game is currently in Adventure Mode
+
+**ItemStack Fields**
+
+| Field Name                   | Type                              | Required? | Notes                                                                                |
+| ---------------------------- | --------------------------------- | --------- | ------------------------------------------------------------------------------------ |
+| Id                           | `Asset`<br />(Asset Type: `Item`) | **Yes**   | The id of the Item asset this stack contains.                                        |
+| Quantity                     | `Integer`<br />(Default: 1)       | **No**    | The number of items in this stack.<br />**Must be greater than 0.**                  |
+| Durability                   | `Double`<br />(Default: 0.0)      | **No**    | The durability of the item stack.<br />**Cannot be negative.**                       |
+| MaxDurability                | `Double`<br />(Default: 0.0)      | **No**    | The maximum durability of the item this stack contains.<br />**Cannot be negative.** |
+| Metadata                     | `Bson Document`                   | **No**    | If provided, applies the bson to the item stack metadata.                            |
+| OverrideDroppedItemAnimation | `Boolean`\*(Default: false)       | **No**    | ???                                                                                  |
+
+### PickupItem
+
+This interaction will attempt to pick up the User entity's current target entity and add it to their inventory. It will
+fail if the User entity is not a player, if they do not have a target entity, or if the target entity is not an item
+located in the world.  It will not fail if the player simply cannot pick up the item.
+
+**This interaction has no additional fields.**
+
+### RefillContainer
+
+This interaction will fail if the User entity is not a player. The interaction will draw a ray from the player's head
+down their look direction until the edge of the player's held item's interaction range or until the first solid block.
+The nearest fluid block of a type listed in this interaction's `States` map will result in the one of the player's
+currently-held items being converted to the fluid's related item state.  If the `States` map indicates a durability
+for the new item state, then the converted item will use that durability. If the item is already in the fluid's related
+item state, then this interaction will fail if the player's held item is already at maximum durability (unless the
+`States` map indicates a durability value greater than the item's maximum, in which case the interaction will succeed
+but the item will not change).  Otherwise, the durability listed for the fluid in the `States` map will be added to the
+item's current durability.
+
+If the interaction has not failed by this point, the fluid block in the world may be transformed to a different type if one is listed
+in the `States` map.
+
+If any part of this process does not proceed for any reason (for instance, if the player is not holding an item),
+then this interaction will fail.
+
+**RefillContainer Fields**
+
+| Field Name | Type                                                       | Required? | Notes                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| ---------- | ---------------------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| States     | `Map`<br />(Key Type: `String`, Value Type: `RefillState`) | **Yes**   | A map from item state names to `RefillState` objects, which contain information such as acceptable fluid block types, durability increases, and what fluid type to convert the targeted fluid block to after refill, if any. If the player targets a fluid block that matches one of the fluid types in the `RefillState`, the item will be converted to the keyed item state and the `RefillState` will be used to decide what happens next. |
+
+**RefillState Fields**
+
+| Field Name     | Type                                  | Required? | Notes                                                                                                                                                                                                                                                                                                                           |
+| -------------- | ------------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| AllowedFluids  | `Array`<br />(Element Type: `String`) | **Yes**   | If any of these fluids are targeted by the player, the player's held item will be converted to the keyed item state and `Durability` and `TransformFluid` will be used.                                                                                                                                                         |
+| Durability     | `Double`<br />(Default: -1.0)         | **No**    | If the player's held item changes item states, this value is the new item's durability, unless it is negative, in which case the item will begin at full durability. If the player's held item is already in the item state, and the item is not already at full durability, this value will be added to the item's durability. |
+| TransformFluid | `String`                              | **No**    | If provided, this field is a fluid id that the targeted fluid block should be transformed to if the player's held item is successfully updated.                                                                                                                                                                                 |
+
+## Entities
+
+### DamageEntity
+
+This interaction does not inherit from SimpleInteraction, but adds its own Next and Failed fields that
+work similarly.
+
+This interaction will cause the User entity to damage the Target entity.  It has the capability to apply different
+damage based on the direction of the attack or what body part was targeted by the User entity, with each possibility
+providing different damage calculations, effects, and Next interaction. If multiple entires match the attack, `TargetedDamage`
+(body part damage) takes highest priority, then the first matching `AngledDamage` in the list, then the default
+damage in the base interaction fields.  It is possible for elements of these different damage priorities to be taken peacemeal if higher-priority
+damage fields do not overwrite lower-priority damage fields. For instance,
+damage calculation could be taken from `TargetedDamage`, the damage effects could be taken from the first matching
+`AngledDamage`, and the Next interaction coming from the default damage field.
+
+If all damage dealt by this interaction is cancelled, then this interaction will fail, and the `Failed` interaction
+will be executed next in the chain. If any damage dealt by this interaction is blocked, then this interaction will
+succeed, but the `Blocked` interaction wil lbe executed next in the chain. Otherwise, the highest-precedent matching
+`Next` interaction that you provide will be executed.  For instance, if you provide `Next` interactions for all
+`TargetedDamage` and `AngledDamage` entries, and one in the interaction's `Next` field, then a headshot could result
+in a unique `Next` interaction being executed, even if there is a matching `AngledDamage` entry. However, if you leave
+the `Next` interaction out of your `TargetedDamage` entries, a special `Next` interaction for backstabs could be
+executed.  Otherwise, the `Next` field in the root of the interaction will be executed instead.
+
+DamageEntity has an unusual relationship with `RunTime`. This interaction always ends immediately after its first tick,
+regardless of the status of `RunTime` or `WaitForAnimationToFinish`.  However, if damage dealt by this interaction is
+calculated as `DamageCalculatorType` `Dps`, then the `RunTime` will be used to determine the precise amount of damage to
+deal. If `RunTime` is 0, then no damage will be dealt.
+
+**DamageEntity Fields**
+
+| Field Name       | Type                                                          | Required?                                                                                                                    | Notes                                                                                                                                                                                                                                                                                                                                                                         |
+| ---------------- | ------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| DamageCalculator | `DamageCalculator`                                            | **No**                                                                                                                       | If provided, describes the damage amounts and types to apply to the Target entity.                                                                                                                                                                                                                                                                                            |
+| DamageEffects    | `DamageEffects`                                               | **No**                                                                                                                       | If provided, describes particles, sounds, knockback, etc. to apply to the target entity on damage.                                                                                                                                                                                                                                                                            |
+| Next             | `Asset`<br />(Asset Type: `Interaction`)                      | **No**  After this interaction has finished, "Next" will be executed if damage was dealt to the target and none was blocked. |                                                                                                                                                                                                                                                                                                                                                                               |
+| AngledDamage     | `Array`<br />(Element Type: `AngledDamage`)                   | **No**                                                                                                                       | If provided, allows alternative `DamageCalculator`, `DamageEffects`, and `Next` entries for attacks that approach the target from certain angles.                                                                                                                                                                                                                             |
+| TargetedDamage   | `Map`<br />(Key Type: `String`, Value Type: `TargetedDamage`) | **Yes**                                                                                                                      | This field must be provided, but is not required to have any entries.  This is a map from body part names to `TargetedDamage` values. Hypixel only uses one body part name: `Head`, and it is not clear whether there are others.  If provided, allows alternative `DamageCalculator`, `DamageEffects`, and `Next` entries for attacks that damage specific enemy body parts. |
+| EntityStatsOnHit | `Array`<br />(Element Type: `EntityStatOnHit`)                | **No**                                                                                                                       | If provided, allows this attack to reduce enemy stats other than health.  Each individual damage application dealt by the same ability will apply stat reductions, at diminishing returns. All damage dealt in interaction chains forked by a Selector interaction will share the number of hits across all targets.                                                          |
+| Failed           | `Asset`<br />(Asset Type: `Interaction`)                      | **No**                                                                                                                       | After this interaction has finished, "Failed" will be executed if no damage hits were applied to the player, or if all damage hits were cancelled.                                                                                                                                                                                                                            |
+| Blocked          | `Asset`<br />(Asset Type: `Interaction`)                      | **No**                                                                                                                       | After this interaction has finished, "Blocked" will be executed if any damage hits were blocked by the target.                                                                                                                                                                                                                                                                |
+
+**DamageCalculator Fields**
+
+| Field Name                | Type                                                      | Required? | Notes                                                                                                                                                                                                                                                 |
+| ------------------------- | --------------------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Type                      | `DamageCalculatorType`<br />(Default: Absolute)           | **No**    | Whether the damage being applied is `Absolute` or \`Dps'.                                                                                                                                                                                             |
+| Class                     | `DamageClass`<br />(Default: Unknown)                     | **No**    | The type of attack producing the damage. Some weapon systems apply equipment modifiers based on this value.                                                                                                                                           |
+| BaseDamage                | `Map`<br />(Key Type: `DamageCause`, Value Type: `Float`) | **No**    | A set of DamageCauses and how much base damage is dealt for each.                                                                                                                                                                                     |
+| SequentialModifierStep    | `Float`<br />(Default: 0.0)                               | **No**    | Value between 0.0-1.0. Each additional hit from a single ability will have its damage reduced by this much as a percentage. All damage dealt in interaction chains forked by a Selector interaction will share the number of hits across all targets. |
+| SequentialModifierMinimum | `Float`<br />(Default: 0.0)                               | **No**    | Value between 0.0-1.0. `SequentialModifierStep` cannot reduce damage below this percentage regardless of the number of hits.                                                                                                                          |
+| RandomPercentageModifier  | `Float`<br />(Default: 0.0)                               | **No**    | A random value between +/- this amount multiplied by the base damage will be added to the base damage.                                                                                                                                                |
+
+**DamageEffects Fields**
+
+| Field Name             | Type                                         | Required? | Notes                                                                                   |
+| ---------------------- | -------------------------------------------- | --------- | --------------------------------------------------------------------------------------- |
+| ModelParticles         | `Array`<br />(Element Type: `ModelParticle`) | **No**    | Particle systems to trigger in the first-person view.                                   |
+| WorldParticles         | `Array`<br />(Element Type: `WorldParticle`) | **No**    | Particle systems to trigger in the third-person view.                                   |
+| LocalSoundEventId      | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | 2D sound to play locally to the attacking entity if they are a player.                  |
+| WorldSoundEventId      | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | Sound to play in the world at the Target entity's location.                             |
+| PlayerSoundEventId     | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | 2D sound to play locally to the Target entity if they are a player.                     |
+| ViewDistance           | `Double`<br />(Default: 75.0)                | **No**    | Distance at which these effects should play for other players.                          |
+| Knockback              | `Knockback`                                  | **No**    | The properties of the knockback that will be applied.                                   |
+| CameraEffect           | `Asset`<br />(Asset Type: `CameraEffect`)    | **No**    | CameraEffect to briefly apply locally to the Target entity if they are a player.        |
+| StaminaDrainMultiplier | `Float`<br />(Default: 1.0)                  | **No**    | This multiplier is applied to the stamina cost incurred by the target blocking, if any. |
+
+**AngledDamage Fields**
+
+| Field Name       | Type                                     | Required? | Notes                                                                                                                                                                                                     |
+| ---------------- | ---------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| AngleDistance    | `Float`<br />(Default: 0)                | **No**    | The width in degrees of the matching arc around the Target entity. If the attack against the Target originates from within the arc, then the properties below will be applied to the attack, if provided. |
+| Angle            | `Float`<br />(Default: 0.0)              | **No**    | The angle in degrees around the Target entity at which the matching arc is centered.                                                                                                                      |
+| DamageCalculator | `DamageCalculator`                       | **No**    | If provided and the attack against the Target entity originates from within the provided arc, this DamageCalculator will override the interaction's `DamageCalculator` field.                             |
+| DamageEffects    | `DamageEffects`                          | **No**    | If provided and the attack against the Target entity originates from within the provided arc, this DamageEffects will override the interaction's `DamageEffects` field.                                   |
+| Next             | `Asset`<br />(Asset Type: `Interaction`) | **No**    | If provided and the attack against the Target entity originates from within the provided arc, this Interaction will override the interaction's `Next` field.                                              |
+
+**TargetedDamage Fields**
+
+| Field Name       | Type                                     | Required? | Notes                                                                                                                                                                                            |
+| ---------------- | ---------------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| DamageCalculator | `DamageCalculator`                       | **No**    | If provided and this TargetedDamage was matched, this DamageCalculator will override the interaction's `DamageCalculator` field and the `DamageCalculator` field of any matching `AngledDamage`. |
+| DamageEffects    | `DamageEffects`                          | **No**    | If provided and this TargetedDamage was matched, this DamageEffects will override the interaction's `DamageEffects` field and the `DamageEffects` field of any matching `AngledDamage`.          |
+| Next             | `Asset`<br />(Asset Type: `Interaction`) | **No**    | If provided and this TargetedDamage was matched, this Interaction will override the interaction's `Next` field and the `Next` field of any matching `AngledDamage`.                              |
+
+**EntityStatOnHit Fields**
+
+| Field Name                  | Type                                                                       | Required? | Notes                                                                                                                                                                                                                                                                                        |
+| --------------------------- | -------------------------------------------------------------------------- | --------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| EntityStatId                | `Asset`<br />(AssetType: `EntityStatType`)                                 | **Yes**   | Which entity stat to affect.                                                                                                                                                                                                                                                                 |
+| Amount                      | `Float`<br />(Default: 0.0)                                                | **No**    | How much of the stat to apply for each damage application. Use negative numbers to reduce stats.                                                                                                                                                                                             |
+| MultipliersPerEntitiesHit   | `Array`<br />(Element Type: `Float`, Default: `[1.0, 0.6, 0.4, 0.2, 0.1]`) | **No**    | The diminishing returns curve to be applied for multiple damage applications by the same ability. Each hit's stat impact will be multiplied by the next value in the list.  If there are more hits than array elements, subsequent hits will be multiplied by `MultiplierPerExtraEntityHit`. |
+| MultiplierPerExtraEntityHit | `Float`<br />(Default: 0.05)                                               | **No**    | If an ability carries out more damage applications than there are elements in the `MultipliersPerEntitiesHit` array, then subsequent stat values will be multiplied by this number.                                                                                                          |
+
+**Knockback Fields**
+
+| Field Name     | Type                                       | Required? | Notes                                                                                                                      |
+| -------------- | ------------------------------------------ | --------- | -------------------------------------------------------------------------------------------------------------------------- |
+| Type           | `String`                                   | **No**    | If provided, specifies a type of knockback to use. Each Target type may come with additional fields.                       |
+| Force          | `Double`<br />(Default: 0.0)               | **No**    | The amount of force to apply to the Owner entity.                                                                          |
+| Duration       | `Double`<br />(Default: 0.0)               | **No**    | If 0.0, apply the force as a single impulse.  If more, continuously apply the force over a period of time.                 |
+| VelocityType   | `ChangeVelocityType`<br />(Default: `Add`) | **No**    | How to apply the force, either adding it to the entity's current velocity, or setting the velocity to the knockback force. |
+| VelocityConfig | `VelocityConfig`                           | **No**    | Characteristics of friction as the Owner entity is thrown by this knockback.                                               |
+
+**Knockback Type: Force**
+
+Apply the calculated knockback force along the provided direction.
+
+| Field Name | Type                         | Required? | Notes                                                                                |
+| ---------- | ---------------------------- | --------- | ------------------------------------------------------------------------------------ |
+| Direction  | `Vector3`<br />(Default: Up) | **No**    | Which direction the entity should be flung, relative to the direction of the attack. |
+
+**Knockback Type: Point**
+
+Apply the calculated knockback force laterally along the XZ plane, plus provided Y velocity.
+
+| Field Name | Type                        | Required? | Notes                                                                                                   |
+| ---------- | --------------------------- | --------- | ------------------------------------------------------------------------------------------------------- |
+| OffsetX    | `Integer`<br />(Default: 0) | **No**    | Offset the source position of the knockback left or right perpendicular to the direction of the attack. |
+| OffsetZ    | `Integer`<br />(Default: 0) | **No**    | Offset the source position of the knockback, forward or backward along the directon of the attack.      |
+| RotateY    | `Integer`<br />(Default: 0) | **No**    | Rotate the knockback direction around the Y axis, where 0 is the default attack direction.              |
+| VelocityY  | `Float`<br />(Default: 0.0) | **No**    | Add vertical velocity to the knockback force after the direction and force has been calculated.         |
+
+**Knockback Type: Directional**
+
+Apply the calculated knockback force along the attack direction, removing any vertical component and replacing it with a provided Y velocity.
+
+| Field Name | Type                      | Required? | Notes                                                                                                                                            |
+| ---------- | ------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------ |
+| RelativeX  | `Float`<br />(Default: 0) | **No**    | Apply additional force left or right perpendicular to the direction of the attack. The additional force is multiplied by the knockback strength. |
+| RelativeZ  | `Float`<br />(Default: 0) | **No**    | Apply additional force forward or backward along the attack direction. The additional force is multiplied by the knockback strength.             |
+| VelocityY  | `Float`<br />(Default: 0) | **No**    | Replace the vertical velocity of the knockback with this value.  This value is not multiplied by knockback strength.                             |
+
+**VelocityConfig Fields**
+
+| Field Name          | Type                                              | Required? | Notes                                                                                                                                                                                           |
+| ------------------- | ------------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| GroundResistance    | `Float`<br />(Default: 0.82)                      | **No**    | The minimum amount of friction applied when the entity is in contact with the ground.  1.0 = no friction, 0.0 = total friction                                                                  |
+| GroundResistanceMax | `Float`<br />(Default: 0.0)                       | **No**    | The maximum amount of friction applied when the entity is in contact with the ground.  1.0 = no friction, 0.0 = total friction                                                                  |
+| AirResistance       | `Float`<br />(Default: 0.96)                      | **No**    | The minimum amount of friction applied when the entity is in the air. 1.0 = no friction, 0.0 = total friction                                                                                   |
+| AirResistanceMax    | `Float`<br />(Default: 0.0)                       | **No**    | The maximum amount of friction applied when the entity is in the air. 1.0 = no friction, 0.0 = total friction                                                                                   |
+| Threshold           | `Float`<br />(Default: 1.0)                       | **No**    | The speed at which the maximum amount of friction will be applied to the entity. The amount of friction applied will increase from minimum to maximum as the entity moves from 0 to this speed. |
+| Style               | `VelocityThresholdStyle`<br />(Default: `Linear`) | **No**    | The curve that friction follows as the entity's speed increases toward the `Threshold`.                                                                                                         |
+
+**DamageCalculatorType Values**
+
+- `Absolute`
+- `Dps`
+
+**DamageClass Values**
+
+- `Unknown`
+- `Light`
+- `Charged`
+- `Signature`
+
+**ChangeVelocityType Values**
+
+- `Add`
+- `Set`
+
+**VelocityThresholdStyle Values**
+
+- `Linear`
+- `Exp`
+
+### LaunchProjectile
+
+This is just a worse version of Projectile and is slated to be removed.  Use Projectile.
+
+### Projectile
+
+This interaction will spawn a new projectile at the User entity's eye position that will travel in its look direction.
+
+| Field Name | Type                                          | Required? | Notes                                                  |
+| ---------- | --------------------------------------------- | --------- | ------------------------------------------------------ |
+| Config     | `Asset`<br />(Asset Type: `ProjectileConfig`) | **No**    | Configuration describing the projectile to be spawned. |
+
+### RemoveEntity
+
+Despawns the specified entity from the world. This interaction will have no effect if the specified entity is a player. This
+interaction has no special failure conditions.
+
+| Field Name | Type                                     | Required? | Notes                  |
+| ---------- | ---------------------------------------- | --------- | ---------------------- |
+| Entity     | `InteractionTarget`<br />(Default: User) | **No**    | The entity to despawn. |
+
+**InteractionTarget Values**
+
+- `User` - The user of this interaction chain. The entity whose actions caused this interaction chain to be executed. This is usually the same as the Owner.
+- `Owner` - The owner of this interaction chain. The entity upon whom this interaction chain is executing.
+- `Target` - The entity target of this interaction chain, if any.  This value is mutable (and can therefore come from many places) but most commonly, it is an entity the User was targeting when this interaction chain began executing.
+
+### SendMessage
+
+This interaction sends a message to the Owner entity if that entity can receive messages.  Otherwise, the message
+is written to the server logs.  If the entity is a player, the message will appear in the player's chat window.
+
+\*\*SendMessage
+
+| Field Name | Type     | Required? | Notes                                                                                                                 |
+| ---------- | -------- | --------- | --------------------------------------------------------------------------------------------------------------------- |
+| Message    | `String` | **No**    | A text message to be sent to the Owner entity.  If this field is not provided, `Key` is used instead.                 |
+| Key        | `String` | **No**    | A translation key for a message to be sent to the Owner entity. If `Message` is provided, then this field is ignored. |
+
+### UseEntity
+
+This interaction is not in use by Hypixel and has some unusual qualities that mean it probably won't do what you want it
+to.  Do not use it.
+
+This interaction will retrieve the entity currently targeted by the client (NOT the interaction chain's current Target
+entity) and execute that entity's RootInteraction for this interaction chain's current interaction type. The
+RootInteraction will be executed as part of this current interaction chain. None of the properties of this interaction
+chain will be modified.
+
+This interaction will fail if the client is not currently targeting an entity, or if no interaction for the current
+interaction type exists on the entity.
+
+## Stats
+
+Hytale's resource system has been written about fairly extensively.  You can use these interactions to modify stats in
+response to actions or use stats as a cost for abilities.
+
+### ChangeStat
+
+This interaction applies a set of raw stat changes to the User entity. It has no special failure conditions.
+
+| Field Name    | Type                                                         | Required? | Notes                                                                                                                                                                                                                      |
+| ------------- | ------------------------------------------------------------ | --------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| StatModifiers | `Map`<br />(Key Type: `EntityStatType`, Value Type: `Float`) | **Yes**   | A set of stats to modify and what value to apply to them.                                                                                                                                                                  |
+| ValueType     | `ValueType`<br />(Default: Absolute)                         | **No**    | Whether the values in the `StatModifiers` map represent flat values to apply to the stat total, or percentages (0.0-100.0). Percentage values are percentage of the difference between the maximum and minimum stat value. |
+| Behaviour     | `ChangeStatBehavior`<br />(Default: Add)                     | **No**    | Whether the values in the `StatModifiers` map represent deltas to add into the User entity's current stat values, or fixed values to set the entity's stats to.                                                            |
+
+**ValueType Values**
+
+- `Absolute`
+- `Percent`
+
+**ChangeStatBehaviour Values**
+
+- `Add`
+- `Set`
+
+### ChangeStatWithModifier
+
+This interaction is like ChangeStat, except an armor stat modifier can be chosen which will apply bonuses and penalties
+to a stat from the User entity's equipped armor before it is applied.
+
+| Field Name            | Type                                                         | Required? | Notes                                                                                                                                                                                                                      |
+| --------------------- | ------------------------------------------------------------ | --------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| StatModifiers         | `Map`<br />(Key Type: `EntityStatType`, Value Type: `Float`) | **Yes**   | A set of stats to modify and what value to apply to them.                                                                                                                                                                  |
+| ValueType             | `ValueType`<br />(Default: Absolute)                         | **No**    | Whether the values in the `StatModifiers` map represent flat values to apply to the stat total, or percentages (0.0-100.0). Percentage values are percentage of the difference between the maximum and minimum stat value. |
+| Behaviour             | `ChangeStatBehavior`<br />(Default: Add)                     | **No**    | Whether the values in the `StatModifiers` map represent deltas to add into the User entity's current stat values, or fixed values to set the entity's stats to.                                                            |
+| InteractionModifierId | `InteractionModifierId`                                      | **Yes**   | The armor interaction modifier to apply bonuses and penalties for.                                                                                                                                                         |
+
+**ValueType Values**
+
+- `Absolute`
+- `Percent`
+
+**ChangeStatBehaviour Values**
+
+- `Add`
+- `Set`
+
+**InteractionModifierId Values**
+
+- `Dodge`
+
+### StatsCondition
+
+This interaction will fail if the User entity cannot afford the specified stats costs, or if it does not have the
+requested stats.
+
+| Field Name | Type                                                         | Required? | Notes                                                                                                                                                                                    |
+| ---------- | ------------------------------------------------------------ | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Costs      | `Map`<br />(Key Type:` EntityStatType`, Value Type: `Float`) | **Yes**   | A set of costs that the User entity needs to be able to afford for this interaction to succeed.                                                                                          |
+| ValueType  | `ValueType`<br />(Default: Absolute)                         | **No**    | Whether the values in the `Costs` map represetn flat values or percentages (0.0-100.0).  Percentage values are percentage of the difference between the maximum and minimum value.       |
+| LessThan   | `Boolean`<br />(Default: false)                              | **No**    | If true, this interaction will fail unless the User entity's current stat values are at or **below** the specified levels.  If false, they must be at or **above** the specified levels. |
+| Lenient    | `Boolean`<br />(Default: false)                              | **No**    | If true and `LessThan` is true, and a player's minimum stat value is below zero, then the player can afford a stat cost if the current value of a stat if above 0.                       |
+
+**ValueType Values**
+
+- `Absolute`
+- `Percent`
+
+### StatsConditionWithModifier
+
+This interaction is like StatsCondition, except an armor stat modifier can be chosen which will apply bonuses and penalties
+to a stat's cost from the User entity's equipped armor before it is compared.
+
+| Field Name            | Type                                                         | Required? | Notes                                                                                                                                                                                    |
+| --------------------- | ------------------------------------------------------------ | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Costs                 | `Map`<br />(Key Type:` EntityStatType`, Value Type: `Float`) | **Yes**   | A set of costs that the User entity needs to be able to afford for this interaction to succeed.                                                                                          |
+| ValueType             | `ValueType`<br />(Default: Absolute)                         | **No**    | Whether the values in the `Costs` map represetn flat values or percentages (0.0-100.0).  Percentage values are percentage of the difference between the maximum and minimum value.       |
+| LessThan              | `Boolean`<br />(Default: false)                              | **No**    | If true, this interaction will fail unless the User entity's current stat values are at or **below** the specified levels.  If false, they must be at or **above** the specified levels. |
+| Lenient               | `Boolean`<br />(Default: false)                              | **No**    | If true and `LessThan` is true, and a player's minimum stat value is below zero, then the player can afford a stat cost if the current value of a stat if above 0.                       |
+| InteractionModifierId | `InteractionModifierId`                                      | **Yes**   | The armor interaction modifier to apply bonuses and penalties for.                                                                                                                       |
+
+**ValueType Values**
+
+- `Absolute`
+- `Percent`
+
+**InteractionModifierId Values**
+
+- `Dodge`
+
+## EntityEffects
+
+EntityEffects are buff or debuff effects that can be applied to a LivingEntity.  These can have a variety of effects from
+movement speed changes to periodic damage.
+
+### EffectCondition
+
+This interaction will fail if the specified entity's EntityEffects do not match the provided conditions.
+
+**EffectCondition Fields**
+
+| Field Name      | Type                                             | Required? | Notes                                                                                                                                                                                                             |
+| --------------- | ------------------------------------------------ | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Entity          | `InteractionTarget`<br />(Default: User)         | **Yes**   | The entity to examine for EntityEffects. This field can indicate the Owner, User, or Target of this interaction chain.                                                                                            |
+| Match           | `Match`<br />(Default: All)                      | **No**    | If `All`, then this interaction will fail if any EntityEffect in the `EntityEffectIds` is not on the specified entity. If `None`, then this interaction will fail if any EntityEffect IS on the specified entity. |
+| EntityEffectIds | `AssetArray`<br />(Element Type: `EntityEffect`) | **Yes**   | The set of EntityEffects to check against the specified entity and `Match`.                                                                                                                                       |
+
+**InteractionTarget Values**
+
+- `User` - The user of this interaction chain. The entity whose actions caused this interaction chain to be executed. This is usually the same as the Owner.
+- `Owner` - The owner of this interaction chain. The entity upon whom this interaction chain is executing.
+- `Target` - The entity target of this interaction chain, if any.  This value is mutable (and can therefore come from many places) but most commonly, it is an entity the User was targeting when this interaction chain began executing.
+
+**Match Values**
+
+- `All` - All EntityEffects must be on the specified entity for this interaction to succeed.
+- `None` - None of the EntityEffects must be on the specified entity for this interaction to succeed.
+
+### ApplyEffect
+
+This interaction will apply the specified EntityEffect to the specified Entity.  It has no special failure conditions.
+
+**ApplyEffect Fields**
+
+| Field Name | Type                                      | Required? | Notes                                                                                                                  |
+| ---------- | ----------------------------------------- | --------- | ---------------------------------------------------------------------------------------------------------------------- |
+| Entity     | `InteractionTarget`<br />(Default: User)  | **Yes**   | The entity to apply the EntityEffect to. This field can indicate the Owner, User, or Target of this interaction chain. |
+| EffectId   | `Asset`<br />(Asset Type: `EntityEffect`) | **Yes**   | The effect to apply.                                                                                                   |
+
+**InteractionTarget Values**
+
+- `User` - The user of this interaction chain. The entity whose actions caused this interaction chain to be executed. This is usually the same as the Owner.
+- `Owner` - The owner of this interaction chain. The entity upon whom this interaction chain is executing.
+- `Target` - The entity target of this interaction chain, if any.  This value is mutable (and can therefore come from many places) but most commonly, it is an entity the User was targeting when this interaction chain began executing.
+
+### ClearEntityEffect
+
+This interaction will remove the specified EntityEffect from the specified Entity. It has no special failure conditions.
+It will not fail if the Entity does not have the EntityEffect.
+
+**ClearEntityEffect Fields**
+
+| Field Name | Type                                      | Required? | Notes                                                                                                                     |
+| ---------- | ----------------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------- |
+| Entity     | `InteractionTarget`<br />(Default: User)  | **Yes**   | The entity to remove the EntityEffect from. This field can indicate the Owner, User, or Target of this interaction chain. |
+| EffectId   | `Asset`<br />(Asset Type: `EntityEffect`) | **Yes**   | The effect to remove.                                                                                                     |
+
+**InteractionTarget Values**
+
+- `User` - The user of this interaction chain. The entity whose actions caused this interaction chain to be executed. This is usually the same as the Owner.
+- `Owner` - The owner of this interaction chain. The entity upon whom this interaction chain is executing.
+- `Target` - The entity target of this interaction chain, if any.  This value is mutable (and can therefore come from many places) but most commonly, it is an entity the User was targeting when this interaction chain began executing.
+
+## Farming
+
+These are interaction types built to support the in-game farming system in Hytale. They are mostly block-related interactions
+with a few exceptions.
+
+### ChangeFarmingStage
+
+If the target block is a farming block, this interaction will attempt to modify the current farming stage in one of
+three ways.  The interaction can optionally specify which StageSet to use for the new stage. If it is not specified,
+the current StageSet will be used. If any part of the the process of changing the growth stage fails, this interaction
+will fail, with the one exception that attempting to set the stage to the crop's existing stage will have no effect but
+still succeed.
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                                                                                                                                                                          |
+| ---------------- | ------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction.                                                                                                                                              |
+| StageSet         | `String`                        | **No**    | If provided, set the block's current stage to one in the provided StageSet. Otherwise, use the crop's current StageSet.                                                                                                                                                        |
+| Increase         | `Integer`                       | **No**    | If provided, increase the current stage by the specified amount. If the specified stage does not exist, the block will be set to the closest extant stage.                                                                                                                     |
+| Decrease         | `Integer`                       | **No**    | If provided and `Increase` is not provided, decrease the current stage by the specified amount. If the specified stage does not exist, the block will be set to the closest extant stage.                                                                                      |
+| Stage            | `Integer`<br />(Default: -1)    | **No**    | If provided and `Increase`/`Decrease` are not provided, set the current stage to the specified stage. If this value is less than 0, set the current stage to the final growth stage. If the specified stage does not exist, the block will be set to the closest extant stage. |
+
+### FertilizeSoil
+
+If the target block is unfertilized tilled soil or a farming block on top of unfertilized tilled soil, fertilizes the soil.
+The interaction will fail otherwise.
+
+**FertilizeSoil Fields**
+
+| Field Name       | Type                                  | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false)       | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+| RefreshModifiers | `Array`<br />(Element Type: `String`) | **No**    | Does nothing.                                                                                                                     |
+
+### HarvestCrop
+
+This interaction will attempt to execute the harvest action on the current block target and add the crop's drops to the User entity's
+inventory.  The block will either be destroyed or set to its post-harvest growth stage, depending on the farming
+configuration of the block.  This will happen (and the player will receive the full harvest drops) regardless of the
+block's current growth stage. This interaction has no special failure conditions, even if the block target isn't a
+farming block or gathering isn't permitted in the current world, but nothing will occur in those cases.
+
+**HarvestCrop Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+
+### UseWateringCan
+
+If the target block is tilled soil or a farming block on top of tilled soil, waters the soil for the specified duration.
+The interaction will fail otherwise.
+
+**UseWateringCan Fields**
+
+| Field Name       | Type                                  | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false)       | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+| Duration         | `Integer`<br />(Default: 0)           | **No**    | The duration in seconds to water the soil for.                                                                                    |
+| RefreshModifiers | `Array`<br />(Element Type: `String`) | **No**    | Does nothing.                                                                                                                     |
diff --git a/content/docs/sq-AL/contributing/pr-guidelines.mdx b/content/docs/sq-AL/contributing/pr-guidelines.mdx
index 7a251032..c226da04 100644
--- a/content/docs/sq-AL/contributing/pr-guidelines.mdx
+++ b/content/docs/sq-AL/contributing/pr-guidelines.mdx
@@ -19,6 +19,8 @@ To ensure a smooth and efficient review process, both contributors and reviewers
 4. **Code Quality**
    - Ensure your code follows the project's coding standards and best practices.
    - Include comments where necessary to explain complex logic.
+   - Always test your changes locally before submitting the PR to catch any issues early.
+   - Format your code using `bun format` to maintain consistency across the codebase.
 5. **Testing**
    - Test your changes thoroughly before submitting the PR.
    - If applicable, include unit tests or integration tests to verify your changes.
diff --git a/content/docs/sq-AL/contributing/translate.mdx b/content/docs/sq-AL/contributing/translate.mdx
new file mode 100644
index 00000000..c62ffdde
--- /dev/null
+++ b/content/docs/sq-AL/contributing/translate.mdx
@@ -0,0 +1,74 @@
+---
+title: Translate
+description: How to translate HytaleModding to your language
+---
+
+# Translating HytaleModding
+
+HytaleModding is translated with the help of the community using **Crowdin**. If you want to help translate or improve existing translations, this is the right place.
+
+## Steps to Translate
+
+All translations are managed **via Crowdin**.
+
+1. Visit [our Crowdin project](https://crowdin.com/project/hytalemodding) and log in if required.
+2. Click on your language.
+3. Click on the file/article you wish to translate. We recommend starting with Official Documentation, and then Server Plugin Documentation.
+4. Start translating!
+5. Approved translations will appear on the website.
+
+### Video Guide
+
+<iframe src="https://www.youtube.com/embed/NHiG1rDRgks" allowFullScreen />
+
+## How to discuss
+
+You can always report issues or discuss specific topics directly on Crowdin, but we recommend using Discord instead of the Crowdin comment system to keep everything organized in one place.
+
+1. Join [our Discord](https://discord.gg/hytalemodding)
+2. Open `#translations` channel. Here you can discuss or ask questions that are not related to a specific language.
+3. If you want to join a thread, you are required to run `/translator <your-language>` command here. The bot will add you to the thread for your language.
+
+## Translation Guidelines
+
+- You need to be confident in what you are translating. You should be able to read the text you just translated and understand the meaning of it very easily.
+- It should use the simplest form of language possible. Use English words if the translation is unknown to the majority in your country.
+- Use your imagination, trust yourself. Feel free to change any context as you wish as long as it can still get the same point across and is understandable.
+- These guidelines are more important than language-specific guidelines, but less important than Hytale terminology and rules.
+
+## What not to translate
+
+We request you all to not translate these specific sections of the website:
+
+### Callout types
+
+Callouts are the boxes that contain important information. We request you to not translate the types as they only work in English.
+
+**Example:**
+
+```mdx
+<Callout type="warning" title="Translate this title!">
+Translate the text inside the callout!
+</Callout>
+```
+
+In this example, please don't translate the word warning, the rest you can translate.
+
+### Icons
+
+Icon names must not be translated.
+They are technical identifiers mapped directly to existing icons. Translating them will break the icon rendering.
+
+```mdx
+icon: Globe
+```
+
+---
+
+{/* 
+For translators who will edit this page:
+
+- You are required to translate the Guidelines as they change.
+- General guidelines should be translated but not edited.
+- Learn how to use Markdown from writing_guides.mdx
+*/}
diff --git a/content/docs/sq-AL/established-information/server/content-categories/art-assets.mdx b/content/docs/sq-AL/established-information/server/content-categories/art-assets.mdx
index 39c2ed37..1e926874 100644
--- a/content/docs/sq-AL/established-information/server/content-categories/art-assets.mdx
+++ b/content/docs/sq-AL/established-information/server/content-categories/art-assets.mdx
@@ -14,7 +14,7 @@ Hytale provides comprehensive support for 3D modeling and texture art creation,
 Hytale uses **Blockbench** as the primary tool for 3D modeling and animation:
 
 * **Official support**: Used for "creating Hytale models, textures, and animations"
-* **Special plugin**: Hytale will have a dedicated Blockbench plugin, to be released ASAP
+* **Special plugin**: Hytale has a dedicated [Blockbench Plugin](https://www.blockbench.net/plugins/hytale_plugin).
 * **Direct compatibility**: The plugin allows creators to "create Hytale-compatible models, textures, and animations directly in Blockbench"
 * **Replaces legacy tools**: Fully replaces the old Hytale Model Maker to better support established creative workflows in the community
 * **Safety features**: Only allows you to add things compatible with the engine, so no need to worry about breaking anything
diff --git a/content/docs/sq-AL/guides/ecs/block-components.mdx b/content/docs/sq-AL/guides/ecs/block-components.mdx
new file mode 100644
index 00000000..ca68b38a
--- /dev/null
+++ b/content/docs/sq-AL/guides/ecs/block-components.mdx
@@ -0,0 +1,247 @@
+---
+title: Block Components
+description: Learn how to use the block components.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+  - name: oskarscot
+    link: https://oskar.scot
+---
+
+# Overview
+
+In this guide, you'll learn how to use block components to create a ticking block.
+
+<Callout>
+  For a more complete reference, you may also want to review FarmingSystems.Ticking, as much of the underlying logic is based on its implementation.
+</Callout>
+
+## Steps
+
+### 1. ExampleBlock - holds block behavior
+
+```java
+public class ExampleBlock implements Component<ChunkStore> {
+
+    public static final BuilderCodec CODEC = BuilderCodec.builder(ExampleBlock.class, ExampleBlock::new).build();
+
+    // Components usually require a copy constructor as well but since we don't actually hold any data in this component this is not neccessary
+    public ExampleBlock() { }
+
+    public static ComponentType getComponentType() {
+        return ExamplePlugin.get().getExampleBlockComponentType();
+    }
+
+    @Nullable
+    public Component<ChunkStore> clone() {
+        return new ExampleBlock();
+    }
+}
+```
+
+ExampleBlock is a custom component that stores the behavior and data for your ticking block. Here, it simply places an Ice Block at x + 1 relative to its current position when it ticks.
+
+---
+
+### 2. ExampleInitializer - marks blocks as ticking when placed
+
+```java
+public class ExampleInitializer extends RefSystem {
+
+    @Override
+    public void onEntityAdded(@Nonnull Ref ref, @Nonnull AddReason reason, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+        BlockModule.BlockStateInfo info = (BlockModule.BlockStateInfo) commandBuffer.getComponent(ref, BlockModule.BlockStateInfo.getComponentType());
+        if (info == null) return;
+
+        ExampleBlock generator = (ExampleBlock) commandBuffer.getComponent(ref, ExamplePlugin.get().getExampleBlockComponentType());
+        if (generator != null) {
+            int x = ChunkUtil.xFromBlockInColumn(info.getIndex());
+            int y = ChunkUtil.yFromBlockInColumn(info.getIndex());
+            int z = ChunkUtil.zFromBlockInColumn(info.getIndex());
+
+            WorldChunk worldChunk = (WorldChunk) commandBuffer.getComponent(info.getChunkRef(), WorldChunk.getComponentType());
+            if (worldChunk != null) {
+				worldChunk.setTicking(x, y, z, true);
+            }
+        }
+    }
+
+    @Override
+    public void onEntityRemove(@Nonnull Ref ref, @Nonnull RemoveReason reason, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+    }
+
+    @Override
+    public Query getQuery() {
+        return Query.and(BlockModule.BlockStateInfo.getComponentType(), ExamplePlugin.get().getExampleBlockComponentType());
+    }
+}
+```
+
+ExampleInitializer is a RefSystem that reacts when block entities with the ExampleBlock component are added or removed. This is crucial for marking blocks as ticking when they're first placed.
+
+**Key Points:**
+
+- Tells the game that this block should tick, allowing `ExampleSystem` to process it.
+
+```java
+worldChunk.setTicking(x, y, z, true);
+```
+
+---
+
+### 3. ExampleSystem - handles ticking
+
+```java
+public class ExampleSystem extends EntityTickingSystem {
+
+    public void tick(float dt, int index, @Nonnull ArchetypeChunk archetypeChunk, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+        BlockSection blocks = (BlockSection) archetypeChunk.getComponent(index, BlockSection.getComponentType());
+
+        assert blocks != null;
+
+        if (blocks.getTickingBlocksCountCopy() != 0) {
+            ChunkSection section = (ChunkSection) archetypeChunk.getComponent(index, ChunkSection.getComponentType());
+
+            assert section != null;
+
+            BlockComponentChunk blockComponentChunk = (BlockComponentChunk) commandBuffer.getComponent(section.getChunkColumnReference(), BlockComponentChunk.getComponentType());
+
+            assert blockComponentChunk != null;
+
+            blocks.forEachTicking(blockComponentChunk, commandBuffer, section.getY(), (blockComponentChunk1, commandBuffer1, localX, localY, localZ, blockId) -> {
+                Ref<ChunkStore> blockRef = blockComponentChunk.getEntityReference(ChunkUtil.indexBlockInColumn(localX, localY, localZ));
+                if (blockRef == null) {
+                    return BlockTickStrategy.IGNORED;
+                } else {
+                    ExampleBlock exampleBlock = (ExampleBlock) commandBuffer1.getComponent(blockRef, ExampleBlock.getComponentType());
+                    if (exampleBlock != null) {
+                        WorldChunk worldChunk = (WorldChunk) commandBuffer.getComponent(section.getChunkColumnReference(), WorldChunk.getComponentType());
+                        World world = worldChunk.getWorld();
+
+                        int globalX = localX + (worldChunk.getX() * 32);
+                        int globalZ = localZ + (worldChunk.getZ() * 32);
+
+                        // We need to execute setBlock on the world thread as you cannot call store functions from a system
+                        // This is because of the architecture of the server, depending on your needs you can also use the CommandBuffer
+                        world.execute(() -> {
+                            world.setBlock(globalX + 1, localY, globalZ, "Rock_Ice");
+                        });
+
+                        return BlockTickStrategy.CONTINUE;
+
+                    } else {
+                        return BlockTickStrategy.IGNORED;
+                    }
+                }
+            });
+        }
+    }
+
+    @Nullable
+    public Query getQuery() {
+        return Query.and(BlockSection.getComponentType(), ChunkSection.getComponentType());;
+    }
+}
+```
+
+ExampleSystem is an EntityTickingSystem that runs every tick to execute the logic for all ticking blocks with the ExampleBlock component.
+
+**Key Points:**
+
+- **Get the block component**
+
+```java
+ExampleBlock exampleBlock = (ExampleBlock) commandBuffer.getComponent(blockRef, ExampleBlock.getComponentType());
+```
+
+- **Convert local chunk coordinates to world coordinates**
+
+```java
+int globalX = localX + (worldChunk.getX() * 32);
+int globalZ = localZ + (worldChunk.getZ() * 32);
+```
+
+- **Run the block logic**
+
+```java
+exampleBlock.runBlockAction(globalX, localY, globalZ, worldChunk.getWorld());
+```
+
+- **Keep the block ticking in the next tick**
+
+```java
+return BlockTickStrategy.CONTINUE;
+```
+
+---
+
+### 4. ExamplePlugin - registers components and systems
+
+```java
+public class ExamplePlugin extends JavaPlugin {
+    protected static ExamplePlugin instance;
+    private static final HytaleLogger LOGGER = HytaleLogger.forEnclosingClass();
+    private ComponentType exampleBlockComponentType;
+
+    public static ExamplePlugin get() {
+        return instance;
+    }
+
+    public ExamplePlugin(@Nonnull JavaPluginInit init) {
+        super(init);
+        LOGGER.atInfo().log("Hello from " + this.getName() + " version " + this.getManifest().getVersion().toString());
+    }
+
+    @Override
+    protected void setup() {
+        instance = this;
+        LOGGER.atInfo().log("Setting up plugin " + this.getName());
+        this.exampleBlockComponentType = this.getChunkStoreRegistry().registerComponent(ExampleBlock.class, "ExampleBlock", ExampleBlock.CODEC);
+    }
+	
+	@Override
+	protected void start() {
+		this.getChunkStoreRegistry().registerSystem(new ExampleSystem());
+		this.getChunkStoreRegistry().registerSystem(new ExampleInitializer());
+	}
+
+    public ComponentType getExampleBlockComponentType() {
+        return this.exampleBlockComponentType;
+    }
+}
+```
+
+---
+
+### 5. Configure In-Game
+
+![block-component-1](/assets/guides/block-component-1.png)
+
+![block-component-2](/assets/guides/block-component-2.png)
+
+With this logic, the block will now continuously place an Ice Block at the coordinates x + 1 relative to its current position every time it ticks.
+
+---
+
+## Common Issues
+
+### NullPointerException on Startup
+
+**Error message:**
+
+```java
+java.lang.NullPointerException: Cannot invoke "com.hypixel.hytale.component.query.Query.validateRegistry(com.hypixel.hytale.component.ComponentRegistry)" because "query" is null
+```
+
+**Cause:**
+This error occurs when your module is loaded **before** the required Hytale modules.
+
+**Fix:**
+Add `EntityModule` and `BlockModule` as dependencies in your `manifest.json` to ensure proper load order.
+
+```json
+"Dependencies": {
+  "Hytale:EntityModule": "*",
+  "Hytale:BlockModule": "*"
+}
+```
diff --git a/content/docs/sq-AL/guides/ecs/hytale-ecs-theory.mdx b/content/docs/sq-AL/guides/ecs/hytale-ecs-theory.mdx
index 20c3a94d..52d8b1f5 100644
--- a/content/docs/sq-AL/guides/ecs/hytale-ecs-theory.mdx
+++ b/content/docs/sq-AL/guides/ecs/hytale-ecs-theory.mdx
@@ -29,7 +29,7 @@ for now this is the basic understanding for the `ChunkStore`. You can use it to
 
 ## Holder
 
-A Holder is essentially a blueprint for an entity. Before an entity exists in the Store (and thus in the world), is exists as a `Holder`. It collects and holds all the necessary components (data). You can compare it analogous to shopping cart. You grab all components you need and once you have everything, check out at the store which will take your cart and create a valid entity ID and hand you back a receipt (a Ref).
+A Holder is essentially a blueprint for an entity. Before an entity exists in the Store (and thus in the world), it exists as a `Holder`. It collects and holds all the necessary components (data). You can compare it analogous to shopping cart. You grab all components you need and once you have everything, check out at the store which will take your cart and create a valid entity ID and hand you back a receipt (a Ref).
 
 Let's take a look at an example: initializing players. In `Universe`, the `addPlayer` method demonstrates it perfectly.
 When a player connects, we don't immediately throw them into the ECS. We first construct their data in a Holder.
@@ -167,7 +167,7 @@ MyComponent comp = commandBuffer.getComponent(ref, componentType);
 
 Codecs handle serialization and deserialization of components. Hytale uses them to save and load entity data to and from disk as well as sending component data over the network. When creating a custom component, you must also create a corresponding Codec.
 
-There are mutliple Codec types already implemented in the default Codec Interface:
+There are multiple Codec types already implemented in the default Codec Interface:
 
 - Codec.STRING
 - Codec.BOOLEAN
@@ -215,7 +215,7 @@ This might seem tedious at first but it ensures that your component can be corre
   KeyedCodec<Integer> exampleInt = new KeyedCodec<Integer>("ExampleIntIdForCodec", Codec.INTEGER);
   ```
 
-- **Setter Function**: This is a lambda function that takes an instance of your component and returns the value of the field you want to serialize. For example, if you have a field called `myCustomField` in your custom component, your getter function would look like this:
+- **Setter Function**: This is a lambda function that takes an instance of your component + the value to set and sets the field value on the component. For example, if you have a field called `myCustomField` in your custom component, your setter function would look like this:
   ```java
   (data, value) -> data.myCustomField = value
   ```
@@ -276,7 +276,7 @@ public class PoisonComponent implements Component<EntityStore> {
 
 You can also add validators to your Codec fields to ensure that the data being serialized/deserialized meets certain criteria. For example, if you want to ensure that the `damagePerTick` field is always non-negative or the poison name is never null, you can add a validator like this:
 
-````java
+```java
 .append(
     new KeyedCodec<Float>("DamagePerTick", Codec.FLOAT),
     (data, value) -> data.damagePerTick = value,
@@ -292,14 +292,15 @@ You can also add validators to your Codec fields to ensure that the data being s
 )
 .addValidator(Validators.nonNull())
 .add()
+```
 
 ### Complex Codec Examples
 
-If you want to have a map inside your component, you can use the MapCodec class to build a KeyedCoded for it. Here's an example of how to create a Codec for a Map field:
+If you want to have a map inside your component, you can use the MapCodec class to build a KeyedCodec for it. Here's an example of how to create a Codec for a Map field:
 
 ```java
 var damagePerTick = new KeyedCodec<>("DamagePerTick", new MapCodec<>(Codec.FLOAT, HashMap<String, Float>::new));
-````
+```
 
 <Callout type="info">
   This also works with custom Objects as long as you have a Codec defined for the Object type.
diff --git a/content/docs/sq-AL/guides/java-basics/00-introduction.mdx b/content/docs/sq-AL/guides/java-basics/00-introduction.mdx
index a03ad638..b0130d74 100644
--- a/content/docs/sq-AL/guides/java-basics/00-introduction.mdx
+++ b/content/docs/sq-AL/guides/java-basics/00-introduction.mdx
@@ -7,7 +7,7 @@ Welcome to your journey into Java Programming! This guide is designed to introdu
 
 ## What is Java?
 
-Java is a powerful, object-oriented programming language created in 1995. It's one of the most popular programming languages in the world and is used for everything from mobile apps to enterprise software. Most importantly for us, it's the language Hytale uses for it's servers & modding API.
+Java is a powerful, object-oriented programming language created in 1995. It's one of the most popular programming languages in the world and is used for everything from mobile apps to enterprise software. Most importantly for us, it's the language Hytale uses for its servers & modding API.
 
 ## What You'll Learn
 
diff --git a/content/docs/sq-AL/guides/java-basics/02-operators.mdx b/content/docs/sq-AL/guides/java-basics/02-operators.mdx
index a132b1c0..18634665 100644
--- a/content/docs/sq-AL/guides/java-basics/02-operators.mdx
+++ b/content/docs/sq-AL/guides/java-basics/02-operators.mdx
@@ -119,7 +119,7 @@ String greetingWithName = "Hello, " + name + "!"; // "Hello, Alice!"
 
 ## Operator Precedence
 
-Operator Precendence means which operator gets evaluated first in an line of code. Think of it like BODMAS/PEMDAS in math!
+Operator Precedence means which operator gets evaluated first in an line of code. Think of it like BODMAS/PEMDAS in math!
 
 ```java
 int result = 10 + 5 * 2; // result is 20, not 30
diff --git a/content/docs/sq-AL/guides/java-basics/03-control-flow-if.mdx b/content/docs/sq-AL/guides/java-basics/03-control-flow-if.mdx
index b9d6c479..af2d1c22 100644
--- a/content/docs/sq-AL/guides/java-basics/03-control-flow-if.mdx
+++ b/content/docs/sq-AL/guides/java-basics/03-control-flow-if.mdx
@@ -7,7 +7,7 @@ Programs need to make decisions. If statements let your code choose different pa
 
 ## Basic If Statement
 
-The simplest form checks one condition;
+The simplest form checks one condition:
 
 ```java
 int health = 20;
diff --git a/content/docs/sq-AL/guides/java-basics/08-access-modifiers.mdx b/content/docs/sq-AL/guides/java-basics/08-access-modifiers.mdx
index af560932..da2bf33b 100644
--- a/content/docs/sq-AL/guides/java-basics/08-access-modifiers.mdx
+++ b/content/docs/sq-AL/guides/java-basics/08-access-modifiers.mdx
@@ -484,7 +484,7 @@ class Data {
     // Static member:
     // cannot access to non-static variables
     public static void bar() {
-        x = 100; // Error: non-static variable x cannot be renference from a static context
+        x = 100; // Error: non-static variable x cannot be referenced from a static context
         y = 100; // OK
     }
 }
@@ -504,7 +504,7 @@ Data.x = 1000; // Error: cannot access instanced variables in a static context
 
 ### Static Fields
 
-A static field represents a data member owned by the class type rather then the object. Static fields are also stored in a specific memory location that's been shared between all the object instances that are created.
+A static field represents a data member owned by the class type rather than the object. Static fields are also stored in a specific memory location that's been shared between all the object instances that are created.
 
 It is declared as following:
 
diff --git a/content/docs/sq-AL/guides/plugin/animated-block-textures.mdx b/content/docs/sq-AL/guides/plugin/animated-block-textures.mdx
new file mode 100644
index 00000000..42bfa51f
--- /dev/null
+++ b/content/docs/sq-AL/guides/plugin/animated-block-textures.mdx
@@ -0,0 +1,101 @@
+---
+title: Animated Block Textures
+description: Learn how to attach a .blockyanim to a block
+authors:
+  - name: Burkino
+---
+
+import { File, Folder, Files } from 'fumadocs-ui/components/files';
+
+So, you want to make your blocks feel more alive through animations, do you?\
+Now for the most part this is the exact same as [Creating custom blocks](./creating-block).
+![blue fire gif](/assets/guides/blue_fire.gif)
+
+## Prerequisites
+
+This is NOT a guide on animating or texturing or even using BlockBench, why? Because I don't know how to do that.\
+The only thing we will be doing is taking the fire texture, changing the color, and applying it to our new fire block.
+
+## Setup
+
+To start, you're obviously going to want to grab the `Common/VFX/Fire/Fire.png` file. How you do it is up to you, in the Asset Editor you'll need to switch to the Common tab.\
+I'll assume you know how colorize or change the hue of an image, so go ahead and do that now and save it as `Blue_Fire.png`.
+
+The other assets used in this guide are `Common/VFX/Fire/Fire.blockymodel` and `Common/Blocks/Animations/Fire/Fire_Burn.blockyanim` (both renamed to `Blue_Fire`) but since we won't be changing them it's probably fine to leave them. I will reference the `Blue_Fire` versions as a way to point out what should be custom assets.\
+I will also duplicate `Server/Item/Item/Deco/Deco_Fire.json` and call it `Deco_Blue_Fire.json`.
+
+## Applying the changes
+
+The `Deco_Blue_Fire` block is actually just a particle emitter, however we will not be using particles, so lets start by removing them in `Block > Particles`.\
+Next we want to set the Block Model (called `CustomModel` in JSON) to `VFX/Blue_Fire/Blue_Fire.blockymodel` and Block Model Textures (`CustomModelTexture` in JSON) to
+
+```json
+[
+    {
+        "Texture": "VFX/Blue_Fire/Blue_Fire.png",
+        "Weight": 1
+    }
+]
+```
+
+Finally, we will apply the .blockyanim to our model, this is done through the Block Model Animation property (`CustomModelAnimation` in JSON) and the value should be `Blocks/Animations/Blue_Fire/Blue_Fire_Burn.blockyanim`.
+
+## Final Code
+
+With that your new blue fire should be done. Here is the minimal JSON for our blue fire.\
+There is an additional `Looping` and `RequiresAlphaBlending` property that I have not gone over, however I hope it is self-explanatory.
+
+```json
+{
+  "BlockType": {
+    "DrawType": "Model",
+    "CustomModel": "VFX/Blue_Fire/Blue_Fire.blockymodel",
+    "CustomModelAnimation": "Blocks/Animations/Blue_Fire/Blue_Fire_Burn.blockyanim",
+    "CustomModelTexture": [
+      {
+        "Texture": "VFX/Blue_Fire/Blue_Fire.png",
+        "Weight": 1
+      }
+    ],
+    "Looping": true,
+    "RequiresAlphaBlending": false
+  },
+  "PlayerAnimationsId": "Block"
+}
+```
+
+<Files>
+  <Folder name="resources" defaultOpen>
+    <Folder name="Server" defaultOpen>
+      <Folder name="Item" defaultOpen>
+        <Folder name="Items" defaultOpen>
+          <Folder name="Deco" defaultOpen>
+            <File name="Deco_Blue_Fire.json" />
+          </Folder>
+        </Folder>
+      </Folder>
+    </Folder>
+
+    <Folder name="Common" defaultOpen>
+      <Folder name="Blocks" defaultOpen>
+        <Folder name="Animations" defaultOpen>
+          <Folder name="Blue_Fire" defaultOpen>
+            <File name="Blue_Fire_Burn.blockyanim" />
+          </Folder>
+        </Folder>
+      </Folder>
+
+      <Folder name="VFX" defaultOpen>
+        <Folder name="Blue_Fire" defaultOpen>
+          <File name="Blue_Fire.blockymodel" />
+
+          <File name="Blue_Fire.png" />
+        </Folder>
+      </Folder>
+    </Folder>
+  </Folder>
+</Files>
+
+## Next steps
+
+Now that you know how to attach an animation to a block, try adding it to a block state.
diff --git a/content/docs/sq-AL/guides/plugin/build-and-test.mdx b/content/docs/sq-AL/guides/plugin/build-and-test.mdx
index 0e7fe7eb..f37534c3 100644
--- a/content/docs/sq-AL/guides/plugin/build-and-test.mdx
+++ b/content/docs/sq-AL/guides/plugin/build-and-test.mdx
@@ -9,18 +9,18 @@ If you followed along with the [Setting Up Your Development Environment](./setti
 
 ## Building Your Mod
 
-In our case, we've **Maven** as the build system. Maven is a powerful build automation tool that manages dependencies, compiles your code, and packages everything into a distributable JAR file.
+In our case, we've **Gradle** as the build system. Gradle is a powerful build automation tool that manages dependencies, compiles your code, and packages everything into a distributable JAR file.
 
-### Understanding Maven
+### Understanding Gradle
 
-Maven uses a `pom.xml` file (Project Object Model) to define your project's configuration, dependencies, and build settings. You can learn more about Maven at the [official Apache Maven website](https://maven.apache.org/).
+Gradle can use a `build.gradle.kts` file (Kotlin DSL) to define your project's configuration, dependencies, and build settings. You can learn more about Gradle at the [official Gradle website](https://gradle.org/).
 
-### Building with Maven
+### Building with Gradle
 
 To build your mod, open a terminal in your project directory and run:
 
 ```bash
-mvn package
+./gradlew build
 ```
 
 This command will:
@@ -29,16 +29,35 @@ This command will:
 2. Run any tests (if present)
 3. Package everything into a JAR file
 
+<Callout type="info">
+  If you are using the plugin template from the [Setting Up Your Development Environment](./setting-up-env) guide, then the build script is already set up for you. It includes paths to your Hytale game library and handles the packaging of your mod, managing hytale dependencies and manifest changes.
+
+  If you have a different path to your Hytale installation, you may receive the following error:
+
+  ```bash
+  FAILURE: Build failed with an exception.
+
+  * What went wrong:
+  Failed to find Hytale at the expected location. Please make sure you have installed the game. The expected location can be changed using the hytale.home_path property. Currently looking in 'C:\Path\To\Hytale'
+  ```
+
+  You can change the path by adding a property to your `gradle.properties` file (if it doesn't exist, create it in the root of your project):
+
+  ```properties
+  hytale.home_path=C:\Correct\Path\To\Hytale
+  ```
+</Callout>
+
 ### Build Output
 
-Once the build completes successfully, your mod will be located in the `target` directory and named:
+Once the build completes successfully, your mod will be located in the `build/libs` directory and named:
 
 ```
-ExamplePlugin-1.0-SNAPSHOT.jar
+ExamplePlugin-1.0.jar
 ```
 
 <Callout type="info">
-  The exact name may vary depending on what you configured in your `pom.xml` file. Check the `artifactId` and `version` fields to see what your JAR will be named.
+  The exact name may vary depending on what you configured in your `build.gradle.kts` and `settings.gradle.kts` file. Check the `rootProject.name` and `version` fields to see what your JAR will be named.
 </Callout>
 
 ## Testing Your Mod
@@ -49,11 +68,11 @@ Now that you've built your mod, it's time to test it in Hytale!
 
 First, you need to find Hytale's mods directory:
 
-1. Press **Win + R** on your keyboard
-2. Type `%appdata%` and press Enter
-3. Navigate to: `Hytale\UserData\Mods`
+1. Go to your Hytale installation directory (The default location is usually in your AppData folder)
+   > On Windows, you can access it by clicking `windows + R` and typing `%appdata%`.
+2. Navigate to: `/UserData/Mods`
 
-The full path should look like:
+The default path would look like:
 
 ```
 C:\Users\YourUsername\AppData\Roaming\Hytale\UserData\Mods
@@ -65,7 +84,7 @@ C:\Users\YourUsername\AppData\Roaming\Hytale\UserData\Mods
 
 ### 2. Copy Your Mod
 
-Copy the `ExamplePlugin-1.0-SNAPSHOT.jar` file from your project's `target` directory into the `Mods` folder you just located.
+Copy the `ExamplePlugin-1.0.jar` file from your project's `build/libs` directory into the `Mods` folder you just located.
 
 ### 3. Launch Hytale and Verify
 
@@ -84,7 +103,7 @@ If your mod doesn't appear in the mods list:
 - Make sure the JAR file is in the correct `Mods` folder
 - Check that your `manifest.json` file is properly configured
 - Look for any error messages in the Hytale logs
-- Verify that you're using the correct version of Java and Maven
+- Verify that you're using the correct version of Java and Gradle
 
 ## Next Steps
 
diff --git a/content/docs/sq-AL/guides/plugin/creating-commands.mdx b/content/docs/sq-AL/guides/plugin/creating-commands.mdx
index d33597f3..08572f16 100644
--- a/content/docs/sq-AL/guides/plugin/creating-commands.mdx
+++ b/content/docs/sq-AL/guides/plugin/creating-commands.mdx
@@ -8,6 +8,8 @@ authors:
     url: https://oskar.scot
   - name: jacobwojoski
     url: https://github.com/jacobwojoski
+  - name: Marcel-TO
+    url: https://marcel-to.net
 ---
 
 In this guide, you will learn how to create custom commands for your Hytale mod.
@@ -36,7 +38,7 @@ The most basic command is an `AbstractAsyncCommand`. It has very minimal data av
   `AbstractAsyncCommand` runs on its own background thread. This means its execute is not tied to any world instance and because of this it can not edit any **Stores** or **Refs** without getting the desired world first. To access this data any of the other command types would be preferred and are likely what you will want to use instead.
 </Callout>
 
-The main purpose for a command like this would be for something that can happen everywhere and is not tied to a specific world. For example a `serverRules` command to tell the user thats running the command in chat what the servers rules are nomatter what world they are in.
+The main purpose for a command like this would be for something that can happen everywhere and is not tied to a specific world. For example a `serverRules` command to tell the user that's running the command in chat what the server's rules are no matter what world they are in.
 
 ```java
 // Command that can be run that lists the server rules in chat to the player
@@ -49,7 +51,7 @@ public class ServerRulesCommand extends AbstractAsyncCommand {
     }
 
     // Run the command
-    // conetext - info about who ran the command. Server console?, Some player?
+    // context - info about who ran the command. Server console?, Some player?
     @Override
     protected CompletableFuture<Void> executeAsync(@Nonnull CommandContext context) {
         context.sendMessage(Message.raw("The only rule is there are no rules."));
@@ -134,7 +136,7 @@ Uses a Ray to see what the player is looking at and tries to run the command on
 
 ## Adding Arguments
 
-Arguments are additional fields that the user can input when running a command. The different types of arguments along with small snipits and a large example can be seen below.
+Arguments are additional fields that the user can input when running a command. The different types of arguments along with small snippets and a large example can be seen below.
 
 ### Command Argument Types
 
@@ -163,14 +165,14 @@ this.messageArg = this.withOptionalArg("message", "Message to print while healin
 
 ### Default Arguments
 
-Adding a default argument has two additional arguemnt for the default value and default value description. You need to use `withDefaultArg` method.
+Adding a default argument has two additional argument for the default value and default value description. You need to use `withDefaultArg` method.
 
 ```java
 // args <Command String> <Description> <Default Value> <Desc of default value>
 this.healthArg = this.withDefaultArg("health", "Amount to heal player", ArgTypes.FLOAT, (float)100, "Desc of Default: 100");
 ```
 
-### Flag Arguemnts
+### Flag Arguments
 
 Similar as above but the flags return is either true if it exists or false if it does not. You need to use `withFlagArg` method.
 
@@ -181,20 +183,13 @@ this.debugArg = this.withFlagArg("debug", "Add debug logs");
 
 ### ArgTypes
 
-The following ArgTypes are available (only lists common types):
-
-- `ArgTypes.STRING`
-- `ArgTypes.INTEGER`
-- `ArgTypes.BOOLEAN`
-- `ArgTypes.FLOAT`
-- `ArgTypes.DOUBLE`
-- `ArgTypes.UUID`
+You can find all the available argument types on the [ArgTypes](../../argtypes) page.
 
 ### Example Command Arg Types
 
-Shows all Command arguemnt types with different various input types.
+Shows all Command argument types with different various input types.
 
-**NOTE:** When getting the value of an argument during execute you need to pass the context with `someArg.get(commandContext)`. Where `commandContext` is the first variable in the execute funtion.
+**NOTE:** When getting the value of an argument during execute you need to pass the context with `someArg.get(commandContext)`. Where `commandContext` is the first variable in the execute function.
 
 ```java
 // Example usage: /healplayer --health 50 --message "Feels Good" --debug
@@ -204,7 +199,7 @@ public class HealPlayerCommand extends AbstractTargetPlayerCommand {
     private final FlagArg debugArg;
 
     public HealPlayerCommand() {
-        super("healplayer", "Healing a player for an <input> ammount of HP (default: 100)");
+        super("healplayer", "Healing a player for an <input> amount of HP (default: 100)");
 
         // Abstract TargetPlayerCommand passes the player that ran the command by default and implements
         // the use of `--player <value>` to specify someone else
@@ -213,10 +208,10 @@ public class HealPlayerCommand extends AbstractTargetPlayerCommand {
         this.healthArg = this.withDefaultArg("health", "Amount to heal player", ArgTypes.FLOAT, (float)100, "Desc of Default: 100");
 
         // Or you could do the following making the health value required instead of with a default.
-        //    You would need to change the decleration to RequiredArg<Float>
+        //    You would need to change the declaration to RequiredArg<Float>
         // this.healthArg = this.withRequiredArg("health", "Amount to heal player", ArgTypes.FLOAT);
 
-        // Optional args reguare the user the input `--<key> <value>` so the following would require `--message "Good Luck"`
+// Optional args require the user the input `--<key> <value>` so the following would require `--message "Good Luck"`
         this.messageArg = this.withOptionalArg("message", "Message to print while healing", ArgTypes.STRING);
 
         // No type needed due to being a bool
@@ -230,7 +225,7 @@ public class HealPlayerCommand extends AbstractTargetPlayerCommand {
             commandContext.sendMessage(Message.raw("We are debugging"));
         }
 
-        // Health is stored in a generic stat map to allowing mods/future contect to easily add more stats if desired.
+        // Health is stored in a generic stat map to allowing mods/future content to easily add more stats if desired.
         EntityStatMap stats = store.getComponent(ref, EntityStatMap.getComponentType());
         int healthIdx = DefaultEntityStatTypes.getHealth();
         EntityStatValue health = stats.get(healthIdx);
@@ -252,7 +247,7 @@ public class HealPlayerCommand extends AbstractTargetPlayerCommand {
 
 ## Argument Validators
 
-Argument validators are a way to check the command before the command gets executed. They are added with the `addValidator` method on an argument when calling `withXxxArg`. They provide a nice output to the user when an input value is invalid.
+Argument validators are a way to check the command before the command gets executed. They are added with the `addValidator` method on an argument when calling `withXxxArg`. They provide a nice output to the user when an input value is invalid. There are some common validators provided in the `Validators` class such as `greaterThan`, `lessThan`, and `or`, `max`, `range`, etc.
 
 ```java
 ...
@@ -260,18 +255,59 @@ Argument validators are a way to check the command before the command gets execu
     OptionalArg<Integer> healAmount = withOptionalArg("amount", "Heal Amount", ArgTypes.INTEGER)
         .addValidator(Validators.greaterThan(0))
         .addValidator(Validators.lessThan(1000));
-
-    // Custom check example
-    OptionalArg<Integer> healAmount = withOptionalArg("amount", "Heal Amount", ArgTypes.INTEGER)
-            .addValidator( value -> {
-                if (value != null && value <= 0) {
-                    return ValidationResult.error("ammount argument must be a positive number");
-                }
-                return ValidationResult.success();
-            });
 ...
 ```
 
+### Custom Validators
+
+You can also create custom validators by implementing the `com.hypixel.hytale.codec.validation.Validator` interface. The interfaces forces you to implement the `accept` and `updateSchema` method. The `accept` method takes in the argument value and validates it. If the validation fails, you can use the `fail` method of the `com.hypixel.hytale.codec.validation.ValidationResults` class to return an error message.
+The `updateSchema` method is used to update the schema of the command argument. This is used for commands that have dynamic schemas based on the input value. For example, if you have a command that takes in a player name as an argument, you can use the `updateSchema` method to update the schema to include a list of online players for validation.
+
+Here is an example of a custom validator that checks if a string value is equal to a banned word. In this example, the banned word is "badword". If the input value is "badword", the validator will fail and return an error message.
+
+```java
+import com.hypixel.hytale.codec.schema.SchemaContext;
+import com.hypixel.hytale.codec.schema.config.Schema;
+import com.hypixel.hytale.codec.validation.ValidationResults;
+import com.hypixel.hytale.codec.validation.Validator;
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+
+public class MyCustomValidator implements Validator<String> {
+    @Nonnull
+    private final String value;
+
+    public MyCustomValidator(@Nonnull String value) {
+        this.value = value;
+    }
+
+    @Override
+    public void accept(@Nullable String input, @Nonnull ValidationResults results) {
+        if (this.value.equalsIgnoreCase(input)) {
+            results.fail("The given role has been banned.");
+        }
+    }
+
+    @Override
+    public void updateSchema(SchemaContext context, @Nonnull Schema target) {
+        // This method can be used to update the schema of the command argument. This is useful for commands that have dynamic schemas based on the input value. For example, if you have a command that takes in a player name as an argument, you can use the `updateSchema` method to update the schema to include a list of online players for validation.
+        throw new UnsupportedOperationException("Not implemented yet.");
+    }
+}
+```
+
+After the custom validator is created, you can add it to an argument like the following example. In this example, we add the `MyCustomValidator` to a string argument called "role". If the user inputs "badword" as the role, the command will fail and return the error message defined in the `MyCustomValidator`.
+
+```java
+    ...
+    // Custom validator example
+    String bannedRole = "badword";
+
+    OptionalArg<String> roleArg = withOptionalArg("role", "Role to assign", ArgTypes.STRING)
+        .addValidator(new MyCustomValidator(bannedRole));
+    ...
+```
+
 ---
 
 ## Permissions
@@ -312,7 +348,7 @@ This allows the server to control who has access to specific commands. You add t
 
 If you want variants of the same command without doing argument parsing you can instead use `addUsageVariant(new OtherCommandClass())` in the original commands constructor.
 
-The only difference is in the `OtherCommandClass()` constrcutor you don't pass the command name to the super class.
+The only difference is in the `OtherCommandClass()` constructor you don't pass the command name to the super class.
 
 <Callout type="info">
   You can also use `addAliases("some_alias", "some_other_alias")` as a way to add shorthand or other ways to write the same command.
@@ -387,7 +423,7 @@ public class AdminCommand extends AbstractCommandCollection {
     public AdminCommand () {
         super("admin", "Admin commands");
         addSubCommand(new UserCommandCollection());
-        addSybCommand(new ServerCommandCollection);
+        addSubCommand(new ServerCommandCollection);
     }
 }
 ```
@@ -417,5 +453,5 @@ public class MyPlugin extends JavaPlugin {
 
 ## Video Link
 
-_Special Thanks to [TroubleDev](https://www.youtube.com/@TroubleDEV) for his excelent video guide on all of these features._
+_Special Thanks to [TroubleDev](https://www.youtube.com/@TroubleDEV) for his excellent video guide on all of these features._
 _Video Link: [TroubleDev - Hytale's Command API Explained](https://www.youtube.com/watch?v=KnmhG9MDMgo)_
diff --git a/content/docs/sq-AL/guides/plugin/creating-events.mdx b/content/docs/sq-AL/guides/plugin/creating-events.mdx
index 95863990..d3f0925d 100644
--- a/content/docs/sq-AL/guides/plugin/creating-events.mdx
+++ b/content/docs/sq-AL/guides/plugin/creating-events.mdx
@@ -1,6 +1,6 @@
 ---
-title: Creating Events
-description: Learn how to create custom events for your Hytale mod.
+title: Creating Events Listeners
+description: Learn how to create event listeners for your Hytale mod.
 authors:
   - name: Neil Revin
     url: https://itsneil.dev
@@ -10,7 +10,7 @@ authors:
 
 ## Event Class
 
-You can import a Event class and create a function with the Event as a argument. [Click here](../../server/events) to look at all available events.
+You can import an Event class and create a function with the Event as an argument. [Click here](../../server/events) to look at all available events.
 
 Example plugin when a player is ready (joins a server):
 
diff --git a/content/docs/sq-AL/guides/plugin/item-registry.mdx b/content/docs/sq-AL/guides/plugin/item-registry.mdx
new file mode 100644
index 00000000..9a0fd53a
--- /dev/null
+++ b/content/docs/sq-AL/guides/plugin/item-registry.mdx
@@ -0,0 +1,95 @@
+---
+title: Working with the Item Registry
+description: Learn how to access and query the game's item registry to list all items, check if items exist, and retrieve item properties.
+authors:
+  - name: Denis
+---
+
+In this guide, you'll learn how to work with Hytale's Item Registry system. This is useful when you need to programmatically list all available items, validate item IDs, or retrieve item properties at runtime.
+
+## Prerequisites
+
+Before diving in, you should be familiar with:
+
+- [Setting up your development environment](./setting-up-env)
+- [Creating commands](./creating-commands) (optional, for testing)
+
+## Required Imports
+
+To work with the Item Registry, you'll need the following imports:
+
+```java
+import com.hypixel.hytale.assetstore.map.DefaultAssetMap;
+import com.hypixel.hytale.server.core.asset.type.item.config.Item;
+```
+
+## Getting the Item Registry
+
+The Item Registry is accessed through the `Item.getAssetMap()` method, which returns a `DefaultAssetMap<String, Item>` containing all registered items in the game:
+
+```java
+DefaultAssetMap<String, Item> itemMap = Item.getAssetMap();
+```
+
+## Listing All Items
+
+To iterate through all items in the registry, you can get the underlying map and loop through its entries:
+
+```java
+DefaultAssetMap<String, Item> itemMap = Item.getAssetMap();
+var map = itemMap.getAssetMap();
+
+for (var entry : map.entrySet()) {
+    String itemId = String.valueOf(entry.getKey());
+    Item item = entry.getValue();
+    
+    // Do something with the item
+    LOGGER.atInfo().log("Item ID: " + itemId);
+}
+```
+
+You can also get the total count of registered items:
+
+```java
+int totalItems = map.size();
+```
+
+## Checking if an Item Exists
+
+To check if a specific item exists in the registry, use `getAsset()` and verify the result:
+
+```java
+public boolean itemExists(String itemId) {
+    var assetMap = Item.getAssetMap();
+    if (assetMap != null) {
+        Item item = assetMap.getAsset(itemId);
+        return item != null && item != Item.UNKNOWN;
+    }
+    return false;
+}
+```
+
+<Callout type="info">
+  The `Item.UNKNOWN` constant represents an invalid or unrecognized item. Always check for both `null` and `Item.UNKNOWN` when validating items.
+</Callout>
+
+## Accessing Item Properties
+
+Once you have an `Item` instance, you can access various properties:
+
+```java
+var assetMap = Item.getAssetMap();
+Item item = assetMap.getAsset("Soil_Grass");
+
+if (item != null && item != Item.UNKNOWN) {
+    String id = item.getId(); // Soil_Grass
+    int maxStack = item.getMaxStack(); // 100
+    boolean isBlock = item.hasBlockType(); // true
+    boolean isConsumable = item.isConsumable(); // false
+}
+```
+
+## Related Guides
+
+- [Inventory Management](./inventory-management) - Learn how to add and remove items from player inventories
+- [Create Custom Item and Interaction](./item-interaction) - Learn how to create your own custom items
diff --git a/content/docs/sq-AL/guides/plugin/permission-management.mdx b/content/docs/sq-AL/guides/plugin/permission-management.mdx
index 6b7cfd46..55f06101 100644
--- a/content/docs/sq-AL/guides/plugin/permission-management.mdx
+++ b/content/docs/sq-AL/guides/plugin/permission-management.mdx
@@ -10,132 +10,569 @@ authors:
     link: https://discord.com/users/292656109939064833
   - name: Ivan
     link: https://discord.com/users/505770451218333717
+  - name: ZenithDevHQ
+    link: https://github.com/ZenithDevHQ
 ---
 
-In this guide, you'll learn how to manage permission nodes and groups in your Hytale plugin.
+In this guide, you'll learn how to manage permission nodes and groups in your Hytale plugin. Permissions control what actions players can perform on your server, from basic commands to advanced administrative functions.
 
-## The `PermissionsModule` class
+## What Are Permissions?
 
-The `PermissionsModule` class is responsible for managing permission nodes and groups in your plugin. It provides methods to check, grant and revoke permissions and groups for players. It allows the following operations
+Permissions are string identifiers that control access to features and commands. When a player tries to perform an action (like using a command), the server checks if they have the required permission.
 
-- Add permissions to user
-- Remove permissions from user
-- Add permissions to group (this also creates the group if it doesn't exist)
-- Remove permissions from group
-- Add user to group
-- Remove user from group
-- List all groups for a user
-- Check if a user has a permission (it checks both user and group permissions for the given player UUID)
+**Example permission nodes:**
 
-With this class you cannot:
+- `hytale.command.gamemode` - Permission to use the gamemode command
+- `hytale.editor.brush.use` - Permission to use brush tools
+- `myplugin.teleport.home` - A custom permission for your plugin
 
-- List all defined groups
-- Remove a group
+Permissions follow a hierarchical naming pattern: `namespace.category.action`
 
-### Adding Permission Nodes
+## Key Concepts
 
-You need a `Set<String>` containing all the permission nodes you want to add, these are added on top of the already existing permission nodes the user may have, it is not a replacement.
+Before diving into code, let's understand the core concepts:
+
+| Concept             | Description                                                                |
+| ------------------- | -------------------------------------------------------------------------- |
+| **Permission Node** | A string like `myplugin.feature.use` that represents a specific permission |
+| **Group**           | A named collection of permissions (e.g., "Admin", "VIP", "Default")        |
+| **Provider**        | The backend that stores and retrieves permissions                          |
+| **Wildcard**        | A pattern like `*` or `myplugin.*` that matches multiple permissions       |
+
+### How Permissions Are Checked
+
+When checking if a player has a permission, Hytale follows this order:
+
+1. **User's direct permissions** - Permissions granted directly to the player
+2. **Group permissions** - Permissions from groups the player belongs to
+3. **Virtual groups** - Game-mode-based permissions (e.g., Creative mode grants builder tools)
+4. **Default value** - Falls back to `false` if no match found
+
+<Callout type="info">
+  The first definitive match wins. If a player has a permission granted at the user level, group permissions won't override it.
+</Callout>
+
+---
+
+## The `PermissionsModule` Class
+
+The `PermissionsModule` class is the central hub for managing permissions. Access it using the singleton pattern:
 
 ```java
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.addUserPermission(playerUUID, permissions);
 ```
 
-### Removing Permission Nodes
+### Available Operations
+
+The module supports these operations:
+
+| Operation                     | Method                                          |
+| ----------------------------- | ----------------------------------------------- |
+| Add permissions to user       | `addUserPermission(uuid, permissions)`          |
+| Remove permissions from user  | `removeUserPermission(uuid, permissions)`       |
+| Add permissions to group      | `addGroupPermission(groupName, permissions)`    |
+| Remove permissions from group | `removeGroupPermission(groupName, permissions)` |
+| Add user to group             | `addUserToGroup(uuid, groupName)`               |
+| Remove user from group        | `removeUserFromGroup(uuid, groupName)`          |
+| Get user's groups             | `getGroupsForUser(uuid)`                        |
+| Check permission              | `hasPermission(uuid, permissionNode)`           |
+
+<Callout type="warning">
+  The module does **not** support:
+
+  - Listing all defined groups
+  - Deleting a group entirely
+
+  Groups are implicitly created when you first add permissions to them.
+</Callout>
+
+---
 
-Same as above, we just use the `removeUserPermission` method instead to remove permission nodes.
+## Checking Permissions
+
+The most common operation is checking if a player has a permission.
+
+### Basic Permission Check
+
+```java
+// Returns true if player has the permission, false otherwise
+boolean canUse = PermissionsModule.get().hasPermission(playerUUID, "myplugin.feature.use");
+
+if (canUse) {
+    // Player has permission, allow the action
+} else {
+    // Player lacks permission, deny or show error
+}
+```
+
+### Permission Check with Default Value
+
+You can specify what to return when no permission is explicitly set:
+
+```java
+// Returns true by default if no explicit permission is found
+boolean canUse = PermissionsModule.get().hasPermission(playerUUID, "myplugin.feature.use", true);
+```
+
+This is useful for features that should be enabled by default but can be revoked.
+
+### Using PermissionHolder Interface
+
+Players and command senders implement `PermissionHolder`, allowing direct checks:
+
+```java
+// In a command or event handler where you have access to the player
+if (player.hasPermission("myplugin.admin.manage")) {
+    // Player has admin permission
+}
+```
+
+---
+
+## Managing User Permissions
+
+### Adding Permissions to a User
+
+Permissions are additive - new permissions are added on top of existing ones, not replaced.
+
+```java
+PermissionsModule perms = PermissionsModule.get();
+
+// Add a single permission
+perms.addUserPermission(playerUUID, Set.of("myplugin.vip.chat"));
+
+// Add multiple permissions at once
+Set<String> newPerms = Set.of(
+    "myplugin.vip.chat",
+    "myplugin.vip.fly",
+    "myplugin.vip.kit"
+);
+perms.addUserPermission(playerUUID, newPerms);
+```
+
+### Removing Permissions from a User
 
 ```java
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.removeUserPermission(playerUUID, permissions);
+
+// Remove specific permissions
+Set<String> toRemove = Set.of("myplugin.vip.fly");
+perms.removeUserPermission(playerUUID, toRemove);
 ```
 
-### Add permissions to group
+---
+
+## Managing Groups
+
+Groups let you assign a collection of permissions to multiple players. This is more manageable than assigning permissions individually.
+
+### Adding Permissions to a Group
+
+If the group doesn't exist, it will be created automatically.
 
 ```java
-String groupName = "testGroup";
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.addGroupPermission(groupName, permissions);
+
+// Create/update the "VIP" group with permissions
+Set<String> vipPerms = Set.of(
+    "myplugin.vip.chat",
+    "myplugin.vip.fly",
+    "myplugin.vip.kit"
+);
+perms.addGroupPermission("VIP", vipPerms);
 ```
 
-### Remove permissions from group
+### Removing Permissions from a Group
 
 ```java
-String groupName = "testGroup";
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.removeGroupPermission(groupName, permissions);
+
+// Remove specific permissions from the group
+Set<String> toRemove = Set.of("myplugin.vip.fly");
+perms.removeGroupPermission("VIP", toRemove);
 ```
 
-### Add user to group
+### Adding a User to a Group
 
 ```java
-String groupName = "testGroup";
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.addUserToGroup(playerUUID, groupName);
+
+// Add player to the VIP group - they now have all VIP permissions
+perms.addUserToGroup(playerUUID, "VIP");
 ```
 
-### Remove user from group
+### Removing a User from a Group
 
 ```java
-String groupName = "testGroup";
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.removeUserFromGroup(playerUUID, groupName);
+
+// Remove player from VIP group
+perms.removeUserFromGroup(playerUUID, "VIP");
 ```
 
-### List all groups for a user
+### Getting a User's Groups
 
 ```java
 PermissionsModule perms = PermissionsModule.get();
-perms.getGroupsForUser(playerUUID);
+
+// Get all groups the player belongs to
+Set<String> groups = perms.getGroupsForUser(playerUUID);
+
+for (String group : groups) {
+    System.out.println("Player is in group: " + group);
+}
 ```
 
-### Check Permission Nodes
+---
+
+## Built-in Groups
+
+Hytale includes two default groups:
+
+| Group     | Default Permissions   | Purpose                           |
+| --------- | --------------------- | --------------------------------- |
+| `OP`      | `*` (all permissions) | Server operators with full access |
+| `Default` | None                  | Base group for all players        |
+
+Players without any explicit group assignment are automatically part of the `Default` group.
 
-To check if a player has a specific permission node, you can use the `hasPermission` method.
+---
+
+## Wildcards
+
+Wildcards let you grant or deny multiple permissions with a single pattern.
+
+### Wildcard Patterns
+
+| Pattern             | Meaning                                          |
+| ------------------- | ------------------------------------------------ |
+| `*`                 | Grants **all** permissions                       |
+| `myplugin.*`        | Grants all permissions starting with `myplugin.` |
+| `-*`                | Denies **all** permissions                       |
+| `-myplugin.admin.*` | Denies all admin permissions in your plugin      |
+
+### Example: Admin Group with Wildcards
 
 ```java
-boolean hasPermission = PermissionsModule.hasPermission(playerUUID, "permission.node");
+// Grant all permissions to admins
+perms.addGroupPermission("Admin", Set.of("*"));
+
+// Grant all plugin permissions to moderators
+perms.addGroupPermission("Moderator", Set.of("myplugin.*"));
+
+// Grant all permissions except admin commands
+perms.addGroupPermission("Helper", Set.of(
+    "*",
+    "-myplugin.admin.*"  // Deny admin permissions
+));
 ```
 
-## Additional: Defining your own provider for permissions and groups
+<Callout type="warning">
+  Negation permissions (starting with `-`) take precedence at each level. Use them carefully to avoid accidentally blocking permissions.
+</Callout>
+
+---
+
+## Built-in Permission Nodes
+
+Hytale provides constants for common permissions in the `HytalePermissions` class:
+
+### Command Permissions
+
+```java
+// Generate permission for a command
+String perm = HytalePermissions.fromCommand("gamemode");
+// Result: "hytale.command.gamemode"
+
+// Generate permission for a subcommand
+String perm = HytalePermissions.fromCommand("gamemode", "creative");
+// Result: "hytale.command.gamemode.creative"
+```
+
+### Common Permission Nodes
+
+| Permission                    | Description                  |
+| ----------------------------- | ---------------------------- |
+| `hytale.command.op.add`       | Add players to OP group      |
+| `hytale.command.op.remove`    | Remove players from OP group |
+| `hytale.editor.brush.use`     | Use brush tools              |
+| `hytale.editor.prefab.use`    | Use prefabs                  |
+| `hytale.editor.selection.use` | Use selection tools          |
+| `hytale.editor.history`       | Undo/redo operations         |
+| `hytale.camera.flycam`        | Use fly camera mode          |
+
+---
+
+## Listening to Permission Events
+
+You can react to permission changes using Hytale's event system.
+
+### Available Events
+
+| Event                                            | Triggered When                   |
+| ------------------------------------------------ | -------------------------------- |
+| `PlayerPermissionChangeEvent.PermissionsAdded`   | Permissions added to a user      |
+| `PlayerPermissionChangeEvent.PermissionsRemoved` | Permissions removed from a user  |
+| `PlayerGroupEvent.Added`                         | User added to a group            |
+| `PlayerGroupEvent.Removed`                       | User removed from a group        |
+| `GroupPermissionChangeEvent.Added`               | Permissions added to a group     |
+| `GroupPermissionChangeEvent.Removed`             | Permissions removed from a group |
 
-The PermissionsModule also enables us to define our own PermissionProvider's, this can be useful for:
+### Example: Reacting to Permission Changes
 
-- Cross server permission systems
-- Implementing features missing in the `HytalePermissionsProvider` like permission expiry
+```java
+public class PermissionListener {
+
+    public static void onPermissionsAdded(PlayerPermissionChangeEvent.PermissionsAdded event) {
+        UUID playerUUID = event.getPlayerUuid();
+        Set<String> added = event.getAddedPermissions();
+
+        System.out.println("Permissions added to " + playerUUID + ": " + added);
 
-To implement our PermissionProvider, first we need to define a provider class that implements PermissionProvider:
+        // Maybe notify the player or update cached data
+    }
+
+    public static void onGroupAdded(PlayerGroupEvent.Added event) {
+        UUID playerUUID = event.getPlayerUuid();
+        String groupName = event.getGroupName();
+
+        System.out.println("Player " + playerUUID + " joined group: " + groupName);
+    }
+}
+```
+
+### Registering the Events
 
 ```java
-public class DatabasePermissionProvider implements PermissionProvider
+public class MyPlugin extends JavaPlugin {
+
+    @Override
+    public void setup() {
+        EventRegistry events = this.getEventRegistry();
+
+        events.registerGlobal(
+            PlayerPermissionChangeEvent.PermissionsAdded.class,
+            PermissionListener::onPermissionsAdded
+        );
+
+        events.registerGlobal(
+            PlayerGroupEvent.Added.class,
+            PermissionListener::onGroupAdded
+        );
+    }
+}
 ```
 
-Then we just implement the required methods using a database implementation.
+---
+
+## Creating a Custom Permission Provider
+
+For advanced use cases, you can create your own permission provider. This is useful for:
+
+- Database-backed permissions (MySQL, MongoDB, etc.)
+- Cross-server permission synchronization
+- Custom features like permission expiry or contexts
+
+### Implementing PermissionProvider
+
+```java
+public class DatabasePermissionProvider implements PermissionProvider {
+
+    @Nonnull
+    @Override
+    public String getName() {
+        return "DatabasePermissionProvider";
+    }
+
+    // User permission methods
+    @Override
+    public void addUserPermissions(@Nonnull UUID uuid, @Nonnull Set<String> permissions) {
+        // Save to your database
+    }
+
+    @Override
+    public void removeUserPermissions(@Nonnull UUID uuid, @Nonnull Set<String> permissions) {
+        // Remove from your database
+    }
+
+    @Override
+    public Set<String> getUserPermissions(@Nonnull UUID uuid) {
+        // Query your database
+        return Set.of();
+    }
+
+    // Group permission methods
+    @Override
+    public void addGroupPermissions(@Nonnull String group, @Nonnull Set<String> permissions) {
+        // Save to your database
+    }
+
+    @Override
+    public void removeGroupPermissions(@Nonnull String group, @Nonnull Set<String> permissions) {
+        // Remove from your database
+    }
+
+    @Override
+    public Set<String> getGroupPermissions(@Nonnull String group) {
+        // Query your database
+        return Set.of();
+    }
+
+    // User-group membership methods
+    @Override
+    public void addUserToGroup(@Nonnull UUID uuid, @Nonnull String group) {
+        // Save to your database
+    }
+
+    @Override
+    public void removeUserFromGroup(@Nonnull UUID uuid, @Nonnull String group) {
+        // Remove from your database
+    }
+
+    @Override
+    public Set<String> getGroupsForUser(@Nonnull UUID uuid) {
+        // Query your database
+        return Set.of("Default");
+    }
+}
+```
 
 <Callout type="warning">
-  Hytale will try to use the first available permissions provider to add/remove gamemode groups (i.e. `Creative`, `Adventure`).
+  Hytale automatically assigns players to game-mode groups (like `Creative` or `Adventure`) using the first available provider.
+
+  If your provider throws an error when the group doesn't exist, the player will be disconnected! Always handle missing groups gracefully.
+</Callout>
+
+### Registering Your Provider
 
-  If your provider throws an error (for instance, if the group does not exist) when the server is preparing the player, the player will be disconnected.
+```java
+public class MyPlugin extends JavaPlugin {
+
+    @Override
+    public void setup() {
+        // Add your provider alongside the default one
+        PermissionsModule.get().addProvider(new DatabasePermissionProvider());
+    }
+}
+```
+
+The `PermissionsModule` aggregates permissions from all registered providers. This means:
+
+- Permission checks query all providers
+- Write operations (add/remove) use the **first** provider
+
+### Replacing the Default Provider
+
+If you want full control, you can remove the default provider:
+
+```java
+public class MyPlugin extends JavaPlugin {
+
+    @Override
+    public void setup() {
+        PermissionsModule perms = PermissionsModule.get();
+
+        // Remove the default provider FIRST
+        perms.removeProvider(perms.getFirstPermissionProvider());
+
+        // Then add your provider
+        perms.addProvider(new DatabasePermissionProvider());
+    }
+}
+```
+
+<Callout type="info">
+  When you remove the default provider, the `/op self` command will stop working since it checks for provider tampering.
 </Callout>
 
-We can then register the provider using the built-in permission module:
+---
+
+## Best Practices
+
+### Permission Naming Conventions
+
+Follow the pattern: `namespace.category.action`
 
 ```java
-PermissionsModule.get().addProvider(new DatabasePermissionProvider());
+// Good - clear hierarchy
+"myplugin.admin.ban"
+"myplugin.user.teleport.home"
+"myplugin.vip.chat.color"
+
+// Bad - unclear structure
+"myplugin_ban"
+"teleport"
+"vipChatColor"
 ```
 
-Please note that the `HytalePermissionsProvider` will still be enabled alongside your provider.
-The `PermissionsModule` will aggregate groups and permissions from all available providers.
+### Use Constants for Permissions
 
-If you want to disable the default `HytalePermissionsProvider`, you can use:
+Define your permissions as constants to avoid typos:
 
 ```java
-// put this **before** you add your provider
-PermissionsModule.get().removeProvider(PermissionsModule.get().getFirstPermissionProvider());
+public final class MyPermissions {
+    public static final String ADMIN_BAN = "myplugin.admin.ban";
+    public static final String ADMIN_KICK = "myplugin.admin.kick";
+    public static final String USER_HOME = "myplugin.user.home";
+    public static final String VIP_FLY = "myplugin.vip.fly";
+}
+
+// Usage
+if (player.hasPermission(MyPermissions.ADMIN_BAN)) {
+    // ...
+}
 ```
+
+### Don't Over-Permission
+
+Only create permissions for actions that genuinely need access control. Not everything needs a permission check.
+
+### Thread Safety
+
+If you create a custom provider, ensure it's thread-safe. Permission checks can occur from multiple threads simultaneously. Use `ReadWriteLock` or `ConcurrentHashMap` for your data structures.
+
+---
+
+## In-Game Commands
+
+Hytale provides built-in commands for managing permissions:
+
+### `/op` Command
+
+| Command               | Description                                                        |
+| --------------------- | ------------------------------------------------------------------ |
+| `/op self`            | Toggle your own OP status (singleplayer or with `--allow-op` flag) |
+| `/op add <player>`    | Add a player to the OP group                                       |
+| `/op remove <player>` | Remove a player from the OP group                                  |
+
+### `/perm` Command
+
+Use `/perm --help` in-game for full usage. Common operations:
+
+| Command                                  | Description                   |
+| ---------------------------------------- | ----------------------------- |
+| `/perm user list <uuid>`                 | List user's permissions       |
+| `/perm user add <uuid> <perm>`           | Add permission to user        |
+| `/perm user remove <uuid> <perm>`        | Remove permission from user   |
+| `/perm user group list <uuid>`           | List user's groups            |
+| `/perm user group add <uuid> <group>`    | Add user to group             |
+| `/perm user group remove <uuid> <group>` | Remove user from group        |
+| `/perm group list <group>`               | List group's permissions      |
+| `/perm group add <group> <perm>`         | Add permission to group       |
+| `/perm group remove <group> <perm>`      | Remove permission from group  |
+| `/perm test <perm>`                      | Test if you have a permission |
+
+---
+
+## Summary
+
+You've learned how to:
+
+- **Check permissions** using `PermissionsModule.hasPermission()`
+- **Manage user permissions** with `addUserPermission()` and `removeUserPermission()`
+- **Work with groups** using `addGroupPermission()`, `addUserToGroup()`, etc.
+- **Use wildcards** like `*` and `myplugin.*` for bulk permissions
+- **Listen to events** for permission changes
+- **Create custom providers** for database-backed permissions
+
+For more advanced permission systems with features like inheritance, expiry, and contexts, we're looking into expanding this guide with advanced permission management techniques in the future.
diff --git a/content/docs/sq-AL/guides/plugin/setting-up-env.mdx b/content/docs/sq-AL/guides/plugin/setting-up-env.mdx
index d2718098..5be5e9e0 100644
--- a/content/docs/sq-AL/guides/plugin/setting-up-env.mdx
+++ b/content/docs/sq-AL/guides/plugin/setting-up-env.mdx
@@ -4,6 +4,10 @@ description: Learn how to set up your development environment for modding Hytale
 authors:
   - name: Neil Revin
     link: https://itsneil.dev
+  - name: Marcel-TO
+    url: https://marcel-to.net
+  - name: Ádám Liszkai
+    link: https://adaliszk.dev
 ---
 
 This guide will walk you through setting up a complete development environment for Hytale modding, including all necessary tools and dependencies.
@@ -19,24 +23,73 @@ Before we begin, make sure you have:
 
 ## Required Software
 
-### 1. Java Development Kit (JDK)
+### Integrated Development Environment (IDE)
 
+We recommend IntelliJ IDEA Community Edition for Hytale modding. If you use IntelliJ IDEA, **almost everything is built-in**. You can clone a template, open a new project, and start working right away!
+
+1. Download from [JetBrains website](https://www.jetbrains.com/idea/download/)
+2. Install with default settings
+3. Launch and complete the initial setup wizard
+
+When opening a project, wait for indexing to finish, then start coding.
+Now, IDEA may say "No JDK configured" at the top of the source file you have.
+In that case, you can click Download JDK and choose JetBrains JDK 25.
+
+<Callout type="success">
+  If IDEA opened the project without errors, your environment is ready.
+</Callout>
+
+More details by [JetBrains](https://www.jetbrains.com/help/idea/2026.1/run-for-the-first-time.html)
+help page, where we recommend that you also check the
+[SDK configuration](https://www.jetbrains.com/help/idea/2026.1/sdk.html) guide.
+
+<Callout type="info">
+  We recommened following
+  [TheNullicorn's](https://gist.github.com/TheNullicorn/90a619796c40f20ae1fcf13094c1a57d) guide to ensure
+  you are using the correct `Nonnull` in your projects.
+</Callout>
+
+#### What the IDE Does for You
+
+When opened in IntelliJ IDEA, the project automatically:
+
+- Detects and configures Gradle or Maven
+- Downloads all dependencies
+- Sets up project structure and classpaths
+- Configures run/build tasks
+
+You do **not** need to manually install or configure Maven or Gradle if you stay inside the IDE.
+
+Skip to the [Setting Up Your Workspace](#setting-up-your-workspace).
+
+### Manual Setup: Java Development Kit (JDK)
+
+For any other setup, you will need to install and configure your system to have and load Java.
 Hytale modding requires Java 25 or later. We recommend using OpenJDK.
 
-#### Windows
+#### Windows via Installer
 
 1. Download OpenJDK 25 from [Adoptium](https://adoptium.net/)
 2. Run the installer with default settings
+   - Optionally enable feature `Set or Override JAVA_HOME variable` to resolve version related build issues with your project.
 3. Verify installation by opening Command Prompt and running:
 
+#### Windows via Scoop
+
+1. Install Scoop via PowerShell using [scoop.sh](https://scoop.sh/)
+2. Install OpenJDK 25:
+
 ```bash
-java -version
+scoop bucket add java
+scoop install java/openjdk25
 ```
 
 #### macOS
 
+1. Install Brew via Terminal using [brew.sh](https://brew.sh)
+2. Install JDK via Homebrew:
+
 ```bash
-# Using Homebrew
 brew install openjdk@25
 ```
 
@@ -51,22 +104,41 @@ brew install openjdk@25
 
 #### Linux (Ubuntu/Debian)
 
+1. Install JDK via the built-in package repository:
+
 ```bash
 sudo apt update
 sudo apt install openjdk-25-jdk
 ```
 
-### 2. Integrated Development Environment (IDE)
+### Verify installation:
 
-We recommend IntelliJ IDEA Community Edition for Hytale modding.
+Run the following command to see what version of Java you have:
 
-1. Download from [JetBrains website](https://www.jetbrains.com/idea/download/)
-2. Install with default settings
-3. Launch and complete the initial setup wizard
+```bash
+java -version
+```
+
+### Java Build Tool (Optional)
+
+We recommend using a Gradle Wrapper for managing dependencies and building your Hytale plugins. It provides benefits by eliminating the need for a system-wide Gradle installation and ensuring consistent Gradle versions across different environments. (Alternatively you can use Maven, but this guide focuses on Gradle since it is the default for our plugin template.)
+
+The plugin template in the following sections includes a Gradle Wrapper, so you can skip this step if you plan to use the template.
+
+#### Choosing Gradle (if not using the template)
+
+If you prefer to install Gradle manually, follow these steps:
 
-### 3) Java Build Tool
+1. Visit the official website: https://gradle.org/releases/
+2. Download the newest gradle binary: `gradle-9.3.1-bin.zip` (Binary zip archive)
+3. Unzip it
+4. Add the `gradle-9.3.1/bin/` folder to your PATH
+
+You can now try the command `gradle -version` to verify Gradle is installed correctly. Make sure to do this in a fresh new terminal instead of one you had opened from before!
+
+#### Choosing Maven (if not using the template)
 
-We recommend using Apache Maven for managing dependencies and building your Hytale plugins. (Alternatively you can use Gradle, but this guide focuses on Maven.)
+If you prefer to use Maven instead of Gradle, follow these steps to install Maven:
 
 1. Visit the official website: https://maven.apache.org/download.cgi
 2. Download this file: `apache-maven-3.9.12-bin.zip` (Binary zip archive)
@@ -89,22 +161,61 @@ cd MyFirstMod
 
 If you don't have Git installed, you can download the ZIP file from the repository page and extract it to a folder named `MyFirstMod`.
 
-### 2. Open Plugin in your IDEA
+### 2. Open Plugin in your IDE
 
-1. Open IntelliJ IDEA
+1. Open Your IDE (e.g., IntelliJ IDEA)
 2. Click "Open" and navigate to your `MyFirstMod` directory
-3. IntelliJ will automatically detect it as a Maven project
+3. Most IDEs like IntelliJ will automatically detect it as a Gradle project
 4. Wait for the project to index and dependencies to download
 
-<Callout type="info">
-  We recommened following [this](https://gist.github.com/TheNullicorn/90a619796c40f20ae1fcf13094c1a57d) guide to ensure you are using the correct `Nonnull` in your projects.
-</Callout>
+## Alternate Approach: Hytale Dependency
+
+If you prefer to set up your project from scratch without using the template and importing the hytale dependencies manually, ensure your build configuration includes the Hytale repositories and dependencies:
+
+For Gradle, add the following to your `build.gradle.kts`:
+
+```kotlin
+repositories {
+    mavenCentral()
+    maven {
+        name = "hytale"
+        url = uri("https://maven.hytale.com/release") // Or "hytale-pre-release" for pre-release versions
+    }
+}
+dependencies {
+    // + here means the latest version, but you can hard-wire any known version!
+    implementation("com.hypixel.hytale:Server:+")
+}
+```
+
+For Maven, add the following to your `pom.xml`:
+
+```xml
+<project>
+    <repositories>
+        <repository>
+            <id>hytale-release</id> <!-- Or "hytale-pre-release" for pre-release versions -->
+            <url>https://maven.hytale.com/release</url> <!-- Or "https://maven.hytale.com/pre-release" -->
+        </repository>
+    </repositories>
+
+    <dependencies>
+        <dependency>
+            <groupId>com.hypixel.hytale</groupId>
+            <artifactId>Server</artifactId>
+            <!-- Replace with latest version, Hytale provides jars for the last five releases -->
+            <version>LATEST_VERSION_HERE</version>
+            <scope>provided</scope>
+        </dependency>
+    </dependencies>
+</project>
+```
 
 ## Next Steps
 
 Now that you have your development environment set up with the plugin template:
 
-1. **Customize the template** - Edit the `pom.xml` and `manifest.json` file to change your mod's name and details
+1. **Customize the template** - Edit the `settings.gradle.kts`, `build.gradle.kts` and `manifest.json` file to change your mod's name and details
 2. **Explore the code structure** - Familiarize yourself with the template's organization
 3. **Start modding** - Begin writing your first Hytale plugin!
 
diff --git a/content/docs/sq-AL/guides/plugin/spawning-entities.mdx b/content/docs/sq-AL/guides/plugin/spawning-entities.mdx
index e12c0aea..15be2fb3 100644
--- a/content/docs/sq-AL/guides/plugin/spawning-entities.mdx
+++ b/content/docs/sq-AL/guides/plugin/spawning-entities.mdx
@@ -36,7 +36,7 @@ Store<EntityStore> store = world.getEntityStore().getStore();
 
 ## Creating Entities
 
-Once you have the `EntityStore` instance, you can start to create a entity and give it components. Entities are just instances of `Holder<EntityStore>` with several components attached to them.
+Once you have the `EntityStore` instance, you can start to create an entity and give it components. Entities are just instances of `Holder<EntityStore>` with several components attached to them.
 
 <Callout type="warning">
   To interact with the `World` instance, some methods require you to run the code inside the world's execution context.
@@ -118,3 +118,48 @@ Finally, we can add the entity to the world by calling the `addEntity` method on
 ```java
 store.addEntity(holder, AddReason.SPAWN);
 ```
+
+## Making the entity persist
+
+Hytale automatically saves all entities, but the `NetworkId` component (required for players to be able to see the entity) needs to be manually added every time the entity is loaded.
+
+### Using a system
+
+If you have a component that is unique to your entities, this can be done by creating and registering a custom system as follows:
+
+```java
+public class AddNetworkIdToMyEntitySystem extends HolderSystem<EntityStore> {
+    private final ComponentType<EntityStore, MyEntityComponent> myEntityComponentType = MyEntityComponent.getComponentType();
+    private final ComponentType<EntityStore, NetworkId> networkIdComponentType = NetworkId.getComponentType();
+    private final Query<EntityStore> query = Query.and(this.myEntityComponentType, Query.not(this.networkIdComponentType));
+
+    @Override
+    public void onEntityAdd(@NotNull Holder<EntityStore> holder, @NotNull AddReason reason, @NotNull Store<EntityStore> store) {
+        if (!holder.getArchetype().contains(NetworkId.getComponentType())) {
+            holder.addComponent(NetworkId.getComponentType(), new NetworkId(store.getExternalData().takeNextNetworkId()));
+        }
+    }
+
+    @Override
+    public void onEntityRemoved(@NotNull Holder<EntityStore> holder, @NotNull RemoveReason reason, @NotNull Store<EntityStore> store) {}
+
+    @Override
+    public @Nullable Query<EntityStore> getQuery() {
+        return query;
+    }
+}
+```
+
+In your plugin's `setup()` function
+
+```java
+this.getEntityStoreRegistry().registerSystem(new AddNetworkIdToMyEntitySystem())
+```
+
+### Using PropComponent
+
+Alternatively you can add `PropComponent` to your entity. Hytale adds `PropComponent` to entities spawned with the Entity Tool, and such entities automatically get `NetworkId` and `PrefabCopyableComponent` (which makes the entity work with prefabs).
+
+<Callout type="warning">
+  There is no guarantee, that Hytale will not add some other behavior to this component in the future, which may break your entity, so be careful if you decide to rely on it.
+</Callout>
diff --git a/content/docs/sq-AL/guides/plugin/store-persistent-data.mdx b/content/docs/sq-AL/guides/plugin/store-persistent-data.mdx
new file mode 100644
index 00000000..1071dff3
--- /dev/null
+++ b/content/docs/sq-AL/guides/plugin/store-persistent-data.mdx
@@ -0,0 +1,171 @@
+---
+title: Storing Persistent Data on the Player
+description: Learn how to save and load persistent data using Components
+authors:
+  - name: Neil Revin
+    url: https://itsneil.dev/
+  - name: ArcticDev
+    url: https://github.com/ArcticRaven
+  - name: oskarscot
+    url: https://oskar.scot
+  - name: JammingEng
+    url: https://github.com/JammingEnd
+---
+
+Here is how to store persistent data using a custom component on a Player.
+
+## Build your Component Class
+
+Creating a custom component class leverages the Component system made with the ECS architecture in mind. For more information on Components, check out the [ECS Guide](../ecs/hytale-ecs-theory#components).
+
+Start by creating your custom component class. This will be extremely similar to how regular components are created, however we'll setup a custom Codec so the server can translate this data to BSON, or the server's internal json encoder.
+
+<Callout type="info">
+  Each variable you want to store in your component must have its own Codec field defined in the BuilderCodec.
+  For more information on how to create custom Codecs, check out the [ECS Codec Guide](../ecs/hytale-ecs-theory#codec).
+</Callout>
+
+```java
+public class YourPlayerData implements Component<EntityStore> {
+
+    // define some vars!
+    private int someInteger;
+    private String someString;
+    private Map<String, String> someMap;
+
+    public static final BuilderCodec<YourPlayerData> CODEC =
+            BuilderCodec.builder(YourPlayerData.class, YourPlayerData::new)
+            .append(new KeyedCodec<>("SomeInteger", Codec.INTEGER),
+                    (data, value) -> data.someInteger = value, // setter
+                    data -> data.someInteger) // getter
+            .addValidator(Validators.nonNull())
+            .add()
+            .append(new KeyedCodec<>("SomeString", Codec.STRING),
+                    (data, value) -> data.someString = value, // setter
+                    data -> data.someString) // getter
+            .add()
+            .append(new KeyedCodec<>("SomeMap",
+                            new MapCodec<>(Codec.STRING, HashMap::new, false)),
+                    (data, value) -> data.someMap = value, // setter
+                    data -> data.someMap) // getter
+            .add()
+            .build();
+
+
+
+    // Getters and Setters are for the purpose of this example omitted.
+
+    // constructor
+    public YourPlayerData() {
+        this.someInteger = 0;
+        this.someString = "";
+        this.someMap = new HashMap<>();
+    }
+
+    // copy constructor for cloning
+    public YourPlayerData(YourPlayerData clone) {
+        this.someInteger = clone.someInteger;
+        this.someString = clone.someString;
+        this.someMap = clone.someMap;
+    }
+
+    @Nonnull
+    @Override
+    public Component<EntityStore> clone() {
+        return new YourPlayerData(this);
+    }
+}
+```
+
+## Register your Component
+
+Inside your main class's `setup()` method, register your new Component.
+
+```java
+public class YourPlugin extends JavaPlugin {
+
+    private ComponentType<EntityStore, YourPlayerData> yourPlayerDataComponent;
+
+    public YourPlugin(@Nonnull JavaPluginInit init) {
+        super(init);
+    }
+
+    @Override
+    protected void setup(){
+        this.yourPlayerDataComponent = this.getEntityStoreRegistry().registerComponent(
+            YourPlayerData.class,
+            "YourPlayerDataComponent",
+            YourPlayerData.CODEC
+        );
+    }
+
+    public ComponentType<EntityStore, YourPlayerData> getYourPlayerDataComponent() {
+        return this.yourPlayerDataComponent;
+    }
+}
+```
+
+## Using your Component
+
+To use your newly created component, you can add the Component to a player using the `addComponent` method, although this only adds it temporarily, meaning when the player/entity leaves the world, the component is removed. You can use `putComponent` to ensure the component persists between sessions.
+
+```java
+// You will need the Ref and Store to apply components
+private void someEntryMethod(@Nonnull Ref<EntityStore> ref, @Nonnull Store<EntityStore> store)
+{
+       // Any entity will work, for now we will use the player
+      Player player = (Player) store.getComponent(ref, Player.getComponentType());
+
+      // since we're using putComponent, it could be useful to check if it already exists on the player in case we want to update it
+     if(store.getComponent(ref, YourPlugin.instance().getYourPlayerDataComponent()) != null)
+     {
+          // here we implement logic that updates the component
+         var comp = store.getComponent(ref, YourPlugin.instance().getYourPlayerDataComponent())
+         // declare public fields or methods in the component class
+         comp.SomeString = "An Updated Field";
+     } else {
+          // Here we put the component
+          var myCustomComp = new CustomComponent();
+          // declare public fields or methods in the component class
+          myCustomComp.SomeString = "Edited String";
+
+          // putComponent allows you to insert declared objects
+          store.putComponent(ref, YourPlugin.instance().getYourPlayerDataComponent(), myCustomComp);
+     }
+}
+```
+
+## Using your Data
+
+Your component will be stored within the `Store<EntityStore>` when added to the player. In the provided example,
+we'll fetch this data off the player using the `ensureAndGetComponent()` method, which will add the component to
+the player if it does not exist with the default values.
+
+```java
+public class IncompleteCustomCommand extends AbstractPlayerCommand {
+
+    public IncompleteCustomCommand() {
+        super("nope", "don't use this command");
+    }
+
+    @Override
+    protected void execute(
+        @NonNullDecl CommandContext commandContext,
+        @NonNullDecl Store<EntityStore> store,
+        @NonNullDecl Ref<EntityStore> ref,
+        @NonNullDecl PlayerRef playerRef,
+        @NonNullDecl World world
+    ) {
+        YourPlayerData customData = store.ensureAndGetComponent(ref, YourPlugin.instance().getYourPlayerDataComponent());
+        // ensureAndGetComponent adds the component to the ref, with the default values defined inside your component.
+ 		// use your data
+    }
+}
+```
+
+And that's it! Your data will now be saved and loaded automatically with the player.
+
+Using custom components to store persistent data on players is a powerful way to maintain state across sessions.
+By following the steps outlined above, you can easily create, register, and utilize your own data structures within the Hytale ECS framework.
+This approach ensures that your data is seamlessly integrated with the game's existing systems.
+For more information about Hytale's Entity Component System visit the [Hytale ECS Theory](https://hytalemodding.dev/en/docs/guides/ecs/hytale-ecs-theory) guide.
diff --git a/content/docs/sq-AL/guides/plugin/teleporting-players.mdx b/content/docs/sq-AL/guides/plugin/teleporting-players.mdx
index 57cee77f..32ce0435 100644
--- a/content/docs/sq-AL/guides/plugin/teleporting-players.mdx
+++ b/content/docs/sq-AL/guides/plugin/teleporting-players.mdx
@@ -1,26 +1,32 @@
 ---
 title: Teleporting the player
 description: Learn how to teleport the player.
+authors:
+  - name: oskarscot
+    url: https://oskar.scot
 ---
 
-To teleport players in Hytale, you will need to get a `World` object so we can safely run the teleport on the world thread. The world thread manages all entity updates, so modifying entities off-thread can crash the server or cause inconsistent state.
-Next, we get the entity store and make a `Teleport` object.
-We add a `Teleport` component to the player’s entity reference in the entity store. This triggers the teleportation logic for that player.
+Teleporting players in Hytale works by simply attaching a `Teleport` component to a player with the desired world and transform.
+You can only trigger teleports from a world where the player is currently present.
+Teleport itself is a component but it also provides factory methods to configure the Teleport. Just as with any entity component, an EntityStore and a Ref to the EntityStore is required
+
+We can create a simple teleport utility like this:
 
 ```java
-public static void teleportPlayer(Player player, int x, int y, int z) {
-        World world = player.getWorld();
-        if (world == null) return;
-        world.execute(() -> {
-            if (player.getReference() == null) return;
-            Store<EntityStore> store = player.getReference().getStore();
-            Teleport teleport = Teleport.createForPlayer(world,
-                new Vector3d(x ,y, z), // Target position
-                new Vector3f(0, 0, 0)  // Target rotation (pitch, yaw, roll)
-            );
+public static void teleportPlayer(Ref<EntityStore> ref, Store<EntityStore> store, World targetWorld, double x, double y, double z) {                                                                                       
+    Transform transform = new Transform(x, y, z);                                                                                                                           
+    Teleport teleport = Teleport.createForPlayer(targetWorld, transform);                                                                                                   
+    store.addComponent(ref, Teleport.getComponentType(), teleport);                                                                                                         
+}  
+```
 
-            store.addComponent(player.getReference(), Teleport.getComponentType(), teleport);
-        });
+A `Transform` is a representation of a position Vector3d and rotation Vector3f which works in the following way:
 
-}
+```java
+Transform transform = new Transform(
+    new Vector3d(x, y, z),      // Position
+    new Rotation(yaw, pitch, 0) // Rotation, last value seems to always be 0
+);
+Teleport teleport = Teleport.createForPlayer(targetWorld, transform);
+store.addComponent(ref, Teleport.getComponentType(), teleport);
 ```
diff --git a/content/docs/sq-AL/guides/plugin/tracking-mod-analytics-with-hstats.mdx b/content/docs/sq-AL/guides/plugin/tracking-mod-analytics-with-hstats.mdx
new file mode 100644
index 00000000..45c022e0
--- /dev/null
+++ b/content/docs/sq-AL/guides/plugin/tracking-mod-analytics-with-hstats.mdx
@@ -0,0 +1,65 @@
+---
+title: Tracking Mod Analytics with HStats
+description: Learn how you can track Analytics for your Hytale Mod for Free using hstats.dev
+authors:
+  - name: Al3x
+    url: https://hstats.dev
+---
+
+In this guide, you will learn how to integrate HStats into your Plugin/Mod which will allow you to track how many Servers are using it along with other stats.
+
+<Callout type="info">
+  HStats is a third-party tool and is not affiliated with HytaleModding or Hypixel Studios
+</Callout>
+
+# Step 1: Register your Mod to HStats
+
+Before you touch any code, you will need to add your mod to the HStats website which will give you a UUID for your mod.
+
+- Create or Login to an Account on https://hstats.dev
+- Navigate to the dashboard page (https://hstats.dev/dashboard)
+- On the left, type in your mod's name and click "Add Mod"
+- Keep note of the UUID generated for later.
+
+# Step 2: Add the HStats Class to Your Project
+
+To keep things simple, HStats uses a single Java class file that handles everything for you.
+
+- Download / Copy the File from the GitHub page (https://github.com/hstats-dev/HStatsExamplePlugin/blob/main/src/main/java/com/al3x/HStats.java)
+- Paste into your Project. You should now have a HStats.java file somewhere in your projects directory.
+- Update the package name from com.al3x to whatever fits your project.
+
+# Step 3: Initialize HStats in your code
+
+You only need to add one line of code to your mod's setup method in your main class to start tracking.
+
+`new HStats("YOUR-MOD-UUID", "1.0.0");`
+
+Replace `YOUR-MOD-UUID` with the Mod UUID we made note of earlier and change the `1.0.0` version to whatever version your mod is currently on.
+
+Your setup method should now look something like this:
+
+```java
+@Override
+protected void setup() {
+  super.setup();
+  new HStats("c34a2b2a-afd8-4d6a-821e-7a63e12c5ea6", "1.0.0");
+}
+```
+
+# Extras
+
+Your done! Your mod should now be listed under the Mods page (https://hstats.dev/mods) as well as under your dashboard.
+
+Servers using your mod should now post updates about every minute to HStats which you can view in the Dashboard.
+
+### Embeds
+
+HStats allows you to generate an Embed Card that you can place on your CurseForge or GitHub page. This is useful for server owners to be able to see how many other servers are using your mod.
+
+- In your dashboard, scroll down to the Embed Card section.
+- Customize the appearance (Light/Dark mode, layout, etc).
+- Copy the generated URL to display your "Active Servers" and "Players Online" live on your mod's description page
+
+Heres an example of what they look like:
+![HStats Example](https://api.hstats.dev/api/embed/d52fa672-6966-47b2-b501-1a11bddebac3/card.svg?theme=light\&layout=compact\&size=md\&show_id=true\&dark=false)
diff --git a/content/docs/sq-AL/guides/plugin/world-gen.mdx b/content/docs/sq-AL/guides/plugin/world-gen.mdx
index 4c23b0c9..7b193ffd 100644
--- a/content/docs/sq-AL/guides/plugin/world-gen.mdx
+++ b/content/docs/sq-AL/guides/plugin/world-gen.mdx
@@ -100,7 +100,7 @@ Biome biome = biomeGen.generateBiomeAt(zoneResult, seed, x, z);
 
 ### Zone & Cave Integration
 
-Each zone defines it's own cave patterns:
+Each zone defines its own cave patterns:
 
 ```java
 Zone zone = /* ... */;
diff --git a/content/docs/sq-AL/guides/prefabs.mdx b/content/docs/sq-AL/guides/prefabs.mdx
index 08404b30..b1a55109 100644
--- a/content/docs/sq-AL/guides/prefabs.mdx
+++ b/content/docs/sq-AL/guides/prefabs.mdx
@@ -14,7 +14,7 @@ Prefabs are Hytale's way of creating reusable structures.
 There are a few fundamental concepts to understand about prefabs:
 
 - Users interact with prefabs via a prefab editing world.
-- Prefabs the physical structures in the game world, and are saved as JSON files.
+- Prefabs are the physical structures in the game world, and are saved as JSON files.
 
 ## How to Create a Prefab
 
diff --git a/content/docs/sq-AL/official-documentation/custom-ui/common-styling.mdx b/content/docs/sq-AL/official-documentation/custom-ui/common-styling.mdx
new file mode 100644
index 00000000..c36e3e3a
--- /dev/null
+++ b/content/docs/sq-AL/official-documentation/custom-ui/common-styling.mdx
@@ -0,0 +1,50 @@
+---
+title: Common Styling
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# Common Styling
+
+## Common UI Styling Library
+
+This document describes the shared UI components and styles defined in `Common.ui`.
+
+---
+
+### Styles
+
+We are providing some styles that can be re-used in any custom UI that, provide a cohesive UI experience with the core game UI. These styles are available in the `Common.ui` file.
+
+You can find a list of all the styles defined with live examples by running the `/ui-gallery` command ingame.
+
+<Callout type="warning">
+  This command is not available yet, but will be in a future patch.
+</Callout>
+
+![Gallery](/assets/official-documentation/ui/gallery.png)
+
+### Importing
+
+To use these styles in your UI file:
+
+```
+$Common = "Common.ui";
+
+// Then reference styles and components:
+$Common.@TextButton { @Text = "My Button"; }
+$Common.@Container { ... }
+```
+
+<Callout type="info">
+  The `Common.ui` file is at `Common/UI/Custom/Common.ui` within the Hytale pack. If your custom ui document is in a subfolder of `Common/UI/Custom/`, reference it via relative path traversal:
+
+  ```
+  $Common = "../Common.ui";
+  ```
+
+  You can find more info about paths [here](markup#path).
+</Callout>
diff --git a/content/docs/sq-AL/official-documentation/custom-ui/index.mdx b/content/docs/sq-AL/official-documentation/custom-ui/index.mdx
new file mode 100644
index 00000000..f94c4e88
--- /dev/null
+++ b/content/docs/sq-AL/official-documentation/custom-ui/index.mdx
@@ -0,0 +1,125 @@
+---
+title: Custom UI
+icon: LayoutDashboard
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# Custom UI
+
+## What is Custom UI?
+
+Custom UI is Hytale's framework for creating **custom user interfaces** controlled by the game server. Unlike the built-in Client UI (which is part of the game client and cannot be modified), Server UI allows you to create interactive screens and HUD overlays through Java plugins and asset packs.
+
+As a modder, Custom UI gives you the power to:
+
+- **Create custom interactive pages** - Shop interfaces, quest dialogs, server settings menus, admin panels
+- **Add custom HUD overlays** - Quest trackers, status displays, custom health bars, server information
+- **Design with markup** - Use `.ui` files to define reusable UI templates
+- **Handle user interactions** - Respond to button clicks, form submissions, and other events
+- **Localize your UI** - Support multiple languages using the game's translation system
+
+## How Custom UI Fits Into Hytale's UI
+
+Hytale's user interface is divided into two main categories:
+
+### Client UI (Not Moddable)
+
+Built-in interfaces controlled by the C# game client:
+
+- Main menu and settings
+- Character creation
+- Built-in HUD (health, hotbar, chat)
+- Inventory and crafting screens
+- Development tools
+
+**You cannot modify these** - they are part of the core game client.
+
+### In-Game UI (Moddable via Server)
+
+Server-controlled interfaces that you can create and customize:
+
+#### Custom Pages
+
+Full-screen interactive overlays that appear during gameplay:
+
+- Can be dismissed by the player (ESC key)
+- Capture all input (keyboard and mouse)
+- Support loading states while waiting for server responses
+- Perfect for: shops, dialogs, menus, configuration screens
+
+#### Custom HUDs
+
+Persistent overlay elements drawn on top of the game world:
+
+- Display-only (no user interaction)
+- Always visible during gameplay
+- Lightweight and non-intrusive
+- Perfect for: quest objectives, status indicators, server info panels
+
+## Architecture Overview
+
+Server UI uses a **command-based architecture**:
+
+```
+┌─────────────────────┐         ┌──────────────────────┐
+│   Java Server       │         │    C# Client         │
+│   (Your Plugin)     │         │    (Game)            │
+├─────────────────────┤         ├──────────────────────┤
+│                     │         │                      │
+│ InteractiveCustomUI │         │   CustomPage or      │
+│ Page                │         │   CustomHud          │
+│   ↓ build()         ├────────→│     ↓ Apply          │
+│ UICommandBuilder    │         │   Element Tree       │
+│   - append()        │         │     ↓ Layout         │
+│   - set()           │         │   Rendered UI        │
+│   - clear()         │         │                      │
+│                     │         │                      │
+│ ↓ handleDataEvent() │← Events │   User Interaction   │
+│   Process input     │         │   (click, type, etc) │
+│   sendUpdate()      │         │                      │
+└─────────────────────┘         └──────────────────────┘
+```
+
+**The flow:**
+
+1. Your Java code builds UI using `UICommandBuilder`
+2. Commands are sent to the client as data
+3. Client parses `.ui` markup files and creates visual elements
+4. User interacts with the UI
+5. Events are sent back to your Java code
+6. You process events and send updates back
+
+## Key Principles
+
+### Declarative, Not Imperative
+
+You don't create UI objects directly. Instead, you send **commands** that describe what you want:
+
+- "Append this button template to that container"
+- "Set this label's text to 'Hello World'"
+- "Clear all children from this list"
+
+### Asset-Driven
+
+UI structure is defined in `.ui` markup files (assets), not hardcoded in Java. This enables:
+
+- Designers to modify layouts without touching code
+- Reusable UI components
+- Consistent visual language
+
+### Event-Driven
+
+User interactions trigger events that flow back to your server code. You register event bindings and handle them in `handleDataEvent()`.
+
+### Selector-Based
+
+You target specific UI elements using **selectors:**
+
+- `#MyButton` - Element with ID "MyButton"
+- `#List[0]` - First child of element "List"
+- `#List[0] #Title` - Element with ID "Title" in the first child of element "List"
+- `#Label.TextColor` - The TextColor property of element "Label"
diff --git a/content/docs/sq-AL/official-documentation/custom-ui/layout.mdx b/content/docs/sq-AL/official-documentation/custom-ui/layout.mdx
new file mode 100644
index 00000000..0a24ca09
--- /dev/null
+++ b/content/docs/sq-AL/official-documentation/custom-ui/layout.mdx
@@ -0,0 +1,492 @@
+---
+title: Layout
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# Layout
+
+The layout system determines how UI elements are positioned and sized on screen. Understanding layout is crucial for creating well-structured, responsive interfaces.
+
+## Layout Fundamentals
+
+Every UI element has:
+
+- **Container Rectangle** - The space allocated by the parent
+- **Anchor** - How the element positions/sizes itself within the container
+- **Padding** - Inner spacing that affects child layout
+- **LayoutMode** - How the element arranges its children (if it's a container)
+
+```
+┌─────────────────────────────────────┐
+│  Container Rectangle (from parent)  │
+│  ┌───────────────────────────────┐  │
+│  │  Anchored Rectangle           │  │
+│  │  ┌─────────────────────────┐  │  │
+│  │  │ Padding                 │  │  │
+│  │  │  ┌───────────────────┐  │  │  │
+│  │  │  │  Content Area     │  │  │  │
+│  │  │  └───────────────────┘  │  │  │
+│  │  └─────────────────────────┘  │  │
+│  └───────────────────────────────┘  │
+└─────────────────────────────────────┘
+```
+
+## Anchor
+
+`Anchor` controls how an element positions and sizes itself within its container rectangle.
+
+### Fixed Size
+
+```
+Button {
+    Anchor: (Width: 200, Height: 40);
+}
+```
+
+Creates a 200×40 pixel button.
+
+### Positioning
+
+```
+Label {
+    Anchor: (Top: 10, Left: 20, Width: 100, Height: 30);
+}
+```
+
+- **Top**: 10 pixels from container's top edge
+- **Left**: 20 pixels from container's left edge
+- **Width**: 100 pixels wide
+- **Height**: 30 pixels tall
+
+### Anchoring to Edges
+
+```
+Button {
+    Anchor: (Bottom: 10, Right: 10, Width: 100, Height: 30);
+}
+```
+
+Anchors the button to the bottom-right corner, 10 pixels from each edge.
+
+### Stretching
+
+```
+Group {
+    Anchor: (Top: 0, Bottom: 0, Left: 0, Right: 0);
+}
+```
+
+Stretches to fill the entire container (all edges at 0 pixels).
+
+**Shorthand:**
+
+```
+Group {
+    Anchor: (Full: 0);
+}
+```
+
+### Mixed Anchoring
+
+```
+Panel {
+    Anchor: (Top: 10, Bottom: 10, Left: 20, Width: 300);
+}
+```
+
+- Fixed width of 300 pixels
+- Stretches vertically between top and bottom edges
+- 10 pixels from top and bottom
+- 20 pixels from left
+
+## Padding
+
+`Padding` creates inner spacing, affecting where children are positioned.
+
+### Uniform Padding
+
+```
+Group {
+    Padding: (Full: 20);
+}
+```
+
+20 pixels of padding on all sides.
+
+### Directional Padding
+
+```
+Group {
+    Padding: (Top: 10, Bottom: 20, Left: 15, Right: 15);
+}
+```
+
+Different padding per edge.
+
+### Shorthand
+
+```
+// Horizontal and vertical
+Group {
+    Padding: (Horizontal: 20, Vertical: 10);
+}
+
+// Equivalent to:
+// Top: 10, Bottom: 10, Left: 20, Right: 20
+```
+
+### Effect on Children
+
+```
+Group {
+    Anchor: (Width: 200, Height: 100);
+    Padding: (Full: 10);
+
+    Label {
+        Anchor: (Full: 0);
+    }
+}
+```
+
+The label fills the group, but there's a 10-pixel gap on all sides due to padding.
+
+```
+┌──────────────────────┐
+│ Group (200×100)      │
+│  ┌────────────────┐  │
+│  │ Label          │  │ ← 10px padding all around
+│  │                │  │
+│  └────────────────┘  │
+└──────────────────────┘
+```
+
+## LayoutMode
+
+`LayoutMode` determines how a container arranges its children.
+
+### Top (Vertical Stack)
+
+```
+Group {
+    LayoutMode: Top;
+
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+}
+```
+
+Children stack vertically from top to bottom:
+
+```
+┌──────────┐
+│ Button 1 │
+├──────────┤
+│ Button 2 │
+├──────────┤
+│ Button 3 │
+└──────────┘
+
+
+```
+
+Each child's `Anchor.Bottom` adds spacing between elements:
+
+```
+Button { Anchor: (Height: 30, Bottom: 10); }  // 10px gap after this button
+```
+
+### Bottom (Vertical Stack)
+
+```
+Group {
+    LayoutMode: Bottom;
+
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+}
+```
+
+Children stack vertically from top to bottom but aligned to the bottom edge of the parent:
+
+```
+
+
+
+┌──────────┐
+│ Button 1 │
+├──────────┤
+│ Button 2 │
+├──────────┤
+│ Button 3 │
+└──────────┘
+```
+
+### Left (Horizontal Stack)
+
+```
+Group {
+    LayoutMode: Left;
+
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+}
+```
+
+Children arrange horizontally from left to right:
+
+```
+┌────────┬────────┬────────┐
+│ Button │ Button │ Button │
+│   1    │   2    │   3    │
+└────────┴────────┴────────┘
+```
+
+Use `Anchor.Right` for spacing between elements.
+
+### Right (Horizontal Stack)
+
+```
+Group {
+    LayoutMode: Right;
+
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+}
+```
+
+Children arrange horizontally from left to right but aligned to the right side of the parent:
+
+```
+                                                                 ┌────────┬────────┬────────┐
+                                                                 │ Button │ Button │ Button │
+                                                                 │   1    │   2    │   3    │
+                                                                 └────────┴────────┴────────┘
+```
+
+### Center
+
+```
+Group {
+    LayoutMode: Center;
+
+    Group #Dialog {
+        Anchor: (Width: 400, Height: 300);
+    }
+}
+```
+
+Centers the children horizontally.
+
+### Middle
+
+```
+Group {
+    LayoutMode: Middle;
+
+    Group #Dialog {
+        Anchor: (Width: 400, Height: 300);
+    }
+}
+```
+
+Centers the children vertically.
+
+### CenterMiddle (Horizontal Stack, Fully Centered)
+
+```
+Group {
+    LayoutMode: CenterMiddle;
+
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+}
+```
+
+Children stack horizontally from left to right, centered both horizontally and vertically within the parent:
+
+```
+┌────────────────────────────────────────────┐
+│                                            │
+│                                            │
+│         ┌──────┐ ┌──────┐ ┌──────┐         │
+│         │  B1  │ │  B2  │ │  B3  │         │
+│         └──────┘ └──────┘ └──────┘         │
+│                                            │
+│                                            │
+└────────────────────────────────────────────┘
+```
+
+---
+
+### MiddleCenter (Vertical Stack, Fully Centered)
+
+```
+Group {
+    LayoutMode: MiddleCenter;
+
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+}
+```
+
+Children stack vertically from top to bottom, centered both horizontally and vertically within the parent:
+
+```
+┌────────────────────────────────────────────┐
+│                                            │
+│              ┌──────────┐                  │
+│              │ Button 1 │                  │
+│              ├──────────┤                  │
+│              │ Button 2 │                  │
+│              ├──────────┤                  │
+│              │ Button 3 │                  │
+│              └──────────┘                  │
+│                                            │
+└────────────────────────────────────────────┘
+```
+
+---
+
+### Full
+
+```
+Group {
+    LayoutMode: Full;
+
+    Label {
+        Anchor: (Top: 20, Left: 20, Width: 100, Height: 30);
+    }
+}
+```
+
+Children use absolute positioning via their `Anchor` properties.
+
+### TopScrolling
+
+```
+Group {
+    LayoutMode: TopScrolling;
+    ScrollbarStyle: $Common.@DefaultScrollbar;
+
+    // ... many children
+}
+```
+
+Like `Top`, but adds a scrollbar if content exceeds container height.
+
+Or use `BottomScrolling` for bottom-aligned content.
+
+### LeftScrolling
+
+```
+Group {
+    LayoutMode: LeftScrolling;
+    ScrollbarStyle: $Common.@DefaultScrollbar;
+
+    // ... many children
+}
+```
+
+Like `Left`, but adds a scrollbar for horizontal scrolling.
+
+Or use `RightScrolling` for right-aligned content.
+
+### LeftCenterWrap (Wrapping Horizontal Stack, Horizontally Centered)
+
+```
+Group {
+    LayoutMode: LeftCenterWrap;
+
+    Button { Anchor: (Width: 80, Height: 30); }
+    Button { Anchor: (Width: 80, Height: 30); }
+    Button { Anchor: (Width: 80, Height: 30); }
+    Button { Anchor: (Width: 80, Height: 30); }
+    Button { Anchor: (Width: 80, Height: 30); }
+}
+```
+
+Children flow left to right. When there's no more horizontal space, they wrap to the next row. Each row is horizontally centered within the parent:
+
+```
+┌────────────────────────────────────────────┐
+│                                            │
+│       ┌──────┐ ┌──────┐ ┌──────┐           │
+│       │  B1  │ │  B2  │ │  B3  │           │
+│       └──────┘ └──────┘ └──────┘           │
+│            ┌──────┐ ┌──────┐               │
+│            │  B4  │ │  B5  │               │
+│            └──────┘ └──────┘               │
+│                                            │
+└────────────────────────────────────────────┘
+```
+
+## FlexWeight
+
+`FlexWeight` distributes remaining space among children.
+
+```
+Group {
+    LayoutMode: Left;
+    Anchor: (Width: 400);
+
+    Button {
+        Anchor: (Width: 100);
+    }
+
+    Group {
+        FlexWeight: 1;  // Takes all remaining space
+    }
+
+    Button {
+        Anchor: (Width: 100);
+    }
+}
+```
+
+Result:
+
+- First button: 100px
+- Middle group: 200px (400 - 100 - 100 = 200)
+- Last button: 100px
+
+### Multiple FlexWeights
+
+```
+Group {
+    LayoutMode: Left;
+    Anchor: (Width: 600);
+
+    Group { FlexWeight: 1; }
+    Group { FlexWeight: 2; }
+    Group { FlexWeight: 1; }
+}
+```
+
+Remaining space (600px) is split:
+
+- First group: 600 × (1/4) = 150px
+- Second group: 600 × (2/4) = 300px
+- Third group: 600 × (1/4) = 150px
+
+## Visibility
+
+```
+Button #HiddenButton {
+    Visible: false;
+}
+```
+
+**Effect:**
+
+- Element and its children are not displayed
+- Element is **not included in layout** (doesn't take up space)
diff --git a/content/docs/sq-AL/official-documentation/custom-ui/markup.mdx b/content/docs/sq-AL/official-documentation/custom-ui/markup.mdx
new file mode 100644
index 00000000..564110ed
--- /dev/null
+++ b/content/docs/sq-AL/official-documentation/custom-ui/markup.mdx
@@ -0,0 +1,226 @@
+---
+title: Markup
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# Markup
+
+## Markup
+
+An element is the basic building block of a user interface. There are various types of elements with different properties, which are documented below.
+
+Here's what the syntax looks like:
+
+```
+// Basic declaration of an element
+// with its Anchor property set to attach on all sides of its parent
+// with 10 pixels of margin
+Group { Anchor: (Left: 10, Top: 10, Right: 10, Bottom: 10); }
+
+Group { Anchor: (Full: 10); } // More concise version
+
+// Declaration of a Label with a name
+// (can be used to access the element from game code)
+Label #MyLabel {
+  Style: LabelStyle(FontSize: 16); // or just Style: (FontSize: 16), type can be inferred.
+  Text: "Hi! I am text.";
+}
+
+// Declaration of a Group containing 2 children
+// You can use FlexWeight to distribute any left-over space after explicit widths/heights have been subtracted
+Group {
+  LayoutMode: Left;
+  Label { Text: "Child 1"; FlexWeight: 2; }
+  Label { Text: "Child 2"; FlexWeight: 1; }
+}
+```
+
+### Documents
+
+A UI document (_.ui_ file) contains trees of elements. There can be multiple root elements.
+
+### Named Expressions
+
+Named expressions can be declared at any level of a document (including at the root) and will be scoped to that subtree, though they need to be declared at the top of the block.
+
+```
+// Example of named expressions, declared and used with @ prefix
+@Title = "Hytale";
+@ExtraSpacing = 5;
+
+Label {
+  Text: @Title;
+  Style: (LetterSpacing: 2 + @ExtraSpacing);
+}
+```
+
+You can use the spread operator `...` to reuse a named expression while overriding some of its fields:
+
+```
+@MyBaseStyle = LabelStyle(FontSize: 24, LetterSpacing: 2);
+
+Label {
+  Style: (...@MyBaseStyle, FontSize: 36);
+}
+```
+
+You can even layer multiple named expressions like so:
+
+```
+@TitleStyle = LabelStyle(FontSize: 24, HorizontalAlignment: Center);
+@SpacedTextStyle = LabelStyle(LetterSpacing: 2);
+
+Label {
+  Style: (...@BigTextStyle, ...@SpacedTextStyle);
+}
+```
+
+#### Document references
+
+A document can reference another document and access its named expressions.
+
+```
+// Document references are defined with $ prefix
+$Common = "../Common.ui";
+
+TextButton {
+  Style: $Common.@DefaultButtonStyle;
+}
+```
+
+### Templates
+
+You can declare a reusable bit of interface as a named expression and then instantiate it as many times as you want in the tree while customizing it.
+
+You can override local named expressions as well as insert additional children at any point in the template tree. However, local named expressions must be defined at the very top of the block, before properties and child elements.
+
+```
+// This is the template
+@Row = Group {
+  Anchor: (Height: 50);
+  Label #Label { Anchor: (Left: 0, Width: 100); Text: @LabelText; }
+  Group #Content { Anchor: (Left: 100); }
+};
+
+// Here we'll be using it twice in the document tree
+Group #Rows {
+  LayoutMode: TopScrolling;
+
+  @Row #MyFirstRow {
+    @LabelText = "First row";
+    #Content { TextInput {} }
+  }
+
+  @Row #MySecondRow {
+    @LabelText = "Second row";
+  }
+}
+```
+
+### Property Types
+
+#### Basic Types
+
+- **Boolean**
+  - `Visible: false;`
+  - `Visible: true;`
+- **Int**
+  - `Height: 20;`
+- **Float, Double, Decimal**
+  - `Min: 0.2;`
+- **String**
+  - `Text: "Hi!";`
+- **Char**
+  - `PasswordChar: "*";`
+  - _Note: The syntax is the same as a string, however a value of this type cannot contain more than one character!_
+- **Color**
+  - `Background: #ffffff;`&#x20;
+- **Objects**
+  - `Style: (Background: #ffffff)`
+- **Array**&#x20;
+  - `TextSpans: [(Text: "Hi", IsBold: true)]`
+
+#### Translations
+
+Translation keys can be referenced anywhere in markup where you can provide a string, and they are then converted to a string when an element gets instantiated.
+
+**Example:**
+
+```
+Label {
+  Text: %ui.general.cancel;
+}
+```
+
+#### Colors
+
+A color literal can be written as follows:
+
+- `#rrggbb`: 6-digit hexadecimal representation for red, green, blue (fully opaque)
+- `#rrggbb(a.a)`: 6-digit hexadecimal representation for red, green, blue with alpha between 0 and 1
+- `#rrggbbaa`: 8-digit hexadecimal representation for red, green, blue and alpha
+
+```
+Group {
+  Background: #000000(0.3);
+}
+```
+
+<Callout>
+  The `#rrggbb(a.a)` format is prefered over the `#rrggbbaa` format for
+  readability reasons.
+</Callout>
+
+#### Font Name
+
+Font names can be referenced directly by their string ID. Internally this is using a custom type called `UIFontName`, however strings will be converted automatically to this type in markup.
+
+```
+Label {
+  Text: "Hi";
+  Style: (FontName: "Secondary");
+}
+```
+
+**Available Font Names**
+
+- _Default_ - This is the default font that is used for most text and is always used unless a different option has been specified
+- _Secondary_ - This font is mostly used for headlines or elements that are supposed to stick out
+- _Mono_ - This is only used for development; For things such as profiling or error overlays.
+
+#### Path
+
+We can reference other UI assets with the `UIPath` type. Similar to `UIFontName`_,_ Strings are automatically converted to a `UIPath`. Paths are always relative to the file where they have been declared in. Looking up _MyButton.png_ in _Menu/MyAwesomeMenu.ui_ will result in _Menu/MyButton.png_. If you want to reference a file that is in a parent folder you can go back one directory by writing two dots (_../MyButton.png_).
+
+The markup syntax of a `UIPath` is the same as a String. (e.g. `Path: "Test.png"`)
+
+Here are some more examples:
+
+| UIPath             | .ui File                              | Resulting Path    |
+| ------------------ | ------------------------------------- | ----------------- |
+| MyButton.png       | Menu/MyAwesomeMenu.ui                 | Menu/MyButton.png |
+| ../MyButton.png    | Menu/MyAwesomeMenu.ui                 | MyButton.png      |
+| ../../MyButton.png | Menu/Popup/Templates/MyAwesomeMenu.ui | Menu/MyButton.png |
+
+#### Objects
+
+Objects contain a set of properties. In this example we are assigning an Anchor object to the _Anchor_ property:
+
+```
+Group {
+  Anchor: (
+   Height: 10,
+   Width: 20
+ );
+}
+```
+
+You can find all objects that can be used in markup [here](type-documentation#elements).
+
+## Visual Studio Code Extension
+
+There is an official extension for Visual Studio Code which adds syntax highlighting for .ui files. You can find it [here](https://marketplace.visualstudio.com/items?itemName=HypixelStudiosCanadaInc.vscode-hytaleui).
diff --git a/content/docs/sq-AL/official-documentation/custom-ui/type-documentation/index.mdx b/content/docs/sq-AL/official-documentation/custom-ui/type-documentation/index.mdx
new file mode 100644
index 00000000..69cea406
--- /dev/null
+++ b/content/docs/sq-AL/official-documentation/custom-ui/type-documentation/index.mdx
@@ -0,0 +1,127 @@
+---
+title: Type Documentation
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# Type Documentation
+
+This is a generated list of UI elements accessible by markup. More information about the User Interface framework can be found in the main documentation.
+
+## Elements
+
+- [ActionButton](type-documentation/elements/actionbutton)
+- [AssetImage](type-documentation/elements/assetimage)
+- [BackButton](type-documentation/elements/backbutton)
+- [BlockSelector](type-documentation/elements/blockselector)
+- [Button](type-documentation/elements/button)
+- [CharacterPreviewComponent](type-documentation/elements/characterpreviewcomponent)
+- [CheckBox](type-documentation/elements/checkbox)
+- [CheckBoxContainer](type-documentation/elements/checkboxcontainer)
+- [CircularProgressBar](type-documentation/elements/circularprogressbar)
+- [CodeEditor](type-documentation/elements/codeeditor)
+- [ColorOptionGrid](type-documentation/elements/coloroptiongrid)
+- [ColorPicker](type-documentation/lements/colorpicker)
+- [ColorPickerDropdownBox](type-documentation/elements/colorpickerdropdownbox)
+- [CompactTextField](type-documentation/elements/compacttextfield)
+- [DropdownBox](type-documentation/elements/dropdownbox)
+- [DropdownEntry](type-documentation/elements/dropdownentry)
+- [DynamicPane](type-documentation/elements/dynamicpane)
+- [DynamicPaneContainer](type-documentation/elements/dynamicpanecontainer)
+- [FloatSlider](type-documentation/elements/floatslider)
+- [FloatSliderNumberField](type-documentation/elements/floatslidernumberfield)
+- [Group](type-documentation/elements/group)
+- [HotkeyLabel](type-documentation/elements/hotkeylabel)
+- [ItemGrid](type-documentation/elements/itemgrid)
+- [ItemIcon](type-documentation/elements/itemicon)
+- [ItemPreviewComponent](type-documentation/elements/itempreviewcomponent)
+- [ItemSlot](type-documentation/elements/itemslot)
+- [ItemSlotButton](type-documentation/elements/itemslotbutton)
+- [Label](type-documentation/elements/label)
+- [LabeledCheckBox](type-documentation/elements/labeledcheckbox)
+- [MenuItem](type-documentation/elements/menuitem)
+- [MultilineTextField](type-documentation/elements/multilinetextfield)
+- [NumberField](type-documentation/elements/numberfield)
+- [Panel](type-documentation/elements/panel)
+- [ProgressBar](type-documentation/elements/progressbar)
+- [ReorderableList](type-documentation/elements/reorderablelist)
+- [ReorderableListGrip](type-documentation/elements/reorderablelistgrip)
+- [SceneBlur](type-documentation/elements/sceneblur)
+- [Slider](type-documentation/elements/slider)
+- [SliderNumberField](type-documentation/elements/slidernumberfield)
+- [Sprite](type-documentation/elements/sprite)
+- [TabButton](type-documentation/elements/tabbutton)
+- [TabNavigation](type-documentation/elements/tabnavigation)
+- [TextButton](type-documentation/elements/textbutton)
+- [TextField](type-documentation/elements/textfield)
+- [TimerLabel](type-documentation/elements/timerlabel)
+- [ToggleButton](type-documentation/elements/togglebutton)
+
+## Property Types
+
+- [Anchor](type-documentation/property-types/anchor)
+- [BlockSelectorStyle](type-documentation/property-types/blockselectorstyle)
+- [ButtonSounds](type-documentation/property-types/buttonsounds)
+- [ButtonStyle](type-documentation/property-types/buttonstyle)
+- [ButtonStyleState](type-documentation/property-types/buttonstylestate)
+- [CheckBoxStyle](type-documentation/property-types/checkboxstyle)
+- [CheckBoxStyleState](type-documentation/property-types/checkboxstylestate)
+- [ClientItemStack](type-documentation/property-types/clientitemstack)
+- [ColorOptionGridStyle](type-documentation/property-types/coloroptiongridstyle)
+- [ColorPickerDropdownBoxStateBackground](type-documentation/property-types/colorpickerdropdownboxstatebackground)
+- [ColorPickerDropdownBoxStyle](type-documentation/property-types/colorpickerdropdownboxstyle)
+- [ColorPickerStyle](type-documentation/property-types/colorpickerstyle)
+- [DropdownBoxSearchInputStyle](type-documentation/property-types/dropdownboxsearchinputstyle)
+- [DropdownBoxSounds](type-documentation/property-types/dropdownboxsounds)
+- [DropdownBoxStyle](type-documentation/property-types/dropdownboxstyle)
+- [InputFieldButtonStyle](type-documentation/property-types/inputfieldbuttonstyle)
+- [InputFieldDecorationStyle](type-documentation/property-types/inputfielddecorationstyle)
+- [InputFieldDecorationStyleState](type-documentation/property-types/inputfielddecorationstylestate)
+- [InputFieldIcon](type-documentation/property-types/inputfieldicon)
+- [InputFieldStyle](type-documentation/property-types/inputfieldstyle)
+- [ItemGridSlot](type-documentation/property-types/itemgridslot)
+- [ItemGridStyle](type-documentation/property-types/itemgridstyle)
+- [LabeledCheckBoxStyle](type-documentation/property-types/labeledcheckboxstyle)
+- [LabeledCheckBoxStyleState](type-documentation/property-types/labeledcheckboxstylestate)
+- [LabelSpan](type-documentation/property-types/labelspan)
+- [LabelStyle](type-documentation/property-types/labelstyle)
+- [NumberFieldFormat](type-documentation/property-types/numberfieldformat)
+- [Padding](type-documentation/property-types/padding)
+- [PatchStyle](type-documentation/property-types/patchstyle)
+- [PopupStyle](type-documentation/property-types/popupstyle)
+- [ScrollbarStyle](type-documentation/property-types/scrollbarstyle)
+- [SliderStyle](type-documentation/property-types/sliderstyle)
+- [SoundStyle](type-documentation/property-types/soundstyle)
+- [SpriteFrame](type-documentation/property-types/spriteframe)
+- [SubMenuItemStyle](type-documentation/property-types/submenuitemstyle)
+- [SubMenuItemStyleState](type-documentation/property-types/submenuitemstylestate)
+- [Tab](type-documentation/property-types/tab)
+- [TabNavigationStyle](type-documentation/property-types/tabnavigationstyle)
+- [TabStyle](type-documentation/property-types/tabstyle)
+- [TabStyleState](type-documentation/property-types/tabstylestate)
+- [TextButtonStyle](type-documentation/property-types/textbuttonstyle)
+- [TextButtonStyleState](type-documentation/property-types/textbuttonstylestate)
+- [TextTooltipStyle](type-documentation/property-types/texttooltipstyle)
+- [ToggleButtonStyle](type-documentation/property-types/togglebuttonstyle)
+- [ToggleButtonStyleState](type-documentation/property-types/togglebuttonstylestate)
+
+## Enums
+
+- [ActionButtonAlignment](type-documentation/enums/actionbuttonalignment)
+- [CodeEditorLanguage](type-documentation/enums/codeeditorlanguage)
+- [ColorFormat](type-documentation/enums/colorformat)
+- [DropdownBoxAlign](type-documentation/enums/dropdownboxalign)
+- [InputFieldButtonSide](type-documentation/enums/inputfieldbuttonside)
+- [InputFieldIconSide](type-documentation/enums/inputfieldiconside)
+- [ItemGridInfoDisplayMode](type-documentation/enums/itemgridinfodisplaymode)
+- [LabelAlignment](type-documentation/enums/labelalignment)
+- [LayoutMode](type-documentation/enums/layoutmode)
+- [MouseWheelScrollBehaviourType](type-documentation/enums/mousewheelscrollbehaviourtype)
+- [ProgressBarAlignment](type-documentation/enums/progressbaralignment)
+- [ProgressBarDirection](type-documentation/enums/progressbardirection)
+- [ResizeType](type-documentation/enums/resizetype)
+- [TimerDirection](type-documentation/enums/timerdirection)
+- [TooltipAlignment](type-documentation/enums/tooltipalignment)
diff --git a/content/docs/sq-AL/official-documentation/npc/2-getting-started-with-templates.mdx b/content/docs/sq-AL/official-documentation/npc/2-getting-started-with-templates.mdx
index 91081ca1..99d078e0 100644
--- a/content/docs/sq-AL/official-documentation/npc/2-getting-started-with-templates.mdx
+++ b/content/docs/sq-AL/official-documentation/npc/2-getting-started-with-templates.mdx
@@ -9,7 +9,7 @@ authors:
 
 There are no hard and fast rules for making a start on a template. I like to duplicate **BlankTemplate** and start from there because it already provides the basic structure of the file.
 
-This leaves me with the following template (`Template_Goblin_Ogre.json`): (note: the file could be looking different in the current version of the game)
+This leaves me with the following template (`Template_Goblin_Ogre.json`): (**note: the file could be looking different in the current version of the game**)
 
 ```json
 {
@@ -33,7 +33,7 @@ This leaves me with the following template (`Template_Goblin_Ogre.json`): (note:
     }
   },
   "Appearance": { "Compute": "Appearance" },
-  "DropList": { "Compute": "Droplist" },
+  "DropList": { "Compute": "DropList" },
   "MaxHealth": { "Compute": "MaxHealth" },
   "MotionControllerList": [
     {
@@ -65,10 +65,10 @@ And the following variant (`Goblin_Ogre.json`) next to the template. There's a t
   "Type": "Variant",
   "Reference": "Template_Goblin_Ogre",
   "Modify": {
-    "Appearance": "Goblin_Ogre",
+    "Appearance": "Goblin",
     "MaxHealth": 124
   }
 }
 ```
 
-Our artists have defined the `Goblin_Ogre` appearance already so I'm going to use that.
+Our artists have not yet finished animations for the `Goblin_Ogre`, for that sake of the tutorial I am going to use appearance `Goblin`, because it offers a more complete set of animations that we will need.
diff --git a/content/docs/sq-AL/official-documentation/worldgen/pack-tutorial/asset-packs.mdx b/content/docs/sq-AL/official-documentation/worldgen/pack-tutorial/asset-packs.mdx
index 38809fad..dcf1f3b9 100644
--- a/content/docs/sq-AL/official-documentation/worldgen/pack-tutorial/asset-packs.mdx
+++ b/content/docs/sq-AL/official-documentation/worldgen/pack-tutorial/asset-packs.mdx
@@ -9,13 +9,13 @@ authors:
 
 <OfficialDocumentationNotice />
 
-# How to modify Hytale
+# How to modify Hytale?
 
-## What's an Asset Pack
+## What's an Asset Pack?
 
-Hytales gameplay is driven by assets in the game that can be modified by creators. Asset Packs are our solution to let you override or add features to the base game with your own work. These can in the form of zip files of folders, which contain a custom set of assets. This is not the only way for a creator to change Hytale but this is the most accessible form.;
+Hytales gameplay is driven by assets in the game that can be modified by creators. Asset Packs are our solution to let you override or add features to the base game with your own work. These can be the form of zip files of folders, which contain a custom set of assets. This is not the only way for a creator to change Hytale but this is the most accessible form.;
 
-### How do I make an Asset Pack
+### How do I make an Asset Pack?
 
 <video controls className="my-6 aspect-video w-full rounded-lg border">
   <source src="https://cdn.internal.hytalemodding.dev/guides/official/how-to-asset-pack.mp4" type="video/mp4" />
@@ -48,7 +48,7 @@ An asset pack is typically a zip or folder, with a `manifest.json` inside. This
 }
 ```
 
-### Where are they stored
+### Where are they stored?
 
 Asset Packs are stored with other mods in the Mods folder.
 
@@ -76,7 +76,7 @@ C:\Users\<user>\AppData\Roaming\Hytale\UserData\Saves\New World 5\mods
 
 When you have Asset Packs or Mods installed, these will appear in the New World menu under the Options menu.;
 
-### How do I change an existing asset
+### How do I change an existing asset?
 
 <video controls className="my-6 aspect-video w-full rounded-lg border">
   <source src="https://cdn.internal.hytalemodding.dev/guides/official/how-to-asset.mp4" type="video/mp4" />
diff --git a/content/docs/sq-AL/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx b/content/docs/sq-AL/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx
index 44528376..24e628b5 100644
--- a/content/docs/sq-AL/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx
+++ b/content/docs/sq-AL/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx
@@ -106,7 +106,7 @@ If a BaseHeight is provided, the TopY and BottomY values are relative to the Bas
 
 Applies a Material Provider slot on a set of horizontal stripes of blocks of varying thickness and position. Below is an example image of basalt stripes into a stone cliff.
 
-{/* ![](https://540086904-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F7KAmBkOg6d13nZCkf9ku%2Fuploads%2FbcxO9LpArn8gPCaBwFg5%2Funknown.png?alt=media&token=1c72b67a-8253-4d03-8c64-1ad5f6830050) */}
+![Example of basalt stripes](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/basalt-stripes-example.png)
 
 #### Parameters:
 
diff --git a/content/docs/sq-AL/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx b/content/docs/sq-AL/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx
index 5e34acd4..a4418473 100644
--- a/content/docs/sq-AL/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx
+++ b/content/docs/sq-AL/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx
@@ -294,7 +294,7 @@ Combines all the positions into a single Positioins field.
 
 ---
 
-### SimpleHoritontal
+### SimpleHorizontal
 
 Keeps only the positions that are within the provided range.
 
diff --git a/content/docs/sq-AL/official-documentation/worldgen/worldgen-tutorial/README.mdx b/content/docs/sq-AL/official-documentation/worldgen/worldgen-tutorial/README.mdx
new file mode 100644
index 00000000..5f66d245
--- /dev/null
+++ b/content/docs/sq-AL/official-documentation/worldgen/worldgen-tutorial/README.mdx
@@ -0,0 +1,166 @@
+---
+title: How to edit and create Biomes
+description: Explores where world generation assets can be found and how to edit them.
+---
+
+### Where are the Assets
+
+World generation assets are kept in the HytaleGenerator directory within the assets.
+
+```
+/Server/HytaleGenerator/
+```
+
+<div className="flex flex-row rounded-lg border p-4">
+  <div className="flex-1/2 border-r pr-4">
+    ```
+    /Biomes
+    ```
+
+    Biome assets, with content configurations.
+  </div>
+
+  <div className="flex-1/2 pl-4">
+    ```
+    /WorldStructure
+    ```
+
+    Generator files that define which biomes spawn together.
+  </div>
+</div>
+
+<div className="flex flex-row rounded-lg border p-4">
+  <div className="flex-1/2 border-r pr-4">
+    ```
+    /Density
+    ```
+
+    Density assets that can be referenced by any other assets.
+  </div>
+
+  <div className="flex-1/2 pl-4">
+    ```
+    /Assignments
+    ```
+
+    Prop assets that can be referenced by any Biome assets.
+  </div>
+</div>
+
+***
+
+An example of this structure can be found bellow, packed in an asset pack with the instance configuration.
+
+[https://drive.google.com/file/d/1sIz_CluANIIe3n8vNiOi-4PQdeqCO0qY/view?usp=drive_link](https://drive.google.com/file/d/1sIz_CluANIIe3n8vNiOi-4PQdeqCO0qY/view?usp=drive_link)
+
+<Callout>
+  Ensure you place your asset pack in the correct directory, under Mods.
+</Callout>
+
+### How to visit our worlds
+
+https://drive.google.com/file/d/1BJurxyj-taE-PXWm04bk7Dl6X7ZHTH92/view?usp=sharing
+
+#### Requirements
+
+- You must be an **Operator** in the world.
+  - To do this, run <mark style="color:$danger;">`/op self`</mark>
+- You must be in **Creative mode**.
+  - Press the <mark style="color:$danger;">`O`</mark> key, O for Orange.&#x20;
+
+The generation assets define a set of generators but on their own you cannot visit these. Currently you require an Instance with a generator that will allow you to visit your work.
+
+```
+/Server/Instances/
+```
+
+Instances are separate worlds that players can join using the `/instances` command. Each instance has an `Instance.bson` configuration asset that specifies which generator to use, among other worldly settings.
+
+```json
+{
+  "WorldGen": {
+    "Type": "HytaleGenerator",
+    "WorldStructure": "Basic",
+    "playerSpawn" : {
+      "X" : 123,
+      "Y" : 480,
+      "Z" : 10000,
+      "Pitch" : 0,
+      "Yaw" : 0,
+      "Roll" : 0
+    }
+  }
+}
+```
+
+<Callout>
+  You can create custom instances for different world structures and biomes as you need them.
+</Callout>
+
+### How to edit Biomes
+
+<video>
+  <source src="https://cdn.internal.hytalemodding.dev/guides/official/How-to-edit-Biomes.mp4" type="video/mp4" />
+</video>
+
+We currently use the Hytale Node Editor when editing world generation assets. This can be accessed while in-game from the Content Creation menu when pressing B. The node editor is then found under the asset editor dropdown on the upper left.&#x20;
+
+![Node Editor 1](/assets/official-documentation/worldgen/worldgen-tutorial/biomes/node-editor-1.png)
+
+Once you have the Hytale Node Editor open, through the file menu you can open Biomes by navigating to the Biomes directory and selecting one from your pack.&#x20;
+
+```
+/Server/HytaleGenerator/Biomes/
+```
+
+### Biome Asset Structure
+
+Every Biome has a root Biome node, this node splits into 5 structures. This is covered briefly but more information on each field can be found on the World Generation Concepts page.
+
+![Node Editor 2](/assets/official-documentation/worldgen/worldgen-tutorial/biomes/node-editor-2.png)
+
+<Callout>
+  Each biome is for the most part self contained, meaning it has control over what appears with the biome. The only exception to this are Base Heights.
+</Callout>
+
+<Tabs>
+  <Tab value="Terrain">
+    Mathematical function nodes that calculate the physical shape of the Biome's terrain.
+  </Tab>
+
+  <Tab value="Materials">
+    Logical nodes that determine what materials (blocks) make up a Biome's terrain.
+  </Tab>
+
+  <Tab value="Props">
+    Function nodes that add objects like prefabs and decorations to the terrain.
+  </Tab>
+
+  <Tab value="Environments">
+    Logical nodes that determine the environment asset at a given coordinate within the biome. This asset determines things like weather, NPC spawns, and sounds.
+  </Tab>
+
+  <Tab value="Tints">
+    Logical function nodes that determine a colour code that can be used by certain blocks in the world. Typically this will be grasses and soils.
+  </Tab>
+</Tabs>
+
+### How to preview your work
+
+[https://drive.google.com/file/d/1mNcHn9LhFnWDF0DzWFH6_YllmKAUvUry/view?t=6](https://drive.google.com/file/d/1mNcHn9LhFnWDF0DzWFH6_YllmKAUvUry/view?t=6)
+
+Once you are in an Instance world with the Hytale Generator active you will only be able to see your work by generating new chunks. There are a few ways to do this.
+
+The viewport command selects an area around the Player that will live reload as you make changes to the generator.&#x20;
+
+```
+/viewport --radius 5 
+```
+
+You can also create a new world to show your changes.&#x20;
+
+```
+/instances spawn <instance> 
+```
+
+The last option is to simply fly south, new chunks will generate with the changes made.
diff --git a/content/docs/sq-AL/quick-start.mdx b/content/docs/sq-AL/quick-start.mdx
index 653644f4..249d803a 100644
--- a/content/docs/sq-AL/quick-start.mdx
+++ b/content/docs/sq-AL/quick-start.mdx
@@ -9,3 +9,8 @@ Welcome to the Hytale modding documentation! Here you'll find everything you nee
 * [Setting up your dev environment](./guides/plugin/setting-up-env)
 * [Entity Component System (ECS)](./guides/ecs/entity-component-system)
 * [Publishing your mod](./publishing)
+
+### Useful Links
+
+* [Kaupenjoe's Modding Videos](https://www.youtube.com/@ModdingByKaupenjoe)
+* [TroubleDEV's Modding Videos](https://www.youtube.com/@TroubleDEV)
diff --git a/content/docs/sq-AL/server/argtypes.mdx b/content/docs/sq-AL/server/argtypes.mdx
new file mode 100644
index 00000000..e54a442e
--- /dev/null
+++ b/content/docs/sq-AL/server/argtypes.mdx
@@ -0,0 +1,61 @@
+---
+title: ArgTypes
+description: Available ArgTypes
+icon: List
+full: true
+authors:
+  - name: Valeena
+---
+
+| Name                        | Target Class                           | Description                                                                                                                               |   |
+| :-------------------------- | :------------------------------------- | :---------------------------------------------------------------------------------------------------------------------------------------- | - |
+| Boolean                     | java.lang.Boolean                      | A 'true' or 'false' input                                                                                                                 |   |
+| Integer                     | java.lang.Integer                      | A whole number                                                                                                                            |   |
+| String                      | java.lang.String                       | Words, text, numbers, letters. To input more than one word at a time, you may need to wrap it with double quotes (`"my fancy sentence"`). |   |
+| Float                       | java.lang.Float                        | A floating-pointer number                                                                                                                 |   |
+| Double                      | java.lang.Double                       | A decimal number                                                                                                                          |   |
+| UUID                        | java.util.UUID                         | A UUID (Universally Unique IDentifier)                                                                                                    |   |
+| Player_UUID                 | java.util.UUID                         | A UUID or an online player username                                                                                                       |   |
+| Game_Profile_Lookup_Async   | ProfileServiceClient.PublicGameProfile | A player UUID or username. If not found locally, performs a remote lookup via the Profile Service.                                        |   |
+| Relative_Double_Coord       | Coord                                  | An x, y, or z coordinate as a decimal, optionally relative by specifying a tilde (~) in front of the number                               |   |
+| Relative_Int_Coord          | IntCoord                               | An x, y, or z coordinate as a whole number, optionally relative by specifying a tilde (~) in front of the number                          |   |
+| Relative_Integer            | RelativeInteger                        | A tilde to mark an integer relative to a base                                                                                             |   |
+| Relative_Float              | RelativeFloat                          | A tilde to mark a float relative to a base                                                                                                |   |
+| Player_Ref                  | PlayerRef                              | A UUID or an online player's username                                                                                                     |   |
+| World                       | World                                  | A world folder name                                                                                                                       |   |
+| Model_Asset                 | ModelAsset                             | A reference to an Asset of type Model                                                                                                     |   |
+| Weather_Asset               | Weather                                | A reference to an Asset of type Weather                                                                                                   |   |
+| Interaction_Asset           | Interaction                            | A reference to an Asset of type Interaction                                                                                               |   |
+| Root_Interaction_Asset      | RootInteraction                        | A reference to an Asset of type Root Interaction                                                                                          |   |
+| Effect_Asset                | EntityEffect                           | A refernece to an Asset of type EntityEffect                                                                                              |   |
+| Environment_Asset           | Environment                            | A reference to an Asset of type Environment                                                                                               |   |
+| Item_Asset                  | Item                                   | A reference to an Asset of type Item                                                                                                      |   |
+| Block_Type_Asset            | BlockType                              | A reference to an Asset of type BlockType                                                                                                 |   |
+| Particle_System             | ParticleSystem                         | A reference to an Asset of type ParticleSystem                                                                                            |   |
+| Hitbox_Collision_Config     | HitboxCollisionConfig                  | A reference to an Asset of type HitboxCollisionConfig                                                                                     |   |
+| Repulsion_Config            | RepulsionConfig                        | A reference to an Asset of type RepulsionConfig                                                                                           |   |
+| Sound_Event_Asset           | SoundEvent                             | A reference to an Asset of type SoundEvent                                                                                                |   |
+| Ambiance_Fx_Asset           | AmbianceFX                             | A reference to an Asset of type AmbianceFX                                                                                                |   |
+| Sound_Category              | SoundCategory                          | A sound category (sfx, music, ambient, ui)                                                                                                |   |
+| Entity_ID                   | `ArgWrapper<EntityWrappedArg, UUID>`   | A UUID representing an entity id                                                                                                          |   |
+| Integer_Comparison_Operator | IntegerComparisonOperator              | A mathematical sign for integer comparison                                                                                                |   |
+| Integer_Operation           | IntegerOperation                       | A mathematical sign for performing an operation                                                                                           |   |
+| Int_Range                   | `Pair<Integer, Integer>`               | Two integers representing a minimum and maximum of a range                                                                                |   |
+| Relative_Int_Range          | RelativeIntRange                       | Two integers representing a minimum and maximum of a range                                                                                |   |
+| Vector2I                    | Vector2i                               | Two integers, generally corresponding to x/z axis                                                                                         |   |
+| Vector3I                    | Vector3i                               | Three integers, generally corresponding to x/y/z axis                                                                                     |   |
+| Relative_Vector3I           | RelativeVector3i                       | Three optionally relative integers, generally corresponding to x/y/z axis                                                                 |   |
+| Relative_Block_Position     | RelativeIntPosition                    | A position with three integer coordinates, representing a block's location in world space.                                                |   |
+| Relative_Position           | Relative                               | A position with three decimal coordinates, representing a location in world space.                                                        |   |
+| Relative_Chunk_Position     | RealtiveChunkPosition                  | A position with two integer coordinates (x, z), representing a chunk's location.                                                          |   |
+| Rotation                    | Vector3f                               | A rotation with three coordinates, representing the pitch, yaw, and roll respectively                                                     |   |
+| Block_Type_Key              | String                                 | A block type                                                                                                                              |   |
+| Block_ID                    | Integer                                | A block type, converted to an int id                                                                                                      |   |
+| Color                       | Integer                                | A color value in hex format, hex integer, or decimal integer                                                                              |   |
+| Weighted_Block_Type         | `Pair<Integer, String>`                | A weight corresponding to a blocktype                                                                                                     |   |
+| Weighted_Block_Entry        | String                                 | A block with optional weight prefix                                                                                                       |   |
+| Block_Pattern               | BlockPattern                           | A list of blocks with optional weights                                                                                                    |   |
+| Individual_Block_Mask       | BlockMask                              | Create a block mask using symbols and block names                                                                                         |   |
+| Block_Mask                  | BlockMask                              | A tick rate value (e.g., 30tps, 33ms, or 30)                                                                                              |   |
+| Tick_Rate                   | Integer                                | A list of block masks that combine together                                                                                               |   |
+| Game_Mode                   | GameMode                               | GameMode                                                                                                                                  |   |
diff --git a/content/docs/sq-AL/server/interaction-reference.mdx b/content/docs/sq-AL/server/interaction-reference.mdx
new file mode 100644
index 00000000..6c0d01b3
--- /dev/null
+++ b/content/docs/sq-AL/server/interaction-reference.mdx
@@ -0,0 +1,1586 @@
+---
+title: Interactions
+description: A list of most Interaction types provided by Hypixel, along with the meaning of their fields, and how they fit together.
+icon: List
+authors:
+  - name: Stephen Baynham
+    url: https://github.com/cannibalvox
+---
+
+### The Interaction Base Type
+
+All interactions of every type below are inherited from Interaction and have these fields.
+
+**Interaction Fields**
+
+| Field Name                | Type                                                                 | Required? | Notes                                                                                                                                                                                                                       |
+| ------------------------- | -------------------------------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| ViewDistance              | `Double`<br />(Default: 96.0)                                        | **No**    | Distance in blocks at which other players can see the effects from this interaction.                                                                                                                                        |
+| Effects                   | `InteractionEffects`                                                 | **No**    | Sound, animations, and particle effects that should trigger when this interaction begins executing.                                                                                                                         |
+| HorizontalSpeedMultiplier | `Float`<br />(Default: 1.0)                                          | **No**    | Multiplier applied to the User entity's movement speed while this interaction is executing                                                                                                                                  |
+| RunTime                   | `Float`                                                              | **No**    | If provided, this interaction will continue executing for at least this long before the interaction chain moves onto the next interaction.                                                                                  |
+| CancelOnItemChange        | `Boolean`<br />(Default: true)                                       | **No**    | If true, this interaction will be cancelled if the User entity's held item changes during execution. This can happen either due to the selected hotbar slot changing or the contents of the item's inventory slot changing. |
+| Rules                     | `InteractionRules`                                                   | **Yes**   | If provided, adds additional limitations and cancellation conditions to this interaction.                                                                                                                                   |
+| Settings                  | `Map`<br />(Key Type: `GameMode`, Value Type: `InteractionSettings`) | **No**    | If provided, adds additional per-GameMode settings to the interaction.                                                                                                                                                      |
+| Camera                    | `InteractionCameraSettings`                                          | **No**    | Arrays of camera motion keyframes for cutscenes and reveals.                                                                                                                                                                |
+
+**GameMode Values**
+
+- `Creative`: The game is currently in Creative Mode
+- `Adventure`: The game is currently in Adventure Mode
+
+**InteractionEffects Fields**
+
+| Field Name               | Type                                              | Required? | Notes                                                                                                                                                 |
+| ------------------------ | ------------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Particles                | `Array`<br />(Element Type: `ModelParticle`)      | **No**    | Particle systems to activate when this interaction begins if the player is in third-person mode.                                                      |
+| FirstPersonParticles     | `Array`<br />(Element Type: `ModelParticle`)      | **No**    | Particle systems to activate when this interaction begins if the player is in first-person mode.                                                      |
+| WorldSoundEventId        | `Asset`<br />(Asset Type: `SoundEvent`)           | **No**    | A sound to play in the world at the User entity's location when this interaction begins.<br />**The SoundEvent must be single-channel (mono) sound.** |
+| LocalSoundEventId        | `Asset`<br />(Asset Type: `SoundEvent`)           | **No**    | A 2D sound to play for the User entity when this interaction begins. Ignored if the User entity is not a player.                                      |
+| Trails                   | `Array`<br />(Element Type: `ModelTrail`)         | **No**    | Trail effects to activate on the User entity when this interaction begins.                                                                            |
+| WaitForAnimationToFinish | `Boolean`<br />(Default: false)                   | **No**    | If true, this interaction will continue executing for at least the length of any animations in this InteractionEffects object.                        |
+| ItemPlayerAnimationsId   | `Asset`<br />(Asset Type: `ItemPlayerAnimations`) | **No**    | If provided, the User entity will use this ItemPlayerAnimations set while this interaction is executing.                                              |
+| ItemAnimationId          | `String`                                          | **No**    | Id of an animation to trigger when this interaction begins executing.<br />**This animation id is not validated on server start.**                    |
+| ClearAnimationOnFinish   | `Boolean`<br />(Default: false)                   | **No**    | If true, animations triggered by this interaction will be halted when the interaction completes.                                                      |
+| ClearSoundEventOnFinish  | `Boolean`<br />(Default: false)                   | **No**    | If true, sounds triggered by this interaction will be halted when the interaction completes.                                                          |
+| CameraEffect             | `Asset`<br />(Asset Type: `CameraEffect` )        | **No**    | If provided, the CameraEffect will be applied while this interaction is executing.                                                                    |
+| MovementEffects          | `MovementEffects`                                 | **No**    | If provided, apply the movement effects to the User entity while this interaction is executing.                                                       |
+| StartDelay               | `Float`<br />(Default: 0.0f)                      | **No**    | The interaction will wait this many seconds before triggering the effects in this object.                                                             |
+
+**InteractionRules Fields**
+
+| Field Name          | Type                                                                                                | Required? | Notes                                                                                                                                                                                                                                     |
+| ------------------- | --------------------------------------------------------------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| BlockedBy           | `Array`<br />(Element Type: `InteractionType`)<br />(Default: Based on the chain's InteractionType) | **No**    | If provided, this RootInteraction cannot be executed while interaction chains of the provided types are executing.<br />**This field only functions for rules attached to a RootInteraction. It has no effect on an Interaction.**        |
+| Blocking            | `Array`<br />(Element Type: `InteractionType`)                                                      | **No**    | If provided, interaction chains with the specified InteractionTypes cannot be executed while this interaction is executing.                                                                                                               |
+| InterruptedBy       | `Array`<br />(Element Type: `InteractionType`)                                                      | **No**    | If provided, interaction chains with the specified InteractionTypes will cancel this interaction chain when they execute.<br />**This field only functions for rules attached to a RootInteraction. It has no effect on an Interaction.** |
+| Interrupting        | `Array`<br />(Element Type: `InteractionType`)                                                      | **No**    | If provided, interaction chains with the specified InteractionTypes will be canceled when this interaction begins.                                                                                                                        |
+| BlockedByBypass     | `String`                                                                                            | **No**    | If provided, this RootInteraction cannot be blocked by interaction chains whose RootInteraction has this value as an asset tag.                                                                                                           |
+| BlockingBypass      | `String`                                                                                            | **No**    | If provided, this interaction will not block RootInteractions that have the this value as an asset tag.                                                                                                                                   |
+| InterruptedByBypass | `String`                                                                                            | **No**    | If provided, this RootInteraction cannot be canceled by RootInteractions that have this value as an asset tag.                                                                                                                            |
+| InterruptingBypass  | `String`                                                                                            | **No**    | If provided, this interaction will not cancel interaction chains whose RootInteraction has this value as an asset tag.                                                                                                                    |
+
+**InteractionType Values**
+
+- `Primary`
+- `Secondary`
+- `Ability1`
+- `Ability2`
+- `Ability3`
+- `Use`
+- `Pick`
+- `Pickup`
+- `CollisionEnter`
+- `CollisionLeave`
+- `Collision`
+- `EntityStatEffect`
+- `SwapTo`
+- `SwapFrom`
+- `Death`
+- `Wielding`
+- `ProjectileSpawn`
+- `ProjectileHit`
+- `ProjectileMiss`
+- `ProjectileBounce`
+- `Held`
+- `HeldOffhand`
+- `Equipped`
+- `Dodge`
+- `GameModeSwap`
+
+**InteractionSettings Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                        |
+| ---------------- | ------------------------------- | --------- | -------------------------------------------------------------------------------------------- |
+| AllowSkipOnClick | `Boolean`<br />(Default: false) | **No**    | If true, the user will be able to skip this interaction by clicking shortly after it starts. |
+
+**InteractionCameraSettings Fields**
+
+| Field Name  | Type                                             | Required? | Notes                                                                                                                                                           |
+| ----------- | ------------------------------------------------ | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| FirstPerson | `Array`<br />(Element Type: `InteractionCamera`) | **No**    | A list of camera keyframes to be played if the player is in first-person.<br />**The time of each keyframe must be after the keyframe before it in the array.** |
+| ThirdPerson | `Array`<br />(Element Type: `InteractionCamera`) | **No**    | A list of camera keyframes to be played if the player is in third-person.<br />**The time of each keyframe must be after the keyframe before it in the array.** |
+
+**InteractionCamera Fields**
+
+| Field Name | Type                         | Required? | Notes                                                                                                                                       |
+| ---------- | ---------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------- |
+| Time       | `Float`<br />(Default: 0.1f) | **No**    | How long after the interaction begins executing that the camera should arrive at this keyframe.<br />**Cannot be less than or equal to 0.** |
+| Position   | `Vector3`                    | **Yes**   | Where the camera should be located when it arrives at this keyframe.                                                                        |
+| Rotation   | `Direction`                  | **Yes**   | Where the camera should be pointing when it arrives at this keyframe.                                                                       |
+
+### SimpleInteraction
+
+Most interaction types below are inherited from SimpleInteraction and have these
+fields.  If a type does not have these fields, the documentation will mention it.
+
+The purpose of SimpleInteraction is to facilitate Interaction chaining by taking different paths
+based on whether the Interaction succeeded or failed.  The circumstances under which
+a given Interaction fails are generally type-specific (and described in the documentation
+below), but all interactions will be marked failed if they are cancelled via one of the
+many, many mechanisms for doing so.
+
+It is valid to create an interaction asset of type "Simple", which can be valuable when you want to use the
+interaction fields with no additional functionality.
+
+**SimpleInteraction Fields**
+
+| Field Name | Type                                     | Required? | Notes                                                                                          |
+| ---------- | ---------------------------------------- | --------- | ---------------------------------------------------------------------------------------------- |
+| Next       | `Asset`<br />(Asset Type: `Interaction`) | **No**    | After this Interaction has finished, "Next" will be executed if this Interaction did not fail. |
+| Failed     | `Asset`<br />(Asset Type: `Interaction`) | **No**    | After this Interaction has finished, "Failed" will be executed if this Interaction failed.     |
+
+## Flow Control
+
+These are interaction types used to control the flow of an interaction chain and allow interactions
+to be composed into more complex behaviors.  These interaction types generally do not pertain to
+the game and instead pertain to the interaction system itself.
+
+### Condition
+
+This interaction will fail if one of the fields is provided but does not match the current state.
+
+**Condition Fields**
+
+| Field Name       | Type       | Required? | Notes                                                                                                                                                                                    |
+| ---------------- | ---------- | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| RequiredGameMode | `GameMode` | **No**    | If provided, the interaction will fail if the current GameMode does not match the provided value.                                                                                        |
+| Jumping          | `Boolean`  | **No**    | If provided, the interaction will fail if the player's Jumping state does not match the provided value. (i.e. if True, the player must be jumping, if False, the player must not be)     |
+| Swimming         | `Boolean`  | **No**    | If provided, the interaction will fail if the player's Swimming state does not match the provided value. (i.e. if True, the player must be swimming, if False, the player must not be)   |
+| Crouching        | `Boolean`  | **No**    | If provided, the interaction will fail if the player's Crouching state does not match the provided value. (i.e. if True, the player must be crouching, if False, the player must not be) |
+| Running          | `Boolean`  | **No**    | If provided, the interaction will fail if the player's Running state does not match the provided value. (i.e. if True, the player must be running, if False, the player must not be)     |
+| Flying           | `Boolean`  | **No**    | If provided, the interaction will fail if the player's Flying state does not match the provided value. (i.e. if True, the player must be flying, if False, the player must not be)       |
+
+**GameMode Values**
+
+- `Creative`: The game is currently in Creative Mode
+- `Adventure`: The game is currently in Adventure Mode
+
+### FirstClick
+
+This interaction does not inherit from SimpleInteraction and therefore has no Next or Failed fields.
+
+This interaction has two fields that each contain a reference to an Interaction: Click and Hold.  If the root interaction
+of the chain was initiated by a client button/key press (or simulated NPC input) and the input was a tap, then
+the Click interaction is run. if it was a longer press, then the Hold interaction is run.
+
+As a minor implementation detail, this interaction is internally marked as failed when the Hold path is followed.
+This generally shouldn't matter.  If the interaction was not initiated by a key press at all, the Click path will be followed,
+but it seems risky to rely on that behavior.
+
+**FirstClick Fields**
+
+| Field Name | Type                                     | Required? | Notes                                                                                                                                                    |
+| ---------- | ---------------------------------------- | --------- | -------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Click      | `Asset`<br />(Asset Type: `Interaction`) | **No**    | If provided and the root interaction of the chain was initiated by button/key press, this interaction is executed next if the press was a quick tap.     |
+| Hold       | `Asset`<br />(Asset Type: `Interaction`) | **No**    | If provided and the root interaction of the chain was initiated by a button/key press, this interaction is executed next if the press was a longer hold. |
+
+### Interrupt
+
+This interaction can be used to cancel one or more running interaction chains on an entity and **all forked interaction
+chains those chains have spawned that are still currently running**.  All interaction chains canceled in this manner will be marked as
+Failed, which may have additional implications if the canceled chains are themselves forked from
+other chains that are still running.
+
+**Interrupt Fields**
+
+| Field Name     | Type                                           | Required? | Notes                                                                                                                                                                                               |
+| -------------- | ---------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Entity         | `InteractionTarget`<br />(Default: User)       | **Yes**   | The entity that is the owner of the target interaction chains.  This field can indicate the Owner, User, or Target of this interaction chain.                                                       |
+| InterruptTypes | `Array`<br />(Element Type: `InteractionType`) | **No**    | A set of InteractionTypes that are to be interrupted. Only interactions of these types are affected. If null, all types will be interrupted.<br />**(Note: An empty set will interrupt NO TYPES.)** |
+| RequiredTag    | `String`                                       | **No**    | An asset tag that, if provided, the RootInteraction of the interaction chain must have in order to be canceled.                                                                                     |
+| ExcludedTag    | `String`                                       | **No**    | An asset tag that, if provided, the RootInteraction of the interaction chain must not have in order to be canceled.                                                                                 |
+
+**InteractionTarget Values**
+
+- `User` - The user of this interaction chain. The entity whose actions caused this interaction chain to be executed. This is usually the same as the Owner.
+- `Owner` - The owner of this interaction chain. The entity upon whom this interaction chain is executing.
+- `Target` - The entity target of this interaction chain, if any.  This value is mutable (and can therefore come from many places) but most commonly, it is an entity the User was targeting when this interaction chain began executing.
+
+**InteractionType Values**
+
+- `Primary`
+- `Secondary`
+- `Ability1`
+- `Ability2`
+- `Ability3`
+- `Use`
+- `Pick`
+- `Pickup`
+- `CollisionEnter`
+- `CollisionLeave`
+- `Collision`
+- `EntityStatEffect`
+- `SwapTo`
+- `SwapFrom`
+- `Death`
+- `Wielding`
+- `ProjectileSpawn`
+- `ProjectileHit`
+- `ProjectileMiss`
+- `ProjectileBounce`
+- `Held`
+- `HeldOffhand`
+- `Equipped`
+- `Dodge`
+- `GameModeSwap`
+
+### Parallel
+
+This interaction does not inherit from SimpleInteraction and therefore has no Next or Failed fields.
+
+This interaction has a field `Interactions` that is an array of RootInteraction assets. The list must contain at least
+two RootInteractions.  This interaction will fork all of its children except for the first into their
+own interaction chains and immediately complete. After this interaction completes, this interaction chain will
+execute the first RootInteraction in the `Interactions` list.
+
+This interaction does not have any failure conditions and is indifferent to the fate of the forked interaction chains.
+
+**Parallel Fields**
+
+| Field Name   | Type                                                | Required? | Notes                                                         |
+| ------------ | --------------------------------------------------- | --------- | ------------------------------------------------------------- |
+| Interactions | `AssetArray`<br />(Element Type: `RootInteraction`) | **Yes**   | An array of RootInteractions that will be forked or executed. |
+
+### Repeat
+
+This interaction has a field `ForkInteractions` that is an asset of type RootInteraction. This interaction will fork that
+RootInteraction into its own interaction chain and then wait for it to complete. If the RootInteraction fails, this
+interaction will complete immediately and be marked failed. Otherwise, the RootInteraction will be forked and run again,
+up to a specified total number of times.
+
+**Repeat Fields**
+
+| Field Name       | Type                                                                                   | Required? | Notes                                                                                                                                                                                                              |
+| ---------------- | -------------------------------------------------------------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| ForkInteractions | `Asset`<br />(Asset Type: `RootInteraction`)                                           | **Yes**   | A RootInteraction that will be forked.                                                                                                                                                                             |
+| Repeat           | `Integer`<br />(Default: 1)<br />**Must be -1 or a positive integer. 0 is not valid.** | **No**    | The total number of times to fork ForkInteractions. If -1 is provided, ForkInteractions will continue being forked and executed indefinitely, until this interaction is cancelled or until ForkInteractions fails. |
+
+### Replace
+
+This interaction does not inherit from SimpleInteraction and therefore has no Next or Failed fields.
+
+This interaction uses the InteractionVars system that is avaiable for items. InteractionVars are RootInteractions that
+can be attached to an Item asset with a name.
+
+This interaction specifies a var name, and if this interaction chain was executed through
+an item and that item has an InteractionVar of the same name, then this interaction will immediately execute
+the RootInteraction on the var.  Otherwise, it will execute the default RootInteraction specified in this interaction.
+If no default is specified, then this interaction will be marked as failed.
+
+**Replace Fields**
+
+| Field Name   | Type                                         | Required? | Notes                                                                                                                                                                                                           |
+| ------------ | -------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Var          | `String`                                     | **Yes**   | The name of the InteractionVar to execute.                                                                                                                                                                      |
+| DefaultValue | `Asset`<br />(Asset Type: `RootInteraction`) | **No**    | The RootInteraction to execute if the owning item does not have an InteractionVar by the specified name. If not provided, the interaction will be marked as failed instead.                                     |
+| DefaultOk    | `Boolean`<br />(Default: false)              | **No**    | If false, then an angry message will be printed to the server logs if the owning item does not have an InteractionVar by the specified name.  The functioning of this interaction will be otherwise unaffected. |
+
+### RunRootInteraction
+
+This interaction immediately executes the provided RootInteraction as part of this interaction chain. This interaction
+does not have any failure conditions.
+
+**RunRootInteraction Fields**
+
+| Field Name      | Type                                         | Required? | Notes                           |
+| --------------- | -------------------------------------------- | --------- | ------------------------------- |
+| RootInteraction | `Asset`<br />(Asset Type: `RootInteraction`) | **Yes**   | The RootInteraction to execute. |
+
+### Selector
+
+This interaction will execute a Selector to find entities and/or blocks (depending on the Selector) and fork off an
+interaction chain for each located entity or block. This interaction will not wait for those interaction chains
+to complete and is indifferent to their fate. The forked interaction chains will use the located entity/block as
+their target entity/target block. Each entity or block will only fork one interaction chain over the life of this
+interaction.  The Selector is guaranteed to run once for each execution of this interaction, but some Selectors
+are intended to be run over a period of time and sweep across an area to locate targets. In order to use those Selectors
+properly, you will need to extend the execution time of this interaction using `RunTime` or `WaitForAnimationToFinish`.
+The Selector will be executed repeatedly over the lifetime of the interaction.
+
+If the Selector is configured to locate entities, you can add additional sets of entity matching rules. If a located entity
+matches one of the rules, the matching RootInteraction will be forked instead of the standard `HitEntity` RootInteraction.
+
+Entities located by the Selector will be ignored if they do not have a NetworkId, if they are dead, or if they are invulnerable.
+The only exception to this rule is that players in Creative Mode that are marked to receive hits will not be ignored.
+
+This interaction's failure conditions are configurable via the `FailOn` field. You can configure this interaction to never
+fail, to fail if the Selector does not locate any blocks before this interaction finishes executing, to fail if the
+Selector does not locate any entities before this interaction finishes executing, or to fail in either case.
+
+**Selector Fields**
+
+| Field Name     | Type                                         | Required? | Notes                                                                                                                                                                                                                                     |
+| -------------- | -------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Selector       | `Selector`                                   | **Yes**   | The Selector is executed at least once and may be executed repeatedly to locate blocks and/or entities in an area.                                                                                                                        |
+| HitEntity      | `Asset`<br />(Asset Type: `RootInteraction`) | **No**    | If included and the `Selector` locates an entity that does not match any `HitEntityRules`, this RootInteraction will be forked into a new interaction chain with the located entity as the target entity.                                 |
+| HitEntityRules | `Array`<br />(Element Type: `HitEntity`)     | **No**    | If included, these rules will be matched against any entity located by the `Selector`. If an entity matches a set of rules, the RootInteraction associated with the rules will be forked instead of the standard `HitEntity` interaction. |
+| HitBlock       | `Asset`<br />(Asset Type: `RootInteraction`) | **No**    | If included and the `Selector` locates a block, this RootInteraction will be forked into a new interaction chain with the located block as the block target.                                                                              |
+| FailOn         | `FailOnType`<br />(Default: `Neither`)       | **No**    | Defines under what circumstances this interaction will fail.  It can be marked to fail when it completes without locating any blocks, it can be marked to fail when it completes without locating any entities, both, or neither.         |
+| IgnoreOwner    | `Boolean`<br />(Default: true)               | **No**    | If true, the Selector will not locate the User entity of this interaction.                                                                                                                                                                |
+
+**HitEntity Fields**
+
+| Field Name | Type                                         | Required? | Notes                                                                                                 |
+| ---------- | -------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------- |
+| Matchers   | `Array`<br />(Element Type: `EntityMatcher`) | **Yes**   | A set of rules that an entity must match. An entity must successful match all rules to be considered. |
+| Next       | `Asset`<br />(Asset Type: `RootInteraction`) | **Yes**   | The RootInteraction to fork if an entity matches all rules.                                           |
+
+**EntityMatcher Fields**
+
+| Field Name | Type                            | Required? | Notes                                                                                                     |
+| ---------- | ------------------------------- | --------- | --------------------------------------------------------------------------------------------------------- |
+| Type       | `String`                        | **Yes**   | If provided, specifies a type of EntityMatcher to use. Each matcher type may come with additional fields. |
+| Invert     | `Boolean`<br />(Default: false) | **No**    | If true, an entity must fail this rule for it to be marked as succeeded.                                  |
+
+**EntityMatcher Type: Player**
+
+This EntityMatcher will succesfully match the entity only if they are a player.
+
+**EntityMatcher Type: Vulnerable**
+
+This Entitymatcher will successfully match the entity only if they are not marked as invulnerable.
+
+**FailOnType Values**
+
+- `Neither`
+- `Entity`
+- `Block`
+- `Either`
+
+### Serial
+
+This interaction does not inherit from SimpleInteraction and therefore has no Next or Failed fields.
+
+This interaction has a field `Interactions` which is a list of Interaction assets. This interaction immediately
+completes and the interaction chain continues by executing the interactions in the list one at a time. This
+interaction does not have any failure conditions.
+
+**Serial Fields**
+
+| Field Name   | Type                                            | Required? | Notes                                      |
+| ------------ | ----------------------------------------------- | --------- | ------------------------------------------ |
+| Interactions | `AssetArray`<br />(Element Type: `Interaction`) | **Yes**   | An array of Interaction assets to execute. |
+
+## Cooldowns
+
+RootInteractions interface with a complex cooldown system that can be used for a variety of purposes. Aside from simply
+adding an important aspect of resource management to your game design, cooldowns can be used to ensure that click-activated
+interaction chains don't repeatedly spam if the player holds down the input.
+
+By default, every RootInteraction has a cooldown timer that is keyed to the RootInteraction name, and by default, it
+will launch a cooldown of 0.35 seconds when activated by client input.  Otherwise, no cooldown will be activated.  However,
+by configuring your RootInteraction, you can change the key for the cooldown (so that multiple RootInteractions can share
+a single cooldown), set the cooldown timer to whatever you like, and configure multiple charges that can build up over time
+to allow the entity to activate the RootInteraction multiple times before being forced to pause.
+
+One important concept to keep in mind is the difference between **cooldown** and **charge time**.  The cooldown, if any,
+is activated each time a RootInteraction triggers, even if the player has more available charges. If the RootInteraction
+is configured to use charges, then they will gradually build up over time. In order for a RootInteraction to be activated,
+the cooldown (if any) must be expired, and the RootInteraction must have at least one charge (if it has been
+configured to use charges).
+
+Bear in mind that the entire Cooldown configuration is shared between different RootInteractions with the same cooldown id.
+If you activate an ability with 5 charges and a short cooldown and then another ability with a much longer cooldown and no
+charges, the second ability will use the cooldown properties of the first ability until/unless the first ability finishes
+charging and is cleared from the system.  You should generally only have multiple RootInteractions share a cooldown id
+if they have the same configuration.
+
+The interactions below interact with the cooldown system to allow you to manipulate cooldowns via the interaction system. By
+using these interactions, you can have several interaction chains with different cooldown configurations share cooldowns
+that are checked and activated as part of the interaction chain itself, or have some components of an interaction change
+use a second cooldown separate from the main one.
+
+### CooldownCondition
+
+**CooldownCondition Fields**
+
+This interaction will fail if the specified cooldown id is on cooldown for the User entity.  This interaction will only
+function for players- the interaction will always succeed for NPCs.  In order for this interaction to succeed, the
+cooldown, if any, must have expired and at least one charge, if any, must have filled.
+
+| Field Name | Type     | Required? | Notes                     |
+| ---------- | -------- | --------- | ------------------------- |
+| Id         | `String` | **Yes**   | The cooldown id to check. |
+
+### IncrementCooldown
+
+**IncrementCooldown Fields**
+
+This interaction will modify a cooldown that is currently active on the User entity, allowing charges and remaining
+cooldown to be modified.
+Despite its name, this interaction can be used to reduce a cooldown as well as increase it. If the cooldown is not
+currently active, this interaction will have no effect. The interaction has no special failure conditions.
+
+| Field Name        | Type                        | Required? | Notes                                                                                                                                                                                                                                                                                     |
+| ----------------- | --------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Id                | `String`                    | **No**    | If provided, the cooldown id of the cooldown to be manipulated. If not provided, the cooldown id of the current chain's RootInteraction will be used.                                                                                                                                     |
+| Time              | `Float`<br />(Default: 0.0) | **No**    | The amount to increase the remaining cooldown by. Can be negative. The remaining cooldown time will not be reduced below zero or increased above the maximum cooldown time.                                                                                                               |
+| ChargeTime        | `Float`<br />(Default: 0.0) | **No**    | The amount to increase the remaining time until the next charge is filled by. Can be negative. The remaining charge time cannot be reduced below zero or increased above the maximum cooldown time. **This will not work on abilities that have a maximum of 1 charge, for some reason.** |
+| Charge            | `Integer`<br />(Default: 0) | **No**    | The amount to increase the number of charges by. Can be negative. The number of charges cannot be reduced below 0 or increased above the maximum.                                                                                                                                         |
+| InterruptRecharge | `Boolean`(Default: false)   | **No**    | If true and `Charge` is not 0, will reset the remaining time to the next charge to the maximum value after changing the charge count.                                                                                                                                                     |
+
+### ResetCooldown
+
+This interaction will trigger a cooldown on the User entity with a specified configuration. The charges will be refilled
+but the cooldown will be immediately triggered.  The mechanisms for deciding on the configuration are a little bit complicated.
+You may specify a cooldown configuration via the `Cooldown` field. If you do not include an `Id` field, then the
+interaction chain's RootInteraction will be used for any field not specified in the configuration. If there is an active
+cooldown under the specified `Id` (or under the RootInteraction's cooldown id if none is specified) then the fields
+from that active cooldown will overwrite data in the RootInteraction's cooldown, but not data in your `Cooldown` field.
+
+**ResetCooldown Fields**
+
+| Field Name | Type                  | Required? | Notes                                                        |
+| ---------- | --------------------- | --------- | ------------------------------------------------------------ |
+| Cooldown   | `InteractionCooldown` | **No**    | A cooldown configuration to use for the new, reset cooldown. |
+
+**InteractionCooldown Fields**
+
+| Field Name        | Type                                 | Required? | Notes                                                                                                                                                                                                 |
+| ----------------- | ------------------------------------ | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Id                | `String`                             | **No**    | The cooldown id to use for this cooldown. If not provided, the RootInteraction's cooldown id will be used, if any.                                                                                    |
+| Cooldown          | `Float`<br />(Default: 0.0)          | **No**    | The duration of the cooldown, in seconds.                                                                                                                                                             |
+| Charges           | `Array`<br />(Element Type: `Float`) | **No**    | If provided, a list of how many charges this cooldown can build, and how long each charge takes to build, in seconds.                                                                                 |
+| InterruptRecharge | `Boolean`<br />(Default: false)      | **No**    | If true, the charge time will be reset when the number of charges changes.                                                                                                                            |
+| ClickBypass       | `Boolean`<br />(Default: false)      | **No**    | If true, RootInteractions keyed to this cooldown can still be activated when it is on cooldown provided that the RootInteraction was triggered by a distinct key or mouse button press on the client. |
+
+### TriggerCooldown
+
+This interaction is similar to ResetCooldown, except instead of refilling the cooldown's charges, one charge will be deducted
+as normal.
+
+**TriggerCooldown Fields**
+
+| Field Name | Type                  | Required? | Notes                                                        |
+| ---------- | --------------------- | --------- | ------------------------------------------------------------ |
+| Cooldown   | `InteractionCooldown` | **No**    | A cooldown configuration to use for the new, reset cooldown. |
+
+**InteractionCooldown Fields**
+
+| Field Name        | Type                                 | Required? | Notes                                                                                                                                                                                                 |
+| ----------------- | ------------------------------------ | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Id                | `String`                             | **No**    | The cooldown id to use for this cooldown. If not provided, the RootInteraction's cooldown id will be used, if any.                                                                                    |
+| Cooldown          | `Float`<br />(Default: 0.0)          | **No**    | The duration of the cooldown, in seconds.                                                                                                                                                             |
+| Charges           | `Array`<br />(Element Type: `Float`) | **No**    | If provided, a list of how many charges this cooldown can build, and how long each charge takes to build, in seconds.                                                                                 |
+| InterruptRecharge | `Boolean`<br />(Default: false)      | **No**    | If true, the charge time will be reset when the number of charges changes.                                                                                                                            |
+| ClickBypass       | `Boolean`<br />(Default: false)      | **No**    | If true, RootInteractions keyed to this cooldown can still be activated when it is on cooldown provided that the RootInteraction was triggered by a distinct key or mouse button press on the client. |
+
+## Combo Chains
+
+Hytale additionally comes with a rich "combo chaining" system, which allows several inputs in a row to result in different
+attacks and special moves.  Rather than being attached to the RootInteraction like the cooldown system, these are
+primarily driven by the `Chaining` interaction.
+
+### Chaining
+
+This interaction does not inherit from SimpleInteraction and therefore has no Failed field. Its Next field works differently
+from most interaction types.
+
+Chaining is a type of flow control interaction- each time a Chaining interaction with the same `ChainId` is called, a single
+interaction in the `Next` list is chosen and the others are ignored. The first time the `ChainId` is used, the first
+interaction in the list is chosen, the next time the second, etc. Once the end of the list is reached, the first
+interaction will be chosen again.
+
+Bear in mind: the progress through the Next list is based on the **ChainId**, not the interaction!  That means that two
+different Chaining interactions can share a single combo chain. You could have a pair of daggers that attacks with
+the left when the left mouse button is clicked and with the right when the right mouse button is clicked.  You could give
+both interaction chains a Chaining interaction with the same `ChainId` and three `Next` entries that do a light-light-heavy
+combo.  Each specific hit would occur with either the left or the right knife based on which button you clicked, but
+the combo would be otherwise identical regardless of which you chose.
+
+The Chaining interaction also has a concept called "flags".  It is possible to attach named flags to a `ChainId` by using
+the ChainFlag interaction.  Then, you specify the flag name in Chaining's `Flags` field. If a Flag is active when the
+Chaining interaction is run, the Flag's interaction will be run instead of the appropriate interaction in `Next`.
+Bear in mind: the entity's progress through the `Next` list still advances, the resulting `Next` interaction is just not
+run.  Only one flag can be active at a time.
+
+Lastly, it is possible to cancel the entity's progress through the combo chain and reset them to the first interaction in
+the list. This can be done with the CancelChain interaction, but it will also happen automatically if the player does
+not trigger an interaction with the ChainId for the specified ChainingAllowance.  When either of these happen, all flags will be
+canceled as well.
+
+All of these effects are triggered on the User entity only. Non-players can use the chaining system, but Flags do not currently
+work for non-players.  This interaction has no special failure conditions.
+
+**Chaining Fields**
+
+| Field Name        | Type                                                       | Required? | Notes                                                                                                                                                                                                                       |
+| ----------------- | ---------------------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| ChainId           | `String`                                                   | **No**    | If provided, acts as a key that multiple Chaining interactions can use to share combo chain progress and flags. If not provided, a unique ChainId will be generated for this interaction.                                   |
+| ChainingAllowance | `Double`<br />(Default: 0.0)                               | **No**    | If, at the time this interaction is triggered, it has been this long in seconds since the last time a Chaining interaction with the same ChainId was executed, all state for this ChainId will be cleared before execution. |
+| Next              | `AssetArray`<br />(Element Type: `Interaction`)            | **Yes**   | A list of interactions to cycle between each time this interaction is run.                                                                                                                                                  |
+| Flags             | `Map`<br />(Key Type: `String`, Value Type: `Interaction`) | **No**    | A map of flag names to interactions to run if the flag is active when this interaction executes.                                                                                                                            |
+
+### CancelChain
+
+This interaction resets all progress and flag data on the User entity for the provided `ChainId`.  The next time a Chaining
+interaction is called for the provided `ChainId`, it will begin at the first interaction in the `Next` list. This
+interaction has no special failure conditions.
+
+**CancelChain Fields**
+
+| Field Name | Type     | Required? | Notes                                 |
+| ---------- | -------- | --------- | ------------------------------------- |
+| ChainId    | `String` | **Yes**   | A ChainId whose data should be reset. |
+
+### ChainFlag
+
+This interaction activates a flag on the User entity for the provided `ChainId`, which can be used to change behavior the
+next time a Chaining interaction with this `ChainId` is run. This will overwrite any flag that has
+already been raised. This interaction will have no effect for non-players. This interaction has no special failure
+conditions.
+
+| Field Name | Type     | Required? | Notes                                        |
+| ---------- | -------- | --------- | -------------------------------------------- |
+| ChainId    | `String` | **Yes**   | A ChainId on whom the flag should be raised. |
+| Flag       | `String` | **Yes**   | The name of the flag to raise.               |
+
+## Charging
+
+A unique flow-control interaction that is frequently used is the Charging interaction.  It is a flow-control interaction
+that delays while the input button used to trigger the interaction chain is held.  When it is released (or the interaction
+is forced to end), the interaction chain can continue with a different interaction based on how long the input was held
+for.
+
+These interactions are all related by either being the Charging interaction, or other interaction types that inherit the
+Charging interaction's behavior.
+
+### Charging
+
+This interaction does not inherit from SimpleInteraction and therefore its Next field works different from most interactions.
+This interaction adds its own Failed field which works the same way that SimpleInteraction's does.
+
+This interaction only works properly when its interaction chain was triggered by a client key or button press (or
+NPC-simulated equivalent). This interaction will continue executing for as long as the key or button press is held (with
+some exceptions, covered below) by the User entity.  Like other interactions, it has a `Next` field indicating which interaction to execute
+after this one, but the field is a map from `Float` values to `Interaction` assets. When this interaction ends, either
+due to the input being released or the charge duration completing, this interaction will determine the largest `Float` key that is less
+than the amount of time in seconds that the interaction was executing for.  The Interaction mapped to that key will be
+executed next.
+
+The interaction includes some cancellation conditions that are specific to this interaction. For instance, the interaction
+has a `CancelOnOtherClick` field that matches the field on RootInteraction. If it is active on this interaction but not
+the RootInteraction, then clicking while charging will cancel this interaction (and execute the `Failed` interaction rather
+than any of the `Next` interactions) but otherwise continue the interaction chain.
+
+Another valuable feature Charging has is the `Forks` field.  For input-triggered interactions that are triggered while the
+Charging interaction is executing, you can add an entry for the relevant InteractionType to this field and instead of
+triggering the usual interaction chain based on held item, targeted block, etc. the RootInteraction specified in the
+`Forks` field will be triggered.  This can unlock rich attack modes and behaviors. For instance, having a shield bash attack
+triggered off left click while blocking, or a special attack that triggers when both mouse buttons are pressed at the
+same time.
+
+There are two modes of operation for the Charging interaction. One is to have the ability charge for as long
+as the input is held and only end execution when the entity releases the input.  Bows in the main Hytale game work
+that way.  That is accomplished by setting `AllowIndefiniteHold` to true.  Another mode of operation is to have the
+interaction complete execution when the execution time has surpassed the largest key value in the `Next` field and
+immediately begin executing the Interaction mapped to that key.  Food in the main Hytale game work like this.  It
+is accomplished by setting `AllowIndefiniteHold` to false.
+
+One pitfall to be careful of when setting `AllowIndefiniteHold` to false is the way it interacts with cooldowns.\
+Normally, input-initiated interaction chains start a 0.35s cooldown on the triggered RootInteraction that prevents
+holding the mouse button from immediately spamming a new interaction when the first one completes.  However, if the
+duration of a Charging interaction is longer than 0.35s, then the cooldown will have already completed when the
+interaction chain finishes, which will often result in a new execution beginning immediately before the player can
+stop pressing the mouse button.  One solution for this problem is to add a `Simple` interaction to the end of your
+interaction chain with a `RunTime` of 0.35s to simulate the cooldown.  Alternatively, you can add a longer cooldown
+(the maximum duration of your Charging interaction plus 0.35s) to the RootInteraction. However, the longer cooldown is
+not always desirable, as the interaction may have ended prematurely, resulting in an unusually long lockout between
+executions.
+
+**Charging Fields**
+
+| Field Name                         | Type                                                                    | Required? | Notes                                                                                                                                                                                                                                                                                                                                                                                       |
+| ---------------------------------- | ----------------------------------------------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| FailOnDamage                       | `Boolean`<br />(Default: false)                                         | **No**    | If true, this interaction will fail and end immediately if the User entity takes any damage while it is executing.                                                                                                                                                                                                                                                                          |
+| CancelOnOtherClick                 | `Boolean`<br />(Default: true)                                          | **No**    | If true, this interaction will fail and end immediately if the User entity sends another button or key press while it is executing.                                                                                                                                                                                                                                                         |
+| Forks                              | `Map`<br />(Key Type: `InteractionType`, Value Type: `RootInteraction`) | **No**    | A map of InteractionType to RootInteraction. If entity input triggers the InteractionType while this interaction is executing, the mapped RootInteraction will be forked into its own interaction chain. This will happen instead of the usual handling for that InteractionType.  This fork will occur even if `CancelOnOtherClick` is set to true.                                        |
+| Failed                             | `Asset`<br />(Asset Type: `Interaction`)                                | **No**    | After this Interaction has finished, "Failed" will be executed if this Interaction failed.                                                                                                                                                                                                                                                                                                  |
+| AllowIndefiniteHold                | `Boolean`<br />(Default: false)                                         | **No**    | If true, this interaction will continue executing for as long as the User entity continues to hold the input. If false, execution will end as soon as the execution time in seconds reaches the largest key value in the `Next` map.                                                                                                                                                        |
+| DisplayProgress                    | `Boolean`<br />(Default: true)                                          | **No**    | If true, players executing this interaction will see a progress bar will be displayed below their cursor indicating how close to reaching the highest key value in `Next` they are.                                                                                                                                                                                                         |
+| Next                               | `Map`<br />(Key Type: `Float`, Value Type: `Interaction`)               | **No**    | A map from `Float` to `Interaction`.  When this interaction successfully finishes executing (either because the input was released or because the maximum duration was reached), this interaction will find the `Float` value with the largest duration in seconds that is less than the amount of time this interaction executed for. That key's mapped Interaction will then be executed. |
+| MouseSensitivityAdjustmentTarget   | `Float`<br />(Default: 1.0)                                             | **No**    | While charging, this mouse sensitivity multiplier will gradually be applied.                                                                                                                                                                                                                                                                                                                |
+| MouseSensitivityAdjustmentDuration | `Float`<br />(Default: 1.0)                                             | **No**    | Duration in seconds. After this many seconds, `MouseSensitivityAdjustmentTarget` will be fully applied to the mouse sensitivity.                                                                                                                                                                                                                                                            |
+| Delay                              | `ChargingDelay`                                                         | **No**    | Settings that allow charging progress to be pushed back when the User entity takes damage.                                                                                                                                                                                                                                                                                                  |
+
+**ChargingDelay Fields**
+
+| Field Name    | Type                        | Required? | Notes                                                                                                                                                                                                                                                                     |
+| ------------- | --------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| MinHealth     | `Float`<br />(Default: 0.0) | **No**    | Damage taken as a percentage of entity health (0.0-1.0). If a hit deals less than this much damage, no pushback will be applied.  If a hit deals exactly this much damage, `MinDelay` seconds worth of pushback will be applied.                                          |
+| MaxHealth     | `Float`<br />(Default: 0.0) | **No**    | Damage taken as a percentage of entity health (0.0-1.0). If a hit deals at least this much damage, `MaxDelay` seconds worth of pushback will be applied.                                                                                                                  |
+| MinDelay      | `Float`<br />(Default: 0)   | **No**    | The amount of pushback, in seconds, to apply if the entity takes a hit that deals `MinHealth` damage. The amount of pushback applied by a hit is a gradiant between `MinDelay` and `MaxDelay` based on the amount of damage between `MinHealth` and `MaxHealth`.          |
+| MaxDelay      | `Float`<br />(Default: 0)   | **No**    | The amount of pushback, in seconds, to apply if the entity takes a hit that deals at least `MaxHealth` damage. The amount of pushback applied by a hit is a gradiant between `MinDelay` and `MaxDelay` based on the amount of damage between `MinHealth` and `MaxHealth`. |
+| MaxTotalDelay | `Float`<br />(Deault: 0)    | **No**    | The maximum amount of pushback the entity can receive over the course of a single charge, regardless of how many times they are hit.                                                                                                                                      |
+
+**InteractionType Values**
+
+- `Primary`
+- `Secondary`
+- `Ability1`
+- `Ability2`
+- `Ability3`
+- `Use`
+- `Pick`
+- `Pickup`
+- `CollisionEnter`
+- `CollisionLeave`
+- `Collision`
+- `EntityStatEffect`
+- `SwapTo`
+- `SwapFrom`
+- `Death`
+- `Wielding`
+- `ProjectileSpawn`
+- `ProjectileHit`
+- `ProjectileMiss`
+- `ProjectileBounce`
+- `Held`
+- `HeldOffhand`
+- `Equipped`
+- `Dodge`
+- `GameModeSwap`
+
+### Wielding
+
+This interaction is inherited from Charging rather than SimpleInteraction.  However, its `Failed` and `Next` fields function
+identically to SimpleInteraction.  It does not inherit all fields from Charging, so be sure to pay close attention to
+the field list below.
+
+This interaction drives most blocking behavior in the game. While this interaction is executing, attacks made against
+the Owner entity will (conditionally) trigger effects defined in this interaction.  Unlike the Charging interaction,
+this interaction can always execute indefinitely and will only end when it fails or when the input is released.
+
+One option available in Wielding is `AngledWielding`, which allows damage and knockback modifiers to only be applied
+depending on the direction the attack against the Owner entity is coming from.  The AngledWielding type has a
+field `Angle` which determines which direction the protection points relative to the player (0 is the player's
+front), and `AngleDistance` which determines how wide the cone of protection extends around the player.  Block effects
+from this interaction (such as `BlockedEffects`, `BlockedInteractions`, and `StaminaCost`) will only apply if
+the DamageCause matches `DamageModifiers` OR if the DamageCause matches `AngledWielding.DamageModifiers` and
+the source of the damage matches `Angle` and `AngleDistance`.  It is possible for damage and knockback multipliers
+specified on both this interaction's modifier fields and `AngledWielding`'s modifier fields to stack, if both
+have entries for the same DamageCause.
+
+This interaction will only have an effect on damage taken by one of the DamageCause entries in `DamageModifiers` or
+`AngledWielding.DamageModifiers`.  If a DamageCause is in `DamageModifiers`, then the block effect will be triggered
+and the damage modifier applied regardless of what direction the Owner entity is attacked from.  If a DamageCause is in
+`AngledWielding.DamageModifiers`, then the damage modifier is only applied if the
+
+\*\* Wielding Fields\*\*
+
+| Field Name          | Type                                                                    | Required? | Notes                                                                                                                                                                                                                                                                                                                                                                                                      |
+| ------------------- | ----------------------------------------------------------------------- | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| FailOnDamage        | `Boolean`<br />(Default: false)                                         | **No**    | If true, this interaction will fail and end immediately if the User entity takes any damage while it is executing.                                                                                                                                                                                                                                                                                         |
+| CancelOnOtherClick  | `Boolean`<br />(Default: true)                                          | **No**    | If true, this interaction will fail and end immediately if the User entity sends another button or key press while it is executing.                                                                                                                                                                                                                                                                        |
+| Forks               | `Map`<br />(Key Type: `InteractionType`, Value Type: `RootInteraction`) | **No**    | A map of InteractionType to RootInteraction. If entity input triggers the InteractionType while this interaction is executing, the mapped RootInteraction will be forked into its own interaction chain. This will happen instead of the usual handling for that InteractionType.  This fork will occur even if `CancelOnOtherClick` is set to true (after which this interaction chain will be canceled). |
+| Next                | `Asset`<br />(Asset Type: `Interaction`)                                | **No**    | After this interaction has finished, "Next" will be executed if this interaction did not fail.                                                                                                                                                                                                                                                                                                             |
+| Failed              | `Asset`<br />(Asset Type: `Interaction`)                                | **No**    | After this interaction has finished, "Failed" will be executed if this interaction failed.                                                                                                                                                                                                                                                                                                                 |
+| DamageModifiers     | `Map`<br />(Key Type: `DamageCause`, Value Type: `Float`)               | **No**    | A map from DamageCause to Float, where the Float is multiplied against any damage received from the mapped DamageCause while this interaction is executing.                                                                                                                                                                                                                                                |
+| KnockbackModifiers  | `Map`<br />(Key Type: `DamageCause`, Value Type: `Float`)               | **No**    | A map from DamageCause to Float, where the Float is multiplied against any knockback force received from the mapped DamageCause while this interaction is executing.                                                                                                                                                                                                                                       |
+| AngledWielding      | `AngledWielding`                                                        | **No**    | Configuration to only trigger block effects from certain angles.                                                                                                                                                                                                                                                                                                                                           |
+| StaminaCost         | `StaminaCost`                                                           | **No**    | If the Owner entity receives damage that matches `DamageModifiers` or `AngledWielding` while this interaction is executing, then the entity's stamina will be deducted according to this configuration.                                                                                                                                                                                                    |
+| BlockedEffects      | `DamageEffects`                                                         | **No**    | If the Owner entity receives damage that matches `DamageModifiers` or `AngledWielding` while this interaction is executing, then these effects will be applied to the instance of damage.                                                                                                                                                                                                                  |
+| BlockedInteractions | `Asset`<br />(Asset Type: `RootInteraction`)                            | **No**    | If the Owner entity receives damage that matches `DamageModifiers` or `AngledWielding` while this interaction is executing, then this RootInteraction will be launched as a brand new interaction chain with the Owner entity as both Owner and User, and the attacker as the Target entity.  This new interaction chain is, notably, brand new, **not** forked from the current one.                      |
+
+**AngledWielding Fields**
+
+| Field Name         | Type                                                      | Required? | Notes                                                                                                                                                                                                            |
+| ------------------ | --------------------------------------------------------- | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Angle              | `Float`<br />(Default: 0.0)                               | **No**    | Angle in degrees relative to the Owner entity where the angled protection is centered. 0.0 means pointed towards the front of the Owner entity.                                                                  |
+| AngleDistance      | `Float`<br />(Default: 0.0)                               | **No**    | Angle in degrees indicating how wide the cone of protection is.                                                                                                                                                  |
+| DamageModifiers    | `Map`<br />(Key Type: `DamageCause`, Value Type: `Float`) | **No**    | A map from DamageCause to Float, where the Float is multiplied against any damage received from the mapped DamageCause received from within the cone of protection while this interaction is executing.          |
+| KnockbackModifiers | `Map`<br />(Key Type: `DamageCause`, Value Type: `Float`) | **No**    | A map from DamageCause to Float, where the Float is multiplied against any knockback force received from the mapped DamageCause received from within the cone of protection while this interaction is executing. |
+
+**StaminaCost Fields**
+
+| Field Name | Type                                             | Required? | Notes                                                                                                                                                                                                                                                |
+| ---------- | ------------------------------------------------ | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| CostType   | `CostType`<br />(Default: `MaxHealthPercentage`) | **No**    | How to calculate stamina consumed by blocking from the raw pre-block damage. If `Damage`, then the stamina consumed will be `rawDamage / Value`. If `MaxHealthPercentage`, then the stamina consumed will be `rawDamage / (EntityMaxHealth * Value)` |
+| Value      | `Float`<br />(Default: 0.04)                     | **No**    | The value to use in the `CostType` formula.                                                                                                                                                                                                          |
+
+**DamageEffects Fields**
+
+| Field Name             | Type                                         | Required? | Notes                                                                           |
+| ---------------------- | -------------------------------------------- | --------- | ------------------------------------------------------------------------------- |
+| ModelParticles         | `Array`<br />(Element Type: `ModelParticle`) | **No**    | Particle systems to trigger in the first-person view.                           |
+| WorldParticles         | `Array`<br />(Element Type: `WorldParticle`) | **No**    | Particle systems to trigger in the third-person view.                           |
+| LocalSoundEventId      | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | 2D sound to play locally to the attacking entity if they are a player.          |
+| WorldSoundEventId      | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | Sound to play in the world at the Owner entity's location.                      |
+| PlayerSoundEventId     | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | 2D sound to play locally to the Owner entity if they are a player.              |
+| ViewDistance           | `Double`<br />(Default: 75.0)                | **No**    | Distance at which these effects should play for other players.                  |
+| Knockback              | `Knockback`                                  | **No**    | The properties of the knockback that will be applied.                           |
+| CameraEffect           | `Asset`<br />(Asset Type: `CameraEffect`)    | **No**    | CameraEffect to briefly apply locally to the Owner entity if they are a player. |
+| StaminaDrainMultiplier | `Float`<br />(Default: 1.0)                  | **No**    | This multiplier is applied to the `StaminaCost`, if any.                        |
+
+**Knockback Fields**
+
+| Field Name     | Type                                       | Required? | Notes                                                                                                                      |
+| -------------- | ------------------------------------------ | --------- | -------------------------------------------------------------------------------------------------------------------------- |
+| Type           | `String`                                   | **No**    | If provided, specifies a type of knockback to use. Each knockback type may come with additional fields.                    |
+| Force          | `Double`<br />(Default: 0.0)               | **No**    | The amount of force to apply to the Owner entity.                                                                          |
+| Duration       | `Double`<br />(Default: 0.0)               | **No**    | If 0.0, apply the force as a single impulse.  If more, continuously apply the force over a period of time.                 |
+| VelocityType   | `ChangeVelocityType`<br />(Default: `Add`) | **No**    | How to apply the force, either adding it to the entity's current velocity, or setting the velocity to the knockback force. |
+| VelocityConfig | `VelocityConfig`                           | **No**    | Characteristics of friction as the Owner entity is thrown by this knockback.                                               |
+
+**Knockback Type: Force**
+
+Apply the calculated knockback force along the provided direction.
+
+| Field Name | Type                         | Required? | Notes                                                                                |
+| ---------- | ---------------------------- | --------- | ------------------------------------------------------------------------------------ |
+| Direction  | `Vector3`<br />(Default: Up) | **No**    | Which direction the player should be flung, relative to the direction of the attack. |
+
+**Knockback Type: Point**
+
+Apply the calculated knockback force laterally along the XZ plane, plus provided Y velocity.
+
+| Field Name | Type                        | Required? | Notes                                                                                                   |
+| ---------- | --------------------------- | --------- | ------------------------------------------------------------------------------------------------------- |
+| OffsetX    | `Integer`<br />(Default: 0) | **No**    | Offset the source position of the knockback left or right perpendicular to the direction of the attack. |
+| OffsetZ    | `Integer`<br />(Default: 0) | **No**    | Offset the source position of the knockback, forward or backward along the directon of the attack.      |
+| RotateY    | `Integer`<br />(Default: 0) | **No**    | Rotate the knockback direction around the Y axis, where 0 is the default attack direction.              |
+| VelocityY  | `Float`<br />(Default: 0.0) | **No**    | Add vertical velocity to the knockback force after the direction and force has been calculated.         |
+
+**Knockback Type: Directional**
+
+Apply the calculated knockback force along the attack direction, removing any vertical component and replacing it with a provided Y velocity.
+
+| Field Name | Type                      | Required? | Notes                                                                                                                                            |
+| ---------- | ------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------ |
+| RelativeX  | `Float`<br />(Default: 0) | **No**    | Apply additional force left or right perpendicular to the direction of the attack. The additional force is multiplied by the knockback strength. |
+| RelativeZ  | `Float`<br />(Default: 0) | **No**    | Apply additional force forward or backward along the attack direction. The additional force is multiplied by the knockback strength.             |
+| VelocityY  | `Float`<br />(Default: 0) | **No**    | Replace the vertical velocity of the knockback with this value.  This value is not multiplied by knockback strength.                             |
+
+**VelocityConfig Fields**
+
+| Field Name          | Type                                              | Required? | Notes                                                                                                                                                                                           |
+| ------------------- | ------------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| GroundResistance    | `Float`<br />(Default: 0.82)                      | **No**    | The minimum amount of friction applied when the entity is in contact with the ground.  1.0 = no friction, 0.0 = total friction                                                                  |
+| GroundResistanceMax | `Float`<br />(Default: 0.0)                       | **No**    | The maximum amount of friction applied when the entity is in contact with the ground.  1.0 = no friction, 0.0 = total friction                                                                  |
+| AirResistance       | `Float`<br />(Default: 0.96)                      | **No**    | The minimum amount of friction applied when the entity is in the air. 1.0 = no friction, 0.0 = total friction                                                                                   |
+| AirResistanceMax    | `Float`<br />(Default: 0.0)                       | **No**    | The maximum amount of friction applied when the entity is in the air. 1.0 = no friction, 0.0 = total friction                                                                                   |
+| Threshold           | `Float`<br />(Default: 1.0)                       | **No**    | The speed at which the maximum amount of friction will be applied to the entity. The amount of friction applied will increase from minimum to maximum as the entity moves from 0 to this speed. |
+| Style               | `VelocityThresholdStyle`<br />(Default: `Linear`) | **No**    | The curve that friction follows as the entity's speed increases toward the `Threshold`.                                                                                                         |
+
+**CostType Values**
+
+- `MaxHealthPercentage`
+- `Damage`
+
+**ChangeVelocityType Values**
+
+- `Add`
+- `Set`
+
+**VelocityThresholdStyle Values**
+
+- `Linear`
+- `Exp`
+
+## Blocks
+
+These are interaction types meant to reason about and modify blocks in the world.  The most important concept unique
+to these interactions is the Block Target.  Like the Entity Target, it is mutable and can come from many places.
+However, for interaction chains initiated by the client, the block target will initially be the block that the player's cursor was
+over, if any.
+
+Additionally, for interaction chains initiated by the client, the client will send along which face of the block is targeted,
+which is used by a few block-related interactions.
+It is left up to each interaction type that cares about block faces as to how to handle this behavior for simulated input
+(i.e. NPCs initiating chains that are normally initated by the client).  At the time of this writing, all block-related
+interactions choose the top face where relevant in simulated input.
+
+### BlockCondition
+
+This interaction has a field `Matchers` which specifies certain conditions, such as block type, state, etc.  This
+interaction fails if the current target block does not match all of them.
+
+**BlockCondition Fields**
+
+| Field Name       | Type                                        | Required? | Notes                                                                                                                                                                                                                                                                                                                                   |
+| ---------------- | ------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false)             | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction.                                                                                                                                                                                                       |
+| Matchers         | `Array`<br />(Element Type: `BlockMatcher`) | **Yes**   | A list of conditions that the target block must match or this condition will fail.<br />**Note: This field is technically not required but there is a bug that makes it dangerous to not provide at the time of this writing.**<br />**Note: If no conditions are added to this array, the interaction will fail, counterintuitively.** |
+
+**BlockMatcher Fields**
+
+| Field Name | Type                       | Required? | Notes                                                                          |
+| ---------- | -------------------------- | --------- | ------------------------------------------------------------------------------ |
+| Block      | `BlockIdMatcher`           | **No**    | If provided, requires the block itself match some set of conditions.           |
+| Face       | `BlockFace`                | **No**    | If provided and not 'None', requires a specific block face be targeted.        |
+| StaticFace | `Boolean` (Default: false) | **No**    | If false, the face condition will be adjusted by the block's current rotation. |
+
+**BlockFace Values**
+
+- `Up`
+- `Down`
+- `North`
+- `South`
+- `East`
+- `West`
+- `None`
+
+**BlockIdMatcher Fields**
+
+| Field Name | Type                                   | Required? | Notes                                                                      |
+| ---------- | -------------------------------------- | --------- | -------------------------------------------------------------------------- |
+| Id         | `Asset`<br />(Asset Type: `BlockType`) | **No**    | If provided, the block must match the specified `BlockType`.               |
+| State      | `String`                               | **No**    | If provided, the block's current state must match the provided state name. |
+| Tag        | `String`                               | **No**    | If provided, the block type's asset tags must contain the provided tag.    |
+
+### DestroyCondition
+
+This interaction fails if the current User entity cannot destroy the current target blcok.
+
+**DestroyCondition Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+
+### PlacementCountCondition
+
+This interaction accepts the name of a BlockType that has the TrackedPlacement BlockEntity. The interaction will fail if the number of
+blocks of the provided BlockType in the world do not match the provided condition.
+
+**PlacementCountCondition Fields**
+
+| Field Name | Type                           | Required? | Notes                                                                                                                                                                                                                                                           |
+| ---------- | ------------------------------ | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Block      | `String`                       | **Yes**   | The BlockType to examine. The number of instances of the BlockType in the world will be compared to Value.<br />**Note: The specified BlockType must have the TrackedPlacement BlockEntity. Otherwise, the number of blocks in the world will always be zero.** |
+| Value      | `Integer`<br />(Default: 0)    | **No**    | The value to compare the number of blocks in the world with.                                                                                                                                                                                                    |
+| LessThan   | \`Boolean<br />(Default: true) | **No**    | If true, the interaction will fail if the number of blocks in the world is greater than or equal to Value. If false, the interaction will fail if the number of blocks in the world is less than or equal to Value.                                             |
+
+### BreakBlock
+
+This interaction attempts to break the target block while acting as the User entity. The User entity must be a player. It
+is not guaranteed to work, depending on world settings and the User entity's current state, it may not work.  If it
+fails, it will fail the interaction under some circumstances, but not others.
+
+**Note: In particular, if `Harvest`=false and the player is in Survival mode, the player will simply execute a damage operation
+against the block. Even when the Tool field is specified, the player's currently-held item can impact the results in unintuitive
+ways.**
+
+This interaction will fail if there is no block target, if `Harvest`=true and the
+block is not harvestable, or if the world settings prevent the Harvest/Break operation.
+It will generally not fail otherwise, even if the block was not broken or damaged.
+The block will generally break every time if `Harvest`=true or the player is in
+Creative mode.
+
+**BreakBlock Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                                                                                                                                                                                                  |
+| ---------------- | ------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction.                                                                                                                                                                      |
+| Harvest          | `Boolean` (Default: false)      | **No**    | If true, harvest the block and deposit the drops in the player's inventory. This operation will generally always succeed.  If false, this interaction will effectively perform whatever action would have occurred if the player had left-clicked the block.                                           |
+| Tool             | `String`                        | **No**    | If `Harvest`=true, the player is in Survival mode, and this field is provided, then the break operation will be performed as though with this tool type.<br />**This field mostly doesn't work.  Your held item will be used for most block damage calculations regardless of this field's contents.** |
+| MatchTool        | `Boolean` (Default: false)      | **No**    | If true, `Harvest`=true, the player is in Survival mode, and `Tool` is provided, block breaking will be prevented unless `Tool` is a valid gathering tool for the target block. The interaction will not be failed, even if block breaking is prevented in this manner.                                |
+
+### ChangeBlock
+
+This interaction requires a mapping from one or more current BlockTypes to one or more target BlockTypes.  If the
+target block is one of the key BlockTypes, then it will be changed to the mapped target BlockType.  If the current
+BlockType of the target block does not appear as a key in the Changes field, then this interaction fails.
+
+**ChangeBlock Fields**
+
+| Field Name        | Type                                                        | Required? | Notes                                                                                                                             |
+| ----------------- | ----------------------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget  | `Boolean`<br />(Default: false)                             | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+| Changes           | `Map`<br />(Key Type: `BlockType`, Value Type: `BlockType`) | **No**    | A list of potential block type changes, with each entry having a current and new BlockType id.                                    |
+| WorldSoundEventId | `Asset`<br />(Asset Type: `SoundEvent`)                     | **No**    | If provided, this SoundEvent is played in the world at the position of the block if the block successfully changes.               |
+| RequireNotBroken  | `Boolean`<br />(Default: false)                             | **No**    | If true, this interaction will fail if the player's held item is broken (durability 0), and the block change will not take place. |
+
+### ChangeState
+
+This interaction requires a mapping from one or more current block state names to one or more state names. If the
+target block is in one of the key block states, then it will be changed to the mapped target blocks tate. If the
+current block state of the target block does nto appear as a key in the Changes field, then this interaction fails.
+
+All blocks start out with a null state by default.  This null state can be referenced by the key "default" and the block
+can be returned to that state with the value "default".
+
+**ChangeState Fields**
+
+| Field Name       | Type                                                  | Required? | Notes                                                                                                                                          |
+| ---------------- | ----------------------------------------------------- | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false)                       | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction.              |
+| Changes          | `Map`<br />(Key Type: `String`, Value Type: `String`) | **No**    | A list of potential block state changes, with each entry having a current and new state name.                                                  |
+| UpdateBlockState | `Boolean`<br />(Default: false)                       | **No**    | If true, performs a full refresh of the block's BlockEntity component and notifies nearby players as though a full block type change occurred. |
+
+### CycleBlockGroup
+
+This interaction will attempt to change the target block to the next block type in one of the BlockGroups it belongs to.
+If the block type belongs to multiple BlockGroups, which one is used is effectively arbitrary. The User entity must be
+a player. If the block cannot be changed for any reason (entity not a player, no block target, block does not belong
+to a BlockGroup, etc.). If the block is the only entry in the BlockGroup, this interaction will succeed and the block
+will be considered changed despite nothing happening.  Unlike most other block-changing interactions, this one will
+fail if the world settings prevent players from breaking blocks.
+
+**This interaction always reduces the player's held item's durability by a single 'hit' worth of damage if the block
+changes. There is no way to prevent it. The block type will change and the interaction will succeed even if the player's
+held item is broken, however.**
+
+**CycleBlockGroup Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+
+### DestroyBlock
+
+This interaction destroys the target block without dropping anything.  It will successfully destroy the block if the
+target block exists and this interaction has no failure conditions.
+
+**This interaction has no additional fields.**
+
+### PickBlock
+
+This interaction is effectively equivalent to using the middle mouse button in creative mode. In survival mode, the
+block's item will be moved to the user's current active hotbar slot if it is in the player's inventory.  This
+interaction is performed entirely on the client and cannot be performed by non-players.  It is unclear if this
+interaction has failure conditions.
+
+**PickBlock Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+
+### PlaceBlock
+
+This interaction is effectively identical to a right clicking while holding a block in their hand, with some
+additional options. For one, it can be executed with any LivingEntity as the User entity. For another, it has some
+useful fields.  For the most part, though, it follows the same behaviors and rules as any ordinary block placement
+by a player.
+
+It's not clear under what circumstances this interaction can fail. The server will not fail the interaction under any
+special circumstances (including when there is no target block, or when `BlockTypeToPlace` is not provided and the
+LivingEntity is not holding a block). However, the client is very involved with the function of this interaction and
+its behavior is unknown.
+
+**PlaceBlock Fields**
+
+| Field Name         | Type                                   | Required? | Notes                                                                                                                                                                                                                                                                                                                                                           |
+| ------------------ | -------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| BlockTypeToPlace   | `Asset`<br />(Asset Type: `BlockType`) | **No**    | If provided, the block placed by this interaction will be the specified BlockType. If not provided, the User entity's held item will be used, instead, if it is a block.                                                                                                                                                                                        |
+| RemoveItemInHand   | `Boolean`<br />(Default: True)         | **No**    | If true and the User entity is not a player in Creative mode, the item in the player's hand must match the block being placed and one quantity will be removed for each block placed. If the item does not match, the block cannot be placed.  If false, the player's hand item is ignored entirely.\*\*                                                        |
+| AllowDragPlacement | `Boolean`<br />(Default: True)         | **No**    | If true and the interaction was triggered on the client by a player, then the player can hold the input that was used to activate this interaction chain and move the mouse around in order to execute this interaction repeatedly and place several blocks. The interaction chain will not move onto the next interaction until the player releases the input. |
+
+### RunOnBlockTypes
+
+This interaction retrieves all blocks within a provided radius of the User entity. For each block that matches any of
+the provided BlockSets, a new interaction chain will be forked that uses the matching block as the target block.
+This interaction will continue executing until all forked interaction chains have completed.  The interaction will fail if no
+blocks within the radius match the provided BlockSets or if all of the forked interaction chains fail.
+
+**RunOnBlockTypes Fields**
+
+| Field Name   | Type                                         | Required?        | Notes                                                                                                                                                                                                                                                                                      |
+| ------------ | -------------------------------------------- | ---------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| Range        | `Integer`                                    | **Yes**          | The spherical radius around the User entity to search for blocks. Must be at least 1.                                                                                                                                                                                                      |
+| BlockSets    | `AssetArray`<br />(Element Type: `BlockSet`) | **No**           | A list of BlockSets to match nearby blocks again. Only blocks that match any of the BlockSets will have interaction chains forked for them.                                                                                                                                                |
+| MaxCount     | `Integer`                                    | **Yes**          | The maximum number of blocks that will be located with the search. Further blocks will be ignored. If there are more matching blocks within the radius than this number, the specific set of blocks that will be found is completely arbitrary and may change from execution to execution. |
+| Interactions | `Asset`<br />(Asset Type: `RootInteraction`) | **No, but yes.** | The RootInteraction that will be forked for each matching block.  This interaction will not fail to validate if it is missing, but every execution of this interaction will fail.                                                                                                          |
+
+### UseBlock
+
+If the target block has an interaction for this interaction chain's interaction type, execute it immediately as part of
+this interaction chain. The execution will be wrapped in UseBlockEvent.Pre and UseBlockEvent.Post events, and cancellations
+of the UserBlockEvent.Pre event are respected. The User entity is considered the triggering entity for both events.
+
+If the target block does not have an interaction for this interaction chain's interaction type, this interaction fails.
+
+**This interaction has no additional fields.**
+
+## Items
+
+These are interactions intended to interface with an entity's inventory. There is no concept of an "item target",
+unfortunately, so these generally either interact with the entity's held item or the entity's inventory at a high level.
+
+### AddItem
+
+Adds a specified quantity of a specified item to the User entity's inventory, preferring to add it to the
+entity's hotbar where possible. This interaction will have no effect on User entities that are not LivingEntities.
+This interaction has no failure states.
+
+**Note: This interaction has a bug in its field validators that will cause interactions that reference items declared
+in the same mod to fail validation on startup.  Additionally, this interaction has a bug that will cause it to
+fail and have no effect if the User entity has no block target. Use ModifyInventory instead.**
+
+**AddItem Fields**
+
+| Field Name       | Type                              | Required? | Notes                                                                                                                             |
+| ---------------- | --------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false)   | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+| ItemId           | `Asset`<br />(Asset Type: `Item`) | **Yes**   | The item id of the item to add to the player's inventory.                                                                         |
+| Quantity         | `Integer`<br />(Default: 0)       | **No**    | The quantity of the item to add to the player's inventory.                                                                        |
+
+### CheckUniqueItemUsage
+
+This interaction will check whether it has run once for the User entity with their currently-held item before. If it hasn't,
+it will succeed. If it has, it will fail. It will also fail if the User entity is not a player. The interaction will record
+the item id of the User entity's currently-held item on success, ensuring it cannot be successfully run with that player
+and item id combination again.
+
+**This interaction has no additional fields.**
+
+### ChangeActiveSlot
+
+This interaction does not inherit from SimpleInteraction and therefore has no Next or Failed fields.  The `CancelOnItemChange`
+field is ignored for this interaction and is always treated as false. This interaction will set the User entity's currently-
+active hotbar slot to the specified slot index. If none is specified, the interaction chain's target slot will be used,
+if any. Otherwise, slot 0 will be used.  If a slot is specified and it is already active, then this interaction will
+have no effect, but if no slot is specified and the interaction chain's target slot is already active, the logic in
+the next paragraph will still be executed. This interaction will also have no effect if the User entity is not a
+LivingEntity.
+
+Once the slot has changed, a new SwapTo interaction chain will be forked off for the selected slot.
+If a target slot was specified, then the interaction chain's current target slot will be set to the specified slot, as will
+the forked SwapTo interaction chain. If this interaction chain was initiated by a player swapping an item into or out of
+an occupied active hotbar slot, then the swap will be executed after the slot is changed and before the SwapTo
+interaction is forked. Not running this interaction in the resulting SwapFrom interaction chain is a way for the server
+to cancel players performing these sorts of swap interactions. The default behavior for these swap interactions is that
+the SwapFrom interaction chain will be initiated with the currently-active-slot as the target slot. As a result, the
+target slot will usually not change when this interaction runs, it merely exists as a signal for the server to continue the
+item swap.
+
+**ChangeActiveSlot Fields**
+
+| Field Name | Type      | Required? | Notes                                                                                                                                                                                                     |
+| ---------- | --------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| TargetSlot | `Integer` | **No**    | If not provided, indicates the slot the player's active hotbar slot should be changed to.  Otherwise, the interaction chain's target slot will be used (which is usually the already-active hotbar slot). |
+
+### EquipItem
+
+This interaction will equip the User entity's currently-held item into the appropriate armor slot, if it is armor. The
+interaction will fail if the item is armor but it cannot be equipped for some reason. The interaction will succeed but
+take no action if the User entity cannot equip armor or if the item is not armor.
+
+**This interaction has no additional fields.**
+
+### IncreaseBackpackCapacity
+
+This interaction will increase the User entity's backpack size by the provided amount.  **It will additionally remove one
+quantity from the player's currently-held item. There is no way to prevent this.**  This interaction will have no effect
+if the User entity is not a player.  This interaction has no special failure conditions, even if the User entity
+is not a player, or the player is not currently holding an item.
+
+| Field Name | Type                        | Required? | Notes                                                                                   |
+| ---------- | --------------------------- | --------- | --------------------------------------------------------------------------------------- |
+| Capacity   | `Integer`<br />(Default: 1) | **No**    | The additional backpack capacity to add to the player. **Must be between 1 and 32767.** |
+
+### ModifyInventory
+
+This interaction attempts to perform one or more inventory-modifying actions against the User entity. The User entity must
+be a player. If they are not, no actions will be performed, but the interaction will not fail. Any item removals performed
+by this interaction, either as a result of `ItemToRemove` or `AdjustHeldItemQuantity`, are both atomic (meaning the entire
+quantity must be removed, or none) and required (meaning that the interaction will fail and no further actions taken if
+the removal fails for any reason).  Item additions performed by this interaction, either as a result of `ItemToAdd` or
+`AdjustHeldItemQuantity` will drop excess items on the ground near the player if necesary and continue on.
+
+This interaction first executes the item removal in `ItemToRemove`, if any, then adjusts the held item as specified by
+`AdjustHeldItemQuantity`, if provided, then executes the item addition in `ItemToAdd`, if any, and then finally executes
+the damage/healing of the held item in `AdjustHeldItemDurability`, if provided.
+
+**ModifyDurability Fields**
+
+| Field Name               | Type                            | Required? | Notes                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
+| ------------------------ | ------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| RequiredGameMode         | `GameMode`                      | **No**    | If provided, only execute the inventory-modifying actions if the player is in the provided GameMode. The interaction will not fail if the GameMode doesn't match.                                                                                                                                                                                                                                                                                                                                                                               |
+| ItemToRemove             | `ItemStack`                     | **No**    | If provided, a matching item will be removed in the provided quantity. If there is no matching item in the player inventory in the required quantity, then the interaction will fail and further actions will not be executed.                                                                                                                                                                                                                                                                                                                  |
+| AdjustHeldItemQuantity   | `Integer`<br />(Default: 0)     | **No**    | The player's held item, if any, will have its quantity will be modified by the provided amount- subtracted from if this number is negative or added to if this item is positive.  If the player has no held item, then this field will have no effect regardless of its value and the interaction will NOT fail.  If the player's inventory does not have sufficient quantity of items to support the removal, this interaction will fail and further actions will not be executed. Excess items will be dropped on the ground near the player. |
+| ItemToAdd                | `ItemStack`                     | **No**    | If provided, the ItemStack will be added to the player's inventory. Excess items will be dropped on the ground near the player.                                                                                                                                                                                                                                                                                                                                                                                                                 |
+| AdjustHeldItemDurability | `Double`<br />(Default: 0.0)    | **No**    | The player's held item, if any, will have its durability adjusted by the specified amount.  The durability cannot go below 0 or raise above the item's maximum durability. Invalid durability values in this field will not cause the interaction to fail. Neither will it fail if the player has no held item.                                                                                                                                                                                                                                 |
+| BrokenItem               | `String`                        | **No**    | This field should contain an ItemId, but it is not validated by the server on startup, so be careful.  This field can have the value of "Empty" to specify no item, or an empty hand. If specified and the `AdjustHeldItemDurability` operation reduces the player's held item to 0 durability, the player's held item is changed to this ItemId. If the inventory replacement fails, this interaction will fail.                                                                                                                               |
+| NotifyOnBreak            | `Boolean`<br />(Default: false) | **No**    | If true and the `AdjustHeldItemDurability` operation reduces the player's held item to 0 durability, this interaction will perform the usual audiovisual feedback of a broken tool. It will play the usual tool breaking sound and send the player a text message in chat that their item has broken.                                                                                                                                                                                                                                           |
+| NotifyOnBreakMessage     | `String`                        | **No**    | If provided, and `NotifyOnBreak` is true, when the player is notified of a broken tool by this interaction, the message sent to their chat will instead be the translation key specified by this field. The translation key supports the templating parameter `{itemName}`. See the translation key `server.general.repair.itemBroken_Hoe` for an example.                                                                                                                                                                                      |
+
+**GameMode Values**
+
+- `Creative`: The game is currently in Creative Mode
+- `Adventure`: The game is currently in Adventure Mode
+
+**ItemStack Fields**
+
+| Field Name                   | Type                              | Required? | Notes                                                                                |
+| ---------------------------- | --------------------------------- | --------- | ------------------------------------------------------------------------------------ |
+| Id                           | `Asset`<br />(Asset Type: `Item`) | **Yes**   | The id of the Item asset this stack contains.                                        |
+| Quantity                     | `Integer`<br />(Default: 1)       | **No**    | The number of items in this stack.<br />**Must be greater than 0.**                  |
+| Durability                   | `Double`<br />(Default: 0.0)      | **No**    | The durability of the item stack.<br />**Cannot be negative.**                       |
+| MaxDurability                | `Double`<br />(Default: 0.0)      | **No**    | The maximum durability of the item this stack contains.<br />**Cannot be negative.** |
+| Metadata                     | `Bson Document`                   | **No**    | If provided, applies the bson to the item stack metadata.                            |
+| OverrideDroppedItemAnimation | `Boolean`\*(Default: false)       | **No**    | ???                                                                                  |
+
+### PickupItem
+
+This interaction will attempt to pick up the User entity's current target entity and add it to their inventory. It will
+fail if the User entity is not a player, if they do not have a target entity, or if the target entity is not an item
+located in the world.  It will not fail if the player simply cannot pick up the item.
+
+**This interaction has no additional fields.**
+
+### RefillContainer
+
+This interaction will fail if the User entity is not a player. The interaction will draw a ray from the player's head
+down their look direction until the edge of the player's held item's interaction range or until the first solid block.
+The nearest fluid block of a type listed in this interaction's `States` map will result in the one of the player's
+currently-held items being converted to the fluid's related item state.  If the `States` map indicates a durability
+for the new item state, then the converted item will use that durability. If the item is already in the fluid's related
+item state, then this interaction will fail if the player's held item is already at maximum durability (unless the
+`States` map indicates a durability value greater than the item's maximum, in which case the interaction will succeed
+but the item will not change).  Otherwise, the durability listed for the fluid in the `States` map will be added to the
+item's current durability.
+
+If the interaction has not failed by this point, the fluid block in the world may be transformed to a different type if one is listed
+in the `States` map.
+
+If any part of this process does not proceed for any reason (for instance, if the player is not holding an item),
+then this interaction will fail.
+
+**RefillContainer Fields**
+
+| Field Name | Type                                                       | Required? | Notes                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| ---------- | ---------------------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| States     | `Map`<br />(Key Type: `String`, Value Type: `RefillState`) | **Yes**   | A map from item state names to `RefillState` objects, which contain information such as acceptable fluid block types, durability increases, and what fluid type to convert the targeted fluid block to after refill, if any. If the player targets a fluid block that matches one of the fluid types in the `RefillState`, the item will be converted to the keyed item state and the `RefillState` will be used to decide what happens next. |
+
+**RefillState Fields**
+
+| Field Name     | Type                                  | Required? | Notes                                                                                                                                                                                                                                                                                                                           |
+| -------------- | ------------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| AllowedFluids  | `Array`<br />(Element Type: `String`) | **Yes**   | If any of these fluids are targeted by the player, the player's held item will be converted to the keyed item state and `Durability` and `TransformFluid` will be used.                                                                                                                                                         |
+| Durability     | `Double`<br />(Default: -1.0)         | **No**    | If the player's held item changes item states, this value is the new item's durability, unless it is negative, in which case the item will begin at full durability. If the player's held item is already in the item state, and the item is not already at full durability, this value will be added to the item's durability. |
+| TransformFluid | `String`                              | **No**    | If provided, this field is a fluid id that the targeted fluid block should be transformed to if the player's held item is successfully updated.                                                                                                                                                                                 |
+
+## Entities
+
+### DamageEntity
+
+This interaction does not inherit from SimpleInteraction, but adds its own Next and Failed fields that
+work similarly.
+
+This interaction will cause the User entity to damage the Target entity.  It has the capability to apply different
+damage based on the direction of the attack or what body part was targeted by the User entity, with each possibility
+providing different damage calculations, effects, and Next interaction. If multiple entires match the attack, `TargetedDamage`
+(body part damage) takes highest priority, then the first matching `AngledDamage` in the list, then the default
+damage in the base interaction fields.  It is possible for elements of these different damage priorities to be taken peacemeal if higher-priority
+damage fields do not overwrite lower-priority damage fields. For instance,
+damage calculation could be taken from `TargetedDamage`, the damage effects could be taken from the first matching
+`AngledDamage`, and the Next interaction coming from the default damage field.
+
+If all damage dealt by this interaction is cancelled, then this interaction will fail, and the `Failed` interaction
+will be executed next in the chain. If any damage dealt by this interaction is blocked, then this interaction will
+succeed, but the `Blocked` interaction wil lbe executed next in the chain. Otherwise, the highest-precedent matching
+`Next` interaction that you provide will be executed.  For instance, if you provide `Next` interactions for all
+`TargetedDamage` and `AngledDamage` entries, and one in the interaction's `Next` field, then a headshot could result
+in a unique `Next` interaction being executed, even if there is a matching `AngledDamage` entry. However, if you leave
+the `Next` interaction out of your `TargetedDamage` entries, a special `Next` interaction for backstabs could be
+executed.  Otherwise, the `Next` field in the root of the interaction will be executed instead.
+
+DamageEntity has an unusual relationship with `RunTime`. This interaction always ends immediately after its first tick,
+regardless of the status of `RunTime` or `WaitForAnimationToFinish`.  However, if damage dealt by this interaction is
+calculated as `DamageCalculatorType` `Dps`, then the `RunTime` will be used to determine the precise amount of damage to
+deal. If `RunTime` is 0, then no damage will be dealt.
+
+**DamageEntity Fields**
+
+| Field Name       | Type                                                          | Required?                                                                                                                    | Notes                                                                                                                                                                                                                                                                                                                                                                         |
+| ---------------- | ------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| DamageCalculator | `DamageCalculator`                                            | **No**                                                                                                                       | If provided, describes the damage amounts and types to apply to the Target entity.                                                                                                                                                                                                                                                                                            |
+| DamageEffects    | `DamageEffects`                                               | **No**                                                                                                                       | If provided, describes particles, sounds, knockback, etc. to apply to the target entity on damage.                                                                                                                                                                                                                                                                            |
+| Next             | `Asset`<br />(Asset Type: `Interaction`)                      | **No**  After this interaction has finished, "Next" will be executed if damage was dealt to the target and none was blocked. |                                                                                                                                                                                                                                                                                                                                                                               |
+| AngledDamage     | `Array`<br />(Element Type: `AngledDamage`)                   | **No**                                                                                                                       | If provided, allows alternative `DamageCalculator`, `DamageEffects`, and `Next` entries for attacks that approach the target from certain angles.                                                                                                                                                                                                                             |
+| TargetedDamage   | `Map`<br />(Key Type: `String`, Value Type: `TargetedDamage`) | **Yes**                                                                                                                      | This field must be provided, but is not required to have any entries.  This is a map from body part names to `TargetedDamage` values. Hypixel only uses one body part name: `Head`, and it is not clear whether there are others.  If provided, allows alternative `DamageCalculator`, `DamageEffects`, and `Next` entries for attacks that damage specific enemy body parts. |
+| EntityStatsOnHit | `Array`<br />(Element Type: `EntityStatOnHit`)                | **No**                                                                                                                       | If provided, allows this attack to reduce enemy stats other than health.  Each individual damage application dealt by the same ability will apply stat reductions, at diminishing returns. All damage dealt in interaction chains forked by a Selector interaction will share the number of hits across all targets.                                                          |
+| Failed           | `Asset`<br />(Asset Type: `Interaction`)                      | **No**                                                                                                                       | After this interaction has finished, "Failed" will be executed if no damage hits were applied to the player, or if all damage hits were cancelled.                                                                                                                                                                                                                            |
+| Blocked          | `Asset`<br />(Asset Type: `Interaction`)                      | **No**                                                                                                                       | After this interaction has finished, "Blocked" will be executed if any damage hits were blocked by the target.                                                                                                                                                                                                                                                                |
+
+**DamageCalculator Fields**
+
+| Field Name                | Type                                                      | Required? | Notes                                                                                                                                                                                                                                                 |
+| ------------------------- | --------------------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Type                      | `DamageCalculatorType`<br />(Default: Absolute)           | **No**    | Whether the damage being applied is `Absolute` or \`Dps'.                                                                                                                                                                                             |
+| Class                     | `DamageClass`<br />(Default: Unknown)                     | **No**    | The type of attack producing the damage. Some weapon systems apply equipment modifiers based on this value.                                                                                                                                           |
+| BaseDamage                | `Map`<br />(Key Type: `DamageCause`, Value Type: `Float`) | **No**    | A set of DamageCauses and how much base damage is dealt for each.                                                                                                                                                                                     |
+| SequentialModifierStep    | `Float`<br />(Default: 0.0)                               | **No**    | Value between 0.0-1.0. Each additional hit from a single ability will have its damage reduced by this much as a percentage. All damage dealt in interaction chains forked by a Selector interaction will share the number of hits across all targets. |
+| SequentialModifierMinimum | `Float`<br />(Default: 0.0)                               | **No**    | Value between 0.0-1.0. `SequentialModifierStep` cannot reduce damage below this percentage regardless of the number of hits.                                                                                                                          |
+| RandomPercentageModifier  | `Float`<br />(Default: 0.0)                               | **No**    | A random value between +/- this amount multiplied by the base damage will be added to the base damage.                                                                                                                                                |
+
+**DamageEffects Fields**
+
+| Field Name             | Type                                         | Required? | Notes                                                                                   |
+| ---------------------- | -------------------------------------------- | --------- | --------------------------------------------------------------------------------------- |
+| ModelParticles         | `Array`<br />(Element Type: `ModelParticle`) | **No**    | Particle systems to trigger in the first-person view.                                   |
+| WorldParticles         | `Array`<br />(Element Type: `WorldParticle`) | **No**    | Particle systems to trigger in the third-person view.                                   |
+| LocalSoundEventId      | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | 2D sound to play locally to the attacking entity if they are a player.                  |
+| WorldSoundEventId      | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | Sound to play in the world at the Target entity's location.                             |
+| PlayerSoundEventId     | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | 2D sound to play locally to the Target entity if they are a player.                     |
+| ViewDistance           | `Double`<br />(Default: 75.0)                | **No**    | Distance at which these effects should play for other players.                          |
+| Knockback              | `Knockback`                                  | **No**    | The properties of the knockback that will be applied.                                   |
+| CameraEffect           | `Asset`<br />(Asset Type: `CameraEffect`)    | **No**    | CameraEffect to briefly apply locally to the Target entity if they are a player.        |
+| StaminaDrainMultiplier | `Float`<br />(Default: 1.0)                  | **No**    | This multiplier is applied to the stamina cost incurred by the target blocking, if any. |
+
+**AngledDamage Fields**
+
+| Field Name       | Type                                     | Required? | Notes                                                                                                                                                                                                     |
+| ---------------- | ---------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| AngleDistance    | `Float`<br />(Default: 0)                | **No**    | The width in degrees of the matching arc around the Target entity. If the attack against the Target originates from within the arc, then the properties below will be applied to the attack, if provided. |
+| Angle            | `Float`<br />(Default: 0.0)              | **No**    | The angle in degrees around the Target entity at which the matching arc is centered.                                                                                                                      |
+| DamageCalculator | `DamageCalculator`                       | **No**    | If provided and the attack against the Target entity originates from within the provided arc, this DamageCalculator will override the interaction's `DamageCalculator` field.                             |
+| DamageEffects    | `DamageEffects`                          | **No**    | If provided and the attack against the Target entity originates from within the provided arc, this DamageEffects will override the interaction's `DamageEffects` field.                                   |
+| Next             | `Asset`<br />(Asset Type: `Interaction`) | **No**    | If provided and the attack against the Target entity originates from within the provided arc, this Interaction will override the interaction's `Next` field.                                              |
+
+**TargetedDamage Fields**
+
+| Field Name       | Type                                     | Required? | Notes                                                                                                                                                                                            |
+| ---------------- | ---------------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| DamageCalculator | `DamageCalculator`                       | **No**    | If provided and this TargetedDamage was matched, this DamageCalculator will override the interaction's `DamageCalculator` field and the `DamageCalculator` field of any matching `AngledDamage`. |
+| DamageEffects    | `DamageEffects`                          | **No**    | If provided and this TargetedDamage was matched, this DamageEffects will override the interaction's `DamageEffects` field and the `DamageEffects` field of any matching `AngledDamage`.          |
+| Next             | `Asset`<br />(Asset Type: `Interaction`) | **No**    | If provided and this TargetedDamage was matched, this Interaction will override the interaction's `Next` field and the `Next` field of any matching `AngledDamage`.                              |
+
+**EntityStatOnHit Fields**
+
+| Field Name                  | Type                                                                       | Required? | Notes                                                                                                                                                                                                                                                                                        |
+| --------------------------- | -------------------------------------------------------------------------- | --------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| EntityStatId                | `Asset`<br />(AssetType: `EntityStatType`)                                 | **Yes**   | Which entity stat to affect.                                                                                                                                                                                                                                                                 |
+| Amount                      | `Float`<br />(Default: 0.0)                                                | **No**    | How much of the stat to apply for each damage application. Use negative numbers to reduce stats.                                                                                                                                                                                             |
+| MultipliersPerEntitiesHit   | `Array`<br />(Element Type: `Float`, Default: `[1.0, 0.6, 0.4, 0.2, 0.1]`) | **No**    | The diminishing returns curve to be applied for multiple damage applications by the same ability. Each hit's stat impact will be multiplied by the next value in the list.  If there are more hits than array elements, subsequent hits will be multiplied by `MultiplierPerExtraEntityHit`. |
+| MultiplierPerExtraEntityHit | `Float`<br />(Default: 0.05)                                               | **No**    | If an ability carries out more damage applications than there are elements in the `MultipliersPerEntitiesHit` array, then subsequent stat values will be multiplied by this number.                                                                                                          |
+
+**Knockback Fields**
+
+| Field Name     | Type                                       | Required? | Notes                                                                                                                      |
+| -------------- | ------------------------------------------ | --------- | -------------------------------------------------------------------------------------------------------------------------- |
+| Type           | `String`                                   | **No**    | If provided, specifies a type of knockback to use. Each Target type may come with additional fields.                       |
+| Force          | `Double`<br />(Default: 0.0)               | **No**    | The amount of force to apply to the Owner entity.                                                                          |
+| Duration       | `Double`<br />(Default: 0.0)               | **No**    | If 0.0, apply the force as a single impulse.  If more, continuously apply the force over a period of time.                 |
+| VelocityType   | `ChangeVelocityType`<br />(Default: `Add`) | **No**    | How to apply the force, either adding it to the entity's current velocity, or setting the velocity to the knockback force. |
+| VelocityConfig | `VelocityConfig`                           | **No**    | Characteristics of friction as the Owner entity is thrown by this knockback.                                               |
+
+**Knockback Type: Force**
+
+Apply the calculated knockback force along the provided direction.
+
+| Field Name | Type                         | Required? | Notes                                                                                |
+| ---------- | ---------------------------- | --------- | ------------------------------------------------------------------------------------ |
+| Direction  | `Vector3`<br />(Default: Up) | **No**    | Which direction the entity should be flung, relative to the direction of the attack. |
+
+**Knockback Type: Point**
+
+Apply the calculated knockback force laterally along the XZ plane, plus provided Y velocity.
+
+| Field Name | Type                        | Required? | Notes                                                                                                   |
+| ---------- | --------------------------- | --------- | ------------------------------------------------------------------------------------------------------- |
+| OffsetX    | `Integer`<br />(Default: 0) | **No**    | Offset the source position of the knockback left or right perpendicular to the direction of the attack. |
+| OffsetZ    | `Integer`<br />(Default: 0) | **No**    | Offset the source position of the knockback, forward or backward along the directon of the attack.      |
+| RotateY    | `Integer`<br />(Default: 0) | **No**    | Rotate the knockback direction around the Y axis, where 0 is the default attack direction.              |
+| VelocityY  | `Float`<br />(Default: 0.0) | **No**    | Add vertical velocity to the knockback force after the direction and force has been calculated.         |
+
+**Knockback Type: Directional**
+
+Apply the calculated knockback force along the attack direction, removing any vertical component and replacing it with a provided Y velocity.
+
+| Field Name | Type                      | Required? | Notes                                                                                                                                            |
+| ---------- | ------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------ |
+| RelativeX  | `Float`<br />(Default: 0) | **No**    | Apply additional force left or right perpendicular to the direction of the attack. The additional force is multiplied by the knockback strength. |
+| RelativeZ  | `Float`<br />(Default: 0) | **No**    | Apply additional force forward or backward along the attack direction. The additional force is multiplied by the knockback strength.             |
+| VelocityY  | `Float`<br />(Default: 0) | **No**    | Replace the vertical velocity of the knockback with this value.  This value is not multiplied by knockback strength.                             |
+
+**VelocityConfig Fields**
+
+| Field Name          | Type                                              | Required? | Notes                                                                                                                                                                                           |
+| ------------------- | ------------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| GroundResistance    | `Float`<br />(Default: 0.82)                      | **No**    | The minimum amount of friction applied when the entity is in contact with the ground.  1.0 = no friction, 0.0 = total friction                                                                  |
+| GroundResistanceMax | `Float`<br />(Default: 0.0)                       | **No**    | The maximum amount of friction applied when the entity is in contact with the ground.  1.0 = no friction, 0.0 = total friction                                                                  |
+| AirResistance       | `Float`<br />(Default: 0.96)                      | **No**    | The minimum amount of friction applied when the entity is in the air. 1.0 = no friction, 0.0 = total friction                                                                                   |
+| AirResistanceMax    | `Float`<br />(Default: 0.0)                       | **No**    | The maximum amount of friction applied when the entity is in the air. 1.0 = no friction, 0.0 = total friction                                                                                   |
+| Threshold           | `Float`<br />(Default: 1.0)                       | **No**    | The speed at which the maximum amount of friction will be applied to the entity. The amount of friction applied will increase from minimum to maximum as the entity moves from 0 to this speed. |
+| Style               | `VelocityThresholdStyle`<br />(Default: `Linear`) | **No**    | The curve that friction follows as the entity's speed increases toward the `Threshold`.                                                                                                         |
+
+**DamageCalculatorType Values**
+
+- `Absolute`
+- `Dps`
+
+**DamageClass Values**
+
+- `Unknown`
+- `Light`
+- `Charged`
+- `Signature`
+
+**ChangeVelocityType Values**
+
+- `Add`
+- `Set`
+
+**VelocityThresholdStyle Values**
+
+- `Linear`
+- `Exp`
+
+### LaunchProjectile
+
+This is just a worse version of Projectile and is slated to be removed.  Use Projectile.
+
+### Projectile
+
+This interaction will spawn a new projectile at the User entity's eye position that will travel in its look direction.
+
+| Field Name | Type                                          | Required? | Notes                                                  |
+| ---------- | --------------------------------------------- | --------- | ------------------------------------------------------ |
+| Config     | `Asset`<br />(Asset Type: `ProjectileConfig`) | **No**    | Configuration describing the projectile to be spawned. |
+
+### RemoveEntity
+
+Despawns the specified entity from the world. This interaction will have no effect if the specified entity is a player. This
+interaction has no special failure conditions.
+
+| Field Name | Type                                     | Required? | Notes                  |
+| ---------- | ---------------------------------------- | --------- | ---------------------- |
+| Entity     | `InteractionTarget`<br />(Default: User) | **No**    | The entity to despawn. |
+
+**InteractionTarget Values**
+
+- `User` - The user of this interaction chain. The entity whose actions caused this interaction chain to be executed. This is usually the same as the Owner.
+- `Owner` - The owner of this interaction chain. The entity upon whom this interaction chain is executing.
+- `Target` - The entity target of this interaction chain, if any.  This value is mutable (and can therefore come from many places) but most commonly, it is an entity the User was targeting when this interaction chain began executing.
+
+### SendMessage
+
+This interaction sends a message to the Owner entity if that entity can receive messages.  Otherwise, the message
+is written to the server logs.  If the entity is a player, the message will appear in the player's chat window.
+
+\*\*SendMessage
+
+| Field Name | Type     | Required? | Notes                                                                                                                 |
+| ---------- | -------- | --------- | --------------------------------------------------------------------------------------------------------------------- |
+| Message    | `String` | **No**    | A text message to be sent to the Owner entity.  If this field is not provided, `Key` is used instead.                 |
+| Key        | `String` | **No**    | A translation key for a message to be sent to the Owner entity. If `Message` is provided, then this field is ignored. |
+
+### UseEntity
+
+This interaction is not in use by Hypixel and has some unusual qualities that mean it probably won't do what you want it
+to.  Do not use it.
+
+This interaction will retrieve the entity currently targeted by the client (NOT the interaction chain's current Target
+entity) and execute that entity's RootInteraction for this interaction chain's current interaction type. The
+RootInteraction will be executed as part of this current interaction chain. None of the properties of this interaction
+chain will be modified.
+
+This interaction will fail if the client is not currently targeting an entity, or if no interaction for the current
+interaction type exists on the entity.
+
+## Stats
+
+Hytale's resource system has been written about fairly extensively.  You can use these interactions to modify stats in
+response to actions or use stats as a cost for abilities.
+
+### ChangeStat
+
+This interaction applies a set of raw stat changes to the User entity. It has no special failure conditions.
+
+| Field Name    | Type                                                         | Required? | Notes                                                                                                                                                                                                                      |
+| ------------- | ------------------------------------------------------------ | --------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| StatModifiers | `Map`<br />(Key Type: `EntityStatType`, Value Type: `Float`) | **Yes**   | A set of stats to modify and what value to apply to them.                                                                                                                                                                  |
+| ValueType     | `ValueType`<br />(Default: Absolute)                         | **No**    | Whether the values in the `StatModifiers` map represent flat values to apply to the stat total, or percentages (0.0-100.0). Percentage values are percentage of the difference between the maximum and minimum stat value. |
+| Behaviour     | `ChangeStatBehavior`<br />(Default: Add)                     | **No**    | Whether the values in the `StatModifiers` map represent deltas to add into the User entity's current stat values, or fixed values to set the entity's stats to.                                                            |
+
+**ValueType Values**
+
+- `Absolute`
+- `Percent`
+
+**ChangeStatBehaviour Values**
+
+- `Add`
+- `Set`
+
+### ChangeStatWithModifier
+
+This interaction is like ChangeStat, except an armor stat modifier can be chosen which will apply bonuses and penalties
+to a stat from the User entity's equipped armor before it is applied.
+
+| Field Name            | Type                                                         | Required? | Notes                                                                                                                                                                                                                      |
+| --------------------- | ------------------------------------------------------------ | --------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| StatModifiers         | `Map`<br />(Key Type: `EntityStatType`, Value Type: `Float`) | **Yes**   | A set of stats to modify and what value to apply to them.                                                                                                                                                                  |
+| ValueType             | `ValueType`<br />(Default: Absolute)                         | **No**    | Whether the values in the `StatModifiers` map represent flat values to apply to the stat total, or percentages (0.0-100.0). Percentage values are percentage of the difference between the maximum and minimum stat value. |
+| Behaviour             | `ChangeStatBehavior`<br />(Default: Add)                     | **No**    | Whether the values in the `StatModifiers` map represent deltas to add into the User entity's current stat values, or fixed values to set the entity's stats to.                                                            |
+| InteractionModifierId | `InteractionModifierId`                                      | **Yes**   | The armor interaction modifier to apply bonuses and penalties for.                                                                                                                                                         |
+
+**ValueType Values**
+
+- `Absolute`
+- `Percent`
+
+**ChangeStatBehaviour Values**
+
+- `Add`
+- `Set`
+
+**InteractionModifierId Values**
+
+- `Dodge`
+
+### StatsCondition
+
+This interaction will fail if the User entity cannot afford the specified stats costs, or if it does not have the
+requested stats.
+
+| Field Name | Type                                                         | Required? | Notes                                                                                                                                                                                    |
+| ---------- | ------------------------------------------------------------ | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Costs      | `Map`<br />(Key Type:` EntityStatType`, Value Type: `Float`) | **Yes**   | A set of costs that the User entity needs to be able to afford for this interaction to succeed.                                                                                          |
+| ValueType  | `ValueType`<br />(Default: Absolute)                         | **No**    | Whether the values in the `Costs` map represetn flat values or percentages (0.0-100.0).  Percentage values are percentage of the difference between the maximum and minimum value.       |
+| LessThan   | `Boolean`<br />(Default: false)                              | **No**    | If true, this interaction will fail unless the User entity's current stat values are at or **below** the specified levels.  If false, they must be at or **above** the specified levels. |
+| Lenient    | `Boolean`<br />(Default: false)                              | **No**    | If true and `LessThan` is true, and a player's minimum stat value is below zero, then the player can afford a stat cost if the current value of a stat if above 0.                       |
+
+**ValueType Values**
+
+- `Absolute`
+- `Percent`
+
+### StatsConditionWithModifier
+
+This interaction is like StatsCondition, except an armor stat modifier can be chosen which will apply bonuses and penalties
+to a stat's cost from the User entity's equipped armor before it is compared.
+
+| Field Name            | Type                                                         | Required? | Notes                                                                                                                                                                                    |
+| --------------------- | ------------------------------------------------------------ | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Costs                 | `Map`<br />(Key Type:` EntityStatType`, Value Type: `Float`) | **Yes**   | A set of costs that the User entity needs to be able to afford for this interaction to succeed.                                                                                          |
+| ValueType             | `ValueType`<br />(Default: Absolute)                         | **No**    | Whether the values in the `Costs` map represetn flat values or percentages (0.0-100.0).  Percentage values are percentage of the difference between the maximum and minimum value.       |
+| LessThan              | `Boolean`<br />(Default: false)                              | **No**    | If true, this interaction will fail unless the User entity's current stat values are at or **below** the specified levels.  If false, they must be at or **above** the specified levels. |
+| Lenient               | `Boolean`<br />(Default: false)                              | **No**    | If true and `LessThan` is true, and a player's minimum stat value is below zero, then the player can afford a stat cost if the current value of a stat if above 0.                       |
+| InteractionModifierId | `InteractionModifierId`                                      | **Yes**   | The armor interaction modifier to apply bonuses and penalties for.                                                                                                                       |
+
+**ValueType Values**
+
+- `Absolute`
+- `Percent`
+
+**InteractionModifierId Values**
+
+- `Dodge`
+
+## EntityEffects
+
+EntityEffects are buff or debuff effects that can be applied to a LivingEntity.  These can have a variety of effects from
+movement speed changes to periodic damage.
+
+### EffectCondition
+
+This interaction will fail if the specified entity's EntityEffects do not match the provided conditions.
+
+**EffectCondition Fields**
+
+| Field Name      | Type                                             | Required? | Notes                                                                                                                                                                                                             |
+| --------------- | ------------------------------------------------ | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Entity          | `InteractionTarget`<br />(Default: User)         | **Yes**   | The entity to examine for EntityEffects. This field can indicate the Owner, User, or Target of this interaction chain.                                                                                            |
+| Match           | `Match`<br />(Default: All)                      | **No**    | If `All`, then this interaction will fail if any EntityEffect in the `EntityEffectIds` is not on the specified entity. If `None`, then this interaction will fail if any EntityEffect IS on the specified entity. |
+| EntityEffectIds | `AssetArray`<br />(Element Type: `EntityEffect`) | **Yes**   | The set of EntityEffects to check against the specified entity and `Match`.                                                                                                                                       |
+
+**InteractionTarget Values**
+
+- `User` - The user of this interaction chain. The entity whose actions caused this interaction chain to be executed. This is usually the same as the Owner.
+- `Owner` - The owner of this interaction chain. The entity upon whom this interaction chain is executing.
+- `Target` - The entity target of this interaction chain, if any.  This value is mutable (and can therefore come from many places) but most commonly, it is an entity the User was targeting when this interaction chain began executing.
+
+**Match Values**
+
+- `All` - All EntityEffects must be on the specified entity for this interaction to succeed.
+- `None` - None of the EntityEffects must be on the specified entity for this interaction to succeed.
+
+### ApplyEffect
+
+This interaction will apply the specified EntityEffect to the specified Entity.  It has no special failure conditions.
+
+**ApplyEffect Fields**
+
+| Field Name | Type                                      | Required? | Notes                                                                                                                  |
+| ---------- | ----------------------------------------- | --------- | ---------------------------------------------------------------------------------------------------------------------- |
+| Entity     | `InteractionTarget`<br />(Default: User)  | **Yes**   | The entity to apply the EntityEffect to. This field can indicate the Owner, User, or Target of this interaction chain. |
+| EffectId   | `Asset`<br />(Asset Type: `EntityEffect`) | **Yes**   | The effect to apply.                                                                                                   |
+
+**InteractionTarget Values**
+
+- `User` - The user of this interaction chain. The entity whose actions caused this interaction chain to be executed. This is usually the same as the Owner.
+- `Owner` - The owner of this interaction chain. The entity upon whom this interaction chain is executing.
+- `Target` - The entity target of this interaction chain, if any.  This value is mutable (and can therefore come from many places) but most commonly, it is an entity the User was targeting when this interaction chain began executing.
+
+### ClearEntityEffect
+
+This interaction will remove the specified EntityEffect from the specified Entity. It has no special failure conditions.
+It will not fail if the Entity does not have the EntityEffect.
+
+**ClearEntityEffect Fields**
+
+| Field Name | Type                                      | Required? | Notes                                                                                                                     |
+| ---------- | ----------------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------- |
+| Entity     | `InteractionTarget`<br />(Default: User)  | **Yes**   | The entity to remove the EntityEffect from. This field can indicate the Owner, User, or Target of this interaction chain. |
+| EffectId   | `Asset`<br />(Asset Type: `EntityEffect`) | **Yes**   | The effect to remove.                                                                                                     |
+
+**InteractionTarget Values**
+
+- `User` - The user of this interaction chain. The entity whose actions caused this interaction chain to be executed. This is usually the same as the Owner.
+- `Owner` - The owner of this interaction chain. The entity upon whom this interaction chain is executing.
+- `Target` - The entity target of this interaction chain, if any.  This value is mutable (and can therefore come from many places) but most commonly, it is an entity the User was targeting when this interaction chain began executing.
+
+## Farming
+
+These are interaction types built to support the in-game farming system in Hytale. They are mostly block-related interactions
+with a few exceptions.
+
+### ChangeFarmingStage
+
+If the target block is a farming block, this interaction will attempt to modify the current farming stage in one of
+three ways.  The interaction can optionally specify which StageSet to use for the new stage. If it is not specified,
+the current StageSet will be used. If any part of the the process of changing the growth stage fails, this interaction
+will fail, with the one exception that attempting to set the stage to the crop's existing stage will have no effect but
+still succeed.
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                                                                                                                                                                          |
+| ---------------- | ------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction.                                                                                                                                              |
+| StageSet         | `String`                        | **No**    | If provided, set the block's current stage to one in the provided StageSet. Otherwise, use the crop's current StageSet.                                                                                                                                                        |
+| Increase         | `Integer`                       | **No**    | If provided, increase the current stage by the specified amount. If the specified stage does not exist, the block will be set to the closest extant stage.                                                                                                                     |
+| Decrease         | `Integer`                       | **No**    | If provided and `Increase` is not provided, decrease the current stage by the specified amount. If the specified stage does not exist, the block will be set to the closest extant stage.                                                                                      |
+| Stage            | `Integer`<br />(Default: -1)    | **No**    | If provided and `Increase`/`Decrease` are not provided, set the current stage to the specified stage. If this value is less than 0, set the current stage to the final growth stage. If the specified stage does not exist, the block will be set to the closest extant stage. |
+
+### FertilizeSoil
+
+If the target block is unfertilized tilled soil or a farming block on top of unfertilized tilled soil, fertilizes the soil.
+The interaction will fail otherwise.
+
+**FertilizeSoil Fields**
+
+| Field Name       | Type                                  | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false)       | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+| RefreshModifiers | `Array`<br />(Element Type: `String`) | **No**    | Does nothing.                                                                                                                     |
+
+### HarvestCrop
+
+This interaction will attempt to execute the harvest action on the current block target and add the crop's drops to the User entity's
+inventory.  The block will either be destroyed or set to its post-harvest growth stage, depending on the farming
+configuration of the block.  This will happen (and the player will receive the full harvest drops) regardless of the
+block's current growth stage. This interaction has no special failure conditions, even if the block target isn't a
+farming block or gathering isn't permitted in the current world, but nothing will occur in those cases.
+
+**HarvestCrop Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+
+### UseWateringCan
+
+If the target block is tilled soil or a farming block on top of tilled soil, waters the soil for the specified duration.
+The interaction will fail otherwise.
+
+**UseWateringCan Fields**
+
+| Field Name       | Type                                  | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false)       | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+| Duration         | `Integer`<br />(Default: 0)           | **No**    | The duration in seconds to water the soil for.                                                                                    |
+| RefreshModifiers | `Array`<br />(Element Type: `String`) | **No**    | Does nothing.                                                                                                                     |
diff --git a/content/docs/sv-SE/contributing/pr-guidelines.mdx b/content/docs/sv-SE/contributing/pr-guidelines.mdx
index 7a251032..c226da04 100644
--- a/content/docs/sv-SE/contributing/pr-guidelines.mdx
+++ b/content/docs/sv-SE/contributing/pr-guidelines.mdx
@@ -19,6 +19,8 @@ To ensure a smooth and efficient review process, both contributors and reviewers
 4. **Code Quality**
    - Ensure your code follows the project's coding standards and best practices.
    - Include comments where necessary to explain complex logic.
+   - Always test your changes locally before submitting the PR to catch any issues early.
+   - Format your code using `bun format` to maintain consistency across the codebase.
 5. **Testing**
    - Test your changes thoroughly before submitting the PR.
    - If applicable, include unit tests or integration tests to verify your changes.
diff --git a/content/docs/sv-SE/contributing/translate.mdx b/content/docs/sv-SE/contributing/translate.mdx
new file mode 100644
index 00000000..c62ffdde
--- /dev/null
+++ b/content/docs/sv-SE/contributing/translate.mdx
@@ -0,0 +1,74 @@
+---
+title: Translate
+description: How to translate HytaleModding to your language
+---
+
+# Translating HytaleModding
+
+HytaleModding is translated with the help of the community using **Crowdin**. If you want to help translate or improve existing translations, this is the right place.
+
+## Steps to Translate
+
+All translations are managed **via Crowdin**.
+
+1. Visit [our Crowdin project](https://crowdin.com/project/hytalemodding) and log in if required.
+2. Click on your language.
+3. Click on the file/article you wish to translate. We recommend starting with Official Documentation, and then Server Plugin Documentation.
+4. Start translating!
+5. Approved translations will appear on the website.
+
+### Video Guide
+
+<iframe src="https://www.youtube.com/embed/NHiG1rDRgks" allowFullScreen />
+
+## How to discuss
+
+You can always report issues or discuss specific topics directly on Crowdin, but we recommend using Discord instead of the Crowdin comment system to keep everything organized in one place.
+
+1. Join [our Discord](https://discord.gg/hytalemodding)
+2. Open `#translations` channel. Here you can discuss or ask questions that are not related to a specific language.
+3. If you want to join a thread, you are required to run `/translator <your-language>` command here. The bot will add you to the thread for your language.
+
+## Translation Guidelines
+
+- You need to be confident in what you are translating. You should be able to read the text you just translated and understand the meaning of it very easily.
+- It should use the simplest form of language possible. Use English words if the translation is unknown to the majority in your country.
+- Use your imagination, trust yourself. Feel free to change any context as you wish as long as it can still get the same point across and is understandable.
+- These guidelines are more important than language-specific guidelines, but less important than Hytale terminology and rules.
+
+## What not to translate
+
+We request you all to not translate these specific sections of the website:
+
+### Callout types
+
+Callouts are the boxes that contain important information. We request you to not translate the types as they only work in English.
+
+**Example:**
+
+```mdx
+<Callout type="warning" title="Translate this title!">
+Translate the text inside the callout!
+</Callout>
+```
+
+In this example, please don't translate the word warning, the rest you can translate.
+
+### Icons
+
+Icon names must not be translated.
+They are technical identifiers mapped directly to existing icons. Translating them will break the icon rendering.
+
+```mdx
+icon: Globe
+```
+
+---
+
+{/* 
+For translators who will edit this page:
+
+- You are required to translate the Guidelines as they change.
+- General guidelines should be translated but not edited.
+- Learn how to use Markdown from writing_guides.mdx
+*/}
diff --git a/content/docs/sv-SE/established-information/server/content-categories/art-assets.mdx b/content/docs/sv-SE/established-information/server/content-categories/art-assets.mdx
index 39c2ed37..1e926874 100644
--- a/content/docs/sv-SE/established-information/server/content-categories/art-assets.mdx
+++ b/content/docs/sv-SE/established-information/server/content-categories/art-assets.mdx
@@ -14,7 +14,7 @@ Hytale provides comprehensive support for 3D modeling and texture art creation,
 Hytale uses **Blockbench** as the primary tool for 3D modeling and animation:
 
 * **Official support**: Used for "creating Hytale models, textures, and animations"
-* **Special plugin**: Hytale will have a dedicated Blockbench plugin, to be released ASAP
+* **Special plugin**: Hytale has a dedicated [Blockbench Plugin](https://www.blockbench.net/plugins/hytale_plugin).
 * **Direct compatibility**: The plugin allows creators to "create Hytale-compatible models, textures, and animations directly in Blockbench"
 * **Replaces legacy tools**: Fully replaces the old Hytale Model Maker to better support established creative workflows in the community
 * **Safety features**: Only allows you to add things compatible with the engine, so no need to worry about breaking anything
diff --git a/content/docs/sv-SE/guides/ecs/block-components.mdx b/content/docs/sv-SE/guides/ecs/block-components.mdx
new file mode 100644
index 00000000..ca68b38a
--- /dev/null
+++ b/content/docs/sv-SE/guides/ecs/block-components.mdx
@@ -0,0 +1,247 @@
+---
+title: Block Components
+description: Learn how to use the block components.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+  - name: oskarscot
+    link: https://oskar.scot
+---
+
+# Overview
+
+In this guide, you'll learn how to use block components to create a ticking block.
+
+<Callout>
+  For a more complete reference, you may also want to review FarmingSystems.Ticking, as much of the underlying logic is based on its implementation.
+</Callout>
+
+## Steps
+
+### 1. ExampleBlock - holds block behavior
+
+```java
+public class ExampleBlock implements Component<ChunkStore> {
+
+    public static final BuilderCodec CODEC = BuilderCodec.builder(ExampleBlock.class, ExampleBlock::new).build();
+
+    // Components usually require a copy constructor as well but since we don't actually hold any data in this component this is not neccessary
+    public ExampleBlock() { }
+
+    public static ComponentType getComponentType() {
+        return ExamplePlugin.get().getExampleBlockComponentType();
+    }
+
+    @Nullable
+    public Component<ChunkStore> clone() {
+        return new ExampleBlock();
+    }
+}
+```
+
+ExampleBlock is a custom component that stores the behavior and data for your ticking block. Here, it simply places an Ice Block at x + 1 relative to its current position when it ticks.
+
+---
+
+### 2. ExampleInitializer - marks blocks as ticking when placed
+
+```java
+public class ExampleInitializer extends RefSystem {
+
+    @Override
+    public void onEntityAdded(@Nonnull Ref ref, @Nonnull AddReason reason, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+        BlockModule.BlockStateInfo info = (BlockModule.BlockStateInfo) commandBuffer.getComponent(ref, BlockModule.BlockStateInfo.getComponentType());
+        if (info == null) return;
+
+        ExampleBlock generator = (ExampleBlock) commandBuffer.getComponent(ref, ExamplePlugin.get().getExampleBlockComponentType());
+        if (generator != null) {
+            int x = ChunkUtil.xFromBlockInColumn(info.getIndex());
+            int y = ChunkUtil.yFromBlockInColumn(info.getIndex());
+            int z = ChunkUtil.zFromBlockInColumn(info.getIndex());
+
+            WorldChunk worldChunk = (WorldChunk) commandBuffer.getComponent(info.getChunkRef(), WorldChunk.getComponentType());
+            if (worldChunk != null) {
+				worldChunk.setTicking(x, y, z, true);
+            }
+        }
+    }
+
+    @Override
+    public void onEntityRemove(@Nonnull Ref ref, @Nonnull RemoveReason reason, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+    }
+
+    @Override
+    public Query getQuery() {
+        return Query.and(BlockModule.BlockStateInfo.getComponentType(), ExamplePlugin.get().getExampleBlockComponentType());
+    }
+}
+```
+
+ExampleInitializer is a RefSystem that reacts when block entities with the ExampleBlock component are added or removed. This is crucial for marking blocks as ticking when they're first placed.
+
+**Key Points:**
+
+- Tells the game that this block should tick, allowing `ExampleSystem` to process it.
+
+```java
+worldChunk.setTicking(x, y, z, true);
+```
+
+---
+
+### 3. ExampleSystem - handles ticking
+
+```java
+public class ExampleSystem extends EntityTickingSystem {
+
+    public void tick(float dt, int index, @Nonnull ArchetypeChunk archetypeChunk, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+        BlockSection blocks = (BlockSection) archetypeChunk.getComponent(index, BlockSection.getComponentType());
+
+        assert blocks != null;
+
+        if (blocks.getTickingBlocksCountCopy() != 0) {
+            ChunkSection section = (ChunkSection) archetypeChunk.getComponent(index, ChunkSection.getComponentType());
+
+            assert section != null;
+
+            BlockComponentChunk blockComponentChunk = (BlockComponentChunk) commandBuffer.getComponent(section.getChunkColumnReference(), BlockComponentChunk.getComponentType());
+
+            assert blockComponentChunk != null;
+
+            blocks.forEachTicking(blockComponentChunk, commandBuffer, section.getY(), (blockComponentChunk1, commandBuffer1, localX, localY, localZ, blockId) -> {
+                Ref<ChunkStore> blockRef = blockComponentChunk.getEntityReference(ChunkUtil.indexBlockInColumn(localX, localY, localZ));
+                if (blockRef == null) {
+                    return BlockTickStrategy.IGNORED;
+                } else {
+                    ExampleBlock exampleBlock = (ExampleBlock) commandBuffer1.getComponent(blockRef, ExampleBlock.getComponentType());
+                    if (exampleBlock != null) {
+                        WorldChunk worldChunk = (WorldChunk) commandBuffer.getComponent(section.getChunkColumnReference(), WorldChunk.getComponentType());
+                        World world = worldChunk.getWorld();
+
+                        int globalX = localX + (worldChunk.getX() * 32);
+                        int globalZ = localZ + (worldChunk.getZ() * 32);
+
+                        // We need to execute setBlock on the world thread as you cannot call store functions from a system
+                        // This is because of the architecture of the server, depending on your needs you can also use the CommandBuffer
+                        world.execute(() -> {
+                            world.setBlock(globalX + 1, localY, globalZ, "Rock_Ice");
+                        });
+
+                        return BlockTickStrategy.CONTINUE;
+
+                    } else {
+                        return BlockTickStrategy.IGNORED;
+                    }
+                }
+            });
+        }
+    }
+
+    @Nullable
+    public Query getQuery() {
+        return Query.and(BlockSection.getComponentType(), ChunkSection.getComponentType());;
+    }
+}
+```
+
+ExampleSystem is an EntityTickingSystem that runs every tick to execute the logic for all ticking blocks with the ExampleBlock component.
+
+**Key Points:**
+
+- **Get the block component**
+
+```java
+ExampleBlock exampleBlock = (ExampleBlock) commandBuffer.getComponent(blockRef, ExampleBlock.getComponentType());
+```
+
+- **Convert local chunk coordinates to world coordinates**
+
+```java
+int globalX = localX + (worldChunk.getX() * 32);
+int globalZ = localZ + (worldChunk.getZ() * 32);
+```
+
+- **Run the block logic**
+
+```java
+exampleBlock.runBlockAction(globalX, localY, globalZ, worldChunk.getWorld());
+```
+
+- **Keep the block ticking in the next tick**
+
+```java
+return BlockTickStrategy.CONTINUE;
+```
+
+---
+
+### 4. ExamplePlugin - registers components and systems
+
+```java
+public class ExamplePlugin extends JavaPlugin {
+    protected static ExamplePlugin instance;
+    private static final HytaleLogger LOGGER = HytaleLogger.forEnclosingClass();
+    private ComponentType exampleBlockComponentType;
+
+    public static ExamplePlugin get() {
+        return instance;
+    }
+
+    public ExamplePlugin(@Nonnull JavaPluginInit init) {
+        super(init);
+        LOGGER.atInfo().log("Hello from " + this.getName() + " version " + this.getManifest().getVersion().toString());
+    }
+
+    @Override
+    protected void setup() {
+        instance = this;
+        LOGGER.atInfo().log("Setting up plugin " + this.getName());
+        this.exampleBlockComponentType = this.getChunkStoreRegistry().registerComponent(ExampleBlock.class, "ExampleBlock", ExampleBlock.CODEC);
+    }
+	
+	@Override
+	protected void start() {
+		this.getChunkStoreRegistry().registerSystem(new ExampleSystem());
+		this.getChunkStoreRegistry().registerSystem(new ExampleInitializer());
+	}
+
+    public ComponentType getExampleBlockComponentType() {
+        return this.exampleBlockComponentType;
+    }
+}
+```
+
+---
+
+### 5. Configure In-Game
+
+![block-component-1](/assets/guides/block-component-1.png)
+
+![block-component-2](/assets/guides/block-component-2.png)
+
+With this logic, the block will now continuously place an Ice Block at the coordinates x + 1 relative to its current position every time it ticks.
+
+---
+
+## Common Issues
+
+### NullPointerException on Startup
+
+**Error message:**
+
+```java
+java.lang.NullPointerException: Cannot invoke "com.hypixel.hytale.component.query.Query.validateRegistry(com.hypixel.hytale.component.ComponentRegistry)" because "query" is null
+```
+
+**Cause:**
+This error occurs when your module is loaded **before** the required Hytale modules.
+
+**Fix:**
+Add `EntityModule` and `BlockModule` as dependencies in your `manifest.json` to ensure proper load order.
+
+```json
+"Dependencies": {
+  "Hytale:EntityModule": "*",
+  "Hytale:BlockModule": "*"
+}
+```
diff --git a/content/docs/sv-SE/guides/ecs/hytale-ecs-theory.mdx b/content/docs/sv-SE/guides/ecs/hytale-ecs-theory.mdx
index 20c3a94d..52d8b1f5 100644
--- a/content/docs/sv-SE/guides/ecs/hytale-ecs-theory.mdx
+++ b/content/docs/sv-SE/guides/ecs/hytale-ecs-theory.mdx
@@ -29,7 +29,7 @@ for now this is the basic understanding for the `ChunkStore`. You can use it to
 
 ## Holder
 
-A Holder is essentially a blueprint for an entity. Before an entity exists in the Store (and thus in the world), is exists as a `Holder`. It collects and holds all the necessary components (data). You can compare it analogous to shopping cart. You grab all components you need and once you have everything, check out at the store which will take your cart and create a valid entity ID and hand you back a receipt (a Ref).
+A Holder is essentially a blueprint for an entity. Before an entity exists in the Store (and thus in the world), it exists as a `Holder`. It collects and holds all the necessary components (data). You can compare it analogous to shopping cart. You grab all components you need and once you have everything, check out at the store which will take your cart and create a valid entity ID and hand you back a receipt (a Ref).
 
 Let's take a look at an example: initializing players. In `Universe`, the `addPlayer` method demonstrates it perfectly.
 When a player connects, we don't immediately throw them into the ECS. We first construct their data in a Holder.
@@ -167,7 +167,7 @@ MyComponent comp = commandBuffer.getComponent(ref, componentType);
 
 Codecs handle serialization and deserialization of components. Hytale uses them to save and load entity data to and from disk as well as sending component data over the network. When creating a custom component, you must also create a corresponding Codec.
 
-There are mutliple Codec types already implemented in the default Codec Interface:
+There are multiple Codec types already implemented in the default Codec Interface:
 
 - Codec.STRING
 - Codec.BOOLEAN
@@ -215,7 +215,7 @@ This might seem tedious at first but it ensures that your component can be corre
   KeyedCodec<Integer> exampleInt = new KeyedCodec<Integer>("ExampleIntIdForCodec", Codec.INTEGER);
   ```
 
-- **Setter Function**: This is a lambda function that takes an instance of your component and returns the value of the field you want to serialize. For example, if you have a field called `myCustomField` in your custom component, your getter function would look like this:
+- **Setter Function**: This is a lambda function that takes an instance of your component + the value to set and sets the field value on the component. For example, if you have a field called `myCustomField` in your custom component, your setter function would look like this:
   ```java
   (data, value) -> data.myCustomField = value
   ```
@@ -276,7 +276,7 @@ public class PoisonComponent implements Component<EntityStore> {
 
 You can also add validators to your Codec fields to ensure that the data being serialized/deserialized meets certain criteria. For example, if you want to ensure that the `damagePerTick` field is always non-negative or the poison name is never null, you can add a validator like this:
 
-````java
+```java
 .append(
     new KeyedCodec<Float>("DamagePerTick", Codec.FLOAT),
     (data, value) -> data.damagePerTick = value,
@@ -292,14 +292,15 @@ You can also add validators to your Codec fields to ensure that the data being s
 )
 .addValidator(Validators.nonNull())
 .add()
+```
 
 ### Complex Codec Examples
 
-If you want to have a map inside your component, you can use the MapCodec class to build a KeyedCoded for it. Here's an example of how to create a Codec for a Map field:
+If you want to have a map inside your component, you can use the MapCodec class to build a KeyedCodec for it. Here's an example of how to create a Codec for a Map field:
 
 ```java
 var damagePerTick = new KeyedCodec<>("DamagePerTick", new MapCodec<>(Codec.FLOAT, HashMap<String, Float>::new));
-````
+```
 
 <Callout type="info">
   This also works with custom Objects as long as you have a Codec defined for the Object type.
diff --git a/content/docs/sv-SE/guides/java-basics/00-introduction.mdx b/content/docs/sv-SE/guides/java-basics/00-introduction.mdx
index a03ad638..b0130d74 100644
--- a/content/docs/sv-SE/guides/java-basics/00-introduction.mdx
+++ b/content/docs/sv-SE/guides/java-basics/00-introduction.mdx
@@ -7,7 +7,7 @@ Welcome to your journey into Java Programming! This guide is designed to introdu
 
 ## What is Java?
 
-Java is a powerful, object-oriented programming language created in 1995. It's one of the most popular programming languages in the world and is used for everything from mobile apps to enterprise software. Most importantly for us, it's the language Hytale uses for it's servers & modding API.
+Java is a powerful, object-oriented programming language created in 1995. It's one of the most popular programming languages in the world and is used for everything from mobile apps to enterprise software. Most importantly for us, it's the language Hytale uses for its servers & modding API.
 
 ## What You'll Learn
 
diff --git a/content/docs/sv-SE/guides/java-basics/02-operators.mdx b/content/docs/sv-SE/guides/java-basics/02-operators.mdx
index a132b1c0..18634665 100644
--- a/content/docs/sv-SE/guides/java-basics/02-operators.mdx
+++ b/content/docs/sv-SE/guides/java-basics/02-operators.mdx
@@ -119,7 +119,7 @@ String greetingWithName = "Hello, " + name + "!"; // "Hello, Alice!"
 
 ## Operator Precedence
 
-Operator Precendence means which operator gets evaluated first in an line of code. Think of it like BODMAS/PEMDAS in math!
+Operator Precedence means which operator gets evaluated first in an line of code. Think of it like BODMAS/PEMDAS in math!
 
 ```java
 int result = 10 + 5 * 2; // result is 20, not 30
diff --git a/content/docs/sv-SE/guides/java-basics/03-control-flow-if.mdx b/content/docs/sv-SE/guides/java-basics/03-control-flow-if.mdx
index b9d6c479..af2d1c22 100644
--- a/content/docs/sv-SE/guides/java-basics/03-control-flow-if.mdx
+++ b/content/docs/sv-SE/guides/java-basics/03-control-flow-if.mdx
@@ -7,7 +7,7 @@ Programs need to make decisions. If statements let your code choose different pa
 
 ## Basic If Statement
 
-The simplest form checks one condition;
+The simplest form checks one condition:
 
 ```java
 int health = 20;
diff --git a/content/docs/sv-SE/guides/java-basics/08-access-modifiers.mdx b/content/docs/sv-SE/guides/java-basics/08-access-modifiers.mdx
index af560932..da2bf33b 100644
--- a/content/docs/sv-SE/guides/java-basics/08-access-modifiers.mdx
+++ b/content/docs/sv-SE/guides/java-basics/08-access-modifiers.mdx
@@ -484,7 +484,7 @@ class Data {
     // Static member:
     // cannot access to non-static variables
     public static void bar() {
-        x = 100; // Error: non-static variable x cannot be renference from a static context
+        x = 100; // Error: non-static variable x cannot be referenced from a static context
         y = 100; // OK
     }
 }
@@ -504,7 +504,7 @@ Data.x = 1000; // Error: cannot access instanced variables in a static context
 
 ### Static Fields
 
-A static field represents a data member owned by the class type rather then the object. Static fields are also stored in a specific memory location that's been shared between all the object instances that are created.
+A static field represents a data member owned by the class type rather than the object. Static fields are also stored in a specific memory location that's been shared between all the object instances that are created.
 
 It is declared as following:
 
diff --git a/content/docs/sv-SE/guides/plugin/animated-block-textures.mdx b/content/docs/sv-SE/guides/plugin/animated-block-textures.mdx
new file mode 100644
index 00000000..42bfa51f
--- /dev/null
+++ b/content/docs/sv-SE/guides/plugin/animated-block-textures.mdx
@@ -0,0 +1,101 @@
+---
+title: Animated Block Textures
+description: Learn how to attach a .blockyanim to a block
+authors:
+  - name: Burkino
+---
+
+import { File, Folder, Files } from 'fumadocs-ui/components/files';
+
+So, you want to make your blocks feel more alive through animations, do you?\
+Now for the most part this is the exact same as [Creating custom blocks](./creating-block).
+![blue fire gif](/assets/guides/blue_fire.gif)
+
+## Prerequisites
+
+This is NOT a guide on animating or texturing or even using BlockBench, why? Because I don't know how to do that.\
+The only thing we will be doing is taking the fire texture, changing the color, and applying it to our new fire block.
+
+## Setup
+
+To start, you're obviously going to want to grab the `Common/VFX/Fire/Fire.png` file. How you do it is up to you, in the Asset Editor you'll need to switch to the Common tab.\
+I'll assume you know how colorize or change the hue of an image, so go ahead and do that now and save it as `Blue_Fire.png`.
+
+The other assets used in this guide are `Common/VFX/Fire/Fire.blockymodel` and `Common/Blocks/Animations/Fire/Fire_Burn.blockyanim` (both renamed to `Blue_Fire`) but since we won't be changing them it's probably fine to leave them. I will reference the `Blue_Fire` versions as a way to point out what should be custom assets.\
+I will also duplicate `Server/Item/Item/Deco/Deco_Fire.json` and call it `Deco_Blue_Fire.json`.
+
+## Applying the changes
+
+The `Deco_Blue_Fire` block is actually just a particle emitter, however we will not be using particles, so lets start by removing them in `Block > Particles`.\
+Next we want to set the Block Model (called `CustomModel` in JSON) to `VFX/Blue_Fire/Blue_Fire.blockymodel` and Block Model Textures (`CustomModelTexture` in JSON) to
+
+```json
+[
+    {
+        "Texture": "VFX/Blue_Fire/Blue_Fire.png",
+        "Weight": 1
+    }
+]
+```
+
+Finally, we will apply the .blockyanim to our model, this is done through the Block Model Animation property (`CustomModelAnimation` in JSON) and the value should be `Blocks/Animations/Blue_Fire/Blue_Fire_Burn.blockyanim`.
+
+## Final Code
+
+With that your new blue fire should be done. Here is the minimal JSON for our blue fire.\
+There is an additional `Looping` and `RequiresAlphaBlending` property that I have not gone over, however I hope it is self-explanatory.
+
+```json
+{
+  "BlockType": {
+    "DrawType": "Model",
+    "CustomModel": "VFX/Blue_Fire/Blue_Fire.blockymodel",
+    "CustomModelAnimation": "Blocks/Animations/Blue_Fire/Blue_Fire_Burn.blockyanim",
+    "CustomModelTexture": [
+      {
+        "Texture": "VFX/Blue_Fire/Blue_Fire.png",
+        "Weight": 1
+      }
+    ],
+    "Looping": true,
+    "RequiresAlphaBlending": false
+  },
+  "PlayerAnimationsId": "Block"
+}
+```
+
+<Files>
+  <Folder name="resources" defaultOpen>
+    <Folder name="Server" defaultOpen>
+      <Folder name="Item" defaultOpen>
+        <Folder name="Items" defaultOpen>
+          <Folder name="Deco" defaultOpen>
+            <File name="Deco_Blue_Fire.json" />
+          </Folder>
+        </Folder>
+      </Folder>
+    </Folder>
+
+    <Folder name="Common" defaultOpen>
+      <Folder name="Blocks" defaultOpen>
+        <Folder name="Animations" defaultOpen>
+          <Folder name="Blue_Fire" defaultOpen>
+            <File name="Blue_Fire_Burn.blockyanim" />
+          </Folder>
+        </Folder>
+      </Folder>
+
+      <Folder name="VFX" defaultOpen>
+        <Folder name="Blue_Fire" defaultOpen>
+          <File name="Blue_Fire.blockymodel" />
+
+          <File name="Blue_Fire.png" />
+        </Folder>
+      </Folder>
+    </Folder>
+  </Folder>
+</Files>
+
+## Next steps
+
+Now that you know how to attach an animation to a block, try adding it to a block state.
diff --git a/content/docs/sv-SE/guides/plugin/build-and-test.mdx b/content/docs/sv-SE/guides/plugin/build-and-test.mdx
index 0e7fe7eb..f37534c3 100644
--- a/content/docs/sv-SE/guides/plugin/build-and-test.mdx
+++ b/content/docs/sv-SE/guides/plugin/build-and-test.mdx
@@ -9,18 +9,18 @@ If you followed along with the [Setting Up Your Development Environment](./setti
 
 ## Building Your Mod
 
-In our case, we've **Maven** as the build system. Maven is a powerful build automation tool that manages dependencies, compiles your code, and packages everything into a distributable JAR file.
+In our case, we've **Gradle** as the build system. Gradle is a powerful build automation tool that manages dependencies, compiles your code, and packages everything into a distributable JAR file.
 
-### Understanding Maven
+### Understanding Gradle
 
-Maven uses a `pom.xml` file (Project Object Model) to define your project's configuration, dependencies, and build settings. You can learn more about Maven at the [official Apache Maven website](https://maven.apache.org/).
+Gradle can use a `build.gradle.kts` file (Kotlin DSL) to define your project's configuration, dependencies, and build settings. You can learn more about Gradle at the [official Gradle website](https://gradle.org/).
 
-### Building with Maven
+### Building with Gradle
 
 To build your mod, open a terminal in your project directory and run:
 
 ```bash
-mvn package
+./gradlew build
 ```
 
 This command will:
@@ -29,16 +29,35 @@ This command will:
 2. Run any tests (if present)
 3. Package everything into a JAR file
 
+<Callout type="info">
+  If you are using the plugin template from the [Setting Up Your Development Environment](./setting-up-env) guide, then the build script is already set up for you. It includes paths to your Hytale game library and handles the packaging of your mod, managing hytale dependencies and manifest changes.
+
+  If you have a different path to your Hytale installation, you may receive the following error:
+
+  ```bash
+  FAILURE: Build failed with an exception.
+
+  * What went wrong:
+  Failed to find Hytale at the expected location. Please make sure you have installed the game. The expected location can be changed using the hytale.home_path property. Currently looking in 'C:\Path\To\Hytale'
+  ```
+
+  You can change the path by adding a property to your `gradle.properties` file (if it doesn't exist, create it in the root of your project):
+
+  ```properties
+  hytale.home_path=C:\Correct\Path\To\Hytale
+  ```
+</Callout>
+
 ### Build Output
 
-Once the build completes successfully, your mod will be located in the `target` directory and named:
+Once the build completes successfully, your mod will be located in the `build/libs` directory and named:
 
 ```
-ExamplePlugin-1.0-SNAPSHOT.jar
+ExamplePlugin-1.0.jar
 ```
 
 <Callout type="info">
-  The exact name may vary depending on what you configured in your `pom.xml` file. Check the `artifactId` and `version` fields to see what your JAR will be named.
+  The exact name may vary depending on what you configured in your `build.gradle.kts` and `settings.gradle.kts` file. Check the `rootProject.name` and `version` fields to see what your JAR will be named.
 </Callout>
 
 ## Testing Your Mod
@@ -49,11 +68,11 @@ Now that you've built your mod, it's time to test it in Hytale!
 
 First, you need to find Hytale's mods directory:
 
-1. Press **Win + R** on your keyboard
-2. Type `%appdata%` and press Enter
-3. Navigate to: `Hytale\UserData\Mods`
+1. Go to your Hytale installation directory (The default location is usually in your AppData folder)
+   > On Windows, you can access it by clicking `windows + R` and typing `%appdata%`.
+2. Navigate to: `/UserData/Mods`
 
-The full path should look like:
+The default path would look like:
 
 ```
 C:\Users\YourUsername\AppData\Roaming\Hytale\UserData\Mods
@@ -65,7 +84,7 @@ C:\Users\YourUsername\AppData\Roaming\Hytale\UserData\Mods
 
 ### 2. Copy Your Mod
 
-Copy the `ExamplePlugin-1.0-SNAPSHOT.jar` file from your project's `target` directory into the `Mods` folder you just located.
+Copy the `ExamplePlugin-1.0.jar` file from your project's `build/libs` directory into the `Mods` folder you just located.
 
 ### 3. Launch Hytale and Verify
 
@@ -84,7 +103,7 @@ If your mod doesn't appear in the mods list:
 - Make sure the JAR file is in the correct `Mods` folder
 - Check that your `manifest.json` file is properly configured
 - Look for any error messages in the Hytale logs
-- Verify that you're using the correct version of Java and Maven
+- Verify that you're using the correct version of Java and Gradle
 
 ## Next Steps
 
diff --git a/content/docs/sv-SE/guides/plugin/creating-commands.mdx b/content/docs/sv-SE/guides/plugin/creating-commands.mdx
index d33597f3..08572f16 100644
--- a/content/docs/sv-SE/guides/plugin/creating-commands.mdx
+++ b/content/docs/sv-SE/guides/plugin/creating-commands.mdx
@@ -8,6 +8,8 @@ authors:
     url: https://oskar.scot
   - name: jacobwojoski
     url: https://github.com/jacobwojoski
+  - name: Marcel-TO
+    url: https://marcel-to.net
 ---
 
 In this guide, you will learn how to create custom commands for your Hytale mod.
@@ -36,7 +38,7 @@ The most basic command is an `AbstractAsyncCommand`. It has very minimal data av
   `AbstractAsyncCommand` runs on its own background thread. This means its execute is not tied to any world instance and because of this it can not edit any **Stores** or **Refs** without getting the desired world first. To access this data any of the other command types would be preferred and are likely what you will want to use instead.
 </Callout>
 
-The main purpose for a command like this would be for something that can happen everywhere and is not tied to a specific world. For example a `serverRules` command to tell the user thats running the command in chat what the servers rules are nomatter what world they are in.
+The main purpose for a command like this would be for something that can happen everywhere and is not tied to a specific world. For example a `serverRules` command to tell the user that's running the command in chat what the server's rules are no matter what world they are in.
 
 ```java
 // Command that can be run that lists the server rules in chat to the player
@@ -49,7 +51,7 @@ public class ServerRulesCommand extends AbstractAsyncCommand {
     }
 
     // Run the command
-    // conetext - info about who ran the command. Server console?, Some player?
+    // context - info about who ran the command. Server console?, Some player?
     @Override
     protected CompletableFuture<Void> executeAsync(@Nonnull CommandContext context) {
         context.sendMessage(Message.raw("The only rule is there are no rules."));
@@ -134,7 +136,7 @@ Uses a Ray to see what the player is looking at and tries to run the command on
 
 ## Adding Arguments
 
-Arguments are additional fields that the user can input when running a command. The different types of arguments along with small snipits and a large example can be seen below.
+Arguments are additional fields that the user can input when running a command. The different types of arguments along with small snippets and a large example can be seen below.
 
 ### Command Argument Types
 
@@ -163,14 +165,14 @@ this.messageArg = this.withOptionalArg("message", "Message to print while healin
 
 ### Default Arguments
 
-Adding a default argument has two additional arguemnt for the default value and default value description. You need to use `withDefaultArg` method.
+Adding a default argument has two additional argument for the default value and default value description. You need to use `withDefaultArg` method.
 
 ```java
 // args <Command String> <Description> <Default Value> <Desc of default value>
 this.healthArg = this.withDefaultArg("health", "Amount to heal player", ArgTypes.FLOAT, (float)100, "Desc of Default: 100");
 ```
 
-### Flag Arguemnts
+### Flag Arguments
 
 Similar as above but the flags return is either true if it exists or false if it does not. You need to use `withFlagArg` method.
 
@@ -181,20 +183,13 @@ this.debugArg = this.withFlagArg("debug", "Add debug logs");
 
 ### ArgTypes
 
-The following ArgTypes are available (only lists common types):
-
-- `ArgTypes.STRING`
-- `ArgTypes.INTEGER`
-- `ArgTypes.BOOLEAN`
-- `ArgTypes.FLOAT`
-- `ArgTypes.DOUBLE`
-- `ArgTypes.UUID`
+You can find all the available argument types on the [ArgTypes](../../argtypes) page.
 
 ### Example Command Arg Types
 
-Shows all Command arguemnt types with different various input types.
+Shows all Command argument types with different various input types.
 
-**NOTE:** When getting the value of an argument during execute you need to pass the context with `someArg.get(commandContext)`. Where `commandContext` is the first variable in the execute funtion.
+**NOTE:** When getting the value of an argument during execute you need to pass the context with `someArg.get(commandContext)`. Where `commandContext` is the first variable in the execute function.
 
 ```java
 // Example usage: /healplayer --health 50 --message "Feels Good" --debug
@@ -204,7 +199,7 @@ public class HealPlayerCommand extends AbstractTargetPlayerCommand {
     private final FlagArg debugArg;
 
     public HealPlayerCommand() {
-        super("healplayer", "Healing a player for an <input> ammount of HP (default: 100)");
+        super("healplayer", "Healing a player for an <input> amount of HP (default: 100)");
 
         // Abstract TargetPlayerCommand passes the player that ran the command by default and implements
         // the use of `--player <value>` to specify someone else
@@ -213,10 +208,10 @@ public class HealPlayerCommand extends AbstractTargetPlayerCommand {
         this.healthArg = this.withDefaultArg("health", "Amount to heal player", ArgTypes.FLOAT, (float)100, "Desc of Default: 100");
 
         // Or you could do the following making the health value required instead of with a default.
-        //    You would need to change the decleration to RequiredArg<Float>
+        //    You would need to change the declaration to RequiredArg<Float>
         // this.healthArg = this.withRequiredArg("health", "Amount to heal player", ArgTypes.FLOAT);
 
-        // Optional args reguare the user the input `--<key> <value>` so the following would require `--message "Good Luck"`
+// Optional args require the user the input `--<key> <value>` so the following would require `--message "Good Luck"`
         this.messageArg = this.withOptionalArg("message", "Message to print while healing", ArgTypes.STRING);
 
         // No type needed due to being a bool
@@ -230,7 +225,7 @@ public class HealPlayerCommand extends AbstractTargetPlayerCommand {
             commandContext.sendMessage(Message.raw("We are debugging"));
         }
 
-        // Health is stored in a generic stat map to allowing mods/future contect to easily add more stats if desired.
+        // Health is stored in a generic stat map to allowing mods/future content to easily add more stats if desired.
         EntityStatMap stats = store.getComponent(ref, EntityStatMap.getComponentType());
         int healthIdx = DefaultEntityStatTypes.getHealth();
         EntityStatValue health = stats.get(healthIdx);
@@ -252,7 +247,7 @@ public class HealPlayerCommand extends AbstractTargetPlayerCommand {
 
 ## Argument Validators
 
-Argument validators are a way to check the command before the command gets executed. They are added with the `addValidator` method on an argument when calling `withXxxArg`. They provide a nice output to the user when an input value is invalid.
+Argument validators are a way to check the command before the command gets executed. They are added with the `addValidator` method on an argument when calling `withXxxArg`. They provide a nice output to the user when an input value is invalid. There are some common validators provided in the `Validators` class such as `greaterThan`, `lessThan`, and `or`, `max`, `range`, etc.
 
 ```java
 ...
@@ -260,18 +255,59 @@ Argument validators are a way to check the command before the command gets execu
     OptionalArg<Integer> healAmount = withOptionalArg("amount", "Heal Amount", ArgTypes.INTEGER)
         .addValidator(Validators.greaterThan(0))
         .addValidator(Validators.lessThan(1000));
-
-    // Custom check example
-    OptionalArg<Integer> healAmount = withOptionalArg("amount", "Heal Amount", ArgTypes.INTEGER)
-            .addValidator( value -> {
-                if (value != null && value <= 0) {
-                    return ValidationResult.error("ammount argument must be a positive number");
-                }
-                return ValidationResult.success();
-            });
 ...
 ```
 
+### Custom Validators
+
+You can also create custom validators by implementing the `com.hypixel.hytale.codec.validation.Validator` interface. The interfaces forces you to implement the `accept` and `updateSchema` method. The `accept` method takes in the argument value and validates it. If the validation fails, you can use the `fail` method of the `com.hypixel.hytale.codec.validation.ValidationResults` class to return an error message.
+The `updateSchema` method is used to update the schema of the command argument. This is used for commands that have dynamic schemas based on the input value. For example, if you have a command that takes in a player name as an argument, you can use the `updateSchema` method to update the schema to include a list of online players for validation.
+
+Here is an example of a custom validator that checks if a string value is equal to a banned word. In this example, the banned word is "badword". If the input value is "badword", the validator will fail and return an error message.
+
+```java
+import com.hypixel.hytale.codec.schema.SchemaContext;
+import com.hypixel.hytale.codec.schema.config.Schema;
+import com.hypixel.hytale.codec.validation.ValidationResults;
+import com.hypixel.hytale.codec.validation.Validator;
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+
+public class MyCustomValidator implements Validator<String> {
+    @Nonnull
+    private final String value;
+
+    public MyCustomValidator(@Nonnull String value) {
+        this.value = value;
+    }
+
+    @Override
+    public void accept(@Nullable String input, @Nonnull ValidationResults results) {
+        if (this.value.equalsIgnoreCase(input)) {
+            results.fail("The given role has been banned.");
+        }
+    }
+
+    @Override
+    public void updateSchema(SchemaContext context, @Nonnull Schema target) {
+        // This method can be used to update the schema of the command argument. This is useful for commands that have dynamic schemas based on the input value. For example, if you have a command that takes in a player name as an argument, you can use the `updateSchema` method to update the schema to include a list of online players for validation.
+        throw new UnsupportedOperationException("Not implemented yet.");
+    }
+}
+```
+
+After the custom validator is created, you can add it to an argument like the following example. In this example, we add the `MyCustomValidator` to a string argument called "role". If the user inputs "badword" as the role, the command will fail and return the error message defined in the `MyCustomValidator`.
+
+```java
+    ...
+    // Custom validator example
+    String bannedRole = "badword";
+
+    OptionalArg<String> roleArg = withOptionalArg("role", "Role to assign", ArgTypes.STRING)
+        .addValidator(new MyCustomValidator(bannedRole));
+    ...
+```
+
 ---
 
 ## Permissions
@@ -312,7 +348,7 @@ This allows the server to control who has access to specific commands. You add t
 
 If you want variants of the same command without doing argument parsing you can instead use `addUsageVariant(new OtherCommandClass())` in the original commands constructor.
 
-The only difference is in the `OtherCommandClass()` constrcutor you don't pass the command name to the super class.
+The only difference is in the `OtherCommandClass()` constructor you don't pass the command name to the super class.
 
 <Callout type="info">
   You can also use `addAliases("some_alias", "some_other_alias")` as a way to add shorthand or other ways to write the same command.
@@ -387,7 +423,7 @@ public class AdminCommand extends AbstractCommandCollection {
     public AdminCommand () {
         super("admin", "Admin commands");
         addSubCommand(new UserCommandCollection());
-        addSybCommand(new ServerCommandCollection);
+        addSubCommand(new ServerCommandCollection);
     }
 }
 ```
@@ -417,5 +453,5 @@ public class MyPlugin extends JavaPlugin {
 
 ## Video Link
 
-_Special Thanks to [TroubleDev](https://www.youtube.com/@TroubleDEV) for his excelent video guide on all of these features._
+_Special Thanks to [TroubleDev](https://www.youtube.com/@TroubleDEV) for his excellent video guide on all of these features._
 _Video Link: [TroubleDev - Hytale's Command API Explained](https://www.youtube.com/watch?v=KnmhG9MDMgo)_
diff --git a/content/docs/sv-SE/guides/plugin/creating-events.mdx b/content/docs/sv-SE/guides/plugin/creating-events.mdx
index 95863990..d3f0925d 100644
--- a/content/docs/sv-SE/guides/plugin/creating-events.mdx
+++ b/content/docs/sv-SE/guides/plugin/creating-events.mdx
@@ -1,6 +1,6 @@
 ---
-title: Creating Events
-description: Learn how to create custom events for your Hytale mod.
+title: Creating Events Listeners
+description: Learn how to create event listeners for your Hytale mod.
 authors:
   - name: Neil Revin
     url: https://itsneil.dev
@@ -10,7 +10,7 @@ authors:
 
 ## Event Class
 
-You can import a Event class and create a function with the Event as a argument. [Click here](../../server/events) to look at all available events.
+You can import an Event class and create a function with the Event as an argument. [Click here](../../server/events) to look at all available events.
 
 Example plugin when a player is ready (joins a server):
 
diff --git a/content/docs/sv-SE/guides/plugin/item-registry.mdx b/content/docs/sv-SE/guides/plugin/item-registry.mdx
new file mode 100644
index 00000000..9a0fd53a
--- /dev/null
+++ b/content/docs/sv-SE/guides/plugin/item-registry.mdx
@@ -0,0 +1,95 @@
+---
+title: Working with the Item Registry
+description: Learn how to access and query the game's item registry to list all items, check if items exist, and retrieve item properties.
+authors:
+  - name: Denis
+---
+
+In this guide, you'll learn how to work with Hytale's Item Registry system. This is useful when you need to programmatically list all available items, validate item IDs, or retrieve item properties at runtime.
+
+## Prerequisites
+
+Before diving in, you should be familiar with:
+
+- [Setting up your development environment](./setting-up-env)
+- [Creating commands](./creating-commands) (optional, for testing)
+
+## Required Imports
+
+To work with the Item Registry, you'll need the following imports:
+
+```java
+import com.hypixel.hytale.assetstore.map.DefaultAssetMap;
+import com.hypixel.hytale.server.core.asset.type.item.config.Item;
+```
+
+## Getting the Item Registry
+
+The Item Registry is accessed through the `Item.getAssetMap()` method, which returns a `DefaultAssetMap<String, Item>` containing all registered items in the game:
+
+```java
+DefaultAssetMap<String, Item> itemMap = Item.getAssetMap();
+```
+
+## Listing All Items
+
+To iterate through all items in the registry, you can get the underlying map and loop through its entries:
+
+```java
+DefaultAssetMap<String, Item> itemMap = Item.getAssetMap();
+var map = itemMap.getAssetMap();
+
+for (var entry : map.entrySet()) {
+    String itemId = String.valueOf(entry.getKey());
+    Item item = entry.getValue();
+    
+    // Do something with the item
+    LOGGER.atInfo().log("Item ID: " + itemId);
+}
+```
+
+You can also get the total count of registered items:
+
+```java
+int totalItems = map.size();
+```
+
+## Checking if an Item Exists
+
+To check if a specific item exists in the registry, use `getAsset()` and verify the result:
+
+```java
+public boolean itemExists(String itemId) {
+    var assetMap = Item.getAssetMap();
+    if (assetMap != null) {
+        Item item = assetMap.getAsset(itemId);
+        return item != null && item != Item.UNKNOWN;
+    }
+    return false;
+}
+```
+
+<Callout type="info">
+  The `Item.UNKNOWN` constant represents an invalid or unrecognized item. Always check for both `null` and `Item.UNKNOWN` when validating items.
+</Callout>
+
+## Accessing Item Properties
+
+Once you have an `Item` instance, you can access various properties:
+
+```java
+var assetMap = Item.getAssetMap();
+Item item = assetMap.getAsset("Soil_Grass");
+
+if (item != null && item != Item.UNKNOWN) {
+    String id = item.getId(); // Soil_Grass
+    int maxStack = item.getMaxStack(); // 100
+    boolean isBlock = item.hasBlockType(); // true
+    boolean isConsumable = item.isConsumable(); // false
+}
+```
+
+## Related Guides
+
+- [Inventory Management](./inventory-management) - Learn how to add and remove items from player inventories
+- [Create Custom Item and Interaction](./item-interaction) - Learn how to create your own custom items
diff --git a/content/docs/sv-SE/guides/plugin/permission-management.mdx b/content/docs/sv-SE/guides/plugin/permission-management.mdx
index 6b7cfd46..55f06101 100644
--- a/content/docs/sv-SE/guides/plugin/permission-management.mdx
+++ b/content/docs/sv-SE/guides/plugin/permission-management.mdx
@@ -10,132 +10,569 @@ authors:
     link: https://discord.com/users/292656109939064833
   - name: Ivan
     link: https://discord.com/users/505770451218333717
+  - name: ZenithDevHQ
+    link: https://github.com/ZenithDevHQ
 ---
 
-In this guide, you'll learn how to manage permission nodes and groups in your Hytale plugin.
+In this guide, you'll learn how to manage permission nodes and groups in your Hytale plugin. Permissions control what actions players can perform on your server, from basic commands to advanced administrative functions.
 
-## The `PermissionsModule` class
+## What Are Permissions?
 
-The `PermissionsModule` class is responsible for managing permission nodes and groups in your plugin. It provides methods to check, grant and revoke permissions and groups for players. It allows the following operations
+Permissions are string identifiers that control access to features and commands. When a player tries to perform an action (like using a command), the server checks if they have the required permission.
 
-- Add permissions to user
-- Remove permissions from user
-- Add permissions to group (this also creates the group if it doesn't exist)
-- Remove permissions from group
-- Add user to group
-- Remove user from group
-- List all groups for a user
-- Check if a user has a permission (it checks both user and group permissions for the given player UUID)
+**Example permission nodes:**
 
-With this class you cannot:
+- `hytale.command.gamemode` - Permission to use the gamemode command
+- `hytale.editor.brush.use` - Permission to use brush tools
+- `myplugin.teleport.home` - A custom permission for your plugin
 
-- List all defined groups
-- Remove a group
+Permissions follow a hierarchical naming pattern: `namespace.category.action`
 
-### Adding Permission Nodes
+## Key Concepts
 
-You need a `Set<String>` containing all the permission nodes you want to add, these are added on top of the already existing permission nodes the user may have, it is not a replacement.
+Before diving into code, let's understand the core concepts:
+
+| Concept             | Description                                                                |
+| ------------------- | -------------------------------------------------------------------------- |
+| **Permission Node** | A string like `myplugin.feature.use` that represents a specific permission |
+| **Group**           | A named collection of permissions (e.g., "Admin", "VIP", "Default")        |
+| **Provider**        | The backend that stores and retrieves permissions                          |
+| **Wildcard**        | A pattern like `*` or `myplugin.*` that matches multiple permissions       |
+
+### How Permissions Are Checked
+
+When checking if a player has a permission, Hytale follows this order:
+
+1. **User's direct permissions** - Permissions granted directly to the player
+2. **Group permissions** - Permissions from groups the player belongs to
+3. **Virtual groups** - Game-mode-based permissions (e.g., Creative mode grants builder tools)
+4. **Default value** - Falls back to `false` if no match found
+
+<Callout type="info">
+  The first definitive match wins. If a player has a permission granted at the user level, group permissions won't override it.
+</Callout>
+
+---
+
+## The `PermissionsModule` Class
+
+The `PermissionsModule` class is the central hub for managing permissions. Access it using the singleton pattern:
 
 ```java
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.addUserPermission(playerUUID, permissions);
 ```
 
-### Removing Permission Nodes
+### Available Operations
+
+The module supports these operations:
+
+| Operation                     | Method                                          |
+| ----------------------------- | ----------------------------------------------- |
+| Add permissions to user       | `addUserPermission(uuid, permissions)`          |
+| Remove permissions from user  | `removeUserPermission(uuid, permissions)`       |
+| Add permissions to group      | `addGroupPermission(groupName, permissions)`    |
+| Remove permissions from group | `removeGroupPermission(groupName, permissions)` |
+| Add user to group             | `addUserToGroup(uuid, groupName)`               |
+| Remove user from group        | `removeUserFromGroup(uuid, groupName)`          |
+| Get user's groups             | `getGroupsForUser(uuid)`                        |
+| Check permission              | `hasPermission(uuid, permissionNode)`           |
+
+<Callout type="warning">
+  The module does **not** support:
+
+  - Listing all defined groups
+  - Deleting a group entirely
+
+  Groups are implicitly created when you first add permissions to them.
+</Callout>
+
+---
 
-Same as above, we just use the `removeUserPermission` method instead to remove permission nodes.
+## Checking Permissions
+
+The most common operation is checking if a player has a permission.
+
+### Basic Permission Check
+
+```java
+// Returns true if player has the permission, false otherwise
+boolean canUse = PermissionsModule.get().hasPermission(playerUUID, "myplugin.feature.use");
+
+if (canUse) {
+    // Player has permission, allow the action
+} else {
+    // Player lacks permission, deny or show error
+}
+```
+
+### Permission Check with Default Value
+
+You can specify what to return when no permission is explicitly set:
+
+```java
+// Returns true by default if no explicit permission is found
+boolean canUse = PermissionsModule.get().hasPermission(playerUUID, "myplugin.feature.use", true);
+```
+
+This is useful for features that should be enabled by default but can be revoked.
+
+### Using PermissionHolder Interface
+
+Players and command senders implement `PermissionHolder`, allowing direct checks:
+
+```java
+// In a command or event handler where you have access to the player
+if (player.hasPermission("myplugin.admin.manage")) {
+    // Player has admin permission
+}
+```
+
+---
+
+## Managing User Permissions
+
+### Adding Permissions to a User
+
+Permissions are additive - new permissions are added on top of existing ones, not replaced.
+
+```java
+PermissionsModule perms = PermissionsModule.get();
+
+// Add a single permission
+perms.addUserPermission(playerUUID, Set.of("myplugin.vip.chat"));
+
+// Add multiple permissions at once
+Set<String> newPerms = Set.of(
+    "myplugin.vip.chat",
+    "myplugin.vip.fly",
+    "myplugin.vip.kit"
+);
+perms.addUserPermission(playerUUID, newPerms);
+```
+
+### Removing Permissions from a User
 
 ```java
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.removeUserPermission(playerUUID, permissions);
+
+// Remove specific permissions
+Set<String> toRemove = Set.of("myplugin.vip.fly");
+perms.removeUserPermission(playerUUID, toRemove);
 ```
 
-### Add permissions to group
+---
+
+## Managing Groups
+
+Groups let you assign a collection of permissions to multiple players. This is more manageable than assigning permissions individually.
+
+### Adding Permissions to a Group
+
+If the group doesn't exist, it will be created automatically.
 
 ```java
-String groupName = "testGroup";
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.addGroupPermission(groupName, permissions);
+
+// Create/update the "VIP" group with permissions
+Set<String> vipPerms = Set.of(
+    "myplugin.vip.chat",
+    "myplugin.vip.fly",
+    "myplugin.vip.kit"
+);
+perms.addGroupPermission("VIP", vipPerms);
 ```
 
-### Remove permissions from group
+### Removing Permissions from a Group
 
 ```java
-String groupName = "testGroup";
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.removeGroupPermission(groupName, permissions);
+
+// Remove specific permissions from the group
+Set<String> toRemove = Set.of("myplugin.vip.fly");
+perms.removeGroupPermission("VIP", toRemove);
 ```
 
-### Add user to group
+### Adding a User to a Group
 
 ```java
-String groupName = "testGroup";
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.addUserToGroup(playerUUID, groupName);
+
+// Add player to the VIP group - they now have all VIP permissions
+perms.addUserToGroup(playerUUID, "VIP");
 ```
 
-### Remove user from group
+### Removing a User from a Group
 
 ```java
-String groupName = "testGroup";
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.removeUserFromGroup(playerUUID, groupName);
+
+// Remove player from VIP group
+perms.removeUserFromGroup(playerUUID, "VIP");
 ```
 
-### List all groups for a user
+### Getting a User's Groups
 
 ```java
 PermissionsModule perms = PermissionsModule.get();
-perms.getGroupsForUser(playerUUID);
+
+// Get all groups the player belongs to
+Set<String> groups = perms.getGroupsForUser(playerUUID);
+
+for (String group : groups) {
+    System.out.println("Player is in group: " + group);
+}
 ```
 
-### Check Permission Nodes
+---
+
+## Built-in Groups
+
+Hytale includes two default groups:
+
+| Group     | Default Permissions   | Purpose                           |
+| --------- | --------------------- | --------------------------------- |
+| `OP`      | `*` (all permissions) | Server operators with full access |
+| `Default` | None                  | Base group for all players        |
+
+Players without any explicit group assignment are automatically part of the `Default` group.
 
-To check if a player has a specific permission node, you can use the `hasPermission` method.
+---
+
+## Wildcards
+
+Wildcards let you grant or deny multiple permissions with a single pattern.
+
+### Wildcard Patterns
+
+| Pattern             | Meaning                                          |
+| ------------------- | ------------------------------------------------ |
+| `*`                 | Grants **all** permissions                       |
+| `myplugin.*`        | Grants all permissions starting with `myplugin.` |
+| `-*`                | Denies **all** permissions                       |
+| `-myplugin.admin.*` | Denies all admin permissions in your plugin      |
+
+### Example: Admin Group with Wildcards
 
 ```java
-boolean hasPermission = PermissionsModule.hasPermission(playerUUID, "permission.node");
+// Grant all permissions to admins
+perms.addGroupPermission("Admin", Set.of("*"));
+
+// Grant all plugin permissions to moderators
+perms.addGroupPermission("Moderator", Set.of("myplugin.*"));
+
+// Grant all permissions except admin commands
+perms.addGroupPermission("Helper", Set.of(
+    "*",
+    "-myplugin.admin.*"  // Deny admin permissions
+));
 ```
 
-## Additional: Defining your own provider for permissions and groups
+<Callout type="warning">
+  Negation permissions (starting with `-`) take precedence at each level. Use them carefully to avoid accidentally blocking permissions.
+</Callout>
+
+---
+
+## Built-in Permission Nodes
+
+Hytale provides constants for common permissions in the `HytalePermissions` class:
+
+### Command Permissions
+
+```java
+// Generate permission for a command
+String perm = HytalePermissions.fromCommand("gamemode");
+// Result: "hytale.command.gamemode"
+
+// Generate permission for a subcommand
+String perm = HytalePermissions.fromCommand("gamemode", "creative");
+// Result: "hytale.command.gamemode.creative"
+```
+
+### Common Permission Nodes
+
+| Permission                    | Description                  |
+| ----------------------------- | ---------------------------- |
+| `hytale.command.op.add`       | Add players to OP group      |
+| `hytale.command.op.remove`    | Remove players from OP group |
+| `hytale.editor.brush.use`     | Use brush tools              |
+| `hytale.editor.prefab.use`    | Use prefabs                  |
+| `hytale.editor.selection.use` | Use selection tools          |
+| `hytale.editor.history`       | Undo/redo operations         |
+| `hytale.camera.flycam`        | Use fly camera mode          |
+
+---
+
+## Listening to Permission Events
+
+You can react to permission changes using Hytale's event system.
+
+### Available Events
+
+| Event                                            | Triggered When                   |
+| ------------------------------------------------ | -------------------------------- |
+| `PlayerPermissionChangeEvent.PermissionsAdded`   | Permissions added to a user      |
+| `PlayerPermissionChangeEvent.PermissionsRemoved` | Permissions removed from a user  |
+| `PlayerGroupEvent.Added`                         | User added to a group            |
+| `PlayerGroupEvent.Removed`                       | User removed from a group        |
+| `GroupPermissionChangeEvent.Added`               | Permissions added to a group     |
+| `GroupPermissionChangeEvent.Removed`             | Permissions removed from a group |
 
-The PermissionsModule also enables us to define our own PermissionProvider's, this can be useful for:
+### Example: Reacting to Permission Changes
 
-- Cross server permission systems
-- Implementing features missing in the `HytalePermissionsProvider` like permission expiry
+```java
+public class PermissionListener {
+
+    public static void onPermissionsAdded(PlayerPermissionChangeEvent.PermissionsAdded event) {
+        UUID playerUUID = event.getPlayerUuid();
+        Set<String> added = event.getAddedPermissions();
+
+        System.out.println("Permissions added to " + playerUUID + ": " + added);
 
-To implement our PermissionProvider, first we need to define a provider class that implements PermissionProvider:
+        // Maybe notify the player or update cached data
+    }
+
+    public static void onGroupAdded(PlayerGroupEvent.Added event) {
+        UUID playerUUID = event.getPlayerUuid();
+        String groupName = event.getGroupName();
+
+        System.out.println("Player " + playerUUID + " joined group: " + groupName);
+    }
+}
+```
+
+### Registering the Events
 
 ```java
-public class DatabasePermissionProvider implements PermissionProvider
+public class MyPlugin extends JavaPlugin {
+
+    @Override
+    public void setup() {
+        EventRegistry events = this.getEventRegistry();
+
+        events.registerGlobal(
+            PlayerPermissionChangeEvent.PermissionsAdded.class,
+            PermissionListener::onPermissionsAdded
+        );
+
+        events.registerGlobal(
+            PlayerGroupEvent.Added.class,
+            PermissionListener::onGroupAdded
+        );
+    }
+}
 ```
 
-Then we just implement the required methods using a database implementation.
+---
+
+## Creating a Custom Permission Provider
+
+For advanced use cases, you can create your own permission provider. This is useful for:
+
+- Database-backed permissions (MySQL, MongoDB, etc.)
+- Cross-server permission synchronization
+- Custom features like permission expiry or contexts
+
+### Implementing PermissionProvider
+
+```java
+public class DatabasePermissionProvider implements PermissionProvider {
+
+    @Nonnull
+    @Override
+    public String getName() {
+        return "DatabasePermissionProvider";
+    }
+
+    // User permission methods
+    @Override
+    public void addUserPermissions(@Nonnull UUID uuid, @Nonnull Set<String> permissions) {
+        // Save to your database
+    }
+
+    @Override
+    public void removeUserPermissions(@Nonnull UUID uuid, @Nonnull Set<String> permissions) {
+        // Remove from your database
+    }
+
+    @Override
+    public Set<String> getUserPermissions(@Nonnull UUID uuid) {
+        // Query your database
+        return Set.of();
+    }
+
+    // Group permission methods
+    @Override
+    public void addGroupPermissions(@Nonnull String group, @Nonnull Set<String> permissions) {
+        // Save to your database
+    }
+
+    @Override
+    public void removeGroupPermissions(@Nonnull String group, @Nonnull Set<String> permissions) {
+        // Remove from your database
+    }
+
+    @Override
+    public Set<String> getGroupPermissions(@Nonnull String group) {
+        // Query your database
+        return Set.of();
+    }
+
+    // User-group membership methods
+    @Override
+    public void addUserToGroup(@Nonnull UUID uuid, @Nonnull String group) {
+        // Save to your database
+    }
+
+    @Override
+    public void removeUserFromGroup(@Nonnull UUID uuid, @Nonnull String group) {
+        // Remove from your database
+    }
+
+    @Override
+    public Set<String> getGroupsForUser(@Nonnull UUID uuid) {
+        // Query your database
+        return Set.of("Default");
+    }
+}
+```
 
 <Callout type="warning">
-  Hytale will try to use the first available permissions provider to add/remove gamemode groups (i.e. `Creative`, `Adventure`).
+  Hytale automatically assigns players to game-mode groups (like `Creative` or `Adventure`) using the first available provider.
+
+  If your provider throws an error when the group doesn't exist, the player will be disconnected! Always handle missing groups gracefully.
+</Callout>
+
+### Registering Your Provider
 
-  If your provider throws an error (for instance, if the group does not exist) when the server is preparing the player, the player will be disconnected.
+```java
+public class MyPlugin extends JavaPlugin {
+
+    @Override
+    public void setup() {
+        // Add your provider alongside the default one
+        PermissionsModule.get().addProvider(new DatabasePermissionProvider());
+    }
+}
+```
+
+The `PermissionsModule` aggregates permissions from all registered providers. This means:
+
+- Permission checks query all providers
+- Write operations (add/remove) use the **first** provider
+
+### Replacing the Default Provider
+
+If you want full control, you can remove the default provider:
+
+```java
+public class MyPlugin extends JavaPlugin {
+
+    @Override
+    public void setup() {
+        PermissionsModule perms = PermissionsModule.get();
+
+        // Remove the default provider FIRST
+        perms.removeProvider(perms.getFirstPermissionProvider());
+
+        // Then add your provider
+        perms.addProvider(new DatabasePermissionProvider());
+    }
+}
+```
+
+<Callout type="info">
+  When you remove the default provider, the `/op self` command will stop working since it checks for provider tampering.
 </Callout>
 
-We can then register the provider using the built-in permission module:
+---
+
+## Best Practices
+
+### Permission Naming Conventions
+
+Follow the pattern: `namespace.category.action`
 
 ```java
-PermissionsModule.get().addProvider(new DatabasePermissionProvider());
+// Good - clear hierarchy
+"myplugin.admin.ban"
+"myplugin.user.teleport.home"
+"myplugin.vip.chat.color"
+
+// Bad - unclear structure
+"myplugin_ban"
+"teleport"
+"vipChatColor"
 ```
 
-Please note that the `HytalePermissionsProvider` will still be enabled alongside your provider.
-The `PermissionsModule` will aggregate groups and permissions from all available providers.
+### Use Constants for Permissions
 
-If you want to disable the default `HytalePermissionsProvider`, you can use:
+Define your permissions as constants to avoid typos:
 
 ```java
-// put this **before** you add your provider
-PermissionsModule.get().removeProvider(PermissionsModule.get().getFirstPermissionProvider());
+public final class MyPermissions {
+    public static final String ADMIN_BAN = "myplugin.admin.ban";
+    public static final String ADMIN_KICK = "myplugin.admin.kick";
+    public static final String USER_HOME = "myplugin.user.home";
+    public static final String VIP_FLY = "myplugin.vip.fly";
+}
+
+// Usage
+if (player.hasPermission(MyPermissions.ADMIN_BAN)) {
+    // ...
+}
 ```
+
+### Don't Over-Permission
+
+Only create permissions for actions that genuinely need access control. Not everything needs a permission check.
+
+### Thread Safety
+
+If you create a custom provider, ensure it's thread-safe. Permission checks can occur from multiple threads simultaneously. Use `ReadWriteLock` or `ConcurrentHashMap` for your data structures.
+
+---
+
+## In-Game Commands
+
+Hytale provides built-in commands for managing permissions:
+
+### `/op` Command
+
+| Command               | Description                                                        |
+| --------------------- | ------------------------------------------------------------------ |
+| `/op self`            | Toggle your own OP status (singleplayer or with `--allow-op` flag) |
+| `/op add <player>`    | Add a player to the OP group                                       |
+| `/op remove <player>` | Remove a player from the OP group                                  |
+
+### `/perm` Command
+
+Use `/perm --help` in-game for full usage. Common operations:
+
+| Command                                  | Description                   |
+| ---------------------------------------- | ----------------------------- |
+| `/perm user list <uuid>`                 | List user's permissions       |
+| `/perm user add <uuid> <perm>`           | Add permission to user        |
+| `/perm user remove <uuid> <perm>`        | Remove permission from user   |
+| `/perm user group list <uuid>`           | List user's groups            |
+| `/perm user group add <uuid> <group>`    | Add user to group             |
+| `/perm user group remove <uuid> <group>` | Remove user from group        |
+| `/perm group list <group>`               | List group's permissions      |
+| `/perm group add <group> <perm>`         | Add permission to group       |
+| `/perm group remove <group> <perm>`      | Remove permission from group  |
+| `/perm test <perm>`                      | Test if you have a permission |
+
+---
+
+## Summary
+
+You've learned how to:
+
+- **Check permissions** using `PermissionsModule.hasPermission()`
+- **Manage user permissions** with `addUserPermission()` and `removeUserPermission()`
+- **Work with groups** using `addGroupPermission()`, `addUserToGroup()`, etc.
+- **Use wildcards** like `*` and `myplugin.*` for bulk permissions
+- **Listen to events** for permission changes
+- **Create custom providers** for database-backed permissions
+
+For more advanced permission systems with features like inheritance, expiry, and contexts, we're looking into expanding this guide with advanced permission management techniques in the future.
diff --git a/content/docs/sv-SE/guides/plugin/setting-up-env.mdx b/content/docs/sv-SE/guides/plugin/setting-up-env.mdx
index d2718098..5be5e9e0 100644
--- a/content/docs/sv-SE/guides/plugin/setting-up-env.mdx
+++ b/content/docs/sv-SE/guides/plugin/setting-up-env.mdx
@@ -4,6 +4,10 @@ description: Learn how to set up your development environment for modding Hytale
 authors:
   - name: Neil Revin
     link: https://itsneil.dev
+  - name: Marcel-TO
+    url: https://marcel-to.net
+  - name: Ádám Liszkai
+    link: https://adaliszk.dev
 ---
 
 This guide will walk you through setting up a complete development environment for Hytale modding, including all necessary tools and dependencies.
@@ -19,24 +23,73 @@ Before we begin, make sure you have:
 
 ## Required Software
 
-### 1. Java Development Kit (JDK)
+### Integrated Development Environment (IDE)
 
+We recommend IntelliJ IDEA Community Edition for Hytale modding. If you use IntelliJ IDEA, **almost everything is built-in**. You can clone a template, open a new project, and start working right away!
+
+1. Download from [JetBrains website](https://www.jetbrains.com/idea/download/)
+2. Install with default settings
+3. Launch and complete the initial setup wizard
+
+When opening a project, wait for indexing to finish, then start coding.
+Now, IDEA may say "No JDK configured" at the top of the source file you have.
+In that case, you can click Download JDK and choose JetBrains JDK 25.
+
+<Callout type="success">
+  If IDEA opened the project without errors, your environment is ready.
+</Callout>
+
+More details by [JetBrains](https://www.jetbrains.com/help/idea/2026.1/run-for-the-first-time.html)
+help page, where we recommend that you also check the
+[SDK configuration](https://www.jetbrains.com/help/idea/2026.1/sdk.html) guide.
+
+<Callout type="info">
+  We recommened following
+  [TheNullicorn's](https://gist.github.com/TheNullicorn/90a619796c40f20ae1fcf13094c1a57d) guide to ensure
+  you are using the correct `Nonnull` in your projects.
+</Callout>
+
+#### What the IDE Does for You
+
+When opened in IntelliJ IDEA, the project automatically:
+
+- Detects and configures Gradle or Maven
+- Downloads all dependencies
+- Sets up project structure and classpaths
+- Configures run/build tasks
+
+You do **not** need to manually install or configure Maven or Gradle if you stay inside the IDE.
+
+Skip to the [Setting Up Your Workspace](#setting-up-your-workspace).
+
+### Manual Setup: Java Development Kit (JDK)
+
+For any other setup, you will need to install and configure your system to have and load Java.
 Hytale modding requires Java 25 or later. We recommend using OpenJDK.
 
-#### Windows
+#### Windows via Installer
 
 1. Download OpenJDK 25 from [Adoptium](https://adoptium.net/)
 2. Run the installer with default settings
+   - Optionally enable feature `Set or Override JAVA_HOME variable` to resolve version related build issues with your project.
 3. Verify installation by opening Command Prompt and running:
 
+#### Windows via Scoop
+
+1. Install Scoop via PowerShell using [scoop.sh](https://scoop.sh/)
+2. Install OpenJDK 25:
+
 ```bash
-java -version
+scoop bucket add java
+scoop install java/openjdk25
 ```
 
 #### macOS
 
+1. Install Brew via Terminal using [brew.sh](https://brew.sh)
+2. Install JDK via Homebrew:
+
 ```bash
-# Using Homebrew
 brew install openjdk@25
 ```
 
@@ -51,22 +104,41 @@ brew install openjdk@25
 
 #### Linux (Ubuntu/Debian)
 
+1. Install JDK via the built-in package repository:
+
 ```bash
 sudo apt update
 sudo apt install openjdk-25-jdk
 ```
 
-### 2. Integrated Development Environment (IDE)
+### Verify installation:
 
-We recommend IntelliJ IDEA Community Edition for Hytale modding.
+Run the following command to see what version of Java you have:
 
-1. Download from [JetBrains website](https://www.jetbrains.com/idea/download/)
-2. Install with default settings
-3. Launch and complete the initial setup wizard
+```bash
+java -version
+```
+
+### Java Build Tool (Optional)
+
+We recommend using a Gradle Wrapper for managing dependencies and building your Hytale plugins. It provides benefits by eliminating the need for a system-wide Gradle installation and ensuring consistent Gradle versions across different environments. (Alternatively you can use Maven, but this guide focuses on Gradle since it is the default for our plugin template.)
+
+The plugin template in the following sections includes a Gradle Wrapper, so you can skip this step if you plan to use the template.
+
+#### Choosing Gradle (if not using the template)
+
+If you prefer to install Gradle manually, follow these steps:
 
-### 3) Java Build Tool
+1. Visit the official website: https://gradle.org/releases/
+2. Download the newest gradle binary: `gradle-9.3.1-bin.zip` (Binary zip archive)
+3. Unzip it
+4. Add the `gradle-9.3.1/bin/` folder to your PATH
+
+You can now try the command `gradle -version` to verify Gradle is installed correctly. Make sure to do this in a fresh new terminal instead of one you had opened from before!
+
+#### Choosing Maven (if not using the template)
 
-We recommend using Apache Maven for managing dependencies and building your Hytale plugins. (Alternatively you can use Gradle, but this guide focuses on Maven.)
+If you prefer to use Maven instead of Gradle, follow these steps to install Maven:
 
 1. Visit the official website: https://maven.apache.org/download.cgi
 2. Download this file: `apache-maven-3.9.12-bin.zip` (Binary zip archive)
@@ -89,22 +161,61 @@ cd MyFirstMod
 
 If you don't have Git installed, you can download the ZIP file from the repository page and extract it to a folder named `MyFirstMod`.
 
-### 2. Open Plugin in your IDEA
+### 2. Open Plugin in your IDE
 
-1. Open IntelliJ IDEA
+1. Open Your IDE (e.g., IntelliJ IDEA)
 2. Click "Open" and navigate to your `MyFirstMod` directory
-3. IntelliJ will automatically detect it as a Maven project
+3. Most IDEs like IntelliJ will automatically detect it as a Gradle project
 4. Wait for the project to index and dependencies to download
 
-<Callout type="info">
-  We recommened following [this](https://gist.github.com/TheNullicorn/90a619796c40f20ae1fcf13094c1a57d) guide to ensure you are using the correct `Nonnull` in your projects.
-</Callout>
+## Alternate Approach: Hytale Dependency
+
+If you prefer to set up your project from scratch without using the template and importing the hytale dependencies manually, ensure your build configuration includes the Hytale repositories and dependencies:
+
+For Gradle, add the following to your `build.gradle.kts`:
+
+```kotlin
+repositories {
+    mavenCentral()
+    maven {
+        name = "hytale"
+        url = uri("https://maven.hytale.com/release") // Or "hytale-pre-release" for pre-release versions
+    }
+}
+dependencies {
+    // + here means the latest version, but you can hard-wire any known version!
+    implementation("com.hypixel.hytale:Server:+")
+}
+```
+
+For Maven, add the following to your `pom.xml`:
+
+```xml
+<project>
+    <repositories>
+        <repository>
+            <id>hytale-release</id> <!-- Or "hytale-pre-release" for pre-release versions -->
+            <url>https://maven.hytale.com/release</url> <!-- Or "https://maven.hytale.com/pre-release" -->
+        </repository>
+    </repositories>
+
+    <dependencies>
+        <dependency>
+            <groupId>com.hypixel.hytale</groupId>
+            <artifactId>Server</artifactId>
+            <!-- Replace with latest version, Hytale provides jars for the last five releases -->
+            <version>LATEST_VERSION_HERE</version>
+            <scope>provided</scope>
+        </dependency>
+    </dependencies>
+</project>
+```
 
 ## Next Steps
 
 Now that you have your development environment set up with the plugin template:
 
-1. **Customize the template** - Edit the `pom.xml` and `manifest.json` file to change your mod's name and details
+1. **Customize the template** - Edit the `settings.gradle.kts`, `build.gradle.kts` and `manifest.json` file to change your mod's name and details
 2. **Explore the code structure** - Familiarize yourself with the template's organization
 3. **Start modding** - Begin writing your first Hytale plugin!
 
diff --git a/content/docs/sv-SE/guides/plugin/spawning-entities.mdx b/content/docs/sv-SE/guides/plugin/spawning-entities.mdx
index e12c0aea..15be2fb3 100644
--- a/content/docs/sv-SE/guides/plugin/spawning-entities.mdx
+++ b/content/docs/sv-SE/guides/plugin/spawning-entities.mdx
@@ -36,7 +36,7 @@ Store<EntityStore> store = world.getEntityStore().getStore();
 
 ## Creating Entities
 
-Once you have the `EntityStore` instance, you can start to create a entity and give it components. Entities are just instances of `Holder<EntityStore>` with several components attached to them.
+Once you have the `EntityStore` instance, you can start to create an entity and give it components. Entities are just instances of `Holder<EntityStore>` with several components attached to them.
 
 <Callout type="warning">
   To interact with the `World` instance, some methods require you to run the code inside the world's execution context.
@@ -118,3 +118,48 @@ Finally, we can add the entity to the world by calling the `addEntity` method on
 ```java
 store.addEntity(holder, AddReason.SPAWN);
 ```
+
+## Making the entity persist
+
+Hytale automatically saves all entities, but the `NetworkId` component (required for players to be able to see the entity) needs to be manually added every time the entity is loaded.
+
+### Using a system
+
+If you have a component that is unique to your entities, this can be done by creating and registering a custom system as follows:
+
+```java
+public class AddNetworkIdToMyEntitySystem extends HolderSystem<EntityStore> {
+    private final ComponentType<EntityStore, MyEntityComponent> myEntityComponentType = MyEntityComponent.getComponentType();
+    private final ComponentType<EntityStore, NetworkId> networkIdComponentType = NetworkId.getComponentType();
+    private final Query<EntityStore> query = Query.and(this.myEntityComponentType, Query.not(this.networkIdComponentType));
+
+    @Override
+    public void onEntityAdd(@NotNull Holder<EntityStore> holder, @NotNull AddReason reason, @NotNull Store<EntityStore> store) {
+        if (!holder.getArchetype().contains(NetworkId.getComponentType())) {
+            holder.addComponent(NetworkId.getComponentType(), new NetworkId(store.getExternalData().takeNextNetworkId()));
+        }
+    }
+
+    @Override
+    public void onEntityRemoved(@NotNull Holder<EntityStore> holder, @NotNull RemoveReason reason, @NotNull Store<EntityStore> store) {}
+
+    @Override
+    public @Nullable Query<EntityStore> getQuery() {
+        return query;
+    }
+}
+```
+
+In your plugin's `setup()` function
+
+```java
+this.getEntityStoreRegistry().registerSystem(new AddNetworkIdToMyEntitySystem())
+```
+
+### Using PropComponent
+
+Alternatively you can add `PropComponent` to your entity. Hytale adds `PropComponent` to entities spawned with the Entity Tool, and such entities automatically get `NetworkId` and `PrefabCopyableComponent` (which makes the entity work with prefabs).
+
+<Callout type="warning">
+  There is no guarantee, that Hytale will not add some other behavior to this component in the future, which may break your entity, so be careful if you decide to rely on it.
+</Callout>
diff --git a/content/docs/sv-SE/guides/plugin/store-persistent-data.mdx b/content/docs/sv-SE/guides/plugin/store-persistent-data.mdx
new file mode 100644
index 00000000..1071dff3
--- /dev/null
+++ b/content/docs/sv-SE/guides/plugin/store-persistent-data.mdx
@@ -0,0 +1,171 @@
+---
+title: Storing Persistent Data on the Player
+description: Learn how to save and load persistent data using Components
+authors:
+  - name: Neil Revin
+    url: https://itsneil.dev/
+  - name: ArcticDev
+    url: https://github.com/ArcticRaven
+  - name: oskarscot
+    url: https://oskar.scot
+  - name: JammingEng
+    url: https://github.com/JammingEnd
+---
+
+Here is how to store persistent data using a custom component on a Player.
+
+## Build your Component Class
+
+Creating a custom component class leverages the Component system made with the ECS architecture in mind. For more information on Components, check out the [ECS Guide](../ecs/hytale-ecs-theory#components).
+
+Start by creating your custom component class. This will be extremely similar to how regular components are created, however we'll setup a custom Codec so the server can translate this data to BSON, or the server's internal json encoder.
+
+<Callout type="info">
+  Each variable you want to store in your component must have its own Codec field defined in the BuilderCodec.
+  For more information on how to create custom Codecs, check out the [ECS Codec Guide](../ecs/hytale-ecs-theory#codec).
+</Callout>
+
+```java
+public class YourPlayerData implements Component<EntityStore> {
+
+    // define some vars!
+    private int someInteger;
+    private String someString;
+    private Map<String, String> someMap;
+
+    public static final BuilderCodec<YourPlayerData> CODEC =
+            BuilderCodec.builder(YourPlayerData.class, YourPlayerData::new)
+            .append(new KeyedCodec<>("SomeInteger", Codec.INTEGER),
+                    (data, value) -> data.someInteger = value, // setter
+                    data -> data.someInteger) // getter
+            .addValidator(Validators.nonNull())
+            .add()
+            .append(new KeyedCodec<>("SomeString", Codec.STRING),
+                    (data, value) -> data.someString = value, // setter
+                    data -> data.someString) // getter
+            .add()
+            .append(new KeyedCodec<>("SomeMap",
+                            new MapCodec<>(Codec.STRING, HashMap::new, false)),
+                    (data, value) -> data.someMap = value, // setter
+                    data -> data.someMap) // getter
+            .add()
+            .build();
+
+
+
+    // Getters and Setters are for the purpose of this example omitted.
+
+    // constructor
+    public YourPlayerData() {
+        this.someInteger = 0;
+        this.someString = "";
+        this.someMap = new HashMap<>();
+    }
+
+    // copy constructor for cloning
+    public YourPlayerData(YourPlayerData clone) {
+        this.someInteger = clone.someInteger;
+        this.someString = clone.someString;
+        this.someMap = clone.someMap;
+    }
+
+    @Nonnull
+    @Override
+    public Component<EntityStore> clone() {
+        return new YourPlayerData(this);
+    }
+}
+```
+
+## Register your Component
+
+Inside your main class's `setup()` method, register your new Component.
+
+```java
+public class YourPlugin extends JavaPlugin {
+
+    private ComponentType<EntityStore, YourPlayerData> yourPlayerDataComponent;
+
+    public YourPlugin(@Nonnull JavaPluginInit init) {
+        super(init);
+    }
+
+    @Override
+    protected void setup(){
+        this.yourPlayerDataComponent = this.getEntityStoreRegistry().registerComponent(
+            YourPlayerData.class,
+            "YourPlayerDataComponent",
+            YourPlayerData.CODEC
+        );
+    }
+
+    public ComponentType<EntityStore, YourPlayerData> getYourPlayerDataComponent() {
+        return this.yourPlayerDataComponent;
+    }
+}
+```
+
+## Using your Component
+
+To use your newly created component, you can add the Component to a player using the `addComponent` method, although this only adds it temporarily, meaning when the player/entity leaves the world, the component is removed. You can use `putComponent` to ensure the component persists between sessions.
+
+```java
+// You will need the Ref and Store to apply components
+private void someEntryMethod(@Nonnull Ref<EntityStore> ref, @Nonnull Store<EntityStore> store)
+{
+       // Any entity will work, for now we will use the player
+      Player player = (Player) store.getComponent(ref, Player.getComponentType());
+
+      // since we're using putComponent, it could be useful to check if it already exists on the player in case we want to update it
+     if(store.getComponent(ref, YourPlugin.instance().getYourPlayerDataComponent()) != null)
+     {
+          // here we implement logic that updates the component
+         var comp = store.getComponent(ref, YourPlugin.instance().getYourPlayerDataComponent())
+         // declare public fields or methods in the component class
+         comp.SomeString = "An Updated Field";
+     } else {
+          // Here we put the component
+          var myCustomComp = new CustomComponent();
+          // declare public fields or methods in the component class
+          myCustomComp.SomeString = "Edited String";
+
+          // putComponent allows you to insert declared objects
+          store.putComponent(ref, YourPlugin.instance().getYourPlayerDataComponent(), myCustomComp);
+     }
+}
+```
+
+## Using your Data
+
+Your component will be stored within the `Store<EntityStore>` when added to the player. In the provided example,
+we'll fetch this data off the player using the `ensureAndGetComponent()` method, which will add the component to
+the player if it does not exist with the default values.
+
+```java
+public class IncompleteCustomCommand extends AbstractPlayerCommand {
+
+    public IncompleteCustomCommand() {
+        super("nope", "don't use this command");
+    }
+
+    @Override
+    protected void execute(
+        @NonNullDecl CommandContext commandContext,
+        @NonNullDecl Store<EntityStore> store,
+        @NonNullDecl Ref<EntityStore> ref,
+        @NonNullDecl PlayerRef playerRef,
+        @NonNullDecl World world
+    ) {
+        YourPlayerData customData = store.ensureAndGetComponent(ref, YourPlugin.instance().getYourPlayerDataComponent());
+        // ensureAndGetComponent adds the component to the ref, with the default values defined inside your component.
+ 		// use your data
+    }
+}
+```
+
+And that's it! Your data will now be saved and loaded automatically with the player.
+
+Using custom components to store persistent data on players is a powerful way to maintain state across sessions.
+By following the steps outlined above, you can easily create, register, and utilize your own data structures within the Hytale ECS framework.
+This approach ensures that your data is seamlessly integrated with the game's existing systems.
+For more information about Hytale's Entity Component System visit the [Hytale ECS Theory](https://hytalemodding.dev/en/docs/guides/ecs/hytale-ecs-theory) guide.
diff --git a/content/docs/sv-SE/guides/plugin/teleporting-players.mdx b/content/docs/sv-SE/guides/plugin/teleporting-players.mdx
index 57cee77f..32ce0435 100644
--- a/content/docs/sv-SE/guides/plugin/teleporting-players.mdx
+++ b/content/docs/sv-SE/guides/plugin/teleporting-players.mdx
@@ -1,26 +1,32 @@
 ---
 title: Teleporting the player
 description: Learn how to teleport the player.
+authors:
+  - name: oskarscot
+    url: https://oskar.scot
 ---
 
-To teleport players in Hytale, you will need to get a `World` object so we can safely run the teleport on the world thread. The world thread manages all entity updates, so modifying entities off-thread can crash the server or cause inconsistent state.
-Next, we get the entity store and make a `Teleport` object.
-We add a `Teleport` component to the player’s entity reference in the entity store. This triggers the teleportation logic for that player.
+Teleporting players in Hytale works by simply attaching a `Teleport` component to a player with the desired world and transform.
+You can only trigger teleports from a world where the player is currently present.
+Teleport itself is a component but it also provides factory methods to configure the Teleport. Just as with any entity component, an EntityStore and a Ref to the EntityStore is required
+
+We can create a simple teleport utility like this:
 
 ```java
-public static void teleportPlayer(Player player, int x, int y, int z) {
-        World world = player.getWorld();
-        if (world == null) return;
-        world.execute(() -> {
-            if (player.getReference() == null) return;
-            Store<EntityStore> store = player.getReference().getStore();
-            Teleport teleport = Teleport.createForPlayer(world,
-                new Vector3d(x ,y, z), // Target position
-                new Vector3f(0, 0, 0)  // Target rotation (pitch, yaw, roll)
-            );
+public static void teleportPlayer(Ref<EntityStore> ref, Store<EntityStore> store, World targetWorld, double x, double y, double z) {                                                                                       
+    Transform transform = new Transform(x, y, z);                                                                                                                           
+    Teleport teleport = Teleport.createForPlayer(targetWorld, transform);                                                                                                   
+    store.addComponent(ref, Teleport.getComponentType(), teleport);                                                                                                         
+}  
+```
 
-            store.addComponent(player.getReference(), Teleport.getComponentType(), teleport);
-        });
+A `Transform` is a representation of a position Vector3d and rotation Vector3f which works in the following way:
 
-}
+```java
+Transform transform = new Transform(
+    new Vector3d(x, y, z),      // Position
+    new Rotation(yaw, pitch, 0) // Rotation, last value seems to always be 0
+);
+Teleport teleport = Teleport.createForPlayer(targetWorld, transform);
+store.addComponent(ref, Teleport.getComponentType(), teleport);
 ```
diff --git a/content/docs/sv-SE/guides/plugin/tracking-mod-analytics-with-hstats.mdx b/content/docs/sv-SE/guides/plugin/tracking-mod-analytics-with-hstats.mdx
new file mode 100644
index 00000000..45c022e0
--- /dev/null
+++ b/content/docs/sv-SE/guides/plugin/tracking-mod-analytics-with-hstats.mdx
@@ -0,0 +1,65 @@
+---
+title: Tracking Mod Analytics with HStats
+description: Learn how you can track Analytics for your Hytale Mod for Free using hstats.dev
+authors:
+  - name: Al3x
+    url: https://hstats.dev
+---
+
+In this guide, you will learn how to integrate HStats into your Plugin/Mod which will allow you to track how many Servers are using it along with other stats.
+
+<Callout type="info">
+  HStats is a third-party tool and is not affiliated with HytaleModding or Hypixel Studios
+</Callout>
+
+# Step 1: Register your Mod to HStats
+
+Before you touch any code, you will need to add your mod to the HStats website which will give you a UUID for your mod.
+
+- Create or Login to an Account on https://hstats.dev
+- Navigate to the dashboard page (https://hstats.dev/dashboard)
+- On the left, type in your mod's name and click "Add Mod"
+- Keep note of the UUID generated for later.
+
+# Step 2: Add the HStats Class to Your Project
+
+To keep things simple, HStats uses a single Java class file that handles everything for you.
+
+- Download / Copy the File from the GitHub page (https://github.com/hstats-dev/HStatsExamplePlugin/blob/main/src/main/java/com/al3x/HStats.java)
+- Paste into your Project. You should now have a HStats.java file somewhere in your projects directory.
+- Update the package name from com.al3x to whatever fits your project.
+
+# Step 3: Initialize HStats in your code
+
+You only need to add one line of code to your mod's setup method in your main class to start tracking.
+
+`new HStats("YOUR-MOD-UUID", "1.0.0");`
+
+Replace `YOUR-MOD-UUID` with the Mod UUID we made note of earlier and change the `1.0.0` version to whatever version your mod is currently on.
+
+Your setup method should now look something like this:
+
+```java
+@Override
+protected void setup() {
+  super.setup();
+  new HStats("c34a2b2a-afd8-4d6a-821e-7a63e12c5ea6", "1.0.0");
+}
+```
+
+# Extras
+
+Your done! Your mod should now be listed under the Mods page (https://hstats.dev/mods) as well as under your dashboard.
+
+Servers using your mod should now post updates about every minute to HStats which you can view in the Dashboard.
+
+### Embeds
+
+HStats allows you to generate an Embed Card that you can place on your CurseForge or GitHub page. This is useful for server owners to be able to see how many other servers are using your mod.
+
+- In your dashboard, scroll down to the Embed Card section.
+- Customize the appearance (Light/Dark mode, layout, etc).
+- Copy the generated URL to display your "Active Servers" and "Players Online" live on your mod's description page
+
+Heres an example of what they look like:
+![HStats Example](https://api.hstats.dev/api/embed/d52fa672-6966-47b2-b501-1a11bddebac3/card.svg?theme=light\&layout=compact\&size=md\&show_id=true\&dark=false)
diff --git a/content/docs/sv-SE/guides/plugin/world-gen.mdx b/content/docs/sv-SE/guides/plugin/world-gen.mdx
index 4c23b0c9..7b193ffd 100644
--- a/content/docs/sv-SE/guides/plugin/world-gen.mdx
+++ b/content/docs/sv-SE/guides/plugin/world-gen.mdx
@@ -100,7 +100,7 @@ Biome biome = biomeGen.generateBiomeAt(zoneResult, seed, x, z);
 
 ### Zone & Cave Integration
 
-Each zone defines it's own cave patterns:
+Each zone defines its own cave patterns:
 
 ```java
 Zone zone = /* ... */;
diff --git a/content/docs/sv-SE/guides/prefabs.mdx b/content/docs/sv-SE/guides/prefabs.mdx
index 08404b30..b1a55109 100644
--- a/content/docs/sv-SE/guides/prefabs.mdx
+++ b/content/docs/sv-SE/guides/prefabs.mdx
@@ -14,7 +14,7 @@ Prefabs are Hytale's way of creating reusable structures.
 There are a few fundamental concepts to understand about prefabs:
 
 - Users interact with prefabs via a prefab editing world.
-- Prefabs the physical structures in the game world, and are saved as JSON files.
+- Prefabs are the physical structures in the game world, and are saved as JSON files.
 
 ## How to Create a Prefab
 
diff --git a/content/docs/sv-SE/official-documentation/custom-ui/common-styling.mdx b/content/docs/sv-SE/official-documentation/custom-ui/common-styling.mdx
new file mode 100644
index 00000000..c36e3e3a
--- /dev/null
+++ b/content/docs/sv-SE/official-documentation/custom-ui/common-styling.mdx
@@ -0,0 +1,50 @@
+---
+title: Common Styling
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# Common Styling
+
+## Common UI Styling Library
+
+This document describes the shared UI components and styles defined in `Common.ui`.
+
+---
+
+### Styles
+
+We are providing some styles that can be re-used in any custom UI that, provide a cohesive UI experience with the core game UI. These styles are available in the `Common.ui` file.
+
+You can find a list of all the styles defined with live examples by running the `/ui-gallery` command ingame.
+
+<Callout type="warning">
+  This command is not available yet, but will be in a future patch.
+</Callout>
+
+![Gallery](/assets/official-documentation/ui/gallery.png)
+
+### Importing
+
+To use these styles in your UI file:
+
+```
+$Common = "Common.ui";
+
+// Then reference styles and components:
+$Common.@TextButton { @Text = "My Button"; }
+$Common.@Container { ... }
+```
+
+<Callout type="info">
+  The `Common.ui` file is at `Common/UI/Custom/Common.ui` within the Hytale pack. If your custom ui document is in a subfolder of `Common/UI/Custom/`, reference it via relative path traversal:
+
+  ```
+  $Common = "../Common.ui";
+  ```
+
+  You can find more info about paths [here](markup#path).
+</Callout>
diff --git a/content/docs/sv-SE/official-documentation/custom-ui/index.mdx b/content/docs/sv-SE/official-documentation/custom-ui/index.mdx
new file mode 100644
index 00000000..f94c4e88
--- /dev/null
+++ b/content/docs/sv-SE/official-documentation/custom-ui/index.mdx
@@ -0,0 +1,125 @@
+---
+title: Custom UI
+icon: LayoutDashboard
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# Custom UI
+
+## What is Custom UI?
+
+Custom UI is Hytale's framework for creating **custom user interfaces** controlled by the game server. Unlike the built-in Client UI (which is part of the game client and cannot be modified), Server UI allows you to create interactive screens and HUD overlays through Java plugins and asset packs.
+
+As a modder, Custom UI gives you the power to:
+
+- **Create custom interactive pages** - Shop interfaces, quest dialogs, server settings menus, admin panels
+- **Add custom HUD overlays** - Quest trackers, status displays, custom health bars, server information
+- **Design with markup** - Use `.ui` files to define reusable UI templates
+- **Handle user interactions** - Respond to button clicks, form submissions, and other events
+- **Localize your UI** - Support multiple languages using the game's translation system
+
+## How Custom UI Fits Into Hytale's UI
+
+Hytale's user interface is divided into two main categories:
+
+### Client UI (Not Moddable)
+
+Built-in interfaces controlled by the C# game client:
+
+- Main menu and settings
+- Character creation
+- Built-in HUD (health, hotbar, chat)
+- Inventory and crafting screens
+- Development tools
+
+**You cannot modify these** - they are part of the core game client.
+
+### In-Game UI (Moddable via Server)
+
+Server-controlled interfaces that you can create and customize:
+
+#### Custom Pages
+
+Full-screen interactive overlays that appear during gameplay:
+
+- Can be dismissed by the player (ESC key)
+- Capture all input (keyboard and mouse)
+- Support loading states while waiting for server responses
+- Perfect for: shops, dialogs, menus, configuration screens
+
+#### Custom HUDs
+
+Persistent overlay elements drawn on top of the game world:
+
+- Display-only (no user interaction)
+- Always visible during gameplay
+- Lightweight and non-intrusive
+- Perfect for: quest objectives, status indicators, server info panels
+
+## Architecture Overview
+
+Server UI uses a **command-based architecture**:
+
+```
+┌─────────────────────┐         ┌──────────────────────┐
+│   Java Server       │         │    C# Client         │
+│   (Your Plugin)     │         │    (Game)            │
+├─────────────────────┤         ├──────────────────────┤
+│                     │         │                      │
+│ InteractiveCustomUI │         │   CustomPage or      │
+│ Page                │         │   CustomHud          │
+│   ↓ build()         ├────────→│     ↓ Apply          │
+│ UICommandBuilder    │         │   Element Tree       │
+│   - append()        │         │     ↓ Layout         │
+│   - set()           │         │   Rendered UI        │
+│   - clear()         │         │                      │
+│                     │         │                      │
+│ ↓ handleDataEvent() │← Events │   User Interaction   │
+│   Process input     │         │   (click, type, etc) │
+│   sendUpdate()      │         │                      │
+└─────────────────────┘         └──────────────────────┘
+```
+
+**The flow:**
+
+1. Your Java code builds UI using `UICommandBuilder`
+2. Commands are sent to the client as data
+3. Client parses `.ui` markup files and creates visual elements
+4. User interacts with the UI
+5. Events are sent back to your Java code
+6. You process events and send updates back
+
+## Key Principles
+
+### Declarative, Not Imperative
+
+You don't create UI objects directly. Instead, you send **commands** that describe what you want:
+
+- "Append this button template to that container"
+- "Set this label's text to 'Hello World'"
+- "Clear all children from this list"
+
+### Asset-Driven
+
+UI structure is defined in `.ui` markup files (assets), not hardcoded in Java. This enables:
+
+- Designers to modify layouts without touching code
+- Reusable UI components
+- Consistent visual language
+
+### Event-Driven
+
+User interactions trigger events that flow back to your server code. You register event bindings and handle them in `handleDataEvent()`.
+
+### Selector-Based
+
+You target specific UI elements using **selectors:**
+
+- `#MyButton` - Element with ID "MyButton"
+- `#List[0]` - First child of element "List"
+- `#List[0] #Title` - Element with ID "Title" in the first child of element "List"
+- `#Label.TextColor` - The TextColor property of element "Label"
diff --git a/content/docs/sv-SE/official-documentation/custom-ui/layout.mdx b/content/docs/sv-SE/official-documentation/custom-ui/layout.mdx
new file mode 100644
index 00000000..0a24ca09
--- /dev/null
+++ b/content/docs/sv-SE/official-documentation/custom-ui/layout.mdx
@@ -0,0 +1,492 @@
+---
+title: Layout
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# Layout
+
+The layout system determines how UI elements are positioned and sized on screen. Understanding layout is crucial for creating well-structured, responsive interfaces.
+
+## Layout Fundamentals
+
+Every UI element has:
+
+- **Container Rectangle** - The space allocated by the parent
+- **Anchor** - How the element positions/sizes itself within the container
+- **Padding** - Inner spacing that affects child layout
+- **LayoutMode** - How the element arranges its children (if it's a container)
+
+```
+┌─────────────────────────────────────┐
+│  Container Rectangle (from parent)  │
+│  ┌───────────────────────────────┐  │
+│  │  Anchored Rectangle           │  │
+│  │  ┌─────────────────────────┐  │  │
+│  │  │ Padding                 │  │  │
+│  │  │  ┌───────────────────┐  │  │  │
+│  │  │  │  Content Area     │  │  │  │
+│  │  │  └───────────────────┘  │  │  │
+│  │  └─────────────────────────┘  │  │
+│  └───────────────────────────────┘  │
+└─────────────────────────────────────┘
+```
+
+## Anchor
+
+`Anchor` controls how an element positions and sizes itself within its container rectangle.
+
+### Fixed Size
+
+```
+Button {
+    Anchor: (Width: 200, Height: 40);
+}
+```
+
+Creates a 200×40 pixel button.
+
+### Positioning
+
+```
+Label {
+    Anchor: (Top: 10, Left: 20, Width: 100, Height: 30);
+}
+```
+
+- **Top**: 10 pixels from container's top edge
+- **Left**: 20 pixels from container's left edge
+- **Width**: 100 pixels wide
+- **Height**: 30 pixels tall
+
+### Anchoring to Edges
+
+```
+Button {
+    Anchor: (Bottom: 10, Right: 10, Width: 100, Height: 30);
+}
+```
+
+Anchors the button to the bottom-right corner, 10 pixels from each edge.
+
+### Stretching
+
+```
+Group {
+    Anchor: (Top: 0, Bottom: 0, Left: 0, Right: 0);
+}
+```
+
+Stretches to fill the entire container (all edges at 0 pixels).
+
+**Shorthand:**
+
+```
+Group {
+    Anchor: (Full: 0);
+}
+```
+
+### Mixed Anchoring
+
+```
+Panel {
+    Anchor: (Top: 10, Bottom: 10, Left: 20, Width: 300);
+}
+```
+
+- Fixed width of 300 pixels
+- Stretches vertically between top and bottom edges
+- 10 pixels from top and bottom
+- 20 pixels from left
+
+## Padding
+
+`Padding` creates inner spacing, affecting where children are positioned.
+
+### Uniform Padding
+
+```
+Group {
+    Padding: (Full: 20);
+}
+```
+
+20 pixels of padding on all sides.
+
+### Directional Padding
+
+```
+Group {
+    Padding: (Top: 10, Bottom: 20, Left: 15, Right: 15);
+}
+```
+
+Different padding per edge.
+
+### Shorthand
+
+```
+// Horizontal and vertical
+Group {
+    Padding: (Horizontal: 20, Vertical: 10);
+}
+
+// Equivalent to:
+// Top: 10, Bottom: 10, Left: 20, Right: 20
+```
+
+### Effect on Children
+
+```
+Group {
+    Anchor: (Width: 200, Height: 100);
+    Padding: (Full: 10);
+
+    Label {
+        Anchor: (Full: 0);
+    }
+}
+```
+
+The label fills the group, but there's a 10-pixel gap on all sides due to padding.
+
+```
+┌──────────────────────┐
+│ Group (200×100)      │
+│  ┌────────────────┐  │
+│  │ Label          │  │ ← 10px padding all around
+│  │                │  │
+│  └────────────────┘  │
+└──────────────────────┘
+```
+
+## LayoutMode
+
+`LayoutMode` determines how a container arranges its children.
+
+### Top (Vertical Stack)
+
+```
+Group {
+    LayoutMode: Top;
+
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+}
+```
+
+Children stack vertically from top to bottom:
+
+```
+┌──────────┐
+│ Button 1 │
+├──────────┤
+│ Button 2 │
+├──────────┤
+│ Button 3 │
+└──────────┘
+
+
+```
+
+Each child's `Anchor.Bottom` adds spacing between elements:
+
+```
+Button { Anchor: (Height: 30, Bottom: 10); }  // 10px gap after this button
+```
+
+### Bottom (Vertical Stack)
+
+```
+Group {
+    LayoutMode: Bottom;
+
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+}
+```
+
+Children stack vertically from top to bottom but aligned to the bottom edge of the parent:
+
+```
+
+
+
+┌──────────┐
+│ Button 1 │
+├──────────┤
+│ Button 2 │
+├──────────┤
+│ Button 3 │
+└──────────┘
+```
+
+### Left (Horizontal Stack)
+
+```
+Group {
+    LayoutMode: Left;
+
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+}
+```
+
+Children arrange horizontally from left to right:
+
+```
+┌────────┬────────┬────────┐
+│ Button │ Button │ Button │
+│   1    │   2    │   3    │
+└────────┴────────┴────────┘
+```
+
+Use `Anchor.Right` for spacing between elements.
+
+### Right (Horizontal Stack)
+
+```
+Group {
+    LayoutMode: Right;
+
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+}
+```
+
+Children arrange horizontally from left to right but aligned to the right side of the parent:
+
+```
+                                                                 ┌────────┬────────┬────────┐
+                                                                 │ Button │ Button │ Button │
+                                                                 │   1    │   2    │   3    │
+                                                                 └────────┴────────┴────────┘
+```
+
+### Center
+
+```
+Group {
+    LayoutMode: Center;
+
+    Group #Dialog {
+        Anchor: (Width: 400, Height: 300);
+    }
+}
+```
+
+Centers the children horizontally.
+
+### Middle
+
+```
+Group {
+    LayoutMode: Middle;
+
+    Group #Dialog {
+        Anchor: (Width: 400, Height: 300);
+    }
+}
+```
+
+Centers the children vertically.
+
+### CenterMiddle (Horizontal Stack, Fully Centered)
+
+```
+Group {
+    LayoutMode: CenterMiddle;
+
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+}
+```
+
+Children stack horizontally from left to right, centered both horizontally and vertically within the parent:
+
+```
+┌────────────────────────────────────────────┐
+│                                            │
+│                                            │
+│         ┌──────┐ ┌──────┐ ┌──────┐         │
+│         │  B1  │ │  B2  │ │  B3  │         │
+│         └──────┘ └──────┘ └──────┘         │
+│                                            │
+│                                            │
+└────────────────────────────────────────────┘
+```
+
+---
+
+### MiddleCenter (Vertical Stack, Fully Centered)
+
+```
+Group {
+    LayoutMode: MiddleCenter;
+
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+}
+```
+
+Children stack vertically from top to bottom, centered both horizontally and vertically within the parent:
+
+```
+┌────────────────────────────────────────────┐
+│                                            │
+│              ┌──────────┐                  │
+│              │ Button 1 │                  │
+│              ├──────────┤                  │
+│              │ Button 2 │                  │
+│              ├──────────┤                  │
+│              │ Button 3 │                  │
+│              └──────────┘                  │
+│                                            │
+└────────────────────────────────────────────┘
+```
+
+---
+
+### Full
+
+```
+Group {
+    LayoutMode: Full;
+
+    Label {
+        Anchor: (Top: 20, Left: 20, Width: 100, Height: 30);
+    }
+}
+```
+
+Children use absolute positioning via their `Anchor` properties.
+
+### TopScrolling
+
+```
+Group {
+    LayoutMode: TopScrolling;
+    ScrollbarStyle: $Common.@DefaultScrollbar;
+
+    // ... many children
+}
+```
+
+Like `Top`, but adds a scrollbar if content exceeds container height.
+
+Or use `BottomScrolling` for bottom-aligned content.
+
+### LeftScrolling
+
+```
+Group {
+    LayoutMode: LeftScrolling;
+    ScrollbarStyle: $Common.@DefaultScrollbar;
+
+    // ... many children
+}
+```
+
+Like `Left`, but adds a scrollbar for horizontal scrolling.
+
+Or use `RightScrolling` for right-aligned content.
+
+### LeftCenterWrap (Wrapping Horizontal Stack, Horizontally Centered)
+
+```
+Group {
+    LayoutMode: LeftCenterWrap;
+
+    Button { Anchor: (Width: 80, Height: 30); }
+    Button { Anchor: (Width: 80, Height: 30); }
+    Button { Anchor: (Width: 80, Height: 30); }
+    Button { Anchor: (Width: 80, Height: 30); }
+    Button { Anchor: (Width: 80, Height: 30); }
+}
+```
+
+Children flow left to right. When there's no more horizontal space, they wrap to the next row. Each row is horizontally centered within the parent:
+
+```
+┌────────────────────────────────────────────┐
+│                                            │
+│       ┌──────┐ ┌──────┐ ┌──────┐           │
+│       │  B1  │ │  B2  │ │  B3  │           │
+│       └──────┘ └──────┘ └──────┘           │
+│            ┌──────┐ ┌──────┐               │
+│            │  B4  │ │  B5  │               │
+│            └──────┘ └──────┘               │
+│                                            │
+└────────────────────────────────────────────┘
+```
+
+## FlexWeight
+
+`FlexWeight` distributes remaining space among children.
+
+```
+Group {
+    LayoutMode: Left;
+    Anchor: (Width: 400);
+
+    Button {
+        Anchor: (Width: 100);
+    }
+
+    Group {
+        FlexWeight: 1;  // Takes all remaining space
+    }
+
+    Button {
+        Anchor: (Width: 100);
+    }
+}
+```
+
+Result:
+
+- First button: 100px
+- Middle group: 200px (400 - 100 - 100 = 200)
+- Last button: 100px
+
+### Multiple FlexWeights
+
+```
+Group {
+    LayoutMode: Left;
+    Anchor: (Width: 600);
+
+    Group { FlexWeight: 1; }
+    Group { FlexWeight: 2; }
+    Group { FlexWeight: 1; }
+}
+```
+
+Remaining space (600px) is split:
+
+- First group: 600 × (1/4) = 150px
+- Second group: 600 × (2/4) = 300px
+- Third group: 600 × (1/4) = 150px
+
+## Visibility
+
+```
+Button #HiddenButton {
+    Visible: false;
+}
+```
+
+**Effect:**
+
+- Element and its children are not displayed
+- Element is **not included in layout** (doesn't take up space)
diff --git a/content/docs/sv-SE/official-documentation/custom-ui/markup.mdx b/content/docs/sv-SE/official-documentation/custom-ui/markup.mdx
new file mode 100644
index 00000000..564110ed
--- /dev/null
+++ b/content/docs/sv-SE/official-documentation/custom-ui/markup.mdx
@@ -0,0 +1,226 @@
+---
+title: Markup
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# Markup
+
+## Markup
+
+An element is the basic building block of a user interface. There are various types of elements with different properties, which are documented below.
+
+Here's what the syntax looks like:
+
+```
+// Basic declaration of an element
+// with its Anchor property set to attach on all sides of its parent
+// with 10 pixels of margin
+Group { Anchor: (Left: 10, Top: 10, Right: 10, Bottom: 10); }
+
+Group { Anchor: (Full: 10); } // More concise version
+
+// Declaration of a Label with a name
+// (can be used to access the element from game code)
+Label #MyLabel {
+  Style: LabelStyle(FontSize: 16); // or just Style: (FontSize: 16), type can be inferred.
+  Text: "Hi! I am text.";
+}
+
+// Declaration of a Group containing 2 children
+// You can use FlexWeight to distribute any left-over space after explicit widths/heights have been subtracted
+Group {
+  LayoutMode: Left;
+  Label { Text: "Child 1"; FlexWeight: 2; }
+  Label { Text: "Child 2"; FlexWeight: 1; }
+}
+```
+
+### Documents
+
+A UI document (_.ui_ file) contains trees of elements. There can be multiple root elements.
+
+### Named Expressions
+
+Named expressions can be declared at any level of a document (including at the root) and will be scoped to that subtree, though they need to be declared at the top of the block.
+
+```
+// Example of named expressions, declared and used with @ prefix
+@Title = "Hytale";
+@ExtraSpacing = 5;
+
+Label {
+  Text: @Title;
+  Style: (LetterSpacing: 2 + @ExtraSpacing);
+}
+```
+
+You can use the spread operator `...` to reuse a named expression while overriding some of its fields:
+
+```
+@MyBaseStyle = LabelStyle(FontSize: 24, LetterSpacing: 2);
+
+Label {
+  Style: (...@MyBaseStyle, FontSize: 36);
+}
+```
+
+You can even layer multiple named expressions like so:
+
+```
+@TitleStyle = LabelStyle(FontSize: 24, HorizontalAlignment: Center);
+@SpacedTextStyle = LabelStyle(LetterSpacing: 2);
+
+Label {
+  Style: (...@BigTextStyle, ...@SpacedTextStyle);
+}
+```
+
+#### Document references
+
+A document can reference another document and access its named expressions.
+
+```
+// Document references are defined with $ prefix
+$Common = "../Common.ui";
+
+TextButton {
+  Style: $Common.@DefaultButtonStyle;
+}
+```
+
+### Templates
+
+You can declare a reusable bit of interface as a named expression and then instantiate it as many times as you want in the tree while customizing it.
+
+You can override local named expressions as well as insert additional children at any point in the template tree. However, local named expressions must be defined at the very top of the block, before properties and child elements.
+
+```
+// This is the template
+@Row = Group {
+  Anchor: (Height: 50);
+  Label #Label { Anchor: (Left: 0, Width: 100); Text: @LabelText; }
+  Group #Content { Anchor: (Left: 100); }
+};
+
+// Here we'll be using it twice in the document tree
+Group #Rows {
+  LayoutMode: TopScrolling;
+
+  @Row #MyFirstRow {
+    @LabelText = "First row";
+    #Content { TextInput {} }
+  }
+
+  @Row #MySecondRow {
+    @LabelText = "Second row";
+  }
+}
+```
+
+### Property Types
+
+#### Basic Types
+
+- **Boolean**
+  - `Visible: false;`
+  - `Visible: true;`
+- **Int**
+  - `Height: 20;`
+- **Float, Double, Decimal**
+  - `Min: 0.2;`
+- **String**
+  - `Text: "Hi!";`
+- **Char**
+  - `PasswordChar: "*";`
+  - _Note: The syntax is the same as a string, however a value of this type cannot contain more than one character!_
+- **Color**
+  - `Background: #ffffff;`&#x20;
+- **Objects**
+  - `Style: (Background: #ffffff)`
+- **Array**&#x20;
+  - `TextSpans: [(Text: "Hi", IsBold: true)]`
+
+#### Translations
+
+Translation keys can be referenced anywhere in markup where you can provide a string, and they are then converted to a string when an element gets instantiated.
+
+**Example:**
+
+```
+Label {
+  Text: %ui.general.cancel;
+}
+```
+
+#### Colors
+
+A color literal can be written as follows:
+
+- `#rrggbb`: 6-digit hexadecimal representation for red, green, blue (fully opaque)
+- `#rrggbb(a.a)`: 6-digit hexadecimal representation for red, green, blue with alpha between 0 and 1
+- `#rrggbbaa`: 8-digit hexadecimal representation for red, green, blue and alpha
+
+```
+Group {
+  Background: #000000(0.3);
+}
+```
+
+<Callout>
+  The `#rrggbb(a.a)` format is prefered over the `#rrggbbaa` format for
+  readability reasons.
+</Callout>
+
+#### Font Name
+
+Font names can be referenced directly by their string ID. Internally this is using a custom type called `UIFontName`, however strings will be converted automatically to this type in markup.
+
+```
+Label {
+  Text: "Hi";
+  Style: (FontName: "Secondary");
+}
+```
+
+**Available Font Names**
+
+- _Default_ - This is the default font that is used for most text and is always used unless a different option has been specified
+- _Secondary_ - This font is mostly used for headlines or elements that are supposed to stick out
+- _Mono_ - This is only used for development; For things such as profiling or error overlays.
+
+#### Path
+
+We can reference other UI assets with the `UIPath` type. Similar to `UIFontName`_,_ Strings are automatically converted to a `UIPath`. Paths are always relative to the file where they have been declared in. Looking up _MyButton.png_ in _Menu/MyAwesomeMenu.ui_ will result in _Menu/MyButton.png_. If you want to reference a file that is in a parent folder you can go back one directory by writing two dots (_../MyButton.png_).
+
+The markup syntax of a `UIPath` is the same as a String. (e.g. `Path: "Test.png"`)
+
+Here are some more examples:
+
+| UIPath             | .ui File                              | Resulting Path    |
+| ------------------ | ------------------------------------- | ----------------- |
+| MyButton.png       | Menu/MyAwesomeMenu.ui                 | Menu/MyButton.png |
+| ../MyButton.png    | Menu/MyAwesomeMenu.ui                 | MyButton.png      |
+| ../../MyButton.png | Menu/Popup/Templates/MyAwesomeMenu.ui | Menu/MyButton.png |
+
+#### Objects
+
+Objects contain a set of properties. In this example we are assigning an Anchor object to the _Anchor_ property:
+
+```
+Group {
+  Anchor: (
+   Height: 10,
+   Width: 20
+ );
+}
+```
+
+You can find all objects that can be used in markup [here](type-documentation#elements).
+
+## Visual Studio Code Extension
+
+There is an official extension for Visual Studio Code which adds syntax highlighting for .ui files. You can find it [here](https://marketplace.visualstudio.com/items?itemName=HypixelStudiosCanadaInc.vscode-hytaleui).
diff --git a/content/docs/sv-SE/official-documentation/custom-ui/type-documentation/index.mdx b/content/docs/sv-SE/official-documentation/custom-ui/type-documentation/index.mdx
new file mode 100644
index 00000000..69cea406
--- /dev/null
+++ b/content/docs/sv-SE/official-documentation/custom-ui/type-documentation/index.mdx
@@ -0,0 +1,127 @@
+---
+title: Type Documentation
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# Type Documentation
+
+This is a generated list of UI elements accessible by markup. More information about the User Interface framework can be found in the main documentation.
+
+## Elements
+
+- [ActionButton](type-documentation/elements/actionbutton)
+- [AssetImage](type-documentation/elements/assetimage)
+- [BackButton](type-documentation/elements/backbutton)
+- [BlockSelector](type-documentation/elements/blockselector)
+- [Button](type-documentation/elements/button)
+- [CharacterPreviewComponent](type-documentation/elements/characterpreviewcomponent)
+- [CheckBox](type-documentation/elements/checkbox)
+- [CheckBoxContainer](type-documentation/elements/checkboxcontainer)
+- [CircularProgressBar](type-documentation/elements/circularprogressbar)
+- [CodeEditor](type-documentation/elements/codeeditor)
+- [ColorOptionGrid](type-documentation/elements/coloroptiongrid)
+- [ColorPicker](type-documentation/lements/colorpicker)
+- [ColorPickerDropdownBox](type-documentation/elements/colorpickerdropdownbox)
+- [CompactTextField](type-documentation/elements/compacttextfield)
+- [DropdownBox](type-documentation/elements/dropdownbox)
+- [DropdownEntry](type-documentation/elements/dropdownentry)
+- [DynamicPane](type-documentation/elements/dynamicpane)
+- [DynamicPaneContainer](type-documentation/elements/dynamicpanecontainer)
+- [FloatSlider](type-documentation/elements/floatslider)
+- [FloatSliderNumberField](type-documentation/elements/floatslidernumberfield)
+- [Group](type-documentation/elements/group)
+- [HotkeyLabel](type-documentation/elements/hotkeylabel)
+- [ItemGrid](type-documentation/elements/itemgrid)
+- [ItemIcon](type-documentation/elements/itemicon)
+- [ItemPreviewComponent](type-documentation/elements/itempreviewcomponent)
+- [ItemSlot](type-documentation/elements/itemslot)
+- [ItemSlotButton](type-documentation/elements/itemslotbutton)
+- [Label](type-documentation/elements/label)
+- [LabeledCheckBox](type-documentation/elements/labeledcheckbox)
+- [MenuItem](type-documentation/elements/menuitem)
+- [MultilineTextField](type-documentation/elements/multilinetextfield)
+- [NumberField](type-documentation/elements/numberfield)
+- [Panel](type-documentation/elements/panel)
+- [ProgressBar](type-documentation/elements/progressbar)
+- [ReorderableList](type-documentation/elements/reorderablelist)
+- [ReorderableListGrip](type-documentation/elements/reorderablelistgrip)
+- [SceneBlur](type-documentation/elements/sceneblur)
+- [Slider](type-documentation/elements/slider)
+- [SliderNumberField](type-documentation/elements/slidernumberfield)
+- [Sprite](type-documentation/elements/sprite)
+- [TabButton](type-documentation/elements/tabbutton)
+- [TabNavigation](type-documentation/elements/tabnavigation)
+- [TextButton](type-documentation/elements/textbutton)
+- [TextField](type-documentation/elements/textfield)
+- [TimerLabel](type-documentation/elements/timerlabel)
+- [ToggleButton](type-documentation/elements/togglebutton)
+
+## Property Types
+
+- [Anchor](type-documentation/property-types/anchor)
+- [BlockSelectorStyle](type-documentation/property-types/blockselectorstyle)
+- [ButtonSounds](type-documentation/property-types/buttonsounds)
+- [ButtonStyle](type-documentation/property-types/buttonstyle)
+- [ButtonStyleState](type-documentation/property-types/buttonstylestate)
+- [CheckBoxStyle](type-documentation/property-types/checkboxstyle)
+- [CheckBoxStyleState](type-documentation/property-types/checkboxstylestate)
+- [ClientItemStack](type-documentation/property-types/clientitemstack)
+- [ColorOptionGridStyle](type-documentation/property-types/coloroptiongridstyle)
+- [ColorPickerDropdownBoxStateBackground](type-documentation/property-types/colorpickerdropdownboxstatebackground)
+- [ColorPickerDropdownBoxStyle](type-documentation/property-types/colorpickerdropdownboxstyle)
+- [ColorPickerStyle](type-documentation/property-types/colorpickerstyle)
+- [DropdownBoxSearchInputStyle](type-documentation/property-types/dropdownboxsearchinputstyle)
+- [DropdownBoxSounds](type-documentation/property-types/dropdownboxsounds)
+- [DropdownBoxStyle](type-documentation/property-types/dropdownboxstyle)
+- [InputFieldButtonStyle](type-documentation/property-types/inputfieldbuttonstyle)
+- [InputFieldDecorationStyle](type-documentation/property-types/inputfielddecorationstyle)
+- [InputFieldDecorationStyleState](type-documentation/property-types/inputfielddecorationstylestate)
+- [InputFieldIcon](type-documentation/property-types/inputfieldicon)
+- [InputFieldStyle](type-documentation/property-types/inputfieldstyle)
+- [ItemGridSlot](type-documentation/property-types/itemgridslot)
+- [ItemGridStyle](type-documentation/property-types/itemgridstyle)
+- [LabeledCheckBoxStyle](type-documentation/property-types/labeledcheckboxstyle)
+- [LabeledCheckBoxStyleState](type-documentation/property-types/labeledcheckboxstylestate)
+- [LabelSpan](type-documentation/property-types/labelspan)
+- [LabelStyle](type-documentation/property-types/labelstyle)
+- [NumberFieldFormat](type-documentation/property-types/numberfieldformat)
+- [Padding](type-documentation/property-types/padding)
+- [PatchStyle](type-documentation/property-types/patchstyle)
+- [PopupStyle](type-documentation/property-types/popupstyle)
+- [ScrollbarStyle](type-documentation/property-types/scrollbarstyle)
+- [SliderStyle](type-documentation/property-types/sliderstyle)
+- [SoundStyle](type-documentation/property-types/soundstyle)
+- [SpriteFrame](type-documentation/property-types/spriteframe)
+- [SubMenuItemStyle](type-documentation/property-types/submenuitemstyle)
+- [SubMenuItemStyleState](type-documentation/property-types/submenuitemstylestate)
+- [Tab](type-documentation/property-types/tab)
+- [TabNavigationStyle](type-documentation/property-types/tabnavigationstyle)
+- [TabStyle](type-documentation/property-types/tabstyle)
+- [TabStyleState](type-documentation/property-types/tabstylestate)
+- [TextButtonStyle](type-documentation/property-types/textbuttonstyle)
+- [TextButtonStyleState](type-documentation/property-types/textbuttonstylestate)
+- [TextTooltipStyle](type-documentation/property-types/texttooltipstyle)
+- [ToggleButtonStyle](type-documentation/property-types/togglebuttonstyle)
+- [ToggleButtonStyleState](type-documentation/property-types/togglebuttonstylestate)
+
+## Enums
+
+- [ActionButtonAlignment](type-documentation/enums/actionbuttonalignment)
+- [CodeEditorLanguage](type-documentation/enums/codeeditorlanguage)
+- [ColorFormat](type-documentation/enums/colorformat)
+- [DropdownBoxAlign](type-documentation/enums/dropdownboxalign)
+- [InputFieldButtonSide](type-documentation/enums/inputfieldbuttonside)
+- [InputFieldIconSide](type-documentation/enums/inputfieldiconside)
+- [ItemGridInfoDisplayMode](type-documentation/enums/itemgridinfodisplaymode)
+- [LabelAlignment](type-documentation/enums/labelalignment)
+- [LayoutMode](type-documentation/enums/layoutmode)
+- [MouseWheelScrollBehaviourType](type-documentation/enums/mousewheelscrollbehaviourtype)
+- [ProgressBarAlignment](type-documentation/enums/progressbaralignment)
+- [ProgressBarDirection](type-documentation/enums/progressbardirection)
+- [ResizeType](type-documentation/enums/resizetype)
+- [TimerDirection](type-documentation/enums/timerdirection)
+- [TooltipAlignment](type-documentation/enums/tooltipalignment)
diff --git a/content/docs/sv-SE/official-documentation/npc/2-getting-started-with-templates.mdx b/content/docs/sv-SE/official-documentation/npc/2-getting-started-with-templates.mdx
index 91081ca1..99d078e0 100644
--- a/content/docs/sv-SE/official-documentation/npc/2-getting-started-with-templates.mdx
+++ b/content/docs/sv-SE/official-documentation/npc/2-getting-started-with-templates.mdx
@@ -9,7 +9,7 @@ authors:
 
 There are no hard and fast rules for making a start on a template. I like to duplicate **BlankTemplate** and start from there because it already provides the basic structure of the file.
 
-This leaves me with the following template (`Template_Goblin_Ogre.json`): (note: the file could be looking different in the current version of the game)
+This leaves me with the following template (`Template_Goblin_Ogre.json`): (**note: the file could be looking different in the current version of the game**)
 
 ```json
 {
@@ -33,7 +33,7 @@ This leaves me with the following template (`Template_Goblin_Ogre.json`): (note:
     }
   },
   "Appearance": { "Compute": "Appearance" },
-  "DropList": { "Compute": "Droplist" },
+  "DropList": { "Compute": "DropList" },
   "MaxHealth": { "Compute": "MaxHealth" },
   "MotionControllerList": [
     {
@@ -65,10 +65,10 @@ And the following variant (`Goblin_Ogre.json`) next to the template. There's a t
   "Type": "Variant",
   "Reference": "Template_Goblin_Ogre",
   "Modify": {
-    "Appearance": "Goblin_Ogre",
+    "Appearance": "Goblin",
     "MaxHealth": 124
   }
 }
 ```
 
-Our artists have defined the `Goblin_Ogre` appearance already so I'm going to use that.
+Our artists have not yet finished animations for the `Goblin_Ogre`, for that sake of the tutorial I am going to use appearance `Goblin`, because it offers a more complete set of animations that we will need.
diff --git a/content/docs/sv-SE/official-documentation/worldgen/pack-tutorial/asset-packs.mdx b/content/docs/sv-SE/official-documentation/worldgen/pack-tutorial/asset-packs.mdx
index 38809fad..dcf1f3b9 100644
--- a/content/docs/sv-SE/official-documentation/worldgen/pack-tutorial/asset-packs.mdx
+++ b/content/docs/sv-SE/official-documentation/worldgen/pack-tutorial/asset-packs.mdx
@@ -9,13 +9,13 @@ authors:
 
 <OfficialDocumentationNotice />
 
-# How to modify Hytale
+# How to modify Hytale?
 
-## What's an Asset Pack
+## What's an Asset Pack?
 
-Hytales gameplay is driven by assets in the game that can be modified by creators. Asset Packs are our solution to let you override or add features to the base game with your own work. These can in the form of zip files of folders, which contain a custom set of assets. This is not the only way for a creator to change Hytale but this is the most accessible form.;
+Hytales gameplay is driven by assets in the game that can be modified by creators. Asset Packs are our solution to let you override or add features to the base game with your own work. These can be the form of zip files of folders, which contain a custom set of assets. This is not the only way for a creator to change Hytale but this is the most accessible form.;
 
-### How do I make an Asset Pack
+### How do I make an Asset Pack?
 
 <video controls className="my-6 aspect-video w-full rounded-lg border">
   <source src="https://cdn.internal.hytalemodding.dev/guides/official/how-to-asset-pack.mp4" type="video/mp4" />
@@ -48,7 +48,7 @@ An asset pack is typically a zip or folder, with a `manifest.json` inside. This
 }
 ```
 
-### Where are they stored
+### Where are they stored?
 
 Asset Packs are stored with other mods in the Mods folder.
 
@@ -76,7 +76,7 @@ C:\Users\<user>\AppData\Roaming\Hytale\UserData\Saves\New World 5\mods
 
 When you have Asset Packs or Mods installed, these will appear in the New World menu under the Options menu.;
 
-### How do I change an existing asset
+### How do I change an existing asset?
 
 <video controls className="my-6 aspect-video w-full rounded-lg border">
   <source src="https://cdn.internal.hytalemodding.dev/guides/official/how-to-asset.mp4" type="video/mp4" />
diff --git a/content/docs/sv-SE/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx b/content/docs/sv-SE/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx
index 44528376..24e628b5 100644
--- a/content/docs/sv-SE/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx
+++ b/content/docs/sv-SE/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx
@@ -106,7 +106,7 @@ If a BaseHeight is provided, the TopY and BottomY values are relative to the Bas
 
 Applies a Material Provider slot on a set of horizontal stripes of blocks of varying thickness and position. Below is an example image of basalt stripes into a stone cliff.
 
-{/* ![](https://540086904-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F7KAmBkOg6d13nZCkf9ku%2Fuploads%2FbcxO9LpArn8gPCaBwFg5%2Funknown.png?alt=media&token=1c72b67a-8253-4d03-8c64-1ad5f6830050) */}
+![Example of basalt stripes](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/basalt-stripes-example.png)
 
 #### Parameters:
 
diff --git a/content/docs/sv-SE/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx b/content/docs/sv-SE/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx
index 5e34acd4..a4418473 100644
--- a/content/docs/sv-SE/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx
+++ b/content/docs/sv-SE/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx
@@ -294,7 +294,7 @@ Combines all the positions into a single Positioins field.
 
 ---
 
-### SimpleHoritontal
+### SimpleHorizontal
 
 Keeps only the positions that are within the provided range.
 
diff --git a/content/docs/sv-SE/official-documentation/worldgen/worldgen-tutorial/README.mdx b/content/docs/sv-SE/official-documentation/worldgen/worldgen-tutorial/README.mdx
new file mode 100644
index 00000000..5f66d245
--- /dev/null
+++ b/content/docs/sv-SE/official-documentation/worldgen/worldgen-tutorial/README.mdx
@@ -0,0 +1,166 @@
+---
+title: How to edit and create Biomes
+description: Explores where world generation assets can be found and how to edit them.
+---
+
+### Where are the Assets
+
+World generation assets are kept in the HytaleGenerator directory within the assets.
+
+```
+/Server/HytaleGenerator/
+```
+
+<div className="flex flex-row rounded-lg border p-4">
+  <div className="flex-1/2 border-r pr-4">
+    ```
+    /Biomes
+    ```
+
+    Biome assets, with content configurations.
+  </div>
+
+  <div className="flex-1/2 pl-4">
+    ```
+    /WorldStructure
+    ```
+
+    Generator files that define which biomes spawn together.
+  </div>
+</div>
+
+<div className="flex flex-row rounded-lg border p-4">
+  <div className="flex-1/2 border-r pr-4">
+    ```
+    /Density
+    ```
+
+    Density assets that can be referenced by any other assets.
+  </div>
+
+  <div className="flex-1/2 pl-4">
+    ```
+    /Assignments
+    ```
+
+    Prop assets that can be referenced by any Biome assets.
+  </div>
+</div>
+
+***
+
+An example of this structure can be found bellow, packed in an asset pack with the instance configuration.
+
+[https://drive.google.com/file/d/1sIz_CluANIIe3n8vNiOi-4PQdeqCO0qY/view?usp=drive_link](https://drive.google.com/file/d/1sIz_CluANIIe3n8vNiOi-4PQdeqCO0qY/view?usp=drive_link)
+
+<Callout>
+  Ensure you place your asset pack in the correct directory, under Mods.
+</Callout>
+
+### How to visit our worlds
+
+https://drive.google.com/file/d/1BJurxyj-taE-PXWm04bk7Dl6X7ZHTH92/view?usp=sharing
+
+#### Requirements
+
+- You must be an **Operator** in the world.
+  - To do this, run <mark style="color:$danger;">`/op self`</mark>
+- You must be in **Creative mode**.
+  - Press the <mark style="color:$danger;">`O`</mark> key, O for Orange.&#x20;
+
+The generation assets define a set of generators but on their own you cannot visit these. Currently you require an Instance with a generator that will allow you to visit your work.
+
+```
+/Server/Instances/
+```
+
+Instances are separate worlds that players can join using the `/instances` command. Each instance has an `Instance.bson` configuration asset that specifies which generator to use, among other worldly settings.
+
+```json
+{
+  "WorldGen": {
+    "Type": "HytaleGenerator",
+    "WorldStructure": "Basic",
+    "playerSpawn" : {
+      "X" : 123,
+      "Y" : 480,
+      "Z" : 10000,
+      "Pitch" : 0,
+      "Yaw" : 0,
+      "Roll" : 0
+    }
+  }
+}
+```
+
+<Callout>
+  You can create custom instances for different world structures and biomes as you need them.
+</Callout>
+
+### How to edit Biomes
+
+<video>
+  <source src="https://cdn.internal.hytalemodding.dev/guides/official/How-to-edit-Biomes.mp4" type="video/mp4" />
+</video>
+
+We currently use the Hytale Node Editor when editing world generation assets. This can be accessed while in-game from the Content Creation menu when pressing B. The node editor is then found under the asset editor dropdown on the upper left.&#x20;
+
+![Node Editor 1](/assets/official-documentation/worldgen/worldgen-tutorial/biomes/node-editor-1.png)
+
+Once you have the Hytale Node Editor open, through the file menu you can open Biomes by navigating to the Biomes directory and selecting one from your pack.&#x20;
+
+```
+/Server/HytaleGenerator/Biomes/
+```
+
+### Biome Asset Structure
+
+Every Biome has a root Biome node, this node splits into 5 structures. This is covered briefly but more information on each field can be found on the World Generation Concepts page.
+
+![Node Editor 2](/assets/official-documentation/worldgen/worldgen-tutorial/biomes/node-editor-2.png)
+
+<Callout>
+  Each biome is for the most part self contained, meaning it has control over what appears with the biome. The only exception to this are Base Heights.
+</Callout>
+
+<Tabs>
+  <Tab value="Terrain">
+    Mathematical function nodes that calculate the physical shape of the Biome's terrain.
+  </Tab>
+
+  <Tab value="Materials">
+    Logical nodes that determine what materials (blocks) make up a Biome's terrain.
+  </Tab>
+
+  <Tab value="Props">
+    Function nodes that add objects like prefabs and decorations to the terrain.
+  </Tab>
+
+  <Tab value="Environments">
+    Logical nodes that determine the environment asset at a given coordinate within the biome. This asset determines things like weather, NPC spawns, and sounds.
+  </Tab>
+
+  <Tab value="Tints">
+    Logical function nodes that determine a colour code that can be used by certain blocks in the world. Typically this will be grasses and soils.
+  </Tab>
+</Tabs>
+
+### How to preview your work
+
+[https://drive.google.com/file/d/1mNcHn9LhFnWDF0DzWFH6_YllmKAUvUry/view?t=6](https://drive.google.com/file/d/1mNcHn9LhFnWDF0DzWFH6_YllmKAUvUry/view?t=6)
+
+Once you are in an Instance world with the Hytale Generator active you will only be able to see your work by generating new chunks. There are a few ways to do this.
+
+The viewport command selects an area around the Player that will live reload as you make changes to the generator.&#x20;
+
+```
+/viewport --radius 5 
+```
+
+You can also create a new world to show your changes.&#x20;
+
+```
+/instances spawn <instance> 
+```
+
+The last option is to simply fly south, new chunks will generate with the changes made.
diff --git a/content/docs/sv-SE/quick-start.mdx b/content/docs/sv-SE/quick-start.mdx
index 653644f4..249d803a 100644
--- a/content/docs/sv-SE/quick-start.mdx
+++ b/content/docs/sv-SE/quick-start.mdx
@@ -9,3 +9,8 @@ Welcome to the Hytale modding documentation! Here you'll find everything you nee
 * [Setting up your dev environment](./guides/plugin/setting-up-env)
 * [Entity Component System (ECS)](./guides/ecs/entity-component-system)
 * [Publishing your mod](./publishing)
+
+### Useful Links
+
+* [Kaupenjoe's Modding Videos](https://www.youtube.com/@ModdingByKaupenjoe)
+* [TroubleDEV's Modding Videos](https://www.youtube.com/@TroubleDEV)
diff --git a/content/docs/sv-SE/server/argtypes.mdx b/content/docs/sv-SE/server/argtypes.mdx
new file mode 100644
index 00000000..e54a442e
--- /dev/null
+++ b/content/docs/sv-SE/server/argtypes.mdx
@@ -0,0 +1,61 @@
+---
+title: ArgTypes
+description: Available ArgTypes
+icon: List
+full: true
+authors:
+  - name: Valeena
+---
+
+| Name                        | Target Class                           | Description                                                                                                                               |   |
+| :-------------------------- | :------------------------------------- | :---------------------------------------------------------------------------------------------------------------------------------------- | - |
+| Boolean                     | java.lang.Boolean                      | A 'true' or 'false' input                                                                                                                 |   |
+| Integer                     | java.lang.Integer                      | A whole number                                                                                                                            |   |
+| String                      | java.lang.String                       | Words, text, numbers, letters. To input more than one word at a time, you may need to wrap it with double quotes (`"my fancy sentence"`). |   |
+| Float                       | java.lang.Float                        | A floating-pointer number                                                                                                                 |   |
+| Double                      | java.lang.Double                       | A decimal number                                                                                                                          |   |
+| UUID                        | java.util.UUID                         | A UUID (Universally Unique IDentifier)                                                                                                    |   |
+| Player_UUID                 | java.util.UUID                         | A UUID or an online player username                                                                                                       |   |
+| Game_Profile_Lookup_Async   | ProfileServiceClient.PublicGameProfile | A player UUID or username. If not found locally, performs a remote lookup via the Profile Service.                                        |   |
+| Relative_Double_Coord       | Coord                                  | An x, y, or z coordinate as a decimal, optionally relative by specifying a tilde (~) in front of the number                               |   |
+| Relative_Int_Coord          | IntCoord                               | An x, y, or z coordinate as a whole number, optionally relative by specifying a tilde (~) in front of the number                          |   |
+| Relative_Integer            | RelativeInteger                        | A tilde to mark an integer relative to a base                                                                                             |   |
+| Relative_Float              | RelativeFloat                          | A tilde to mark a float relative to a base                                                                                                |   |
+| Player_Ref                  | PlayerRef                              | A UUID or an online player's username                                                                                                     |   |
+| World                       | World                                  | A world folder name                                                                                                                       |   |
+| Model_Asset                 | ModelAsset                             | A reference to an Asset of type Model                                                                                                     |   |
+| Weather_Asset               | Weather                                | A reference to an Asset of type Weather                                                                                                   |   |
+| Interaction_Asset           | Interaction                            | A reference to an Asset of type Interaction                                                                                               |   |
+| Root_Interaction_Asset      | RootInteraction                        | A reference to an Asset of type Root Interaction                                                                                          |   |
+| Effect_Asset                | EntityEffect                           | A refernece to an Asset of type EntityEffect                                                                                              |   |
+| Environment_Asset           | Environment                            | A reference to an Asset of type Environment                                                                                               |   |
+| Item_Asset                  | Item                                   | A reference to an Asset of type Item                                                                                                      |   |
+| Block_Type_Asset            | BlockType                              | A reference to an Asset of type BlockType                                                                                                 |   |
+| Particle_System             | ParticleSystem                         | A reference to an Asset of type ParticleSystem                                                                                            |   |
+| Hitbox_Collision_Config     | HitboxCollisionConfig                  | A reference to an Asset of type HitboxCollisionConfig                                                                                     |   |
+| Repulsion_Config            | RepulsionConfig                        | A reference to an Asset of type RepulsionConfig                                                                                           |   |
+| Sound_Event_Asset           | SoundEvent                             | A reference to an Asset of type SoundEvent                                                                                                |   |
+| Ambiance_Fx_Asset           | AmbianceFX                             | A reference to an Asset of type AmbianceFX                                                                                                |   |
+| Sound_Category              | SoundCategory                          | A sound category (sfx, music, ambient, ui)                                                                                                |   |
+| Entity_ID                   | `ArgWrapper<EntityWrappedArg, UUID>`   | A UUID representing an entity id                                                                                                          |   |
+| Integer_Comparison_Operator | IntegerComparisonOperator              | A mathematical sign for integer comparison                                                                                                |   |
+| Integer_Operation           | IntegerOperation                       | A mathematical sign for performing an operation                                                                                           |   |
+| Int_Range                   | `Pair<Integer, Integer>`               | Two integers representing a minimum and maximum of a range                                                                                |   |
+| Relative_Int_Range          | RelativeIntRange                       | Two integers representing a minimum and maximum of a range                                                                                |   |
+| Vector2I                    | Vector2i                               | Two integers, generally corresponding to x/z axis                                                                                         |   |
+| Vector3I                    | Vector3i                               | Three integers, generally corresponding to x/y/z axis                                                                                     |   |
+| Relative_Vector3I           | RelativeVector3i                       | Three optionally relative integers, generally corresponding to x/y/z axis                                                                 |   |
+| Relative_Block_Position     | RelativeIntPosition                    | A position with three integer coordinates, representing a block's location in world space.                                                |   |
+| Relative_Position           | Relative                               | A position with three decimal coordinates, representing a location in world space.                                                        |   |
+| Relative_Chunk_Position     | RealtiveChunkPosition                  | A position with two integer coordinates (x, z), representing a chunk's location.                                                          |   |
+| Rotation                    | Vector3f                               | A rotation with three coordinates, representing the pitch, yaw, and roll respectively                                                     |   |
+| Block_Type_Key              | String                                 | A block type                                                                                                                              |   |
+| Block_ID                    | Integer                                | A block type, converted to an int id                                                                                                      |   |
+| Color                       | Integer                                | A color value in hex format, hex integer, or decimal integer                                                                              |   |
+| Weighted_Block_Type         | `Pair<Integer, String>`                | A weight corresponding to a blocktype                                                                                                     |   |
+| Weighted_Block_Entry        | String                                 | A block with optional weight prefix                                                                                                       |   |
+| Block_Pattern               | BlockPattern                           | A list of blocks with optional weights                                                                                                    |   |
+| Individual_Block_Mask       | BlockMask                              | Create a block mask using symbols and block names                                                                                         |   |
+| Block_Mask                  | BlockMask                              | A tick rate value (e.g., 30tps, 33ms, or 30)                                                                                              |   |
+| Tick_Rate                   | Integer                                | A list of block masks that combine together                                                                                               |   |
+| Game_Mode                   | GameMode                               | GameMode                                                                                                                                  |   |
diff --git a/content/docs/sv-SE/server/interaction-reference.mdx b/content/docs/sv-SE/server/interaction-reference.mdx
new file mode 100644
index 00000000..6c0d01b3
--- /dev/null
+++ b/content/docs/sv-SE/server/interaction-reference.mdx
@@ -0,0 +1,1586 @@
+---
+title: Interactions
+description: A list of most Interaction types provided by Hypixel, along with the meaning of their fields, and how they fit together.
+icon: List
+authors:
+  - name: Stephen Baynham
+    url: https://github.com/cannibalvox
+---
+
+### The Interaction Base Type
+
+All interactions of every type below are inherited from Interaction and have these fields.
+
+**Interaction Fields**
+
+| Field Name                | Type                                                                 | Required? | Notes                                                                                                                                                                                                                       |
+| ------------------------- | -------------------------------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| ViewDistance              | `Double`<br />(Default: 96.0)                                        | **No**    | Distance in blocks at which other players can see the effects from this interaction.                                                                                                                                        |
+| Effects                   | `InteractionEffects`                                                 | **No**    | Sound, animations, and particle effects that should trigger when this interaction begins executing.                                                                                                                         |
+| HorizontalSpeedMultiplier | `Float`<br />(Default: 1.0)                                          | **No**    | Multiplier applied to the User entity's movement speed while this interaction is executing                                                                                                                                  |
+| RunTime                   | `Float`                                                              | **No**    | If provided, this interaction will continue executing for at least this long before the interaction chain moves onto the next interaction.                                                                                  |
+| CancelOnItemChange        | `Boolean`<br />(Default: true)                                       | **No**    | If true, this interaction will be cancelled if the User entity's held item changes during execution. This can happen either due to the selected hotbar slot changing or the contents of the item's inventory slot changing. |
+| Rules                     | `InteractionRules`                                                   | **Yes**   | If provided, adds additional limitations and cancellation conditions to this interaction.                                                                                                                                   |
+| Settings                  | `Map`<br />(Key Type: `GameMode`, Value Type: `InteractionSettings`) | **No**    | If provided, adds additional per-GameMode settings to the interaction.                                                                                                                                                      |
+| Camera                    | `InteractionCameraSettings`                                          | **No**    | Arrays of camera motion keyframes for cutscenes and reveals.                                                                                                                                                                |
+
+**GameMode Values**
+
+- `Creative`: The game is currently in Creative Mode
+- `Adventure`: The game is currently in Adventure Mode
+
+**InteractionEffects Fields**
+
+| Field Name               | Type                                              | Required? | Notes                                                                                                                                                 |
+| ------------------------ | ------------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Particles                | `Array`<br />(Element Type: `ModelParticle`)      | **No**    | Particle systems to activate when this interaction begins if the player is in third-person mode.                                                      |
+| FirstPersonParticles     | `Array`<br />(Element Type: `ModelParticle`)      | **No**    | Particle systems to activate when this interaction begins if the player is in first-person mode.                                                      |
+| WorldSoundEventId        | `Asset`<br />(Asset Type: `SoundEvent`)           | **No**    | A sound to play in the world at the User entity's location when this interaction begins.<br />**The SoundEvent must be single-channel (mono) sound.** |
+| LocalSoundEventId        | `Asset`<br />(Asset Type: `SoundEvent`)           | **No**    | A 2D sound to play for the User entity when this interaction begins. Ignored if the User entity is not a player.                                      |
+| Trails                   | `Array`<br />(Element Type: `ModelTrail`)         | **No**    | Trail effects to activate on the User entity when this interaction begins.                                                                            |
+| WaitForAnimationToFinish | `Boolean`<br />(Default: false)                   | **No**    | If true, this interaction will continue executing for at least the length of any animations in this InteractionEffects object.                        |
+| ItemPlayerAnimationsId   | `Asset`<br />(Asset Type: `ItemPlayerAnimations`) | **No**    | If provided, the User entity will use this ItemPlayerAnimations set while this interaction is executing.                                              |
+| ItemAnimationId          | `String`                                          | **No**    | Id of an animation to trigger when this interaction begins executing.<br />**This animation id is not validated on server start.**                    |
+| ClearAnimationOnFinish   | `Boolean`<br />(Default: false)                   | **No**    | If true, animations triggered by this interaction will be halted when the interaction completes.                                                      |
+| ClearSoundEventOnFinish  | `Boolean`<br />(Default: false)                   | **No**    | If true, sounds triggered by this interaction will be halted when the interaction completes.                                                          |
+| CameraEffect             | `Asset`<br />(Asset Type: `CameraEffect` )        | **No**    | If provided, the CameraEffect will be applied while this interaction is executing.                                                                    |
+| MovementEffects          | `MovementEffects`                                 | **No**    | If provided, apply the movement effects to the User entity while this interaction is executing.                                                       |
+| StartDelay               | `Float`<br />(Default: 0.0f)                      | **No**    | The interaction will wait this many seconds before triggering the effects in this object.                                                             |
+
+**InteractionRules Fields**
+
+| Field Name          | Type                                                                                                | Required? | Notes                                                                                                                                                                                                                                     |
+| ------------------- | --------------------------------------------------------------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| BlockedBy           | `Array`<br />(Element Type: `InteractionType`)<br />(Default: Based on the chain's InteractionType) | **No**    | If provided, this RootInteraction cannot be executed while interaction chains of the provided types are executing.<br />**This field only functions for rules attached to a RootInteraction. It has no effect on an Interaction.**        |
+| Blocking            | `Array`<br />(Element Type: `InteractionType`)                                                      | **No**    | If provided, interaction chains with the specified InteractionTypes cannot be executed while this interaction is executing.                                                                                                               |
+| InterruptedBy       | `Array`<br />(Element Type: `InteractionType`)                                                      | **No**    | If provided, interaction chains with the specified InteractionTypes will cancel this interaction chain when they execute.<br />**This field only functions for rules attached to a RootInteraction. It has no effect on an Interaction.** |
+| Interrupting        | `Array`<br />(Element Type: `InteractionType`)                                                      | **No**    | If provided, interaction chains with the specified InteractionTypes will be canceled when this interaction begins.                                                                                                                        |
+| BlockedByBypass     | `String`                                                                                            | **No**    | If provided, this RootInteraction cannot be blocked by interaction chains whose RootInteraction has this value as an asset tag.                                                                                                           |
+| BlockingBypass      | `String`                                                                                            | **No**    | If provided, this interaction will not block RootInteractions that have the this value as an asset tag.                                                                                                                                   |
+| InterruptedByBypass | `String`                                                                                            | **No**    | If provided, this RootInteraction cannot be canceled by RootInteractions that have this value as an asset tag.                                                                                                                            |
+| InterruptingBypass  | `String`                                                                                            | **No**    | If provided, this interaction will not cancel interaction chains whose RootInteraction has this value as an asset tag.                                                                                                                    |
+
+**InteractionType Values**
+
+- `Primary`
+- `Secondary`
+- `Ability1`
+- `Ability2`
+- `Ability3`
+- `Use`
+- `Pick`
+- `Pickup`
+- `CollisionEnter`
+- `CollisionLeave`
+- `Collision`
+- `EntityStatEffect`
+- `SwapTo`
+- `SwapFrom`
+- `Death`
+- `Wielding`
+- `ProjectileSpawn`
+- `ProjectileHit`
+- `ProjectileMiss`
+- `ProjectileBounce`
+- `Held`
+- `HeldOffhand`
+- `Equipped`
+- `Dodge`
+- `GameModeSwap`
+
+**InteractionSettings Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                        |
+| ---------------- | ------------------------------- | --------- | -------------------------------------------------------------------------------------------- |
+| AllowSkipOnClick | `Boolean`<br />(Default: false) | **No**    | If true, the user will be able to skip this interaction by clicking shortly after it starts. |
+
+**InteractionCameraSettings Fields**
+
+| Field Name  | Type                                             | Required? | Notes                                                                                                                                                           |
+| ----------- | ------------------------------------------------ | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| FirstPerson | `Array`<br />(Element Type: `InteractionCamera`) | **No**    | A list of camera keyframes to be played if the player is in first-person.<br />**The time of each keyframe must be after the keyframe before it in the array.** |
+| ThirdPerson | `Array`<br />(Element Type: `InteractionCamera`) | **No**    | A list of camera keyframes to be played if the player is in third-person.<br />**The time of each keyframe must be after the keyframe before it in the array.** |
+
+**InteractionCamera Fields**
+
+| Field Name | Type                         | Required? | Notes                                                                                                                                       |
+| ---------- | ---------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------- |
+| Time       | `Float`<br />(Default: 0.1f) | **No**    | How long after the interaction begins executing that the camera should arrive at this keyframe.<br />**Cannot be less than or equal to 0.** |
+| Position   | `Vector3`                    | **Yes**   | Where the camera should be located when it arrives at this keyframe.                                                                        |
+| Rotation   | `Direction`                  | **Yes**   | Where the camera should be pointing when it arrives at this keyframe.                                                                       |
+
+### SimpleInteraction
+
+Most interaction types below are inherited from SimpleInteraction and have these
+fields.  If a type does not have these fields, the documentation will mention it.
+
+The purpose of SimpleInteraction is to facilitate Interaction chaining by taking different paths
+based on whether the Interaction succeeded or failed.  The circumstances under which
+a given Interaction fails are generally type-specific (and described in the documentation
+below), but all interactions will be marked failed if they are cancelled via one of the
+many, many mechanisms for doing so.
+
+It is valid to create an interaction asset of type "Simple", which can be valuable when you want to use the
+interaction fields with no additional functionality.
+
+**SimpleInteraction Fields**
+
+| Field Name | Type                                     | Required? | Notes                                                                                          |
+| ---------- | ---------------------------------------- | --------- | ---------------------------------------------------------------------------------------------- |
+| Next       | `Asset`<br />(Asset Type: `Interaction`) | **No**    | After this Interaction has finished, "Next" will be executed if this Interaction did not fail. |
+| Failed     | `Asset`<br />(Asset Type: `Interaction`) | **No**    | After this Interaction has finished, "Failed" will be executed if this Interaction failed.     |
+
+## Flow Control
+
+These are interaction types used to control the flow of an interaction chain and allow interactions
+to be composed into more complex behaviors.  These interaction types generally do not pertain to
+the game and instead pertain to the interaction system itself.
+
+### Condition
+
+This interaction will fail if one of the fields is provided but does not match the current state.
+
+**Condition Fields**
+
+| Field Name       | Type       | Required? | Notes                                                                                                                                                                                    |
+| ---------------- | ---------- | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| RequiredGameMode | `GameMode` | **No**    | If provided, the interaction will fail if the current GameMode does not match the provided value.                                                                                        |
+| Jumping          | `Boolean`  | **No**    | If provided, the interaction will fail if the player's Jumping state does not match the provided value. (i.e. if True, the player must be jumping, if False, the player must not be)     |
+| Swimming         | `Boolean`  | **No**    | If provided, the interaction will fail if the player's Swimming state does not match the provided value. (i.e. if True, the player must be swimming, if False, the player must not be)   |
+| Crouching        | `Boolean`  | **No**    | If provided, the interaction will fail if the player's Crouching state does not match the provided value. (i.e. if True, the player must be crouching, if False, the player must not be) |
+| Running          | `Boolean`  | **No**    | If provided, the interaction will fail if the player's Running state does not match the provided value. (i.e. if True, the player must be running, if False, the player must not be)     |
+| Flying           | `Boolean`  | **No**    | If provided, the interaction will fail if the player's Flying state does not match the provided value. (i.e. if True, the player must be flying, if False, the player must not be)       |
+
+**GameMode Values**
+
+- `Creative`: The game is currently in Creative Mode
+- `Adventure`: The game is currently in Adventure Mode
+
+### FirstClick
+
+This interaction does not inherit from SimpleInteraction and therefore has no Next or Failed fields.
+
+This interaction has two fields that each contain a reference to an Interaction: Click and Hold.  If the root interaction
+of the chain was initiated by a client button/key press (or simulated NPC input) and the input was a tap, then
+the Click interaction is run. if it was a longer press, then the Hold interaction is run.
+
+As a minor implementation detail, this interaction is internally marked as failed when the Hold path is followed.
+This generally shouldn't matter.  If the interaction was not initiated by a key press at all, the Click path will be followed,
+but it seems risky to rely on that behavior.
+
+**FirstClick Fields**
+
+| Field Name | Type                                     | Required? | Notes                                                                                                                                                    |
+| ---------- | ---------------------------------------- | --------- | -------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Click      | `Asset`<br />(Asset Type: `Interaction`) | **No**    | If provided and the root interaction of the chain was initiated by button/key press, this interaction is executed next if the press was a quick tap.     |
+| Hold       | `Asset`<br />(Asset Type: `Interaction`) | **No**    | If provided and the root interaction of the chain was initiated by a button/key press, this interaction is executed next if the press was a longer hold. |
+
+### Interrupt
+
+This interaction can be used to cancel one or more running interaction chains on an entity and **all forked interaction
+chains those chains have spawned that are still currently running**.  All interaction chains canceled in this manner will be marked as
+Failed, which may have additional implications if the canceled chains are themselves forked from
+other chains that are still running.
+
+**Interrupt Fields**
+
+| Field Name     | Type                                           | Required? | Notes                                                                                                                                                                                               |
+| -------------- | ---------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Entity         | `InteractionTarget`<br />(Default: User)       | **Yes**   | The entity that is the owner of the target interaction chains.  This field can indicate the Owner, User, or Target of this interaction chain.                                                       |
+| InterruptTypes | `Array`<br />(Element Type: `InteractionType`) | **No**    | A set of InteractionTypes that are to be interrupted. Only interactions of these types are affected. If null, all types will be interrupted.<br />**(Note: An empty set will interrupt NO TYPES.)** |
+| RequiredTag    | `String`                                       | **No**    | An asset tag that, if provided, the RootInteraction of the interaction chain must have in order to be canceled.                                                                                     |
+| ExcludedTag    | `String`                                       | **No**    | An asset tag that, if provided, the RootInteraction of the interaction chain must not have in order to be canceled.                                                                                 |
+
+**InteractionTarget Values**
+
+- `User` - The user of this interaction chain. The entity whose actions caused this interaction chain to be executed. This is usually the same as the Owner.
+- `Owner` - The owner of this interaction chain. The entity upon whom this interaction chain is executing.
+- `Target` - The entity target of this interaction chain, if any.  This value is mutable (and can therefore come from many places) but most commonly, it is an entity the User was targeting when this interaction chain began executing.
+
+**InteractionType Values**
+
+- `Primary`
+- `Secondary`
+- `Ability1`
+- `Ability2`
+- `Ability3`
+- `Use`
+- `Pick`
+- `Pickup`
+- `CollisionEnter`
+- `CollisionLeave`
+- `Collision`
+- `EntityStatEffect`
+- `SwapTo`
+- `SwapFrom`
+- `Death`
+- `Wielding`
+- `ProjectileSpawn`
+- `ProjectileHit`
+- `ProjectileMiss`
+- `ProjectileBounce`
+- `Held`
+- `HeldOffhand`
+- `Equipped`
+- `Dodge`
+- `GameModeSwap`
+
+### Parallel
+
+This interaction does not inherit from SimpleInteraction and therefore has no Next or Failed fields.
+
+This interaction has a field `Interactions` that is an array of RootInteraction assets. The list must contain at least
+two RootInteractions.  This interaction will fork all of its children except for the first into their
+own interaction chains and immediately complete. After this interaction completes, this interaction chain will
+execute the first RootInteraction in the `Interactions` list.
+
+This interaction does not have any failure conditions and is indifferent to the fate of the forked interaction chains.
+
+**Parallel Fields**
+
+| Field Name   | Type                                                | Required? | Notes                                                         |
+| ------------ | --------------------------------------------------- | --------- | ------------------------------------------------------------- |
+| Interactions | `AssetArray`<br />(Element Type: `RootInteraction`) | **Yes**   | An array of RootInteractions that will be forked or executed. |
+
+### Repeat
+
+This interaction has a field `ForkInteractions` that is an asset of type RootInteraction. This interaction will fork that
+RootInteraction into its own interaction chain and then wait for it to complete. If the RootInteraction fails, this
+interaction will complete immediately and be marked failed. Otherwise, the RootInteraction will be forked and run again,
+up to a specified total number of times.
+
+**Repeat Fields**
+
+| Field Name       | Type                                                                                   | Required? | Notes                                                                                                                                                                                                              |
+| ---------------- | -------------------------------------------------------------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| ForkInteractions | `Asset`<br />(Asset Type: `RootInteraction`)                                           | **Yes**   | A RootInteraction that will be forked.                                                                                                                                                                             |
+| Repeat           | `Integer`<br />(Default: 1)<br />**Must be -1 or a positive integer. 0 is not valid.** | **No**    | The total number of times to fork ForkInteractions. If -1 is provided, ForkInteractions will continue being forked and executed indefinitely, until this interaction is cancelled or until ForkInteractions fails. |
+
+### Replace
+
+This interaction does not inherit from SimpleInteraction and therefore has no Next or Failed fields.
+
+This interaction uses the InteractionVars system that is avaiable for items. InteractionVars are RootInteractions that
+can be attached to an Item asset with a name.
+
+This interaction specifies a var name, and if this interaction chain was executed through
+an item and that item has an InteractionVar of the same name, then this interaction will immediately execute
+the RootInteraction on the var.  Otherwise, it will execute the default RootInteraction specified in this interaction.
+If no default is specified, then this interaction will be marked as failed.
+
+**Replace Fields**
+
+| Field Name   | Type                                         | Required? | Notes                                                                                                                                                                                                           |
+| ------------ | -------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Var          | `String`                                     | **Yes**   | The name of the InteractionVar to execute.                                                                                                                                                                      |
+| DefaultValue | `Asset`<br />(Asset Type: `RootInteraction`) | **No**    | The RootInteraction to execute if the owning item does not have an InteractionVar by the specified name. If not provided, the interaction will be marked as failed instead.                                     |
+| DefaultOk    | `Boolean`<br />(Default: false)              | **No**    | If false, then an angry message will be printed to the server logs if the owning item does not have an InteractionVar by the specified name.  The functioning of this interaction will be otherwise unaffected. |
+
+### RunRootInteraction
+
+This interaction immediately executes the provided RootInteraction as part of this interaction chain. This interaction
+does not have any failure conditions.
+
+**RunRootInteraction Fields**
+
+| Field Name      | Type                                         | Required? | Notes                           |
+| --------------- | -------------------------------------------- | --------- | ------------------------------- |
+| RootInteraction | `Asset`<br />(Asset Type: `RootInteraction`) | **Yes**   | The RootInteraction to execute. |
+
+### Selector
+
+This interaction will execute a Selector to find entities and/or blocks (depending on the Selector) and fork off an
+interaction chain for each located entity or block. This interaction will not wait for those interaction chains
+to complete and is indifferent to their fate. The forked interaction chains will use the located entity/block as
+their target entity/target block. Each entity or block will only fork one interaction chain over the life of this
+interaction.  The Selector is guaranteed to run once for each execution of this interaction, but some Selectors
+are intended to be run over a period of time and sweep across an area to locate targets. In order to use those Selectors
+properly, you will need to extend the execution time of this interaction using `RunTime` or `WaitForAnimationToFinish`.
+The Selector will be executed repeatedly over the lifetime of the interaction.
+
+If the Selector is configured to locate entities, you can add additional sets of entity matching rules. If a located entity
+matches one of the rules, the matching RootInteraction will be forked instead of the standard `HitEntity` RootInteraction.
+
+Entities located by the Selector will be ignored if they do not have a NetworkId, if they are dead, or if they are invulnerable.
+The only exception to this rule is that players in Creative Mode that are marked to receive hits will not be ignored.
+
+This interaction's failure conditions are configurable via the `FailOn` field. You can configure this interaction to never
+fail, to fail if the Selector does not locate any blocks before this interaction finishes executing, to fail if the
+Selector does not locate any entities before this interaction finishes executing, or to fail in either case.
+
+**Selector Fields**
+
+| Field Name     | Type                                         | Required? | Notes                                                                                                                                                                                                                                     |
+| -------------- | -------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Selector       | `Selector`                                   | **Yes**   | The Selector is executed at least once and may be executed repeatedly to locate blocks and/or entities in an area.                                                                                                                        |
+| HitEntity      | `Asset`<br />(Asset Type: `RootInteraction`) | **No**    | If included and the `Selector` locates an entity that does not match any `HitEntityRules`, this RootInteraction will be forked into a new interaction chain with the located entity as the target entity.                                 |
+| HitEntityRules | `Array`<br />(Element Type: `HitEntity`)     | **No**    | If included, these rules will be matched against any entity located by the `Selector`. If an entity matches a set of rules, the RootInteraction associated with the rules will be forked instead of the standard `HitEntity` interaction. |
+| HitBlock       | `Asset`<br />(Asset Type: `RootInteraction`) | **No**    | If included and the `Selector` locates a block, this RootInteraction will be forked into a new interaction chain with the located block as the block target.                                                                              |
+| FailOn         | `FailOnType`<br />(Default: `Neither`)       | **No**    | Defines under what circumstances this interaction will fail.  It can be marked to fail when it completes without locating any blocks, it can be marked to fail when it completes without locating any entities, both, or neither.         |
+| IgnoreOwner    | `Boolean`<br />(Default: true)               | **No**    | If true, the Selector will not locate the User entity of this interaction.                                                                                                                                                                |
+
+**HitEntity Fields**
+
+| Field Name | Type                                         | Required? | Notes                                                                                                 |
+| ---------- | -------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------- |
+| Matchers   | `Array`<br />(Element Type: `EntityMatcher`) | **Yes**   | A set of rules that an entity must match. An entity must successful match all rules to be considered. |
+| Next       | `Asset`<br />(Asset Type: `RootInteraction`) | **Yes**   | The RootInteraction to fork if an entity matches all rules.                                           |
+
+**EntityMatcher Fields**
+
+| Field Name | Type                            | Required? | Notes                                                                                                     |
+| ---------- | ------------------------------- | --------- | --------------------------------------------------------------------------------------------------------- |
+| Type       | `String`                        | **Yes**   | If provided, specifies a type of EntityMatcher to use. Each matcher type may come with additional fields. |
+| Invert     | `Boolean`<br />(Default: false) | **No**    | If true, an entity must fail this rule for it to be marked as succeeded.                                  |
+
+**EntityMatcher Type: Player**
+
+This EntityMatcher will succesfully match the entity only if they are a player.
+
+**EntityMatcher Type: Vulnerable**
+
+This Entitymatcher will successfully match the entity only if they are not marked as invulnerable.
+
+**FailOnType Values**
+
+- `Neither`
+- `Entity`
+- `Block`
+- `Either`
+
+### Serial
+
+This interaction does not inherit from SimpleInteraction and therefore has no Next or Failed fields.
+
+This interaction has a field `Interactions` which is a list of Interaction assets. This interaction immediately
+completes and the interaction chain continues by executing the interactions in the list one at a time. This
+interaction does not have any failure conditions.
+
+**Serial Fields**
+
+| Field Name   | Type                                            | Required? | Notes                                      |
+| ------------ | ----------------------------------------------- | --------- | ------------------------------------------ |
+| Interactions | `AssetArray`<br />(Element Type: `Interaction`) | **Yes**   | An array of Interaction assets to execute. |
+
+## Cooldowns
+
+RootInteractions interface with a complex cooldown system that can be used for a variety of purposes. Aside from simply
+adding an important aspect of resource management to your game design, cooldowns can be used to ensure that click-activated
+interaction chains don't repeatedly spam if the player holds down the input.
+
+By default, every RootInteraction has a cooldown timer that is keyed to the RootInteraction name, and by default, it
+will launch a cooldown of 0.35 seconds when activated by client input.  Otherwise, no cooldown will be activated.  However,
+by configuring your RootInteraction, you can change the key for the cooldown (so that multiple RootInteractions can share
+a single cooldown), set the cooldown timer to whatever you like, and configure multiple charges that can build up over time
+to allow the entity to activate the RootInteraction multiple times before being forced to pause.
+
+One important concept to keep in mind is the difference between **cooldown** and **charge time**.  The cooldown, if any,
+is activated each time a RootInteraction triggers, even if the player has more available charges. If the RootInteraction
+is configured to use charges, then they will gradually build up over time. In order for a RootInteraction to be activated,
+the cooldown (if any) must be expired, and the RootInteraction must have at least one charge (if it has been
+configured to use charges).
+
+Bear in mind that the entire Cooldown configuration is shared between different RootInteractions with the same cooldown id.
+If you activate an ability with 5 charges and a short cooldown and then another ability with a much longer cooldown and no
+charges, the second ability will use the cooldown properties of the first ability until/unless the first ability finishes
+charging and is cleared from the system.  You should generally only have multiple RootInteractions share a cooldown id
+if they have the same configuration.
+
+The interactions below interact with the cooldown system to allow you to manipulate cooldowns via the interaction system. By
+using these interactions, you can have several interaction chains with different cooldown configurations share cooldowns
+that are checked and activated as part of the interaction chain itself, or have some components of an interaction change
+use a second cooldown separate from the main one.
+
+### CooldownCondition
+
+**CooldownCondition Fields**
+
+This interaction will fail if the specified cooldown id is on cooldown for the User entity.  This interaction will only
+function for players- the interaction will always succeed for NPCs.  In order for this interaction to succeed, the
+cooldown, if any, must have expired and at least one charge, if any, must have filled.
+
+| Field Name | Type     | Required? | Notes                     |
+| ---------- | -------- | --------- | ------------------------- |
+| Id         | `String` | **Yes**   | The cooldown id to check. |
+
+### IncrementCooldown
+
+**IncrementCooldown Fields**
+
+This interaction will modify a cooldown that is currently active on the User entity, allowing charges and remaining
+cooldown to be modified.
+Despite its name, this interaction can be used to reduce a cooldown as well as increase it. If the cooldown is not
+currently active, this interaction will have no effect. The interaction has no special failure conditions.
+
+| Field Name        | Type                        | Required? | Notes                                                                                                                                                                                                                                                                                     |
+| ----------------- | --------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Id                | `String`                    | **No**    | If provided, the cooldown id of the cooldown to be manipulated. If not provided, the cooldown id of the current chain's RootInteraction will be used.                                                                                                                                     |
+| Time              | `Float`<br />(Default: 0.0) | **No**    | The amount to increase the remaining cooldown by. Can be negative. The remaining cooldown time will not be reduced below zero or increased above the maximum cooldown time.                                                                                                               |
+| ChargeTime        | `Float`<br />(Default: 0.0) | **No**    | The amount to increase the remaining time until the next charge is filled by. Can be negative. The remaining charge time cannot be reduced below zero or increased above the maximum cooldown time. **This will not work on abilities that have a maximum of 1 charge, for some reason.** |
+| Charge            | `Integer`<br />(Default: 0) | **No**    | The amount to increase the number of charges by. Can be negative. The number of charges cannot be reduced below 0 or increased above the maximum.                                                                                                                                         |
+| InterruptRecharge | `Boolean`(Default: false)   | **No**    | If true and `Charge` is not 0, will reset the remaining time to the next charge to the maximum value after changing the charge count.                                                                                                                                                     |
+
+### ResetCooldown
+
+This interaction will trigger a cooldown on the User entity with a specified configuration. The charges will be refilled
+but the cooldown will be immediately triggered.  The mechanisms for deciding on the configuration are a little bit complicated.
+You may specify a cooldown configuration via the `Cooldown` field. If you do not include an `Id` field, then the
+interaction chain's RootInteraction will be used for any field not specified in the configuration. If there is an active
+cooldown under the specified `Id` (or under the RootInteraction's cooldown id if none is specified) then the fields
+from that active cooldown will overwrite data in the RootInteraction's cooldown, but not data in your `Cooldown` field.
+
+**ResetCooldown Fields**
+
+| Field Name | Type                  | Required? | Notes                                                        |
+| ---------- | --------------------- | --------- | ------------------------------------------------------------ |
+| Cooldown   | `InteractionCooldown` | **No**    | A cooldown configuration to use for the new, reset cooldown. |
+
+**InteractionCooldown Fields**
+
+| Field Name        | Type                                 | Required? | Notes                                                                                                                                                                                                 |
+| ----------------- | ------------------------------------ | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Id                | `String`                             | **No**    | The cooldown id to use for this cooldown. If not provided, the RootInteraction's cooldown id will be used, if any.                                                                                    |
+| Cooldown          | `Float`<br />(Default: 0.0)          | **No**    | The duration of the cooldown, in seconds.                                                                                                                                                             |
+| Charges           | `Array`<br />(Element Type: `Float`) | **No**    | If provided, a list of how many charges this cooldown can build, and how long each charge takes to build, in seconds.                                                                                 |
+| InterruptRecharge | `Boolean`<br />(Default: false)      | **No**    | If true, the charge time will be reset when the number of charges changes.                                                                                                                            |
+| ClickBypass       | `Boolean`<br />(Default: false)      | **No**    | If true, RootInteractions keyed to this cooldown can still be activated when it is on cooldown provided that the RootInteraction was triggered by a distinct key or mouse button press on the client. |
+
+### TriggerCooldown
+
+This interaction is similar to ResetCooldown, except instead of refilling the cooldown's charges, one charge will be deducted
+as normal.
+
+**TriggerCooldown Fields**
+
+| Field Name | Type                  | Required? | Notes                                                        |
+| ---------- | --------------------- | --------- | ------------------------------------------------------------ |
+| Cooldown   | `InteractionCooldown` | **No**    | A cooldown configuration to use for the new, reset cooldown. |
+
+**InteractionCooldown Fields**
+
+| Field Name        | Type                                 | Required? | Notes                                                                                                                                                                                                 |
+| ----------------- | ------------------------------------ | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Id                | `String`                             | **No**    | The cooldown id to use for this cooldown. If not provided, the RootInteraction's cooldown id will be used, if any.                                                                                    |
+| Cooldown          | `Float`<br />(Default: 0.0)          | **No**    | The duration of the cooldown, in seconds.                                                                                                                                                             |
+| Charges           | `Array`<br />(Element Type: `Float`) | **No**    | If provided, a list of how many charges this cooldown can build, and how long each charge takes to build, in seconds.                                                                                 |
+| InterruptRecharge | `Boolean`<br />(Default: false)      | **No**    | If true, the charge time will be reset when the number of charges changes.                                                                                                                            |
+| ClickBypass       | `Boolean`<br />(Default: false)      | **No**    | If true, RootInteractions keyed to this cooldown can still be activated when it is on cooldown provided that the RootInteraction was triggered by a distinct key or mouse button press on the client. |
+
+## Combo Chains
+
+Hytale additionally comes with a rich "combo chaining" system, which allows several inputs in a row to result in different
+attacks and special moves.  Rather than being attached to the RootInteraction like the cooldown system, these are
+primarily driven by the `Chaining` interaction.
+
+### Chaining
+
+This interaction does not inherit from SimpleInteraction and therefore has no Failed field. Its Next field works differently
+from most interaction types.
+
+Chaining is a type of flow control interaction- each time a Chaining interaction with the same `ChainId` is called, a single
+interaction in the `Next` list is chosen and the others are ignored. The first time the `ChainId` is used, the first
+interaction in the list is chosen, the next time the second, etc. Once the end of the list is reached, the first
+interaction will be chosen again.
+
+Bear in mind: the progress through the Next list is based on the **ChainId**, not the interaction!  That means that two
+different Chaining interactions can share a single combo chain. You could have a pair of daggers that attacks with
+the left when the left mouse button is clicked and with the right when the right mouse button is clicked.  You could give
+both interaction chains a Chaining interaction with the same `ChainId` and three `Next` entries that do a light-light-heavy
+combo.  Each specific hit would occur with either the left or the right knife based on which button you clicked, but
+the combo would be otherwise identical regardless of which you chose.
+
+The Chaining interaction also has a concept called "flags".  It is possible to attach named flags to a `ChainId` by using
+the ChainFlag interaction.  Then, you specify the flag name in Chaining's `Flags` field. If a Flag is active when the
+Chaining interaction is run, the Flag's interaction will be run instead of the appropriate interaction in `Next`.
+Bear in mind: the entity's progress through the `Next` list still advances, the resulting `Next` interaction is just not
+run.  Only one flag can be active at a time.
+
+Lastly, it is possible to cancel the entity's progress through the combo chain and reset them to the first interaction in
+the list. This can be done with the CancelChain interaction, but it will also happen automatically if the player does
+not trigger an interaction with the ChainId for the specified ChainingAllowance.  When either of these happen, all flags will be
+canceled as well.
+
+All of these effects are triggered on the User entity only. Non-players can use the chaining system, but Flags do not currently
+work for non-players.  This interaction has no special failure conditions.
+
+**Chaining Fields**
+
+| Field Name        | Type                                                       | Required? | Notes                                                                                                                                                                                                                       |
+| ----------------- | ---------------------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| ChainId           | `String`                                                   | **No**    | If provided, acts as a key that multiple Chaining interactions can use to share combo chain progress and flags. If not provided, a unique ChainId will be generated for this interaction.                                   |
+| ChainingAllowance | `Double`<br />(Default: 0.0)                               | **No**    | If, at the time this interaction is triggered, it has been this long in seconds since the last time a Chaining interaction with the same ChainId was executed, all state for this ChainId will be cleared before execution. |
+| Next              | `AssetArray`<br />(Element Type: `Interaction`)            | **Yes**   | A list of interactions to cycle between each time this interaction is run.                                                                                                                                                  |
+| Flags             | `Map`<br />(Key Type: `String`, Value Type: `Interaction`) | **No**    | A map of flag names to interactions to run if the flag is active when this interaction executes.                                                                                                                            |
+
+### CancelChain
+
+This interaction resets all progress and flag data on the User entity for the provided `ChainId`.  The next time a Chaining
+interaction is called for the provided `ChainId`, it will begin at the first interaction in the `Next` list. This
+interaction has no special failure conditions.
+
+**CancelChain Fields**
+
+| Field Name | Type     | Required? | Notes                                 |
+| ---------- | -------- | --------- | ------------------------------------- |
+| ChainId    | `String` | **Yes**   | A ChainId whose data should be reset. |
+
+### ChainFlag
+
+This interaction activates a flag on the User entity for the provided `ChainId`, which can be used to change behavior the
+next time a Chaining interaction with this `ChainId` is run. This will overwrite any flag that has
+already been raised. This interaction will have no effect for non-players. This interaction has no special failure
+conditions.
+
+| Field Name | Type     | Required? | Notes                                        |
+| ---------- | -------- | --------- | -------------------------------------------- |
+| ChainId    | `String` | **Yes**   | A ChainId on whom the flag should be raised. |
+| Flag       | `String` | **Yes**   | The name of the flag to raise.               |
+
+## Charging
+
+A unique flow-control interaction that is frequently used is the Charging interaction.  It is a flow-control interaction
+that delays while the input button used to trigger the interaction chain is held.  When it is released (or the interaction
+is forced to end), the interaction chain can continue with a different interaction based on how long the input was held
+for.
+
+These interactions are all related by either being the Charging interaction, or other interaction types that inherit the
+Charging interaction's behavior.
+
+### Charging
+
+This interaction does not inherit from SimpleInteraction and therefore its Next field works different from most interactions.
+This interaction adds its own Failed field which works the same way that SimpleInteraction's does.
+
+This interaction only works properly when its interaction chain was triggered by a client key or button press (or
+NPC-simulated equivalent). This interaction will continue executing for as long as the key or button press is held (with
+some exceptions, covered below) by the User entity.  Like other interactions, it has a `Next` field indicating which interaction to execute
+after this one, but the field is a map from `Float` values to `Interaction` assets. When this interaction ends, either
+due to the input being released or the charge duration completing, this interaction will determine the largest `Float` key that is less
+than the amount of time in seconds that the interaction was executing for.  The Interaction mapped to that key will be
+executed next.
+
+The interaction includes some cancellation conditions that are specific to this interaction. For instance, the interaction
+has a `CancelOnOtherClick` field that matches the field on RootInteraction. If it is active on this interaction but not
+the RootInteraction, then clicking while charging will cancel this interaction (and execute the `Failed` interaction rather
+than any of the `Next` interactions) but otherwise continue the interaction chain.
+
+Another valuable feature Charging has is the `Forks` field.  For input-triggered interactions that are triggered while the
+Charging interaction is executing, you can add an entry for the relevant InteractionType to this field and instead of
+triggering the usual interaction chain based on held item, targeted block, etc. the RootInteraction specified in the
+`Forks` field will be triggered.  This can unlock rich attack modes and behaviors. For instance, having a shield bash attack
+triggered off left click while blocking, or a special attack that triggers when both mouse buttons are pressed at the
+same time.
+
+There are two modes of operation for the Charging interaction. One is to have the ability charge for as long
+as the input is held and only end execution when the entity releases the input.  Bows in the main Hytale game work
+that way.  That is accomplished by setting `AllowIndefiniteHold` to true.  Another mode of operation is to have the
+interaction complete execution when the execution time has surpassed the largest key value in the `Next` field and
+immediately begin executing the Interaction mapped to that key.  Food in the main Hytale game work like this.  It
+is accomplished by setting `AllowIndefiniteHold` to false.
+
+One pitfall to be careful of when setting `AllowIndefiniteHold` to false is the way it interacts with cooldowns.\
+Normally, input-initiated interaction chains start a 0.35s cooldown on the triggered RootInteraction that prevents
+holding the mouse button from immediately spamming a new interaction when the first one completes.  However, if the
+duration of a Charging interaction is longer than 0.35s, then the cooldown will have already completed when the
+interaction chain finishes, which will often result in a new execution beginning immediately before the player can
+stop pressing the mouse button.  One solution for this problem is to add a `Simple` interaction to the end of your
+interaction chain with a `RunTime` of 0.35s to simulate the cooldown.  Alternatively, you can add a longer cooldown
+(the maximum duration of your Charging interaction plus 0.35s) to the RootInteraction. However, the longer cooldown is
+not always desirable, as the interaction may have ended prematurely, resulting in an unusually long lockout between
+executions.
+
+**Charging Fields**
+
+| Field Name                         | Type                                                                    | Required? | Notes                                                                                                                                                                                                                                                                                                                                                                                       |
+| ---------------------------------- | ----------------------------------------------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| FailOnDamage                       | `Boolean`<br />(Default: false)                                         | **No**    | If true, this interaction will fail and end immediately if the User entity takes any damage while it is executing.                                                                                                                                                                                                                                                                          |
+| CancelOnOtherClick                 | `Boolean`<br />(Default: true)                                          | **No**    | If true, this interaction will fail and end immediately if the User entity sends another button or key press while it is executing.                                                                                                                                                                                                                                                         |
+| Forks                              | `Map`<br />(Key Type: `InteractionType`, Value Type: `RootInteraction`) | **No**    | A map of InteractionType to RootInteraction. If entity input triggers the InteractionType while this interaction is executing, the mapped RootInteraction will be forked into its own interaction chain. This will happen instead of the usual handling for that InteractionType.  This fork will occur even if `CancelOnOtherClick` is set to true.                                        |
+| Failed                             | `Asset`<br />(Asset Type: `Interaction`)                                | **No**    | After this Interaction has finished, "Failed" will be executed if this Interaction failed.                                                                                                                                                                                                                                                                                                  |
+| AllowIndefiniteHold                | `Boolean`<br />(Default: false)                                         | **No**    | If true, this interaction will continue executing for as long as the User entity continues to hold the input. If false, execution will end as soon as the execution time in seconds reaches the largest key value in the `Next` map.                                                                                                                                                        |
+| DisplayProgress                    | `Boolean`<br />(Default: true)                                          | **No**    | If true, players executing this interaction will see a progress bar will be displayed below their cursor indicating how close to reaching the highest key value in `Next` they are.                                                                                                                                                                                                         |
+| Next                               | `Map`<br />(Key Type: `Float`, Value Type: `Interaction`)               | **No**    | A map from `Float` to `Interaction`.  When this interaction successfully finishes executing (either because the input was released or because the maximum duration was reached), this interaction will find the `Float` value with the largest duration in seconds that is less than the amount of time this interaction executed for. That key's mapped Interaction will then be executed. |
+| MouseSensitivityAdjustmentTarget   | `Float`<br />(Default: 1.0)                                             | **No**    | While charging, this mouse sensitivity multiplier will gradually be applied.                                                                                                                                                                                                                                                                                                                |
+| MouseSensitivityAdjustmentDuration | `Float`<br />(Default: 1.0)                                             | **No**    | Duration in seconds. After this many seconds, `MouseSensitivityAdjustmentTarget` will be fully applied to the mouse sensitivity.                                                                                                                                                                                                                                                            |
+| Delay                              | `ChargingDelay`                                                         | **No**    | Settings that allow charging progress to be pushed back when the User entity takes damage.                                                                                                                                                                                                                                                                                                  |
+
+**ChargingDelay Fields**
+
+| Field Name    | Type                        | Required? | Notes                                                                                                                                                                                                                                                                     |
+| ------------- | --------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| MinHealth     | `Float`<br />(Default: 0.0) | **No**    | Damage taken as a percentage of entity health (0.0-1.0). If a hit deals less than this much damage, no pushback will be applied.  If a hit deals exactly this much damage, `MinDelay` seconds worth of pushback will be applied.                                          |
+| MaxHealth     | `Float`<br />(Default: 0.0) | **No**    | Damage taken as a percentage of entity health (0.0-1.0). If a hit deals at least this much damage, `MaxDelay` seconds worth of pushback will be applied.                                                                                                                  |
+| MinDelay      | `Float`<br />(Default: 0)   | **No**    | The amount of pushback, in seconds, to apply if the entity takes a hit that deals `MinHealth` damage. The amount of pushback applied by a hit is a gradiant between `MinDelay` and `MaxDelay` based on the amount of damage between `MinHealth` and `MaxHealth`.          |
+| MaxDelay      | `Float`<br />(Default: 0)   | **No**    | The amount of pushback, in seconds, to apply if the entity takes a hit that deals at least `MaxHealth` damage. The amount of pushback applied by a hit is a gradiant between `MinDelay` and `MaxDelay` based on the amount of damage between `MinHealth` and `MaxHealth`. |
+| MaxTotalDelay | `Float`<br />(Deault: 0)    | **No**    | The maximum amount of pushback the entity can receive over the course of a single charge, regardless of how many times they are hit.                                                                                                                                      |
+
+**InteractionType Values**
+
+- `Primary`
+- `Secondary`
+- `Ability1`
+- `Ability2`
+- `Ability3`
+- `Use`
+- `Pick`
+- `Pickup`
+- `CollisionEnter`
+- `CollisionLeave`
+- `Collision`
+- `EntityStatEffect`
+- `SwapTo`
+- `SwapFrom`
+- `Death`
+- `Wielding`
+- `ProjectileSpawn`
+- `ProjectileHit`
+- `ProjectileMiss`
+- `ProjectileBounce`
+- `Held`
+- `HeldOffhand`
+- `Equipped`
+- `Dodge`
+- `GameModeSwap`
+
+### Wielding
+
+This interaction is inherited from Charging rather than SimpleInteraction.  However, its `Failed` and `Next` fields function
+identically to SimpleInteraction.  It does not inherit all fields from Charging, so be sure to pay close attention to
+the field list below.
+
+This interaction drives most blocking behavior in the game. While this interaction is executing, attacks made against
+the Owner entity will (conditionally) trigger effects defined in this interaction.  Unlike the Charging interaction,
+this interaction can always execute indefinitely and will only end when it fails or when the input is released.
+
+One option available in Wielding is `AngledWielding`, which allows damage and knockback modifiers to only be applied
+depending on the direction the attack against the Owner entity is coming from.  The AngledWielding type has a
+field `Angle` which determines which direction the protection points relative to the player (0 is the player's
+front), and `AngleDistance` which determines how wide the cone of protection extends around the player.  Block effects
+from this interaction (such as `BlockedEffects`, `BlockedInteractions`, and `StaminaCost`) will only apply if
+the DamageCause matches `DamageModifiers` OR if the DamageCause matches `AngledWielding.DamageModifiers` and
+the source of the damage matches `Angle` and `AngleDistance`.  It is possible for damage and knockback multipliers
+specified on both this interaction's modifier fields and `AngledWielding`'s modifier fields to stack, if both
+have entries for the same DamageCause.
+
+This interaction will only have an effect on damage taken by one of the DamageCause entries in `DamageModifiers` or
+`AngledWielding.DamageModifiers`.  If a DamageCause is in `DamageModifiers`, then the block effect will be triggered
+and the damage modifier applied regardless of what direction the Owner entity is attacked from.  If a DamageCause is in
+`AngledWielding.DamageModifiers`, then the damage modifier is only applied if the
+
+\*\* Wielding Fields\*\*
+
+| Field Name          | Type                                                                    | Required? | Notes                                                                                                                                                                                                                                                                                                                                                                                                      |
+| ------------------- | ----------------------------------------------------------------------- | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| FailOnDamage        | `Boolean`<br />(Default: false)                                         | **No**    | If true, this interaction will fail and end immediately if the User entity takes any damage while it is executing.                                                                                                                                                                                                                                                                                         |
+| CancelOnOtherClick  | `Boolean`<br />(Default: true)                                          | **No**    | If true, this interaction will fail and end immediately if the User entity sends another button or key press while it is executing.                                                                                                                                                                                                                                                                        |
+| Forks               | `Map`<br />(Key Type: `InteractionType`, Value Type: `RootInteraction`) | **No**    | A map of InteractionType to RootInteraction. If entity input triggers the InteractionType while this interaction is executing, the mapped RootInteraction will be forked into its own interaction chain. This will happen instead of the usual handling for that InteractionType.  This fork will occur even if `CancelOnOtherClick` is set to true (after which this interaction chain will be canceled). |
+| Next                | `Asset`<br />(Asset Type: `Interaction`)                                | **No**    | After this interaction has finished, "Next" will be executed if this interaction did not fail.                                                                                                                                                                                                                                                                                                             |
+| Failed              | `Asset`<br />(Asset Type: `Interaction`)                                | **No**    | After this interaction has finished, "Failed" will be executed if this interaction failed.                                                                                                                                                                                                                                                                                                                 |
+| DamageModifiers     | `Map`<br />(Key Type: `DamageCause`, Value Type: `Float`)               | **No**    | A map from DamageCause to Float, where the Float is multiplied against any damage received from the mapped DamageCause while this interaction is executing.                                                                                                                                                                                                                                                |
+| KnockbackModifiers  | `Map`<br />(Key Type: `DamageCause`, Value Type: `Float`)               | **No**    | A map from DamageCause to Float, where the Float is multiplied against any knockback force received from the mapped DamageCause while this interaction is executing.                                                                                                                                                                                                                                       |
+| AngledWielding      | `AngledWielding`                                                        | **No**    | Configuration to only trigger block effects from certain angles.                                                                                                                                                                                                                                                                                                                                           |
+| StaminaCost         | `StaminaCost`                                                           | **No**    | If the Owner entity receives damage that matches `DamageModifiers` or `AngledWielding` while this interaction is executing, then the entity's stamina will be deducted according to this configuration.                                                                                                                                                                                                    |
+| BlockedEffects      | `DamageEffects`                                                         | **No**    | If the Owner entity receives damage that matches `DamageModifiers` or `AngledWielding` while this interaction is executing, then these effects will be applied to the instance of damage.                                                                                                                                                                                                                  |
+| BlockedInteractions | `Asset`<br />(Asset Type: `RootInteraction`)                            | **No**    | If the Owner entity receives damage that matches `DamageModifiers` or `AngledWielding` while this interaction is executing, then this RootInteraction will be launched as a brand new interaction chain with the Owner entity as both Owner and User, and the attacker as the Target entity.  This new interaction chain is, notably, brand new, **not** forked from the current one.                      |
+
+**AngledWielding Fields**
+
+| Field Name         | Type                                                      | Required? | Notes                                                                                                                                                                                                            |
+| ------------------ | --------------------------------------------------------- | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Angle              | `Float`<br />(Default: 0.0)                               | **No**    | Angle in degrees relative to the Owner entity where the angled protection is centered. 0.0 means pointed towards the front of the Owner entity.                                                                  |
+| AngleDistance      | `Float`<br />(Default: 0.0)                               | **No**    | Angle in degrees indicating how wide the cone of protection is.                                                                                                                                                  |
+| DamageModifiers    | `Map`<br />(Key Type: `DamageCause`, Value Type: `Float`) | **No**    | A map from DamageCause to Float, where the Float is multiplied against any damage received from the mapped DamageCause received from within the cone of protection while this interaction is executing.          |
+| KnockbackModifiers | `Map`<br />(Key Type: `DamageCause`, Value Type: `Float`) | **No**    | A map from DamageCause to Float, where the Float is multiplied against any knockback force received from the mapped DamageCause received from within the cone of protection while this interaction is executing. |
+
+**StaminaCost Fields**
+
+| Field Name | Type                                             | Required? | Notes                                                                                                                                                                                                                                                |
+| ---------- | ------------------------------------------------ | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| CostType   | `CostType`<br />(Default: `MaxHealthPercentage`) | **No**    | How to calculate stamina consumed by blocking from the raw pre-block damage. If `Damage`, then the stamina consumed will be `rawDamage / Value`. If `MaxHealthPercentage`, then the stamina consumed will be `rawDamage / (EntityMaxHealth * Value)` |
+| Value      | `Float`<br />(Default: 0.04)                     | **No**    | The value to use in the `CostType` formula.                                                                                                                                                                                                          |
+
+**DamageEffects Fields**
+
+| Field Name             | Type                                         | Required? | Notes                                                                           |
+| ---------------------- | -------------------------------------------- | --------- | ------------------------------------------------------------------------------- |
+| ModelParticles         | `Array`<br />(Element Type: `ModelParticle`) | **No**    | Particle systems to trigger in the first-person view.                           |
+| WorldParticles         | `Array`<br />(Element Type: `WorldParticle`) | **No**    | Particle systems to trigger in the third-person view.                           |
+| LocalSoundEventId      | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | 2D sound to play locally to the attacking entity if they are a player.          |
+| WorldSoundEventId      | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | Sound to play in the world at the Owner entity's location.                      |
+| PlayerSoundEventId     | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | 2D sound to play locally to the Owner entity if they are a player.              |
+| ViewDistance           | `Double`<br />(Default: 75.0)                | **No**    | Distance at which these effects should play for other players.                  |
+| Knockback              | `Knockback`                                  | **No**    | The properties of the knockback that will be applied.                           |
+| CameraEffect           | `Asset`<br />(Asset Type: `CameraEffect`)    | **No**    | CameraEffect to briefly apply locally to the Owner entity if they are a player. |
+| StaminaDrainMultiplier | `Float`<br />(Default: 1.0)                  | **No**    | This multiplier is applied to the `StaminaCost`, if any.                        |
+
+**Knockback Fields**
+
+| Field Name     | Type                                       | Required? | Notes                                                                                                                      |
+| -------------- | ------------------------------------------ | --------- | -------------------------------------------------------------------------------------------------------------------------- |
+| Type           | `String`                                   | **No**    | If provided, specifies a type of knockback to use. Each knockback type may come with additional fields.                    |
+| Force          | `Double`<br />(Default: 0.0)               | **No**    | The amount of force to apply to the Owner entity.                                                                          |
+| Duration       | `Double`<br />(Default: 0.0)               | **No**    | If 0.0, apply the force as a single impulse.  If more, continuously apply the force over a period of time.                 |
+| VelocityType   | `ChangeVelocityType`<br />(Default: `Add`) | **No**    | How to apply the force, either adding it to the entity's current velocity, or setting the velocity to the knockback force. |
+| VelocityConfig | `VelocityConfig`                           | **No**    | Characteristics of friction as the Owner entity is thrown by this knockback.                                               |
+
+**Knockback Type: Force**
+
+Apply the calculated knockback force along the provided direction.
+
+| Field Name | Type                         | Required? | Notes                                                                                |
+| ---------- | ---------------------------- | --------- | ------------------------------------------------------------------------------------ |
+| Direction  | `Vector3`<br />(Default: Up) | **No**    | Which direction the player should be flung, relative to the direction of the attack. |
+
+**Knockback Type: Point**
+
+Apply the calculated knockback force laterally along the XZ plane, plus provided Y velocity.
+
+| Field Name | Type                        | Required? | Notes                                                                                                   |
+| ---------- | --------------------------- | --------- | ------------------------------------------------------------------------------------------------------- |
+| OffsetX    | `Integer`<br />(Default: 0) | **No**    | Offset the source position of the knockback left or right perpendicular to the direction of the attack. |
+| OffsetZ    | `Integer`<br />(Default: 0) | **No**    | Offset the source position of the knockback, forward or backward along the directon of the attack.      |
+| RotateY    | `Integer`<br />(Default: 0) | **No**    | Rotate the knockback direction around the Y axis, where 0 is the default attack direction.              |
+| VelocityY  | `Float`<br />(Default: 0.0) | **No**    | Add vertical velocity to the knockback force after the direction and force has been calculated.         |
+
+**Knockback Type: Directional**
+
+Apply the calculated knockback force along the attack direction, removing any vertical component and replacing it with a provided Y velocity.
+
+| Field Name | Type                      | Required? | Notes                                                                                                                                            |
+| ---------- | ------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------ |
+| RelativeX  | `Float`<br />(Default: 0) | **No**    | Apply additional force left or right perpendicular to the direction of the attack. The additional force is multiplied by the knockback strength. |
+| RelativeZ  | `Float`<br />(Default: 0) | **No**    | Apply additional force forward or backward along the attack direction. The additional force is multiplied by the knockback strength.             |
+| VelocityY  | `Float`<br />(Default: 0) | **No**    | Replace the vertical velocity of the knockback with this value.  This value is not multiplied by knockback strength.                             |
+
+**VelocityConfig Fields**
+
+| Field Name          | Type                                              | Required? | Notes                                                                                                                                                                                           |
+| ------------------- | ------------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| GroundResistance    | `Float`<br />(Default: 0.82)                      | **No**    | The minimum amount of friction applied when the entity is in contact with the ground.  1.0 = no friction, 0.0 = total friction                                                                  |
+| GroundResistanceMax | `Float`<br />(Default: 0.0)                       | **No**    | The maximum amount of friction applied when the entity is in contact with the ground.  1.0 = no friction, 0.0 = total friction                                                                  |
+| AirResistance       | `Float`<br />(Default: 0.96)                      | **No**    | The minimum amount of friction applied when the entity is in the air. 1.0 = no friction, 0.0 = total friction                                                                                   |
+| AirResistanceMax    | `Float`<br />(Default: 0.0)                       | **No**    | The maximum amount of friction applied when the entity is in the air. 1.0 = no friction, 0.0 = total friction                                                                                   |
+| Threshold           | `Float`<br />(Default: 1.0)                       | **No**    | The speed at which the maximum amount of friction will be applied to the entity. The amount of friction applied will increase from minimum to maximum as the entity moves from 0 to this speed. |
+| Style               | `VelocityThresholdStyle`<br />(Default: `Linear`) | **No**    | The curve that friction follows as the entity's speed increases toward the `Threshold`.                                                                                                         |
+
+**CostType Values**
+
+- `MaxHealthPercentage`
+- `Damage`
+
+**ChangeVelocityType Values**
+
+- `Add`
+- `Set`
+
+**VelocityThresholdStyle Values**
+
+- `Linear`
+- `Exp`
+
+## Blocks
+
+These are interaction types meant to reason about and modify blocks in the world.  The most important concept unique
+to these interactions is the Block Target.  Like the Entity Target, it is mutable and can come from many places.
+However, for interaction chains initiated by the client, the block target will initially be the block that the player's cursor was
+over, if any.
+
+Additionally, for interaction chains initiated by the client, the client will send along which face of the block is targeted,
+which is used by a few block-related interactions.
+It is left up to each interaction type that cares about block faces as to how to handle this behavior for simulated input
+(i.e. NPCs initiating chains that are normally initated by the client).  At the time of this writing, all block-related
+interactions choose the top face where relevant in simulated input.
+
+### BlockCondition
+
+This interaction has a field `Matchers` which specifies certain conditions, such as block type, state, etc.  This
+interaction fails if the current target block does not match all of them.
+
+**BlockCondition Fields**
+
+| Field Name       | Type                                        | Required? | Notes                                                                                                                                                                                                                                                                                                                                   |
+| ---------------- | ------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false)             | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction.                                                                                                                                                                                                       |
+| Matchers         | `Array`<br />(Element Type: `BlockMatcher`) | **Yes**   | A list of conditions that the target block must match or this condition will fail.<br />**Note: This field is technically not required but there is a bug that makes it dangerous to not provide at the time of this writing.**<br />**Note: If no conditions are added to this array, the interaction will fail, counterintuitively.** |
+
+**BlockMatcher Fields**
+
+| Field Name | Type                       | Required? | Notes                                                                          |
+| ---------- | -------------------------- | --------- | ------------------------------------------------------------------------------ |
+| Block      | `BlockIdMatcher`           | **No**    | If provided, requires the block itself match some set of conditions.           |
+| Face       | `BlockFace`                | **No**    | If provided and not 'None', requires a specific block face be targeted.        |
+| StaticFace | `Boolean` (Default: false) | **No**    | If false, the face condition will be adjusted by the block's current rotation. |
+
+**BlockFace Values**
+
+- `Up`
+- `Down`
+- `North`
+- `South`
+- `East`
+- `West`
+- `None`
+
+**BlockIdMatcher Fields**
+
+| Field Name | Type                                   | Required? | Notes                                                                      |
+| ---------- | -------------------------------------- | --------- | -------------------------------------------------------------------------- |
+| Id         | `Asset`<br />(Asset Type: `BlockType`) | **No**    | If provided, the block must match the specified `BlockType`.               |
+| State      | `String`                               | **No**    | If provided, the block's current state must match the provided state name. |
+| Tag        | `String`                               | **No**    | If provided, the block type's asset tags must contain the provided tag.    |
+
+### DestroyCondition
+
+This interaction fails if the current User entity cannot destroy the current target blcok.
+
+**DestroyCondition Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+
+### PlacementCountCondition
+
+This interaction accepts the name of a BlockType that has the TrackedPlacement BlockEntity. The interaction will fail if the number of
+blocks of the provided BlockType in the world do not match the provided condition.
+
+**PlacementCountCondition Fields**
+
+| Field Name | Type                           | Required? | Notes                                                                                                                                                                                                                                                           |
+| ---------- | ------------------------------ | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Block      | `String`                       | **Yes**   | The BlockType to examine. The number of instances of the BlockType in the world will be compared to Value.<br />**Note: The specified BlockType must have the TrackedPlacement BlockEntity. Otherwise, the number of blocks in the world will always be zero.** |
+| Value      | `Integer`<br />(Default: 0)    | **No**    | The value to compare the number of blocks in the world with.                                                                                                                                                                                                    |
+| LessThan   | \`Boolean<br />(Default: true) | **No**    | If true, the interaction will fail if the number of blocks in the world is greater than or equal to Value. If false, the interaction will fail if the number of blocks in the world is less than or equal to Value.                                             |
+
+### BreakBlock
+
+This interaction attempts to break the target block while acting as the User entity. The User entity must be a player. It
+is not guaranteed to work, depending on world settings and the User entity's current state, it may not work.  If it
+fails, it will fail the interaction under some circumstances, but not others.
+
+**Note: In particular, if `Harvest`=false and the player is in Survival mode, the player will simply execute a damage operation
+against the block. Even when the Tool field is specified, the player's currently-held item can impact the results in unintuitive
+ways.**
+
+This interaction will fail if there is no block target, if `Harvest`=true and the
+block is not harvestable, or if the world settings prevent the Harvest/Break operation.
+It will generally not fail otherwise, even if the block was not broken or damaged.
+The block will generally break every time if `Harvest`=true or the player is in
+Creative mode.
+
+**BreakBlock Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                                                                                                                                                                                                  |
+| ---------------- | ------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction.                                                                                                                                                                      |
+| Harvest          | `Boolean` (Default: false)      | **No**    | If true, harvest the block and deposit the drops in the player's inventory. This operation will generally always succeed.  If false, this interaction will effectively perform whatever action would have occurred if the player had left-clicked the block.                                           |
+| Tool             | `String`                        | **No**    | If `Harvest`=true, the player is in Survival mode, and this field is provided, then the break operation will be performed as though with this tool type.<br />**This field mostly doesn't work.  Your held item will be used for most block damage calculations regardless of this field's contents.** |
+| MatchTool        | `Boolean` (Default: false)      | **No**    | If true, `Harvest`=true, the player is in Survival mode, and `Tool` is provided, block breaking will be prevented unless `Tool` is a valid gathering tool for the target block. The interaction will not be failed, even if block breaking is prevented in this manner.                                |
+
+### ChangeBlock
+
+This interaction requires a mapping from one or more current BlockTypes to one or more target BlockTypes.  If the
+target block is one of the key BlockTypes, then it will be changed to the mapped target BlockType.  If the current
+BlockType of the target block does not appear as a key in the Changes field, then this interaction fails.
+
+**ChangeBlock Fields**
+
+| Field Name        | Type                                                        | Required? | Notes                                                                                                                             |
+| ----------------- | ----------------------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget  | `Boolean`<br />(Default: false)                             | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+| Changes           | `Map`<br />(Key Type: `BlockType`, Value Type: `BlockType`) | **No**    | A list of potential block type changes, with each entry having a current and new BlockType id.                                    |
+| WorldSoundEventId | `Asset`<br />(Asset Type: `SoundEvent`)                     | **No**    | If provided, this SoundEvent is played in the world at the position of the block if the block successfully changes.               |
+| RequireNotBroken  | `Boolean`<br />(Default: false)                             | **No**    | If true, this interaction will fail if the player's held item is broken (durability 0), and the block change will not take place. |
+
+### ChangeState
+
+This interaction requires a mapping from one or more current block state names to one or more state names. If the
+target block is in one of the key block states, then it will be changed to the mapped target blocks tate. If the
+current block state of the target block does nto appear as a key in the Changes field, then this interaction fails.
+
+All blocks start out with a null state by default.  This null state can be referenced by the key "default" and the block
+can be returned to that state with the value "default".
+
+**ChangeState Fields**
+
+| Field Name       | Type                                                  | Required? | Notes                                                                                                                                          |
+| ---------------- | ----------------------------------------------------- | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false)                       | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction.              |
+| Changes          | `Map`<br />(Key Type: `String`, Value Type: `String`) | **No**    | A list of potential block state changes, with each entry having a current and new state name.                                                  |
+| UpdateBlockState | `Boolean`<br />(Default: false)                       | **No**    | If true, performs a full refresh of the block's BlockEntity component and notifies nearby players as though a full block type change occurred. |
+
+### CycleBlockGroup
+
+This interaction will attempt to change the target block to the next block type in one of the BlockGroups it belongs to.
+If the block type belongs to multiple BlockGroups, which one is used is effectively arbitrary. The User entity must be
+a player. If the block cannot be changed for any reason (entity not a player, no block target, block does not belong
+to a BlockGroup, etc.). If the block is the only entry in the BlockGroup, this interaction will succeed and the block
+will be considered changed despite nothing happening.  Unlike most other block-changing interactions, this one will
+fail if the world settings prevent players from breaking blocks.
+
+**This interaction always reduces the player's held item's durability by a single 'hit' worth of damage if the block
+changes. There is no way to prevent it. The block type will change and the interaction will succeed even if the player's
+held item is broken, however.**
+
+**CycleBlockGroup Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+
+### DestroyBlock
+
+This interaction destroys the target block without dropping anything.  It will successfully destroy the block if the
+target block exists and this interaction has no failure conditions.
+
+**This interaction has no additional fields.**
+
+### PickBlock
+
+This interaction is effectively equivalent to using the middle mouse button in creative mode. In survival mode, the
+block's item will be moved to the user's current active hotbar slot if it is in the player's inventory.  This
+interaction is performed entirely on the client and cannot be performed by non-players.  It is unclear if this
+interaction has failure conditions.
+
+**PickBlock Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+
+### PlaceBlock
+
+This interaction is effectively identical to a right clicking while holding a block in their hand, with some
+additional options. For one, it can be executed with any LivingEntity as the User entity. For another, it has some
+useful fields.  For the most part, though, it follows the same behaviors and rules as any ordinary block placement
+by a player.
+
+It's not clear under what circumstances this interaction can fail. The server will not fail the interaction under any
+special circumstances (including when there is no target block, or when `BlockTypeToPlace` is not provided and the
+LivingEntity is not holding a block). However, the client is very involved with the function of this interaction and
+its behavior is unknown.
+
+**PlaceBlock Fields**
+
+| Field Name         | Type                                   | Required? | Notes                                                                                                                                                                                                                                                                                                                                                           |
+| ------------------ | -------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| BlockTypeToPlace   | `Asset`<br />(Asset Type: `BlockType`) | **No**    | If provided, the block placed by this interaction will be the specified BlockType. If not provided, the User entity's held item will be used, instead, if it is a block.                                                                                                                                                                                        |
+| RemoveItemInHand   | `Boolean`<br />(Default: True)         | **No**    | If true and the User entity is not a player in Creative mode, the item in the player's hand must match the block being placed and one quantity will be removed for each block placed. If the item does not match, the block cannot be placed.  If false, the player's hand item is ignored entirely.\*\*                                                        |
+| AllowDragPlacement | `Boolean`<br />(Default: True)         | **No**    | If true and the interaction was triggered on the client by a player, then the player can hold the input that was used to activate this interaction chain and move the mouse around in order to execute this interaction repeatedly and place several blocks. The interaction chain will not move onto the next interaction until the player releases the input. |
+
+### RunOnBlockTypes
+
+This interaction retrieves all blocks within a provided radius of the User entity. For each block that matches any of
+the provided BlockSets, a new interaction chain will be forked that uses the matching block as the target block.
+This interaction will continue executing until all forked interaction chains have completed.  The interaction will fail if no
+blocks within the radius match the provided BlockSets or if all of the forked interaction chains fail.
+
+**RunOnBlockTypes Fields**
+
+| Field Name   | Type                                         | Required?        | Notes                                                                                                                                                                                                                                                                                      |
+| ------------ | -------------------------------------------- | ---------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| Range        | `Integer`                                    | **Yes**          | The spherical radius around the User entity to search for blocks. Must be at least 1.                                                                                                                                                                                                      |
+| BlockSets    | `AssetArray`<br />(Element Type: `BlockSet`) | **No**           | A list of BlockSets to match nearby blocks again. Only blocks that match any of the BlockSets will have interaction chains forked for them.                                                                                                                                                |
+| MaxCount     | `Integer`                                    | **Yes**          | The maximum number of blocks that will be located with the search. Further blocks will be ignored. If there are more matching blocks within the radius than this number, the specific set of blocks that will be found is completely arbitrary and may change from execution to execution. |
+| Interactions | `Asset`<br />(Asset Type: `RootInteraction`) | **No, but yes.** | The RootInteraction that will be forked for each matching block.  This interaction will not fail to validate if it is missing, but every execution of this interaction will fail.                                                                                                          |
+
+### UseBlock
+
+If the target block has an interaction for this interaction chain's interaction type, execute it immediately as part of
+this interaction chain. The execution will be wrapped in UseBlockEvent.Pre and UseBlockEvent.Post events, and cancellations
+of the UserBlockEvent.Pre event are respected. The User entity is considered the triggering entity for both events.
+
+If the target block does not have an interaction for this interaction chain's interaction type, this interaction fails.
+
+**This interaction has no additional fields.**
+
+## Items
+
+These are interactions intended to interface with an entity's inventory. There is no concept of an "item target",
+unfortunately, so these generally either interact with the entity's held item or the entity's inventory at a high level.
+
+### AddItem
+
+Adds a specified quantity of a specified item to the User entity's inventory, preferring to add it to the
+entity's hotbar where possible. This interaction will have no effect on User entities that are not LivingEntities.
+This interaction has no failure states.
+
+**Note: This interaction has a bug in its field validators that will cause interactions that reference items declared
+in the same mod to fail validation on startup.  Additionally, this interaction has a bug that will cause it to
+fail and have no effect if the User entity has no block target. Use ModifyInventory instead.**
+
+**AddItem Fields**
+
+| Field Name       | Type                              | Required? | Notes                                                                                                                             |
+| ---------------- | --------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false)   | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+| ItemId           | `Asset`<br />(Asset Type: `Item`) | **Yes**   | The item id of the item to add to the player's inventory.                                                                         |
+| Quantity         | `Integer`<br />(Default: 0)       | **No**    | The quantity of the item to add to the player's inventory.                                                                        |
+
+### CheckUniqueItemUsage
+
+This interaction will check whether it has run once for the User entity with their currently-held item before. If it hasn't,
+it will succeed. If it has, it will fail. It will also fail if the User entity is not a player. The interaction will record
+the item id of the User entity's currently-held item on success, ensuring it cannot be successfully run with that player
+and item id combination again.
+
+**This interaction has no additional fields.**
+
+### ChangeActiveSlot
+
+This interaction does not inherit from SimpleInteraction and therefore has no Next or Failed fields.  The `CancelOnItemChange`
+field is ignored for this interaction and is always treated as false. This interaction will set the User entity's currently-
+active hotbar slot to the specified slot index. If none is specified, the interaction chain's target slot will be used,
+if any. Otherwise, slot 0 will be used.  If a slot is specified and it is already active, then this interaction will
+have no effect, but if no slot is specified and the interaction chain's target slot is already active, the logic in
+the next paragraph will still be executed. This interaction will also have no effect if the User entity is not a
+LivingEntity.
+
+Once the slot has changed, a new SwapTo interaction chain will be forked off for the selected slot.
+If a target slot was specified, then the interaction chain's current target slot will be set to the specified slot, as will
+the forked SwapTo interaction chain. If this interaction chain was initiated by a player swapping an item into or out of
+an occupied active hotbar slot, then the swap will be executed after the slot is changed and before the SwapTo
+interaction is forked. Not running this interaction in the resulting SwapFrom interaction chain is a way for the server
+to cancel players performing these sorts of swap interactions. The default behavior for these swap interactions is that
+the SwapFrom interaction chain will be initiated with the currently-active-slot as the target slot. As a result, the
+target slot will usually not change when this interaction runs, it merely exists as a signal for the server to continue the
+item swap.
+
+**ChangeActiveSlot Fields**
+
+| Field Name | Type      | Required? | Notes                                                                                                                                                                                                     |
+| ---------- | --------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| TargetSlot | `Integer` | **No**    | If not provided, indicates the slot the player's active hotbar slot should be changed to.  Otherwise, the interaction chain's target slot will be used (which is usually the already-active hotbar slot). |
+
+### EquipItem
+
+This interaction will equip the User entity's currently-held item into the appropriate armor slot, if it is armor. The
+interaction will fail if the item is armor but it cannot be equipped for some reason. The interaction will succeed but
+take no action if the User entity cannot equip armor or if the item is not armor.
+
+**This interaction has no additional fields.**
+
+### IncreaseBackpackCapacity
+
+This interaction will increase the User entity's backpack size by the provided amount.  **It will additionally remove one
+quantity from the player's currently-held item. There is no way to prevent this.**  This interaction will have no effect
+if the User entity is not a player.  This interaction has no special failure conditions, even if the User entity
+is not a player, or the player is not currently holding an item.
+
+| Field Name | Type                        | Required? | Notes                                                                                   |
+| ---------- | --------------------------- | --------- | --------------------------------------------------------------------------------------- |
+| Capacity   | `Integer`<br />(Default: 1) | **No**    | The additional backpack capacity to add to the player. **Must be between 1 and 32767.** |
+
+### ModifyInventory
+
+This interaction attempts to perform one or more inventory-modifying actions against the User entity. The User entity must
+be a player. If they are not, no actions will be performed, but the interaction will not fail. Any item removals performed
+by this interaction, either as a result of `ItemToRemove` or `AdjustHeldItemQuantity`, are both atomic (meaning the entire
+quantity must be removed, or none) and required (meaning that the interaction will fail and no further actions taken if
+the removal fails for any reason).  Item additions performed by this interaction, either as a result of `ItemToAdd` or
+`AdjustHeldItemQuantity` will drop excess items on the ground near the player if necesary and continue on.
+
+This interaction first executes the item removal in `ItemToRemove`, if any, then adjusts the held item as specified by
+`AdjustHeldItemQuantity`, if provided, then executes the item addition in `ItemToAdd`, if any, and then finally executes
+the damage/healing of the held item in `AdjustHeldItemDurability`, if provided.
+
+**ModifyDurability Fields**
+
+| Field Name               | Type                            | Required? | Notes                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
+| ------------------------ | ------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| RequiredGameMode         | `GameMode`                      | **No**    | If provided, only execute the inventory-modifying actions if the player is in the provided GameMode. The interaction will not fail if the GameMode doesn't match.                                                                                                                                                                                                                                                                                                                                                                               |
+| ItemToRemove             | `ItemStack`                     | **No**    | If provided, a matching item will be removed in the provided quantity. If there is no matching item in the player inventory in the required quantity, then the interaction will fail and further actions will not be executed.                                                                                                                                                                                                                                                                                                                  |
+| AdjustHeldItemQuantity   | `Integer`<br />(Default: 0)     | **No**    | The player's held item, if any, will have its quantity will be modified by the provided amount- subtracted from if this number is negative or added to if this item is positive.  If the player has no held item, then this field will have no effect regardless of its value and the interaction will NOT fail.  If the player's inventory does not have sufficient quantity of items to support the removal, this interaction will fail and further actions will not be executed. Excess items will be dropped on the ground near the player. |
+| ItemToAdd                | `ItemStack`                     | **No**    | If provided, the ItemStack will be added to the player's inventory. Excess items will be dropped on the ground near the player.                                                                                                                                                                                                                                                                                                                                                                                                                 |
+| AdjustHeldItemDurability | `Double`<br />(Default: 0.0)    | **No**    | The player's held item, if any, will have its durability adjusted by the specified amount.  The durability cannot go below 0 or raise above the item's maximum durability. Invalid durability values in this field will not cause the interaction to fail. Neither will it fail if the player has no held item.                                                                                                                                                                                                                                 |
+| BrokenItem               | `String`                        | **No**    | This field should contain an ItemId, but it is not validated by the server on startup, so be careful.  This field can have the value of "Empty" to specify no item, or an empty hand. If specified and the `AdjustHeldItemDurability` operation reduces the player's held item to 0 durability, the player's held item is changed to this ItemId. If the inventory replacement fails, this interaction will fail.                                                                                                                               |
+| NotifyOnBreak            | `Boolean`<br />(Default: false) | **No**    | If true and the `AdjustHeldItemDurability` operation reduces the player's held item to 0 durability, this interaction will perform the usual audiovisual feedback of a broken tool. It will play the usual tool breaking sound and send the player a text message in chat that their item has broken.                                                                                                                                                                                                                                           |
+| NotifyOnBreakMessage     | `String`                        | **No**    | If provided, and `NotifyOnBreak` is true, when the player is notified of a broken tool by this interaction, the message sent to their chat will instead be the translation key specified by this field. The translation key supports the templating parameter `{itemName}`. See the translation key `server.general.repair.itemBroken_Hoe` for an example.                                                                                                                                                                                      |
+
+**GameMode Values**
+
+- `Creative`: The game is currently in Creative Mode
+- `Adventure`: The game is currently in Adventure Mode
+
+**ItemStack Fields**
+
+| Field Name                   | Type                              | Required? | Notes                                                                                |
+| ---------------------------- | --------------------------------- | --------- | ------------------------------------------------------------------------------------ |
+| Id                           | `Asset`<br />(Asset Type: `Item`) | **Yes**   | The id of the Item asset this stack contains.                                        |
+| Quantity                     | `Integer`<br />(Default: 1)       | **No**    | The number of items in this stack.<br />**Must be greater than 0.**                  |
+| Durability                   | `Double`<br />(Default: 0.0)      | **No**    | The durability of the item stack.<br />**Cannot be negative.**                       |
+| MaxDurability                | `Double`<br />(Default: 0.0)      | **No**    | The maximum durability of the item this stack contains.<br />**Cannot be negative.** |
+| Metadata                     | `Bson Document`                   | **No**    | If provided, applies the bson to the item stack metadata.                            |
+| OverrideDroppedItemAnimation | `Boolean`\*(Default: false)       | **No**    | ???                                                                                  |
+
+### PickupItem
+
+This interaction will attempt to pick up the User entity's current target entity and add it to their inventory. It will
+fail if the User entity is not a player, if they do not have a target entity, or if the target entity is not an item
+located in the world.  It will not fail if the player simply cannot pick up the item.
+
+**This interaction has no additional fields.**
+
+### RefillContainer
+
+This interaction will fail if the User entity is not a player. The interaction will draw a ray from the player's head
+down their look direction until the edge of the player's held item's interaction range or until the first solid block.
+The nearest fluid block of a type listed in this interaction's `States` map will result in the one of the player's
+currently-held items being converted to the fluid's related item state.  If the `States` map indicates a durability
+for the new item state, then the converted item will use that durability. If the item is already in the fluid's related
+item state, then this interaction will fail if the player's held item is already at maximum durability (unless the
+`States` map indicates a durability value greater than the item's maximum, in which case the interaction will succeed
+but the item will not change).  Otherwise, the durability listed for the fluid in the `States` map will be added to the
+item's current durability.
+
+If the interaction has not failed by this point, the fluid block in the world may be transformed to a different type if one is listed
+in the `States` map.
+
+If any part of this process does not proceed for any reason (for instance, if the player is not holding an item),
+then this interaction will fail.
+
+**RefillContainer Fields**
+
+| Field Name | Type                                                       | Required? | Notes                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| ---------- | ---------------------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| States     | `Map`<br />(Key Type: `String`, Value Type: `RefillState`) | **Yes**   | A map from item state names to `RefillState` objects, which contain information such as acceptable fluid block types, durability increases, and what fluid type to convert the targeted fluid block to after refill, if any. If the player targets a fluid block that matches one of the fluid types in the `RefillState`, the item will be converted to the keyed item state and the `RefillState` will be used to decide what happens next. |
+
+**RefillState Fields**
+
+| Field Name     | Type                                  | Required? | Notes                                                                                                                                                                                                                                                                                                                           |
+| -------------- | ------------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| AllowedFluids  | `Array`<br />(Element Type: `String`) | **Yes**   | If any of these fluids are targeted by the player, the player's held item will be converted to the keyed item state and `Durability` and `TransformFluid` will be used.                                                                                                                                                         |
+| Durability     | `Double`<br />(Default: -1.0)         | **No**    | If the player's held item changes item states, this value is the new item's durability, unless it is negative, in which case the item will begin at full durability. If the player's held item is already in the item state, and the item is not already at full durability, this value will be added to the item's durability. |
+| TransformFluid | `String`                              | **No**    | If provided, this field is a fluid id that the targeted fluid block should be transformed to if the player's held item is successfully updated.                                                                                                                                                                                 |
+
+## Entities
+
+### DamageEntity
+
+This interaction does not inherit from SimpleInteraction, but adds its own Next and Failed fields that
+work similarly.
+
+This interaction will cause the User entity to damage the Target entity.  It has the capability to apply different
+damage based on the direction of the attack or what body part was targeted by the User entity, with each possibility
+providing different damage calculations, effects, and Next interaction. If multiple entires match the attack, `TargetedDamage`
+(body part damage) takes highest priority, then the first matching `AngledDamage` in the list, then the default
+damage in the base interaction fields.  It is possible for elements of these different damage priorities to be taken peacemeal if higher-priority
+damage fields do not overwrite lower-priority damage fields. For instance,
+damage calculation could be taken from `TargetedDamage`, the damage effects could be taken from the first matching
+`AngledDamage`, and the Next interaction coming from the default damage field.
+
+If all damage dealt by this interaction is cancelled, then this interaction will fail, and the `Failed` interaction
+will be executed next in the chain. If any damage dealt by this interaction is blocked, then this interaction will
+succeed, but the `Blocked` interaction wil lbe executed next in the chain. Otherwise, the highest-precedent matching
+`Next` interaction that you provide will be executed.  For instance, if you provide `Next` interactions for all
+`TargetedDamage` and `AngledDamage` entries, and one in the interaction's `Next` field, then a headshot could result
+in a unique `Next` interaction being executed, even if there is a matching `AngledDamage` entry. However, if you leave
+the `Next` interaction out of your `TargetedDamage` entries, a special `Next` interaction for backstabs could be
+executed.  Otherwise, the `Next` field in the root of the interaction will be executed instead.
+
+DamageEntity has an unusual relationship with `RunTime`. This interaction always ends immediately after its first tick,
+regardless of the status of `RunTime` or `WaitForAnimationToFinish`.  However, if damage dealt by this interaction is
+calculated as `DamageCalculatorType` `Dps`, then the `RunTime` will be used to determine the precise amount of damage to
+deal. If `RunTime` is 0, then no damage will be dealt.
+
+**DamageEntity Fields**
+
+| Field Name       | Type                                                          | Required?                                                                                                                    | Notes                                                                                                                                                                                                                                                                                                                                                                         |
+| ---------------- | ------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| DamageCalculator | `DamageCalculator`                                            | **No**                                                                                                                       | If provided, describes the damage amounts and types to apply to the Target entity.                                                                                                                                                                                                                                                                                            |
+| DamageEffects    | `DamageEffects`                                               | **No**                                                                                                                       | If provided, describes particles, sounds, knockback, etc. to apply to the target entity on damage.                                                                                                                                                                                                                                                                            |
+| Next             | `Asset`<br />(Asset Type: `Interaction`)                      | **No**  After this interaction has finished, "Next" will be executed if damage was dealt to the target and none was blocked. |                                                                                                                                                                                                                                                                                                                                                                               |
+| AngledDamage     | `Array`<br />(Element Type: `AngledDamage`)                   | **No**                                                                                                                       | If provided, allows alternative `DamageCalculator`, `DamageEffects`, and `Next` entries for attacks that approach the target from certain angles.                                                                                                                                                                                                                             |
+| TargetedDamage   | `Map`<br />(Key Type: `String`, Value Type: `TargetedDamage`) | **Yes**                                                                                                                      | This field must be provided, but is not required to have any entries.  This is a map from body part names to `TargetedDamage` values. Hypixel only uses one body part name: `Head`, and it is not clear whether there are others.  If provided, allows alternative `DamageCalculator`, `DamageEffects`, and `Next` entries for attacks that damage specific enemy body parts. |
+| EntityStatsOnHit | `Array`<br />(Element Type: `EntityStatOnHit`)                | **No**                                                                                                                       | If provided, allows this attack to reduce enemy stats other than health.  Each individual damage application dealt by the same ability will apply stat reductions, at diminishing returns. All damage dealt in interaction chains forked by a Selector interaction will share the number of hits across all targets.                                                          |
+| Failed           | `Asset`<br />(Asset Type: `Interaction`)                      | **No**                                                                                                                       | After this interaction has finished, "Failed" will be executed if no damage hits were applied to the player, or if all damage hits were cancelled.                                                                                                                                                                                                                            |
+| Blocked          | `Asset`<br />(Asset Type: `Interaction`)                      | **No**                                                                                                                       | After this interaction has finished, "Blocked" will be executed if any damage hits were blocked by the target.                                                                                                                                                                                                                                                                |
+
+**DamageCalculator Fields**
+
+| Field Name                | Type                                                      | Required? | Notes                                                                                                                                                                                                                                                 |
+| ------------------------- | --------------------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Type                      | `DamageCalculatorType`<br />(Default: Absolute)           | **No**    | Whether the damage being applied is `Absolute` or \`Dps'.                                                                                                                                                                                             |
+| Class                     | `DamageClass`<br />(Default: Unknown)                     | **No**    | The type of attack producing the damage. Some weapon systems apply equipment modifiers based on this value.                                                                                                                                           |
+| BaseDamage                | `Map`<br />(Key Type: `DamageCause`, Value Type: `Float`) | **No**    | A set of DamageCauses and how much base damage is dealt for each.                                                                                                                                                                                     |
+| SequentialModifierStep    | `Float`<br />(Default: 0.0)                               | **No**    | Value between 0.0-1.0. Each additional hit from a single ability will have its damage reduced by this much as a percentage. All damage dealt in interaction chains forked by a Selector interaction will share the number of hits across all targets. |
+| SequentialModifierMinimum | `Float`<br />(Default: 0.0)                               | **No**    | Value between 0.0-1.0. `SequentialModifierStep` cannot reduce damage below this percentage regardless of the number of hits.                                                                                                                          |
+| RandomPercentageModifier  | `Float`<br />(Default: 0.0)                               | **No**    | A random value between +/- this amount multiplied by the base damage will be added to the base damage.                                                                                                                                                |
+
+**DamageEffects Fields**
+
+| Field Name             | Type                                         | Required? | Notes                                                                                   |
+| ---------------------- | -------------------------------------------- | --------- | --------------------------------------------------------------------------------------- |
+| ModelParticles         | `Array`<br />(Element Type: `ModelParticle`) | **No**    | Particle systems to trigger in the first-person view.                                   |
+| WorldParticles         | `Array`<br />(Element Type: `WorldParticle`) | **No**    | Particle systems to trigger in the third-person view.                                   |
+| LocalSoundEventId      | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | 2D sound to play locally to the attacking entity if they are a player.                  |
+| WorldSoundEventId      | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | Sound to play in the world at the Target entity's location.                             |
+| PlayerSoundEventId     | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | 2D sound to play locally to the Target entity if they are a player.                     |
+| ViewDistance           | `Double`<br />(Default: 75.0)                | **No**    | Distance at which these effects should play for other players.                          |
+| Knockback              | `Knockback`                                  | **No**    | The properties of the knockback that will be applied.                                   |
+| CameraEffect           | `Asset`<br />(Asset Type: `CameraEffect`)    | **No**    | CameraEffect to briefly apply locally to the Target entity if they are a player.        |
+| StaminaDrainMultiplier | `Float`<br />(Default: 1.0)                  | **No**    | This multiplier is applied to the stamina cost incurred by the target blocking, if any. |
+
+**AngledDamage Fields**
+
+| Field Name       | Type                                     | Required? | Notes                                                                                                                                                                                                     |
+| ---------------- | ---------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| AngleDistance    | `Float`<br />(Default: 0)                | **No**    | The width in degrees of the matching arc around the Target entity. If the attack against the Target originates from within the arc, then the properties below will be applied to the attack, if provided. |
+| Angle            | `Float`<br />(Default: 0.0)              | **No**    | The angle in degrees around the Target entity at which the matching arc is centered.                                                                                                                      |
+| DamageCalculator | `DamageCalculator`                       | **No**    | If provided and the attack against the Target entity originates from within the provided arc, this DamageCalculator will override the interaction's `DamageCalculator` field.                             |
+| DamageEffects    | `DamageEffects`                          | **No**    | If provided and the attack against the Target entity originates from within the provided arc, this DamageEffects will override the interaction's `DamageEffects` field.                                   |
+| Next             | `Asset`<br />(Asset Type: `Interaction`) | **No**    | If provided and the attack against the Target entity originates from within the provided arc, this Interaction will override the interaction's `Next` field.                                              |
+
+**TargetedDamage Fields**
+
+| Field Name       | Type                                     | Required? | Notes                                                                                                                                                                                            |
+| ---------------- | ---------------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| DamageCalculator | `DamageCalculator`                       | **No**    | If provided and this TargetedDamage was matched, this DamageCalculator will override the interaction's `DamageCalculator` field and the `DamageCalculator` field of any matching `AngledDamage`. |
+| DamageEffects    | `DamageEffects`                          | **No**    | If provided and this TargetedDamage was matched, this DamageEffects will override the interaction's `DamageEffects` field and the `DamageEffects` field of any matching `AngledDamage`.          |
+| Next             | `Asset`<br />(Asset Type: `Interaction`) | **No**    | If provided and this TargetedDamage was matched, this Interaction will override the interaction's `Next` field and the `Next` field of any matching `AngledDamage`.                              |
+
+**EntityStatOnHit Fields**
+
+| Field Name                  | Type                                                                       | Required? | Notes                                                                                                                                                                                                                                                                                        |
+| --------------------------- | -------------------------------------------------------------------------- | --------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| EntityStatId                | `Asset`<br />(AssetType: `EntityStatType`)                                 | **Yes**   | Which entity stat to affect.                                                                                                                                                                                                                                                                 |
+| Amount                      | `Float`<br />(Default: 0.0)                                                | **No**    | How much of the stat to apply for each damage application. Use negative numbers to reduce stats.                                                                                                                                                                                             |
+| MultipliersPerEntitiesHit   | `Array`<br />(Element Type: `Float`, Default: `[1.0, 0.6, 0.4, 0.2, 0.1]`) | **No**    | The diminishing returns curve to be applied for multiple damage applications by the same ability. Each hit's stat impact will be multiplied by the next value in the list.  If there are more hits than array elements, subsequent hits will be multiplied by `MultiplierPerExtraEntityHit`. |
+| MultiplierPerExtraEntityHit | `Float`<br />(Default: 0.05)                                               | **No**    | If an ability carries out more damage applications than there are elements in the `MultipliersPerEntitiesHit` array, then subsequent stat values will be multiplied by this number.                                                                                                          |
+
+**Knockback Fields**
+
+| Field Name     | Type                                       | Required? | Notes                                                                                                                      |
+| -------------- | ------------------------------------------ | --------- | -------------------------------------------------------------------------------------------------------------------------- |
+| Type           | `String`                                   | **No**    | If provided, specifies a type of knockback to use. Each Target type may come with additional fields.                       |
+| Force          | `Double`<br />(Default: 0.0)               | **No**    | The amount of force to apply to the Owner entity.                                                                          |
+| Duration       | `Double`<br />(Default: 0.0)               | **No**    | If 0.0, apply the force as a single impulse.  If more, continuously apply the force over a period of time.                 |
+| VelocityType   | `ChangeVelocityType`<br />(Default: `Add`) | **No**    | How to apply the force, either adding it to the entity's current velocity, or setting the velocity to the knockback force. |
+| VelocityConfig | `VelocityConfig`                           | **No**    | Characteristics of friction as the Owner entity is thrown by this knockback.                                               |
+
+**Knockback Type: Force**
+
+Apply the calculated knockback force along the provided direction.
+
+| Field Name | Type                         | Required? | Notes                                                                                |
+| ---------- | ---------------------------- | --------- | ------------------------------------------------------------------------------------ |
+| Direction  | `Vector3`<br />(Default: Up) | **No**    | Which direction the entity should be flung, relative to the direction of the attack. |
+
+**Knockback Type: Point**
+
+Apply the calculated knockback force laterally along the XZ plane, plus provided Y velocity.
+
+| Field Name | Type                        | Required? | Notes                                                                                                   |
+| ---------- | --------------------------- | --------- | ------------------------------------------------------------------------------------------------------- |
+| OffsetX    | `Integer`<br />(Default: 0) | **No**    | Offset the source position of the knockback left or right perpendicular to the direction of the attack. |
+| OffsetZ    | `Integer`<br />(Default: 0) | **No**    | Offset the source position of the knockback, forward or backward along the directon of the attack.      |
+| RotateY    | `Integer`<br />(Default: 0) | **No**    | Rotate the knockback direction around the Y axis, where 0 is the default attack direction.              |
+| VelocityY  | `Float`<br />(Default: 0.0) | **No**    | Add vertical velocity to the knockback force after the direction and force has been calculated.         |
+
+**Knockback Type: Directional**
+
+Apply the calculated knockback force along the attack direction, removing any vertical component and replacing it with a provided Y velocity.
+
+| Field Name | Type                      | Required? | Notes                                                                                                                                            |
+| ---------- | ------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------ |
+| RelativeX  | `Float`<br />(Default: 0) | **No**    | Apply additional force left or right perpendicular to the direction of the attack. The additional force is multiplied by the knockback strength. |
+| RelativeZ  | `Float`<br />(Default: 0) | **No**    | Apply additional force forward or backward along the attack direction. The additional force is multiplied by the knockback strength.             |
+| VelocityY  | `Float`<br />(Default: 0) | **No**    | Replace the vertical velocity of the knockback with this value.  This value is not multiplied by knockback strength.                             |
+
+**VelocityConfig Fields**
+
+| Field Name          | Type                                              | Required? | Notes                                                                                                                                                                                           |
+| ------------------- | ------------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| GroundResistance    | `Float`<br />(Default: 0.82)                      | **No**    | The minimum amount of friction applied when the entity is in contact with the ground.  1.0 = no friction, 0.0 = total friction                                                                  |
+| GroundResistanceMax | `Float`<br />(Default: 0.0)                       | **No**    | The maximum amount of friction applied when the entity is in contact with the ground.  1.0 = no friction, 0.0 = total friction                                                                  |
+| AirResistance       | `Float`<br />(Default: 0.96)                      | **No**    | The minimum amount of friction applied when the entity is in the air. 1.0 = no friction, 0.0 = total friction                                                                                   |
+| AirResistanceMax    | `Float`<br />(Default: 0.0)                       | **No**    | The maximum amount of friction applied when the entity is in the air. 1.0 = no friction, 0.0 = total friction                                                                                   |
+| Threshold           | `Float`<br />(Default: 1.0)                       | **No**    | The speed at which the maximum amount of friction will be applied to the entity. The amount of friction applied will increase from minimum to maximum as the entity moves from 0 to this speed. |
+| Style               | `VelocityThresholdStyle`<br />(Default: `Linear`) | **No**    | The curve that friction follows as the entity's speed increases toward the `Threshold`.                                                                                                         |
+
+**DamageCalculatorType Values**
+
+- `Absolute`
+- `Dps`
+
+**DamageClass Values**
+
+- `Unknown`
+- `Light`
+- `Charged`
+- `Signature`
+
+**ChangeVelocityType Values**
+
+- `Add`
+- `Set`
+
+**VelocityThresholdStyle Values**
+
+- `Linear`
+- `Exp`
+
+### LaunchProjectile
+
+This is just a worse version of Projectile and is slated to be removed.  Use Projectile.
+
+### Projectile
+
+This interaction will spawn a new projectile at the User entity's eye position that will travel in its look direction.
+
+| Field Name | Type                                          | Required? | Notes                                                  |
+| ---------- | --------------------------------------------- | --------- | ------------------------------------------------------ |
+| Config     | `Asset`<br />(Asset Type: `ProjectileConfig`) | **No**    | Configuration describing the projectile to be spawned. |
+
+### RemoveEntity
+
+Despawns the specified entity from the world. This interaction will have no effect if the specified entity is a player. This
+interaction has no special failure conditions.
+
+| Field Name | Type                                     | Required? | Notes                  |
+| ---------- | ---------------------------------------- | --------- | ---------------------- |
+| Entity     | `InteractionTarget`<br />(Default: User) | **No**    | The entity to despawn. |
+
+**InteractionTarget Values**
+
+- `User` - The user of this interaction chain. The entity whose actions caused this interaction chain to be executed. This is usually the same as the Owner.
+- `Owner` - The owner of this interaction chain. The entity upon whom this interaction chain is executing.
+- `Target` - The entity target of this interaction chain, if any.  This value is mutable (and can therefore come from many places) but most commonly, it is an entity the User was targeting when this interaction chain began executing.
+
+### SendMessage
+
+This interaction sends a message to the Owner entity if that entity can receive messages.  Otherwise, the message
+is written to the server logs.  If the entity is a player, the message will appear in the player's chat window.
+
+\*\*SendMessage
+
+| Field Name | Type     | Required? | Notes                                                                                                                 |
+| ---------- | -------- | --------- | --------------------------------------------------------------------------------------------------------------------- |
+| Message    | `String` | **No**    | A text message to be sent to the Owner entity.  If this field is not provided, `Key` is used instead.                 |
+| Key        | `String` | **No**    | A translation key for a message to be sent to the Owner entity. If `Message` is provided, then this field is ignored. |
+
+### UseEntity
+
+This interaction is not in use by Hypixel and has some unusual qualities that mean it probably won't do what you want it
+to.  Do not use it.
+
+This interaction will retrieve the entity currently targeted by the client (NOT the interaction chain's current Target
+entity) and execute that entity's RootInteraction for this interaction chain's current interaction type. The
+RootInteraction will be executed as part of this current interaction chain. None of the properties of this interaction
+chain will be modified.
+
+This interaction will fail if the client is not currently targeting an entity, or if no interaction for the current
+interaction type exists on the entity.
+
+## Stats
+
+Hytale's resource system has been written about fairly extensively.  You can use these interactions to modify stats in
+response to actions or use stats as a cost for abilities.
+
+### ChangeStat
+
+This interaction applies a set of raw stat changes to the User entity. It has no special failure conditions.
+
+| Field Name    | Type                                                         | Required? | Notes                                                                                                                                                                                                                      |
+| ------------- | ------------------------------------------------------------ | --------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| StatModifiers | `Map`<br />(Key Type: `EntityStatType`, Value Type: `Float`) | **Yes**   | A set of stats to modify and what value to apply to them.                                                                                                                                                                  |
+| ValueType     | `ValueType`<br />(Default: Absolute)                         | **No**    | Whether the values in the `StatModifiers` map represent flat values to apply to the stat total, or percentages (0.0-100.0). Percentage values are percentage of the difference between the maximum and minimum stat value. |
+| Behaviour     | `ChangeStatBehavior`<br />(Default: Add)                     | **No**    | Whether the values in the `StatModifiers` map represent deltas to add into the User entity's current stat values, or fixed values to set the entity's stats to.                                                            |
+
+**ValueType Values**
+
+- `Absolute`
+- `Percent`
+
+**ChangeStatBehaviour Values**
+
+- `Add`
+- `Set`
+
+### ChangeStatWithModifier
+
+This interaction is like ChangeStat, except an armor stat modifier can be chosen which will apply bonuses and penalties
+to a stat from the User entity's equipped armor before it is applied.
+
+| Field Name            | Type                                                         | Required? | Notes                                                                                                                                                                                                                      |
+| --------------------- | ------------------------------------------------------------ | --------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| StatModifiers         | `Map`<br />(Key Type: `EntityStatType`, Value Type: `Float`) | **Yes**   | A set of stats to modify and what value to apply to them.                                                                                                                                                                  |
+| ValueType             | `ValueType`<br />(Default: Absolute)                         | **No**    | Whether the values in the `StatModifiers` map represent flat values to apply to the stat total, or percentages (0.0-100.0). Percentage values are percentage of the difference between the maximum and minimum stat value. |
+| Behaviour             | `ChangeStatBehavior`<br />(Default: Add)                     | **No**    | Whether the values in the `StatModifiers` map represent deltas to add into the User entity's current stat values, or fixed values to set the entity's stats to.                                                            |
+| InteractionModifierId | `InteractionModifierId`                                      | **Yes**   | The armor interaction modifier to apply bonuses and penalties for.                                                                                                                                                         |
+
+**ValueType Values**
+
+- `Absolute`
+- `Percent`
+
+**ChangeStatBehaviour Values**
+
+- `Add`
+- `Set`
+
+**InteractionModifierId Values**
+
+- `Dodge`
+
+### StatsCondition
+
+This interaction will fail if the User entity cannot afford the specified stats costs, or if it does not have the
+requested stats.
+
+| Field Name | Type                                                         | Required? | Notes                                                                                                                                                                                    |
+| ---------- | ------------------------------------------------------------ | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Costs      | `Map`<br />(Key Type:` EntityStatType`, Value Type: `Float`) | **Yes**   | A set of costs that the User entity needs to be able to afford for this interaction to succeed.                                                                                          |
+| ValueType  | `ValueType`<br />(Default: Absolute)                         | **No**    | Whether the values in the `Costs` map represetn flat values or percentages (0.0-100.0).  Percentage values are percentage of the difference between the maximum and minimum value.       |
+| LessThan   | `Boolean`<br />(Default: false)                              | **No**    | If true, this interaction will fail unless the User entity's current stat values are at or **below** the specified levels.  If false, they must be at or **above** the specified levels. |
+| Lenient    | `Boolean`<br />(Default: false)                              | **No**    | If true and `LessThan` is true, and a player's minimum stat value is below zero, then the player can afford a stat cost if the current value of a stat if above 0.                       |
+
+**ValueType Values**
+
+- `Absolute`
+- `Percent`
+
+### StatsConditionWithModifier
+
+This interaction is like StatsCondition, except an armor stat modifier can be chosen which will apply bonuses and penalties
+to a stat's cost from the User entity's equipped armor before it is compared.
+
+| Field Name            | Type                                                         | Required? | Notes                                                                                                                                                                                    |
+| --------------------- | ------------------------------------------------------------ | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Costs                 | `Map`<br />(Key Type:` EntityStatType`, Value Type: `Float`) | **Yes**   | A set of costs that the User entity needs to be able to afford for this interaction to succeed.                                                                                          |
+| ValueType             | `ValueType`<br />(Default: Absolute)                         | **No**    | Whether the values in the `Costs` map represetn flat values or percentages (0.0-100.0).  Percentage values are percentage of the difference between the maximum and minimum value.       |
+| LessThan              | `Boolean`<br />(Default: false)                              | **No**    | If true, this interaction will fail unless the User entity's current stat values are at or **below** the specified levels.  If false, they must be at or **above** the specified levels. |
+| Lenient               | `Boolean`<br />(Default: false)                              | **No**    | If true and `LessThan` is true, and a player's minimum stat value is below zero, then the player can afford a stat cost if the current value of a stat if above 0.                       |
+| InteractionModifierId | `InteractionModifierId`                                      | **Yes**   | The armor interaction modifier to apply bonuses and penalties for.                                                                                                                       |
+
+**ValueType Values**
+
+- `Absolute`
+- `Percent`
+
+**InteractionModifierId Values**
+
+- `Dodge`
+
+## EntityEffects
+
+EntityEffects are buff or debuff effects that can be applied to a LivingEntity.  These can have a variety of effects from
+movement speed changes to periodic damage.
+
+### EffectCondition
+
+This interaction will fail if the specified entity's EntityEffects do not match the provided conditions.
+
+**EffectCondition Fields**
+
+| Field Name      | Type                                             | Required? | Notes                                                                                                                                                                                                             |
+| --------------- | ------------------------------------------------ | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Entity          | `InteractionTarget`<br />(Default: User)         | **Yes**   | The entity to examine for EntityEffects. This field can indicate the Owner, User, or Target of this interaction chain.                                                                                            |
+| Match           | `Match`<br />(Default: All)                      | **No**    | If `All`, then this interaction will fail if any EntityEffect in the `EntityEffectIds` is not on the specified entity. If `None`, then this interaction will fail if any EntityEffect IS on the specified entity. |
+| EntityEffectIds | `AssetArray`<br />(Element Type: `EntityEffect`) | **Yes**   | The set of EntityEffects to check against the specified entity and `Match`.                                                                                                                                       |
+
+**InteractionTarget Values**
+
+- `User` - The user of this interaction chain. The entity whose actions caused this interaction chain to be executed. This is usually the same as the Owner.
+- `Owner` - The owner of this interaction chain. The entity upon whom this interaction chain is executing.
+- `Target` - The entity target of this interaction chain, if any.  This value is mutable (and can therefore come from many places) but most commonly, it is an entity the User was targeting when this interaction chain began executing.
+
+**Match Values**
+
+- `All` - All EntityEffects must be on the specified entity for this interaction to succeed.
+- `None` - None of the EntityEffects must be on the specified entity for this interaction to succeed.
+
+### ApplyEffect
+
+This interaction will apply the specified EntityEffect to the specified Entity.  It has no special failure conditions.
+
+**ApplyEffect Fields**
+
+| Field Name | Type                                      | Required? | Notes                                                                                                                  |
+| ---------- | ----------------------------------------- | --------- | ---------------------------------------------------------------------------------------------------------------------- |
+| Entity     | `InteractionTarget`<br />(Default: User)  | **Yes**   | The entity to apply the EntityEffect to. This field can indicate the Owner, User, or Target of this interaction chain. |
+| EffectId   | `Asset`<br />(Asset Type: `EntityEffect`) | **Yes**   | The effect to apply.                                                                                                   |
+
+**InteractionTarget Values**
+
+- `User` - The user of this interaction chain. The entity whose actions caused this interaction chain to be executed. This is usually the same as the Owner.
+- `Owner` - The owner of this interaction chain. The entity upon whom this interaction chain is executing.
+- `Target` - The entity target of this interaction chain, if any.  This value is mutable (and can therefore come from many places) but most commonly, it is an entity the User was targeting when this interaction chain began executing.
+
+### ClearEntityEffect
+
+This interaction will remove the specified EntityEffect from the specified Entity. It has no special failure conditions.
+It will not fail if the Entity does not have the EntityEffect.
+
+**ClearEntityEffect Fields**
+
+| Field Name | Type                                      | Required? | Notes                                                                                                                     |
+| ---------- | ----------------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------- |
+| Entity     | `InteractionTarget`<br />(Default: User)  | **Yes**   | The entity to remove the EntityEffect from. This field can indicate the Owner, User, or Target of this interaction chain. |
+| EffectId   | `Asset`<br />(Asset Type: `EntityEffect`) | **Yes**   | The effect to remove.                                                                                                     |
+
+**InteractionTarget Values**
+
+- `User` - The user of this interaction chain. The entity whose actions caused this interaction chain to be executed. This is usually the same as the Owner.
+- `Owner` - The owner of this interaction chain. The entity upon whom this interaction chain is executing.
+- `Target` - The entity target of this interaction chain, if any.  This value is mutable (and can therefore come from many places) but most commonly, it is an entity the User was targeting when this interaction chain began executing.
+
+## Farming
+
+These are interaction types built to support the in-game farming system in Hytale. They are mostly block-related interactions
+with a few exceptions.
+
+### ChangeFarmingStage
+
+If the target block is a farming block, this interaction will attempt to modify the current farming stage in one of
+three ways.  The interaction can optionally specify which StageSet to use for the new stage. If it is not specified,
+the current StageSet will be used. If any part of the the process of changing the growth stage fails, this interaction
+will fail, with the one exception that attempting to set the stage to the crop's existing stage will have no effect but
+still succeed.
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                                                                                                                                                                          |
+| ---------------- | ------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction.                                                                                                                                              |
+| StageSet         | `String`                        | **No**    | If provided, set the block's current stage to one in the provided StageSet. Otherwise, use the crop's current StageSet.                                                                                                                                                        |
+| Increase         | `Integer`                       | **No**    | If provided, increase the current stage by the specified amount. If the specified stage does not exist, the block will be set to the closest extant stage.                                                                                                                     |
+| Decrease         | `Integer`                       | **No**    | If provided and `Increase` is not provided, decrease the current stage by the specified amount. If the specified stage does not exist, the block will be set to the closest extant stage.                                                                                      |
+| Stage            | `Integer`<br />(Default: -1)    | **No**    | If provided and `Increase`/`Decrease` are not provided, set the current stage to the specified stage. If this value is less than 0, set the current stage to the final growth stage. If the specified stage does not exist, the block will be set to the closest extant stage. |
+
+### FertilizeSoil
+
+If the target block is unfertilized tilled soil or a farming block on top of unfertilized tilled soil, fertilizes the soil.
+The interaction will fail otherwise.
+
+**FertilizeSoil Fields**
+
+| Field Name       | Type                                  | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false)       | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+| RefreshModifiers | `Array`<br />(Element Type: `String`) | **No**    | Does nothing.                                                                                                                     |
+
+### HarvestCrop
+
+This interaction will attempt to execute the harvest action on the current block target and add the crop's drops to the User entity's
+inventory.  The block will either be destroyed or set to its post-harvest growth stage, depending on the farming
+configuration of the block.  This will happen (and the player will receive the full harvest drops) regardless of the
+block's current growth stage. This interaction has no special failure conditions, even if the block target isn't a
+farming block or gathering isn't permitted in the current world, but nothing will occur in those cases.
+
+**HarvestCrop Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+
+### UseWateringCan
+
+If the target block is tilled soil or a farming block on top of tilled soil, waters the soil for the specified duration.
+The interaction will fail otherwise.
+
+**UseWateringCan Fields**
+
+| Field Name       | Type                                  | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false)       | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+| Duration         | `Integer`<br />(Default: 0)           | **No**    | The duration in seconds to water the soil for.                                                                                    |
+| RefreshModifiers | `Array`<br />(Element Type: `String`) | **No**    | Does nothing.                                                                                                                     |
diff --git a/content/docs/tr-TR/contributing/pr-guidelines.mdx b/content/docs/tr-TR/contributing/pr-guidelines.mdx
index 7a251032..c226da04 100644
--- a/content/docs/tr-TR/contributing/pr-guidelines.mdx
+++ b/content/docs/tr-TR/contributing/pr-guidelines.mdx
@@ -19,6 +19,8 @@ To ensure a smooth and efficient review process, both contributors and reviewers
 4. **Code Quality**
    - Ensure your code follows the project's coding standards and best practices.
    - Include comments where necessary to explain complex logic.
+   - Always test your changes locally before submitting the PR to catch any issues early.
+   - Format your code using `bun format` to maintain consistency across the codebase.
 5. **Testing**
    - Test your changes thoroughly before submitting the PR.
    - If applicable, include unit tests or integration tests to verify your changes.
diff --git a/content/docs/tr-TR/contributing/translate.mdx b/content/docs/tr-TR/contributing/translate.mdx
new file mode 100644
index 00000000..c62ffdde
--- /dev/null
+++ b/content/docs/tr-TR/contributing/translate.mdx
@@ -0,0 +1,74 @@
+---
+title: Translate
+description: How to translate HytaleModding to your language
+---
+
+# Translating HytaleModding
+
+HytaleModding is translated with the help of the community using **Crowdin**. If you want to help translate or improve existing translations, this is the right place.
+
+## Steps to Translate
+
+All translations are managed **via Crowdin**.
+
+1. Visit [our Crowdin project](https://crowdin.com/project/hytalemodding) and log in if required.
+2. Click on your language.
+3. Click on the file/article you wish to translate. We recommend starting with Official Documentation, and then Server Plugin Documentation.
+4. Start translating!
+5. Approved translations will appear on the website.
+
+### Video Guide
+
+<iframe src="https://www.youtube.com/embed/NHiG1rDRgks" allowFullScreen />
+
+## How to discuss
+
+You can always report issues or discuss specific topics directly on Crowdin, but we recommend using Discord instead of the Crowdin comment system to keep everything organized in one place.
+
+1. Join [our Discord](https://discord.gg/hytalemodding)
+2. Open `#translations` channel. Here you can discuss or ask questions that are not related to a specific language.
+3. If you want to join a thread, you are required to run `/translator <your-language>` command here. The bot will add you to the thread for your language.
+
+## Translation Guidelines
+
+- You need to be confident in what you are translating. You should be able to read the text you just translated and understand the meaning of it very easily.
+- It should use the simplest form of language possible. Use English words if the translation is unknown to the majority in your country.
+- Use your imagination, trust yourself. Feel free to change any context as you wish as long as it can still get the same point across and is understandable.
+- These guidelines are more important than language-specific guidelines, but less important than Hytale terminology and rules.
+
+## What not to translate
+
+We request you all to not translate these specific sections of the website:
+
+### Callout types
+
+Callouts are the boxes that contain important information. We request you to not translate the types as they only work in English.
+
+**Example:**
+
+```mdx
+<Callout type="warning" title="Translate this title!">
+Translate the text inside the callout!
+</Callout>
+```
+
+In this example, please don't translate the word warning, the rest you can translate.
+
+### Icons
+
+Icon names must not be translated.
+They are technical identifiers mapped directly to existing icons. Translating them will break the icon rendering.
+
+```mdx
+icon: Globe
+```
+
+---
+
+{/* 
+For translators who will edit this page:
+
+- You are required to translate the Guidelines as they change.
+- General guidelines should be translated but not edited.
+- Learn how to use Markdown from writing_guides.mdx
+*/}
diff --git a/content/docs/tr-TR/established-information/server/content-categories/art-assets.mdx b/content/docs/tr-TR/established-information/server/content-categories/art-assets.mdx
index 39c2ed37..1e926874 100644
--- a/content/docs/tr-TR/established-information/server/content-categories/art-assets.mdx
+++ b/content/docs/tr-TR/established-information/server/content-categories/art-assets.mdx
@@ -14,7 +14,7 @@ Hytale provides comprehensive support for 3D modeling and texture art creation,
 Hytale uses **Blockbench** as the primary tool for 3D modeling and animation:
 
 * **Official support**: Used for "creating Hytale models, textures, and animations"
-* **Special plugin**: Hytale will have a dedicated Blockbench plugin, to be released ASAP
+* **Special plugin**: Hytale has a dedicated [Blockbench Plugin](https://www.blockbench.net/plugins/hytale_plugin).
 * **Direct compatibility**: The plugin allows creators to "create Hytale-compatible models, textures, and animations directly in Blockbench"
 * **Replaces legacy tools**: Fully replaces the old Hytale Model Maker to better support established creative workflows in the community
 * **Safety features**: Only allows you to add things compatible with the engine, so no need to worry about breaking anything
diff --git a/content/docs/tr-TR/guides/ecs/block-components.mdx b/content/docs/tr-TR/guides/ecs/block-components.mdx
new file mode 100644
index 00000000..ca68b38a
--- /dev/null
+++ b/content/docs/tr-TR/guides/ecs/block-components.mdx
@@ -0,0 +1,247 @@
+---
+title: Block Components
+description: Learn how to use the block components.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+  - name: oskarscot
+    link: https://oskar.scot
+---
+
+# Overview
+
+In this guide, you'll learn how to use block components to create a ticking block.
+
+<Callout>
+  For a more complete reference, you may also want to review FarmingSystems.Ticking, as much of the underlying logic is based on its implementation.
+</Callout>
+
+## Steps
+
+### 1. ExampleBlock - holds block behavior
+
+```java
+public class ExampleBlock implements Component<ChunkStore> {
+
+    public static final BuilderCodec CODEC = BuilderCodec.builder(ExampleBlock.class, ExampleBlock::new).build();
+
+    // Components usually require a copy constructor as well but since we don't actually hold any data in this component this is not neccessary
+    public ExampleBlock() { }
+
+    public static ComponentType getComponentType() {
+        return ExamplePlugin.get().getExampleBlockComponentType();
+    }
+
+    @Nullable
+    public Component<ChunkStore> clone() {
+        return new ExampleBlock();
+    }
+}
+```
+
+ExampleBlock is a custom component that stores the behavior and data for your ticking block. Here, it simply places an Ice Block at x + 1 relative to its current position when it ticks.
+
+---
+
+### 2. ExampleInitializer - marks blocks as ticking when placed
+
+```java
+public class ExampleInitializer extends RefSystem {
+
+    @Override
+    public void onEntityAdded(@Nonnull Ref ref, @Nonnull AddReason reason, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+        BlockModule.BlockStateInfo info = (BlockModule.BlockStateInfo) commandBuffer.getComponent(ref, BlockModule.BlockStateInfo.getComponentType());
+        if (info == null) return;
+
+        ExampleBlock generator = (ExampleBlock) commandBuffer.getComponent(ref, ExamplePlugin.get().getExampleBlockComponentType());
+        if (generator != null) {
+            int x = ChunkUtil.xFromBlockInColumn(info.getIndex());
+            int y = ChunkUtil.yFromBlockInColumn(info.getIndex());
+            int z = ChunkUtil.zFromBlockInColumn(info.getIndex());
+
+            WorldChunk worldChunk = (WorldChunk) commandBuffer.getComponent(info.getChunkRef(), WorldChunk.getComponentType());
+            if (worldChunk != null) {
+				worldChunk.setTicking(x, y, z, true);
+            }
+        }
+    }
+
+    @Override
+    public void onEntityRemove(@Nonnull Ref ref, @Nonnull RemoveReason reason, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+    }
+
+    @Override
+    public Query getQuery() {
+        return Query.and(BlockModule.BlockStateInfo.getComponentType(), ExamplePlugin.get().getExampleBlockComponentType());
+    }
+}
+```
+
+ExampleInitializer is a RefSystem that reacts when block entities with the ExampleBlock component are added or removed. This is crucial for marking blocks as ticking when they're first placed.
+
+**Key Points:**
+
+- Tells the game that this block should tick, allowing `ExampleSystem` to process it.
+
+```java
+worldChunk.setTicking(x, y, z, true);
+```
+
+---
+
+### 3. ExampleSystem - handles ticking
+
+```java
+public class ExampleSystem extends EntityTickingSystem {
+
+    public void tick(float dt, int index, @Nonnull ArchetypeChunk archetypeChunk, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+        BlockSection blocks = (BlockSection) archetypeChunk.getComponent(index, BlockSection.getComponentType());
+
+        assert blocks != null;
+
+        if (blocks.getTickingBlocksCountCopy() != 0) {
+            ChunkSection section = (ChunkSection) archetypeChunk.getComponent(index, ChunkSection.getComponentType());
+
+            assert section != null;
+
+            BlockComponentChunk blockComponentChunk = (BlockComponentChunk) commandBuffer.getComponent(section.getChunkColumnReference(), BlockComponentChunk.getComponentType());
+
+            assert blockComponentChunk != null;
+
+            blocks.forEachTicking(blockComponentChunk, commandBuffer, section.getY(), (blockComponentChunk1, commandBuffer1, localX, localY, localZ, blockId) -> {
+                Ref<ChunkStore> blockRef = blockComponentChunk.getEntityReference(ChunkUtil.indexBlockInColumn(localX, localY, localZ));
+                if (blockRef == null) {
+                    return BlockTickStrategy.IGNORED;
+                } else {
+                    ExampleBlock exampleBlock = (ExampleBlock) commandBuffer1.getComponent(blockRef, ExampleBlock.getComponentType());
+                    if (exampleBlock != null) {
+                        WorldChunk worldChunk = (WorldChunk) commandBuffer.getComponent(section.getChunkColumnReference(), WorldChunk.getComponentType());
+                        World world = worldChunk.getWorld();
+
+                        int globalX = localX + (worldChunk.getX() * 32);
+                        int globalZ = localZ + (worldChunk.getZ() * 32);
+
+                        // We need to execute setBlock on the world thread as you cannot call store functions from a system
+                        // This is because of the architecture of the server, depending on your needs you can also use the CommandBuffer
+                        world.execute(() -> {
+                            world.setBlock(globalX + 1, localY, globalZ, "Rock_Ice");
+                        });
+
+                        return BlockTickStrategy.CONTINUE;
+
+                    } else {
+                        return BlockTickStrategy.IGNORED;
+                    }
+                }
+            });
+        }
+    }
+
+    @Nullable
+    public Query getQuery() {
+        return Query.and(BlockSection.getComponentType(), ChunkSection.getComponentType());;
+    }
+}
+```
+
+ExampleSystem is an EntityTickingSystem that runs every tick to execute the logic for all ticking blocks with the ExampleBlock component.
+
+**Key Points:**
+
+- **Get the block component**
+
+```java
+ExampleBlock exampleBlock = (ExampleBlock) commandBuffer.getComponent(blockRef, ExampleBlock.getComponentType());
+```
+
+- **Convert local chunk coordinates to world coordinates**
+
+```java
+int globalX = localX + (worldChunk.getX() * 32);
+int globalZ = localZ + (worldChunk.getZ() * 32);
+```
+
+- **Run the block logic**
+
+```java
+exampleBlock.runBlockAction(globalX, localY, globalZ, worldChunk.getWorld());
+```
+
+- **Keep the block ticking in the next tick**
+
+```java
+return BlockTickStrategy.CONTINUE;
+```
+
+---
+
+### 4. ExamplePlugin - registers components and systems
+
+```java
+public class ExamplePlugin extends JavaPlugin {
+    protected static ExamplePlugin instance;
+    private static final HytaleLogger LOGGER = HytaleLogger.forEnclosingClass();
+    private ComponentType exampleBlockComponentType;
+
+    public static ExamplePlugin get() {
+        return instance;
+    }
+
+    public ExamplePlugin(@Nonnull JavaPluginInit init) {
+        super(init);
+        LOGGER.atInfo().log("Hello from " + this.getName() + " version " + this.getManifest().getVersion().toString());
+    }
+
+    @Override
+    protected void setup() {
+        instance = this;
+        LOGGER.atInfo().log("Setting up plugin " + this.getName());
+        this.exampleBlockComponentType = this.getChunkStoreRegistry().registerComponent(ExampleBlock.class, "ExampleBlock", ExampleBlock.CODEC);
+    }
+	
+	@Override
+	protected void start() {
+		this.getChunkStoreRegistry().registerSystem(new ExampleSystem());
+		this.getChunkStoreRegistry().registerSystem(new ExampleInitializer());
+	}
+
+    public ComponentType getExampleBlockComponentType() {
+        return this.exampleBlockComponentType;
+    }
+}
+```
+
+---
+
+### 5. Configure In-Game
+
+![block-component-1](/assets/guides/block-component-1.png)
+
+![block-component-2](/assets/guides/block-component-2.png)
+
+With this logic, the block will now continuously place an Ice Block at the coordinates x + 1 relative to its current position every time it ticks.
+
+---
+
+## Common Issues
+
+### NullPointerException on Startup
+
+**Error message:**
+
+```java
+java.lang.NullPointerException: Cannot invoke "com.hypixel.hytale.component.query.Query.validateRegistry(com.hypixel.hytale.component.ComponentRegistry)" because "query" is null
+```
+
+**Cause:**
+This error occurs when your module is loaded **before** the required Hytale modules.
+
+**Fix:**
+Add `EntityModule` and `BlockModule` as dependencies in your `manifest.json` to ensure proper load order.
+
+```json
+"Dependencies": {
+  "Hytale:EntityModule": "*",
+  "Hytale:BlockModule": "*"
+}
+```
diff --git a/content/docs/tr-TR/guides/ecs/hytale-ecs-theory.mdx b/content/docs/tr-TR/guides/ecs/hytale-ecs-theory.mdx
index 20c3a94d..52d8b1f5 100644
--- a/content/docs/tr-TR/guides/ecs/hytale-ecs-theory.mdx
+++ b/content/docs/tr-TR/guides/ecs/hytale-ecs-theory.mdx
@@ -29,7 +29,7 @@ for now this is the basic understanding for the `ChunkStore`. You can use it to
 
 ## Holder
 
-A Holder is essentially a blueprint for an entity. Before an entity exists in the Store (and thus in the world), is exists as a `Holder`. It collects and holds all the necessary components (data). You can compare it analogous to shopping cart. You grab all components you need and once you have everything, check out at the store which will take your cart and create a valid entity ID and hand you back a receipt (a Ref).
+A Holder is essentially a blueprint for an entity. Before an entity exists in the Store (and thus in the world), it exists as a `Holder`. It collects and holds all the necessary components (data). You can compare it analogous to shopping cart. You grab all components you need and once you have everything, check out at the store which will take your cart and create a valid entity ID and hand you back a receipt (a Ref).
 
 Let's take a look at an example: initializing players. In `Universe`, the `addPlayer` method demonstrates it perfectly.
 When a player connects, we don't immediately throw them into the ECS. We first construct their data in a Holder.
@@ -167,7 +167,7 @@ MyComponent comp = commandBuffer.getComponent(ref, componentType);
 
 Codecs handle serialization and deserialization of components. Hytale uses them to save and load entity data to and from disk as well as sending component data over the network. When creating a custom component, you must also create a corresponding Codec.
 
-There are mutliple Codec types already implemented in the default Codec Interface:
+There are multiple Codec types already implemented in the default Codec Interface:
 
 - Codec.STRING
 - Codec.BOOLEAN
@@ -215,7 +215,7 @@ This might seem tedious at first but it ensures that your component can be corre
   KeyedCodec<Integer> exampleInt = new KeyedCodec<Integer>("ExampleIntIdForCodec", Codec.INTEGER);
   ```
 
-- **Setter Function**: This is a lambda function that takes an instance of your component and returns the value of the field you want to serialize. For example, if you have a field called `myCustomField` in your custom component, your getter function would look like this:
+- **Setter Function**: This is a lambda function that takes an instance of your component + the value to set and sets the field value on the component. For example, if you have a field called `myCustomField` in your custom component, your setter function would look like this:
   ```java
   (data, value) -> data.myCustomField = value
   ```
@@ -276,7 +276,7 @@ public class PoisonComponent implements Component<EntityStore> {
 
 You can also add validators to your Codec fields to ensure that the data being serialized/deserialized meets certain criteria. For example, if you want to ensure that the `damagePerTick` field is always non-negative or the poison name is never null, you can add a validator like this:
 
-````java
+```java
 .append(
     new KeyedCodec<Float>("DamagePerTick", Codec.FLOAT),
     (data, value) -> data.damagePerTick = value,
@@ -292,14 +292,15 @@ You can also add validators to your Codec fields to ensure that the data being s
 )
 .addValidator(Validators.nonNull())
 .add()
+```
 
 ### Complex Codec Examples
 
-If you want to have a map inside your component, you can use the MapCodec class to build a KeyedCoded for it. Here's an example of how to create a Codec for a Map field:
+If you want to have a map inside your component, you can use the MapCodec class to build a KeyedCodec for it. Here's an example of how to create a Codec for a Map field:
 
 ```java
 var damagePerTick = new KeyedCodec<>("DamagePerTick", new MapCodec<>(Codec.FLOAT, HashMap<String, Float>::new));
-````
+```
 
 <Callout type="info">
   This also works with custom Objects as long as you have a Codec defined for the Object type.
diff --git a/content/docs/tr-TR/guides/java-basics/00-introduction.mdx b/content/docs/tr-TR/guides/java-basics/00-introduction.mdx
index 2198df86..8b374619 100644
--- a/content/docs/tr-TR/guides/java-basics/00-introduction.mdx
+++ b/content/docs/tr-TR/guides/java-basics/00-introduction.mdx
@@ -7,7 +7,7 @@ Java programlama yolculuğuna hoş geldiniz! Bu kılavuz size Java'nın temeller
 
 ## Java Nedir?
 
-Java, 1995 senesinde geliştirilen güçlü bir nesne yönelimli programlama (OOP) dilidir. Dünya üzerindeki en popüler programlama dillerinden biri olup mobil uygulamalardan kurumsal yazılımlara kadar her şey için kullanılıyor. Bizim için en önemlisi, Hytale'ın sunucular ve modlama API'si için kullandığı dil olması.
+Java, 1995 senesinde geliştirilen güçlü bir nesne yönelimli programlama (OOP) dilidir. Dünya üzerindeki en popüler programlama dillerinden biri olup mobil uygulamalardan kurumsal yazılımlara kadar her şey için kullanılıyor. Most importantly for us, it's the language Hytale uses for its servers & modding API.
 
 ## Öğreneceklerin
 
diff --git a/content/docs/tr-TR/guides/java-basics/02-operators.mdx b/content/docs/tr-TR/guides/java-basics/02-operators.mdx
index a132b1c0..18634665 100644
--- a/content/docs/tr-TR/guides/java-basics/02-operators.mdx
+++ b/content/docs/tr-TR/guides/java-basics/02-operators.mdx
@@ -119,7 +119,7 @@ String greetingWithName = "Hello, " + name + "!"; // "Hello, Alice!"
 
 ## Operator Precedence
 
-Operator Precendence means which operator gets evaluated first in an line of code. Think of it like BODMAS/PEMDAS in math!
+Operator Precedence means which operator gets evaluated first in an line of code. Think of it like BODMAS/PEMDAS in math!
 
 ```java
 int result = 10 + 5 * 2; // result is 20, not 30
diff --git a/content/docs/tr-TR/guides/java-basics/03-control-flow-if.mdx b/content/docs/tr-TR/guides/java-basics/03-control-flow-if.mdx
index b9d6c479..af2d1c22 100644
--- a/content/docs/tr-TR/guides/java-basics/03-control-flow-if.mdx
+++ b/content/docs/tr-TR/guides/java-basics/03-control-flow-if.mdx
@@ -7,7 +7,7 @@ Programs need to make decisions. If statements let your code choose different pa
 
 ## Basic If Statement
 
-The simplest form checks one condition;
+The simplest form checks one condition:
 
 ```java
 int health = 20;
diff --git a/content/docs/tr-TR/guides/java-basics/08-access-modifiers.mdx b/content/docs/tr-TR/guides/java-basics/08-access-modifiers.mdx
index af560932..da2bf33b 100644
--- a/content/docs/tr-TR/guides/java-basics/08-access-modifiers.mdx
+++ b/content/docs/tr-TR/guides/java-basics/08-access-modifiers.mdx
@@ -484,7 +484,7 @@ class Data {
     // Static member:
     // cannot access to non-static variables
     public static void bar() {
-        x = 100; // Error: non-static variable x cannot be renference from a static context
+        x = 100; // Error: non-static variable x cannot be referenced from a static context
         y = 100; // OK
     }
 }
@@ -504,7 +504,7 @@ Data.x = 1000; // Error: cannot access instanced variables in a static context
 
 ### Static Fields
 
-A static field represents a data member owned by the class type rather then the object. Static fields are also stored in a specific memory location that's been shared between all the object instances that are created.
+A static field represents a data member owned by the class type rather than the object. Static fields are also stored in a specific memory location that's been shared between all the object instances that are created.
 
 It is declared as following:
 
diff --git a/content/docs/tr-TR/guides/plugin/animated-block-textures.mdx b/content/docs/tr-TR/guides/plugin/animated-block-textures.mdx
new file mode 100644
index 00000000..42bfa51f
--- /dev/null
+++ b/content/docs/tr-TR/guides/plugin/animated-block-textures.mdx
@@ -0,0 +1,101 @@
+---
+title: Animated Block Textures
+description: Learn how to attach a .blockyanim to a block
+authors:
+  - name: Burkino
+---
+
+import { File, Folder, Files } from 'fumadocs-ui/components/files';
+
+So, you want to make your blocks feel more alive through animations, do you?\
+Now for the most part this is the exact same as [Creating custom blocks](./creating-block).
+![blue fire gif](/assets/guides/blue_fire.gif)
+
+## Prerequisites
+
+This is NOT a guide on animating or texturing or even using BlockBench, why? Because I don't know how to do that.\
+The only thing we will be doing is taking the fire texture, changing the color, and applying it to our new fire block.
+
+## Setup
+
+To start, you're obviously going to want to grab the `Common/VFX/Fire/Fire.png` file. How you do it is up to you, in the Asset Editor you'll need to switch to the Common tab.\
+I'll assume you know how colorize or change the hue of an image, so go ahead and do that now and save it as `Blue_Fire.png`.
+
+The other assets used in this guide are `Common/VFX/Fire/Fire.blockymodel` and `Common/Blocks/Animations/Fire/Fire_Burn.blockyanim` (both renamed to `Blue_Fire`) but since we won't be changing them it's probably fine to leave them. I will reference the `Blue_Fire` versions as a way to point out what should be custom assets.\
+I will also duplicate `Server/Item/Item/Deco/Deco_Fire.json` and call it `Deco_Blue_Fire.json`.
+
+## Applying the changes
+
+The `Deco_Blue_Fire` block is actually just a particle emitter, however we will not be using particles, so lets start by removing them in `Block > Particles`.\
+Next we want to set the Block Model (called `CustomModel` in JSON) to `VFX/Blue_Fire/Blue_Fire.blockymodel` and Block Model Textures (`CustomModelTexture` in JSON) to
+
+```json
+[
+    {
+        "Texture": "VFX/Blue_Fire/Blue_Fire.png",
+        "Weight": 1
+    }
+]
+```
+
+Finally, we will apply the .blockyanim to our model, this is done through the Block Model Animation property (`CustomModelAnimation` in JSON) and the value should be `Blocks/Animations/Blue_Fire/Blue_Fire_Burn.blockyanim`.
+
+## Final Code
+
+With that your new blue fire should be done. Here is the minimal JSON for our blue fire.\
+There is an additional `Looping` and `RequiresAlphaBlending` property that I have not gone over, however I hope it is self-explanatory.
+
+```json
+{
+  "BlockType": {
+    "DrawType": "Model",
+    "CustomModel": "VFX/Blue_Fire/Blue_Fire.blockymodel",
+    "CustomModelAnimation": "Blocks/Animations/Blue_Fire/Blue_Fire_Burn.blockyanim",
+    "CustomModelTexture": [
+      {
+        "Texture": "VFX/Blue_Fire/Blue_Fire.png",
+        "Weight": 1
+      }
+    ],
+    "Looping": true,
+    "RequiresAlphaBlending": false
+  },
+  "PlayerAnimationsId": "Block"
+}
+```
+
+<Files>
+  <Folder name="resources" defaultOpen>
+    <Folder name="Server" defaultOpen>
+      <Folder name="Item" defaultOpen>
+        <Folder name="Items" defaultOpen>
+          <Folder name="Deco" defaultOpen>
+            <File name="Deco_Blue_Fire.json" />
+          </Folder>
+        </Folder>
+      </Folder>
+    </Folder>
+
+    <Folder name="Common" defaultOpen>
+      <Folder name="Blocks" defaultOpen>
+        <Folder name="Animations" defaultOpen>
+          <Folder name="Blue_Fire" defaultOpen>
+            <File name="Blue_Fire_Burn.blockyanim" />
+          </Folder>
+        </Folder>
+      </Folder>
+
+      <Folder name="VFX" defaultOpen>
+        <Folder name="Blue_Fire" defaultOpen>
+          <File name="Blue_Fire.blockymodel" />
+
+          <File name="Blue_Fire.png" />
+        </Folder>
+      </Folder>
+    </Folder>
+  </Folder>
+</Files>
+
+## Next steps
+
+Now that you know how to attach an animation to a block, try adding it to a block state.
diff --git a/content/docs/tr-TR/guides/plugin/build-and-test.mdx b/content/docs/tr-TR/guides/plugin/build-and-test.mdx
index 0e7fe7eb..f37534c3 100644
--- a/content/docs/tr-TR/guides/plugin/build-and-test.mdx
+++ b/content/docs/tr-TR/guides/plugin/build-and-test.mdx
@@ -9,18 +9,18 @@ If you followed along with the [Setting Up Your Development Environment](./setti
 
 ## Building Your Mod
 
-In our case, we've **Maven** as the build system. Maven is a powerful build automation tool that manages dependencies, compiles your code, and packages everything into a distributable JAR file.
+In our case, we've **Gradle** as the build system. Gradle is a powerful build automation tool that manages dependencies, compiles your code, and packages everything into a distributable JAR file.
 
-### Understanding Maven
+### Understanding Gradle
 
-Maven uses a `pom.xml` file (Project Object Model) to define your project's configuration, dependencies, and build settings. You can learn more about Maven at the [official Apache Maven website](https://maven.apache.org/).
+Gradle can use a `build.gradle.kts` file (Kotlin DSL) to define your project's configuration, dependencies, and build settings. You can learn more about Gradle at the [official Gradle website](https://gradle.org/).
 
-### Building with Maven
+### Building with Gradle
 
 To build your mod, open a terminal in your project directory and run:
 
 ```bash
-mvn package
+./gradlew build
 ```
 
 This command will:
@@ -29,16 +29,35 @@ This command will:
 2. Run any tests (if present)
 3. Package everything into a JAR file
 
+<Callout type="info">
+  If you are using the plugin template from the [Setting Up Your Development Environment](./setting-up-env) guide, then the build script is already set up for you. It includes paths to your Hytale game library and handles the packaging of your mod, managing hytale dependencies and manifest changes.
+
+  If you have a different path to your Hytale installation, you may receive the following error:
+
+  ```bash
+  FAILURE: Build failed with an exception.
+
+  * What went wrong:
+  Failed to find Hytale at the expected location. Please make sure you have installed the game. The expected location can be changed using the hytale.home_path property. Currently looking in 'C:\Path\To\Hytale'
+  ```
+
+  You can change the path by adding a property to your `gradle.properties` file (if it doesn't exist, create it in the root of your project):
+
+  ```properties
+  hytale.home_path=C:\Correct\Path\To\Hytale
+  ```
+</Callout>
+
 ### Build Output
 
-Once the build completes successfully, your mod will be located in the `target` directory and named:
+Once the build completes successfully, your mod will be located in the `build/libs` directory and named:
 
 ```
-ExamplePlugin-1.0-SNAPSHOT.jar
+ExamplePlugin-1.0.jar
 ```
 
 <Callout type="info">
-  The exact name may vary depending on what you configured in your `pom.xml` file. Check the `artifactId` and `version` fields to see what your JAR will be named.
+  The exact name may vary depending on what you configured in your `build.gradle.kts` and `settings.gradle.kts` file. Check the `rootProject.name` and `version` fields to see what your JAR will be named.
 </Callout>
 
 ## Testing Your Mod
@@ -49,11 +68,11 @@ Now that you've built your mod, it's time to test it in Hytale!
 
 First, you need to find Hytale's mods directory:
 
-1. Press **Win + R** on your keyboard
-2. Type `%appdata%` and press Enter
-3. Navigate to: `Hytale\UserData\Mods`
+1. Go to your Hytale installation directory (The default location is usually in your AppData folder)
+   > On Windows, you can access it by clicking `windows + R` and typing `%appdata%`.
+2. Navigate to: `/UserData/Mods`
 
-The full path should look like:
+The default path would look like:
 
 ```
 C:\Users\YourUsername\AppData\Roaming\Hytale\UserData\Mods
@@ -65,7 +84,7 @@ C:\Users\YourUsername\AppData\Roaming\Hytale\UserData\Mods
 
 ### 2. Copy Your Mod
 
-Copy the `ExamplePlugin-1.0-SNAPSHOT.jar` file from your project's `target` directory into the `Mods` folder you just located.
+Copy the `ExamplePlugin-1.0.jar` file from your project's `build/libs` directory into the `Mods` folder you just located.
 
 ### 3. Launch Hytale and Verify
 
@@ -84,7 +103,7 @@ If your mod doesn't appear in the mods list:
 - Make sure the JAR file is in the correct `Mods` folder
 - Check that your `manifest.json` file is properly configured
 - Look for any error messages in the Hytale logs
-- Verify that you're using the correct version of Java and Maven
+- Verify that you're using the correct version of Java and Gradle
 
 ## Next Steps
 
diff --git a/content/docs/tr-TR/guides/plugin/creating-commands.mdx b/content/docs/tr-TR/guides/plugin/creating-commands.mdx
index d33597f3..08572f16 100644
--- a/content/docs/tr-TR/guides/plugin/creating-commands.mdx
+++ b/content/docs/tr-TR/guides/plugin/creating-commands.mdx
@@ -8,6 +8,8 @@ authors:
     url: https://oskar.scot
   - name: jacobwojoski
     url: https://github.com/jacobwojoski
+  - name: Marcel-TO
+    url: https://marcel-to.net
 ---
 
 In this guide, you will learn how to create custom commands for your Hytale mod.
@@ -36,7 +38,7 @@ The most basic command is an `AbstractAsyncCommand`. It has very minimal data av
   `AbstractAsyncCommand` runs on its own background thread. This means its execute is not tied to any world instance and because of this it can not edit any **Stores** or **Refs** without getting the desired world first. To access this data any of the other command types would be preferred and are likely what you will want to use instead.
 </Callout>
 
-The main purpose for a command like this would be for something that can happen everywhere and is not tied to a specific world. For example a `serverRules` command to tell the user thats running the command in chat what the servers rules are nomatter what world they are in.
+The main purpose for a command like this would be for something that can happen everywhere and is not tied to a specific world. For example a `serverRules` command to tell the user that's running the command in chat what the server's rules are no matter what world they are in.
 
 ```java
 // Command that can be run that lists the server rules in chat to the player
@@ -49,7 +51,7 @@ public class ServerRulesCommand extends AbstractAsyncCommand {
     }
 
     // Run the command
-    // conetext - info about who ran the command. Server console?, Some player?
+    // context - info about who ran the command. Server console?, Some player?
     @Override
     protected CompletableFuture<Void> executeAsync(@Nonnull CommandContext context) {
         context.sendMessage(Message.raw("The only rule is there are no rules."));
@@ -134,7 +136,7 @@ Uses a Ray to see what the player is looking at and tries to run the command on
 
 ## Adding Arguments
 
-Arguments are additional fields that the user can input when running a command. The different types of arguments along with small snipits and a large example can be seen below.
+Arguments are additional fields that the user can input when running a command. The different types of arguments along with small snippets and a large example can be seen below.
 
 ### Command Argument Types
 
@@ -163,14 +165,14 @@ this.messageArg = this.withOptionalArg("message", "Message to print while healin
 
 ### Default Arguments
 
-Adding a default argument has two additional arguemnt for the default value and default value description. You need to use `withDefaultArg` method.
+Adding a default argument has two additional argument for the default value and default value description. You need to use `withDefaultArg` method.
 
 ```java
 // args <Command String> <Description> <Default Value> <Desc of default value>
 this.healthArg = this.withDefaultArg("health", "Amount to heal player", ArgTypes.FLOAT, (float)100, "Desc of Default: 100");
 ```
 
-### Flag Arguemnts
+### Flag Arguments
 
 Similar as above but the flags return is either true if it exists or false if it does not. You need to use `withFlagArg` method.
 
@@ -181,20 +183,13 @@ this.debugArg = this.withFlagArg("debug", "Add debug logs");
 
 ### ArgTypes
 
-The following ArgTypes are available (only lists common types):
-
-- `ArgTypes.STRING`
-- `ArgTypes.INTEGER`
-- `ArgTypes.BOOLEAN`
-- `ArgTypes.FLOAT`
-- `ArgTypes.DOUBLE`
-- `ArgTypes.UUID`
+You can find all the available argument types on the [ArgTypes](../../argtypes) page.
 
 ### Example Command Arg Types
 
-Shows all Command arguemnt types with different various input types.
+Shows all Command argument types with different various input types.
 
-**NOTE:** When getting the value of an argument during execute you need to pass the context with `someArg.get(commandContext)`. Where `commandContext` is the first variable in the execute funtion.
+**NOTE:** When getting the value of an argument during execute you need to pass the context with `someArg.get(commandContext)`. Where `commandContext` is the first variable in the execute function.
 
 ```java
 // Example usage: /healplayer --health 50 --message "Feels Good" --debug
@@ -204,7 +199,7 @@ public class HealPlayerCommand extends AbstractTargetPlayerCommand {
     private final FlagArg debugArg;
 
     public HealPlayerCommand() {
-        super("healplayer", "Healing a player for an <input> ammount of HP (default: 100)");
+        super("healplayer", "Healing a player for an <input> amount of HP (default: 100)");
 
         // Abstract TargetPlayerCommand passes the player that ran the command by default and implements
         // the use of `--player <value>` to specify someone else
@@ -213,10 +208,10 @@ public class HealPlayerCommand extends AbstractTargetPlayerCommand {
         this.healthArg = this.withDefaultArg("health", "Amount to heal player", ArgTypes.FLOAT, (float)100, "Desc of Default: 100");
 
         // Or you could do the following making the health value required instead of with a default.
-        //    You would need to change the decleration to RequiredArg<Float>
+        //    You would need to change the declaration to RequiredArg<Float>
         // this.healthArg = this.withRequiredArg("health", "Amount to heal player", ArgTypes.FLOAT);
 
-        // Optional args reguare the user the input `--<key> <value>` so the following would require `--message "Good Luck"`
+// Optional args require the user the input `--<key> <value>` so the following would require `--message "Good Luck"`
         this.messageArg = this.withOptionalArg("message", "Message to print while healing", ArgTypes.STRING);
 
         // No type needed due to being a bool
@@ -230,7 +225,7 @@ public class HealPlayerCommand extends AbstractTargetPlayerCommand {
             commandContext.sendMessage(Message.raw("We are debugging"));
         }
 
-        // Health is stored in a generic stat map to allowing mods/future contect to easily add more stats if desired.
+        // Health is stored in a generic stat map to allowing mods/future content to easily add more stats if desired.
         EntityStatMap stats = store.getComponent(ref, EntityStatMap.getComponentType());
         int healthIdx = DefaultEntityStatTypes.getHealth();
         EntityStatValue health = stats.get(healthIdx);
@@ -252,7 +247,7 @@ public class HealPlayerCommand extends AbstractTargetPlayerCommand {
 
 ## Argument Validators
 
-Argument validators are a way to check the command before the command gets executed. They are added with the `addValidator` method on an argument when calling `withXxxArg`. They provide a nice output to the user when an input value is invalid.
+Argument validators are a way to check the command before the command gets executed. They are added with the `addValidator` method on an argument when calling `withXxxArg`. They provide a nice output to the user when an input value is invalid. There are some common validators provided in the `Validators` class such as `greaterThan`, `lessThan`, and `or`, `max`, `range`, etc.
 
 ```java
 ...
@@ -260,18 +255,59 @@ Argument validators are a way to check the command before the command gets execu
     OptionalArg<Integer> healAmount = withOptionalArg("amount", "Heal Amount", ArgTypes.INTEGER)
         .addValidator(Validators.greaterThan(0))
         .addValidator(Validators.lessThan(1000));
-
-    // Custom check example
-    OptionalArg<Integer> healAmount = withOptionalArg("amount", "Heal Amount", ArgTypes.INTEGER)
-            .addValidator( value -> {
-                if (value != null && value <= 0) {
-                    return ValidationResult.error("ammount argument must be a positive number");
-                }
-                return ValidationResult.success();
-            });
 ...
 ```
 
+### Custom Validators
+
+You can also create custom validators by implementing the `com.hypixel.hytale.codec.validation.Validator` interface. The interfaces forces you to implement the `accept` and `updateSchema` method. The `accept` method takes in the argument value and validates it. If the validation fails, you can use the `fail` method of the `com.hypixel.hytale.codec.validation.ValidationResults` class to return an error message.
+The `updateSchema` method is used to update the schema of the command argument. This is used for commands that have dynamic schemas based on the input value. For example, if you have a command that takes in a player name as an argument, you can use the `updateSchema` method to update the schema to include a list of online players for validation.
+
+Here is an example of a custom validator that checks if a string value is equal to a banned word. In this example, the banned word is "badword". If the input value is "badword", the validator will fail and return an error message.
+
+```java
+import com.hypixel.hytale.codec.schema.SchemaContext;
+import com.hypixel.hytale.codec.schema.config.Schema;
+import com.hypixel.hytale.codec.validation.ValidationResults;
+import com.hypixel.hytale.codec.validation.Validator;
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+
+public class MyCustomValidator implements Validator<String> {
+    @Nonnull
+    private final String value;
+
+    public MyCustomValidator(@Nonnull String value) {
+        this.value = value;
+    }
+
+    @Override
+    public void accept(@Nullable String input, @Nonnull ValidationResults results) {
+        if (this.value.equalsIgnoreCase(input)) {
+            results.fail("The given role has been banned.");
+        }
+    }
+
+    @Override
+    public void updateSchema(SchemaContext context, @Nonnull Schema target) {
+        // This method can be used to update the schema of the command argument. This is useful for commands that have dynamic schemas based on the input value. For example, if you have a command that takes in a player name as an argument, you can use the `updateSchema` method to update the schema to include a list of online players for validation.
+        throw new UnsupportedOperationException("Not implemented yet.");
+    }
+}
+```
+
+After the custom validator is created, you can add it to an argument like the following example. In this example, we add the `MyCustomValidator` to a string argument called "role". If the user inputs "badword" as the role, the command will fail and return the error message defined in the `MyCustomValidator`.
+
+```java
+    ...
+    // Custom validator example
+    String bannedRole = "badword";
+
+    OptionalArg<String> roleArg = withOptionalArg("role", "Role to assign", ArgTypes.STRING)
+        .addValidator(new MyCustomValidator(bannedRole));
+    ...
+```
+
 ---
 
 ## Permissions
@@ -312,7 +348,7 @@ This allows the server to control who has access to specific commands. You add t
 
 If you want variants of the same command without doing argument parsing you can instead use `addUsageVariant(new OtherCommandClass())` in the original commands constructor.
 
-The only difference is in the `OtherCommandClass()` constrcutor you don't pass the command name to the super class.
+The only difference is in the `OtherCommandClass()` constructor you don't pass the command name to the super class.
 
 <Callout type="info">
   You can also use `addAliases("some_alias", "some_other_alias")` as a way to add shorthand or other ways to write the same command.
@@ -387,7 +423,7 @@ public class AdminCommand extends AbstractCommandCollection {
     public AdminCommand () {
         super("admin", "Admin commands");
         addSubCommand(new UserCommandCollection());
-        addSybCommand(new ServerCommandCollection);
+        addSubCommand(new ServerCommandCollection);
     }
 }
 ```
@@ -417,5 +453,5 @@ public class MyPlugin extends JavaPlugin {
 
 ## Video Link
 
-_Special Thanks to [TroubleDev](https://www.youtube.com/@TroubleDEV) for his excelent video guide on all of these features._
+_Special Thanks to [TroubleDev](https://www.youtube.com/@TroubleDEV) for his excellent video guide on all of these features._
 _Video Link: [TroubleDev - Hytale's Command API Explained](https://www.youtube.com/watch?v=KnmhG9MDMgo)_
diff --git a/content/docs/tr-TR/guides/plugin/creating-events.mdx b/content/docs/tr-TR/guides/plugin/creating-events.mdx
index 95863990..d3f0925d 100644
--- a/content/docs/tr-TR/guides/plugin/creating-events.mdx
+++ b/content/docs/tr-TR/guides/plugin/creating-events.mdx
@@ -1,6 +1,6 @@
 ---
-title: Creating Events
-description: Learn how to create custom events for your Hytale mod.
+title: Creating Events Listeners
+description: Learn how to create event listeners for your Hytale mod.
 authors:
   - name: Neil Revin
     url: https://itsneil.dev
@@ -10,7 +10,7 @@ authors:
 
 ## Event Class
 
-You can import a Event class and create a function with the Event as a argument. [Click here](../../server/events) to look at all available events.
+You can import an Event class and create a function with the Event as an argument. [Click here](../../server/events) to look at all available events.
 
 Example plugin when a player is ready (joins a server):
 
diff --git a/content/docs/tr-TR/guides/plugin/item-registry.mdx b/content/docs/tr-TR/guides/plugin/item-registry.mdx
new file mode 100644
index 00000000..9a0fd53a
--- /dev/null
+++ b/content/docs/tr-TR/guides/plugin/item-registry.mdx
@@ -0,0 +1,95 @@
+---
+title: Working with the Item Registry
+description: Learn how to access and query the game's item registry to list all items, check if items exist, and retrieve item properties.
+authors:
+  - name: Denis
+---
+
+In this guide, you'll learn how to work with Hytale's Item Registry system. This is useful when you need to programmatically list all available items, validate item IDs, or retrieve item properties at runtime.
+
+## Prerequisites
+
+Before diving in, you should be familiar with:
+
+- [Setting up your development environment](./setting-up-env)
+- [Creating commands](./creating-commands) (optional, for testing)
+
+## Required Imports
+
+To work with the Item Registry, you'll need the following imports:
+
+```java
+import com.hypixel.hytale.assetstore.map.DefaultAssetMap;
+import com.hypixel.hytale.server.core.asset.type.item.config.Item;
+```
+
+## Getting the Item Registry
+
+The Item Registry is accessed through the `Item.getAssetMap()` method, which returns a `DefaultAssetMap<String, Item>` containing all registered items in the game:
+
+```java
+DefaultAssetMap<String, Item> itemMap = Item.getAssetMap();
+```
+
+## Listing All Items
+
+To iterate through all items in the registry, you can get the underlying map and loop through its entries:
+
+```java
+DefaultAssetMap<String, Item> itemMap = Item.getAssetMap();
+var map = itemMap.getAssetMap();
+
+for (var entry : map.entrySet()) {
+    String itemId = String.valueOf(entry.getKey());
+    Item item = entry.getValue();
+    
+    // Do something with the item
+    LOGGER.atInfo().log("Item ID: " + itemId);
+}
+```
+
+You can also get the total count of registered items:
+
+```java
+int totalItems = map.size();
+```
+
+## Checking if an Item Exists
+
+To check if a specific item exists in the registry, use `getAsset()` and verify the result:
+
+```java
+public boolean itemExists(String itemId) {
+    var assetMap = Item.getAssetMap();
+    if (assetMap != null) {
+        Item item = assetMap.getAsset(itemId);
+        return item != null && item != Item.UNKNOWN;
+    }
+    return false;
+}
+```
+
+<Callout type="info">
+  The `Item.UNKNOWN` constant represents an invalid or unrecognized item. Always check for both `null` and `Item.UNKNOWN` when validating items.
+</Callout>
+
+## Accessing Item Properties
+
+Once you have an `Item` instance, you can access various properties:
+
+```java
+var assetMap = Item.getAssetMap();
+Item item = assetMap.getAsset("Soil_Grass");
+
+if (item != null && item != Item.UNKNOWN) {
+    String id = item.getId(); // Soil_Grass
+    int maxStack = item.getMaxStack(); // 100
+    boolean isBlock = item.hasBlockType(); // true
+    boolean isConsumable = item.isConsumable(); // false
+}
+```
+
+## Related Guides
+
+- [Inventory Management](./inventory-management) - Learn how to add and remove items from player inventories
+- [Create Custom Item and Interaction](./item-interaction) - Learn how to create your own custom items
diff --git a/content/docs/tr-TR/guides/plugin/permission-management.mdx b/content/docs/tr-TR/guides/plugin/permission-management.mdx
index 6b7cfd46..55f06101 100644
--- a/content/docs/tr-TR/guides/plugin/permission-management.mdx
+++ b/content/docs/tr-TR/guides/plugin/permission-management.mdx
@@ -10,132 +10,569 @@ authors:
     link: https://discord.com/users/292656109939064833
   - name: Ivan
     link: https://discord.com/users/505770451218333717
+  - name: ZenithDevHQ
+    link: https://github.com/ZenithDevHQ
 ---
 
-In this guide, you'll learn how to manage permission nodes and groups in your Hytale plugin.
+In this guide, you'll learn how to manage permission nodes and groups in your Hytale plugin. Permissions control what actions players can perform on your server, from basic commands to advanced administrative functions.
 
-## The `PermissionsModule` class
+## What Are Permissions?
 
-The `PermissionsModule` class is responsible for managing permission nodes and groups in your plugin. It provides methods to check, grant and revoke permissions and groups for players. It allows the following operations
+Permissions are string identifiers that control access to features and commands. When a player tries to perform an action (like using a command), the server checks if they have the required permission.
 
-- Add permissions to user
-- Remove permissions from user
-- Add permissions to group (this also creates the group if it doesn't exist)
-- Remove permissions from group
-- Add user to group
-- Remove user from group
-- List all groups for a user
-- Check if a user has a permission (it checks both user and group permissions for the given player UUID)
+**Example permission nodes:**
 
-With this class you cannot:
+- `hytale.command.gamemode` - Permission to use the gamemode command
+- `hytale.editor.brush.use` - Permission to use brush tools
+- `myplugin.teleport.home` - A custom permission for your plugin
 
-- List all defined groups
-- Remove a group
+Permissions follow a hierarchical naming pattern: `namespace.category.action`
 
-### Adding Permission Nodes
+## Key Concepts
 
-You need a `Set<String>` containing all the permission nodes you want to add, these are added on top of the already existing permission nodes the user may have, it is not a replacement.
+Before diving into code, let's understand the core concepts:
+
+| Concept             | Description                                                                |
+| ------------------- | -------------------------------------------------------------------------- |
+| **Permission Node** | A string like `myplugin.feature.use` that represents a specific permission |
+| **Group**           | A named collection of permissions (e.g., "Admin", "VIP", "Default")        |
+| **Provider**        | The backend that stores and retrieves permissions                          |
+| **Wildcard**        | A pattern like `*` or `myplugin.*` that matches multiple permissions       |
+
+### How Permissions Are Checked
+
+When checking if a player has a permission, Hytale follows this order:
+
+1. **User's direct permissions** - Permissions granted directly to the player
+2. **Group permissions** - Permissions from groups the player belongs to
+3. **Virtual groups** - Game-mode-based permissions (e.g., Creative mode grants builder tools)
+4. **Default value** - Falls back to `false` if no match found
+
+<Callout type="info">
+  The first definitive match wins. If a player has a permission granted at the user level, group permissions won't override it.
+</Callout>
+
+---
+
+## The `PermissionsModule` Class
+
+The `PermissionsModule` class is the central hub for managing permissions. Access it using the singleton pattern:
 
 ```java
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.addUserPermission(playerUUID, permissions);
 ```
 
-### Removing Permission Nodes
+### Available Operations
+
+The module supports these operations:
+
+| Operation                     | Method                                          |
+| ----------------------------- | ----------------------------------------------- |
+| Add permissions to user       | `addUserPermission(uuid, permissions)`          |
+| Remove permissions from user  | `removeUserPermission(uuid, permissions)`       |
+| Add permissions to group      | `addGroupPermission(groupName, permissions)`    |
+| Remove permissions from group | `removeGroupPermission(groupName, permissions)` |
+| Add user to group             | `addUserToGroup(uuid, groupName)`               |
+| Remove user from group        | `removeUserFromGroup(uuid, groupName)`          |
+| Get user's groups             | `getGroupsForUser(uuid)`                        |
+| Check permission              | `hasPermission(uuid, permissionNode)`           |
+
+<Callout type="warning">
+  The module does **not** support:
+
+  - Listing all defined groups
+  - Deleting a group entirely
+
+  Groups are implicitly created when you first add permissions to them.
+</Callout>
+
+---
 
-Same as above, we just use the `removeUserPermission` method instead to remove permission nodes.
+## Checking Permissions
+
+The most common operation is checking if a player has a permission.
+
+### Basic Permission Check
+
+```java
+// Returns true if player has the permission, false otherwise
+boolean canUse = PermissionsModule.get().hasPermission(playerUUID, "myplugin.feature.use");
+
+if (canUse) {
+    // Player has permission, allow the action
+} else {
+    // Player lacks permission, deny or show error
+}
+```
+
+### Permission Check with Default Value
+
+You can specify what to return when no permission is explicitly set:
+
+```java
+// Returns true by default if no explicit permission is found
+boolean canUse = PermissionsModule.get().hasPermission(playerUUID, "myplugin.feature.use", true);
+```
+
+This is useful for features that should be enabled by default but can be revoked.
+
+### Using PermissionHolder Interface
+
+Players and command senders implement `PermissionHolder`, allowing direct checks:
+
+```java
+// In a command or event handler where you have access to the player
+if (player.hasPermission("myplugin.admin.manage")) {
+    // Player has admin permission
+}
+```
+
+---
+
+## Managing User Permissions
+
+### Adding Permissions to a User
+
+Permissions are additive - new permissions are added on top of existing ones, not replaced.
+
+```java
+PermissionsModule perms = PermissionsModule.get();
+
+// Add a single permission
+perms.addUserPermission(playerUUID, Set.of("myplugin.vip.chat"));
+
+// Add multiple permissions at once
+Set<String> newPerms = Set.of(
+    "myplugin.vip.chat",
+    "myplugin.vip.fly",
+    "myplugin.vip.kit"
+);
+perms.addUserPermission(playerUUID, newPerms);
+```
+
+### Removing Permissions from a User
 
 ```java
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.removeUserPermission(playerUUID, permissions);
+
+// Remove specific permissions
+Set<String> toRemove = Set.of("myplugin.vip.fly");
+perms.removeUserPermission(playerUUID, toRemove);
 ```
 
-### Add permissions to group
+---
+
+## Managing Groups
+
+Groups let you assign a collection of permissions to multiple players. This is more manageable than assigning permissions individually.
+
+### Adding Permissions to a Group
+
+If the group doesn't exist, it will be created automatically.
 
 ```java
-String groupName = "testGroup";
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.addGroupPermission(groupName, permissions);
+
+// Create/update the "VIP" group with permissions
+Set<String> vipPerms = Set.of(
+    "myplugin.vip.chat",
+    "myplugin.vip.fly",
+    "myplugin.vip.kit"
+);
+perms.addGroupPermission("VIP", vipPerms);
 ```
 
-### Remove permissions from group
+### Removing Permissions from a Group
 
 ```java
-String groupName = "testGroup";
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.removeGroupPermission(groupName, permissions);
+
+// Remove specific permissions from the group
+Set<String> toRemove = Set.of("myplugin.vip.fly");
+perms.removeGroupPermission("VIP", toRemove);
 ```
 
-### Add user to group
+### Adding a User to a Group
 
 ```java
-String groupName = "testGroup";
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.addUserToGroup(playerUUID, groupName);
+
+// Add player to the VIP group - they now have all VIP permissions
+perms.addUserToGroup(playerUUID, "VIP");
 ```
 
-### Remove user from group
+### Removing a User from a Group
 
 ```java
-String groupName = "testGroup";
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.removeUserFromGroup(playerUUID, groupName);
+
+// Remove player from VIP group
+perms.removeUserFromGroup(playerUUID, "VIP");
 ```
 
-### List all groups for a user
+### Getting a User's Groups
 
 ```java
 PermissionsModule perms = PermissionsModule.get();
-perms.getGroupsForUser(playerUUID);
+
+// Get all groups the player belongs to
+Set<String> groups = perms.getGroupsForUser(playerUUID);
+
+for (String group : groups) {
+    System.out.println("Player is in group: " + group);
+}
 ```
 
-### Check Permission Nodes
+---
+
+## Built-in Groups
+
+Hytale includes two default groups:
+
+| Group     | Default Permissions   | Purpose                           |
+| --------- | --------------------- | --------------------------------- |
+| `OP`      | `*` (all permissions) | Server operators with full access |
+| `Default` | None                  | Base group for all players        |
+
+Players without any explicit group assignment are automatically part of the `Default` group.
 
-To check if a player has a specific permission node, you can use the `hasPermission` method.
+---
+
+## Wildcards
+
+Wildcards let you grant or deny multiple permissions with a single pattern.
+
+### Wildcard Patterns
+
+| Pattern             | Meaning                                          |
+| ------------------- | ------------------------------------------------ |
+| `*`                 | Grants **all** permissions                       |
+| `myplugin.*`        | Grants all permissions starting with `myplugin.` |
+| `-*`                | Denies **all** permissions                       |
+| `-myplugin.admin.*` | Denies all admin permissions in your plugin      |
+
+### Example: Admin Group with Wildcards
 
 ```java
-boolean hasPermission = PermissionsModule.hasPermission(playerUUID, "permission.node");
+// Grant all permissions to admins
+perms.addGroupPermission("Admin", Set.of("*"));
+
+// Grant all plugin permissions to moderators
+perms.addGroupPermission("Moderator", Set.of("myplugin.*"));
+
+// Grant all permissions except admin commands
+perms.addGroupPermission("Helper", Set.of(
+    "*",
+    "-myplugin.admin.*"  // Deny admin permissions
+));
 ```
 
-## Additional: Defining your own provider for permissions and groups
+<Callout type="warning">
+  Negation permissions (starting with `-`) take precedence at each level. Use them carefully to avoid accidentally blocking permissions.
+</Callout>
+
+---
+
+## Built-in Permission Nodes
+
+Hytale provides constants for common permissions in the `HytalePermissions` class:
+
+### Command Permissions
+
+```java
+// Generate permission for a command
+String perm = HytalePermissions.fromCommand("gamemode");
+// Result: "hytale.command.gamemode"
+
+// Generate permission for a subcommand
+String perm = HytalePermissions.fromCommand("gamemode", "creative");
+// Result: "hytale.command.gamemode.creative"
+```
+
+### Common Permission Nodes
+
+| Permission                    | Description                  |
+| ----------------------------- | ---------------------------- |
+| `hytale.command.op.add`       | Add players to OP group      |
+| `hytale.command.op.remove`    | Remove players from OP group |
+| `hytale.editor.brush.use`     | Use brush tools              |
+| `hytale.editor.prefab.use`    | Use prefabs                  |
+| `hytale.editor.selection.use` | Use selection tools          |
+| `hytale.editor.history`       | Undo/redo operations         |
+| `hytale.camera.flycam`        | Use fly camera mode          |
+
+---
+
+## Listening to Permission Events
+
+You can react to permission changes using Hytale's event system.
+
+### Available Events
+
+| Event                                            | Triggered When                   |
+| ------------------------------------------------ | -------------------------------- |
+| `PlayerPermissionChangeEvent.PermissionsAdded`   | Permissions added to a user      |
+| `PlayerPermissionChangeEvent.PermissionsRemoved` | Permissions removed from a user  |
+| `PlayerGroupEvent.Added`                         | User added to a group            |
+| `PlayerGroupEvent.Removed`                       | User removed from a group        |
+| `GroupPermissionChangeEvent.Added`               | Permissions added to a group     |
+| `GroupPermissionChangeEvent.Removed`             | Permissions removed from a group |
 
-The PermissionsModule also enables us to define our own PermissionProvider's, this can be useful for:
+### Example: Reacting to Permission Changes
 
-- Cross server permission systems
-- Implementing features missing in the `HytalePermissionsProvider` like permission expiry
+```java
+public class PermissionListener {
+
+    public static void onPermissionsAdded(PlayerPermissionChangeEvent.PermissionsAdded event) {
+        UUID playerUUID = event.getPlayerUuid();
+        Set<String> added = event.getAddedPermissions();
+
+        System.out.println("Permissions added to " + playerUUID + ": " + added);
 
-To implement our PermissionProvider, first we need to define a provider class that implements PermissionProvider:
+        // Maybe notify the player or update cached data
+    }
+
+    public static void onGroupAdded(PlayerGroupEvent.Added event) {
+        UUID playerUUID = event.getPlayerUuid();
+        String groupName = event.getGroupName();
+
+        System.out.println("Player " + playerUUID + " joined group: " + groupName);
+    }
+}
+```
+
+### Registering the Events
 
 ```java
-public class DatabasePermissionProvider implements PermissionProvider
+public class MyPlugin extends JavaPlugin {
+
+    @Override
+    public void setup() {
+        EventRegistry events = this.getEventRegistry();
+
+        events.registerGlobal(
+            PlayerPermissionChangeEvent.PermissionsAdded.class,
+            PermissionListener::onPermissionsAdded
+        );
+
+        events.registerGlobal(
+            PlayerGroupEvent.Added.class,
+            PermissionListener::onGroupAdded
+        );
+    }
+}
 ```
 
-Then we just implement the required methods using a database implementation.
+---
+
+## Creating a Custom Permission Provider
+
+For advanced use cases, you can create your own permission provider. This is useful for:
+
+- Database-backed permissions (MySQL, MongoDB, etc.)
+- Cross-server permission synchronization
+- Custom features like permission expiry or contexts
+
+### Implementing PermissionProvider
+
+```java
+public class DatabasePermissionProvider implements PermissionProvider {
+
+    @Nonnull
+    @Override
+    public String getName() {
+        return "DatabasePermissionProvider";
+    }
+
+    // User permission methods
+    @Override
+    public void addUserPermissions(@Nonnull UUID uuid, @Nonnull Set<String> permissions) {
+        // Save to your database
+    }
+
+    @Override
+    public void removeUserPermissions(@Nonnull UUID uuid, @Nonnull Set<String> permissions) {
+        // Remove from your database
+    }
+
+    @Override
+    public Set<String> getUserPermissions(@Nonnull UUID uuid) {
+        // Query your database
+        return Set.of();
+    }
+
+    // Group permission methods
+    @Override
+    public void addGroupPermissions(@Nonnull String group, @Nonnull Set<String> permissions) {
+        // Save to your database
+    }
+
+    @Override
+    public void removeGroupPermissions(@Nonnull String group, @Nonnull Set<String> permissions) {
+        // Remove from your database
+    }
+
+    @Override
+    public Set<String> getGroupPermissions(@Nonnull String group) {
+        // Query your database
+        return Set.of();
+    }
+
+    // User-group membership methods
+    @Override
+    public void addUserToGroup(@Nonnull UUID uuid, @Nonnull String group) {
+        // Save to your database
+    }
+
+    @Override
+    public void removeUserFromGroup(@Nonnull UUID uuid, @Nonnull String group) {
+        // Remove from your database
+    }
+
+    @Override
+    public Set<String> getGroupsForUser(@Nonnull UUID uuid) {
+        // Query your database
+        return Set.of("Default");
+    }
+}
+```
 
 <Callout type="warning">
-  Hytale will try to use the first available permissions provider to add/remove gamemode groups (i.e. `Creative`, `Adventure`).
+  Hytale automatically assigns players to game-mode groups (like `Creative` or `Adventure`) using the first available provider.
+
+  If your provider throws an error when the group doesn't exist, the player will be disconnected! Always handle missing groups gracefully.
+</Callout>
+
+### Registering Your Provider
 
-  If your provider throws an error (for instance, if the group does not exist) when the server is preparing the player, the player will be disconnected.
+```java
+public class MyPlugin extends JavaPlugin {
+
+    @Override
+    public void setup() {
+        // Add your provider alongside the default one
+        PermissionsModule.get().addProvider(new DatabasePermissionProvider());
+    }
+}
+```
+
+The `PermissionsModule` aggregates permissions from all registered providers. This means:
+
+- Permission checks query all providers
+- Write operations (add/remove) use the **first** provider
+
+### Replacing the Default Provider
+
+If you want full control, you can remove the default provider:
+
+```java
+public class MyPlugin extends JavaPlugin {
+
+    @Override
+    public void setup() {
+        PermissionsModule perms = PermissionsModule.get();
+
+        // Remove the default provider FIRST
+        perms.removeProvider(perms.getFirstPermissionProvider());
+
+        // Then add your provider
+        perms.addProvider(new DatabasePermissionProvider());
+    }
+}
+```
+
+<Callout type="info">
+  When you remove the default provider, the `/op self` command will stop working since it checks for provider tampering.
 </Callout>
 
-We can then register the provider using the built-in permission module:
+---
+
+## Best Practices
+
+### Permission Naming Conventions
+
+Follow the pattern: `namespace.category.action`
 
 ```java
-PermissionsModule.get().addProvider(new DatabasePermissionProvider());
+// Good - clear hierarchy
+"myplugin.admin.ban"
+"myplugin.user.teleport.home"
+"myplugin.vip.chat.color"
+
+// Bad - unclear structure
+"myplugin_ban"
+"teleport"
+"vipChatColor"
 ```
 
-Please note that the `HytalePermissionsProvider` will still be enabled alongside your provider.
-The `PermissionsModule` will aggregate groups and permissions from all available providers.
+### Use Constants for Permissions
 
-If you want to disable the default `HytalePermissionsProvider`, you can use:
+Define your permissions as constants to avoid typos:
 
 ```java
-// put this **before** you add your provider
-PermissionsModule.get().removeProvider(PermissionsModule.get().getFirstPermissionProvider());
+public final class MyPermissions {
+    public static final String ADMIN_BAN = "myplugin.admin.ban";
+    public static final String ADMIN_KICK = "myplugin.admin.kick";
+    public static final String USER_HOME = "myplugin.user.home";
+    public static final String VIP_FLY = "myplugin.vip.fly";
+}
+
+// Usage
+if (player.hasPermission(MyPermissions.ADMIN_BAN)) {
+    // ...
+}
 ```
+
+### Don't Over-Permission
+
+Only create permissions for actions that genuinely need access control. Not everything needs a permission check.
+
+### Thread Safety
+
+If you create a custom provider, ensure it's thread-safe. Permission checks can occur from multiple threads simultaneously. Use `ReadWriteLock` or `ConcurrentHashMap` for your data structures.
+
+---
+
+## In-Game Commands
+
+Hytale provides built-in commands for managing permissions:
+
+### `/op` Command
+
+| Command               | Description                                                        |
+| --------------------- | ------------------------------------------------------------------ |
+| `/op self`            | Toggle your own OP status (singleplayer or with `--allow-op` flag) |
+| `/op add <player>`    | Add a player to the OP group                                       |
+| `/op remove <player>` | Remove a player from the OP group                                  |
+
+### `/perm` Command
+
+Use `/perm --help` in-game for full usage. Common operations:
+
+| Command                                  | Description                   |
+| ---------------------------------------- | ----------------------------- |
+| `/perm user list <uuid>`                 | List user's permissions       |
+| `/perm user add <uuid> <perm>`           | Add permission to user        |
+| `/perm user remove <uuid> <perm>`        | Remove permission from user   |
+| `/perm user group list <uuid>`           | List user's groups            |
+| `/perm user group add <uuid> <group>`    | Add user to group             |
+| `/perm user group remove <uuid> <group>` | Remove user from group        |
+| `/perm group list <group>`               | List group's permissions      |
+| `/perm group add <group> <perm>`         | Add permission to group       |
+| `/perm group remove <group> <perm>`      | Remove permission from group  |
+| `/perm test <perm>`                      | Test if you have a permission |
+
+---
+
+## Summary
+
+You've learned how to:
+
+- **Check permissions** using `PermissionsModule.hasPermission()`
+- **Manage user permissions** with `addUserPermission()` and `removeUserPermission()`
+- **Work with groups** using `addGroupPermission()`, `addUserToGroup()`, etc.
+- **Use wildcards** like `*` and `myplugin.*` for bulk permissions
+- **Listen to events** for permission changes
+- **Create custom providers** for database-backed permissions
+
+For more advanced permission systems with features like inheritance, expiry, and contexts, we're looking into expanding this guide with advanced permission management techniques in the future.
diff --git a/content/docs/tr-TR/guides/plugin/setting-up-env.mdx b/content/docs/tr-TR/guides/plugin/setting-up-env.mdx
index d2718098..5be5e9e0 100644
--- a/content/docs/tr-TR/guides/plugin/setting-up-env.mdx
+++ b/content/docs/tr-TR/guides/plugin/setting-up-env.mdx
@@ -4,6 +4,10 @@ description: Learn how to set up your development environment for modding Hytale
 authors:
   - name: Neil Revin
     link: https://itsneil.dev
+  - name: Marcel-TO
+    url: https://marcel-to.net
+  - name: Ádám Liszkai
+    link: https://adaliszk.dev
 ---
 
 This guide will walk you through setting up a complete development environment for Hytale modding, including all necessary tools and dependencies.
@@ -19,24 +23,73 @@ Before we begin, make sure you have:
 
 ## Required Software
 
-### 1. Java Development Kit (JDK)
+### Integrated Development Environment (IDE)
 
+We recommend IntelliJ IDEA Community Edition for Hytale modding. If you use IntelliJ IDEA, **almost everything is built-in**. You can clone a template, open a new project, and start working right away!
+
+1. Download from [JetBrains website](https://www.jetbrains.com/idea/download/)
+2. Install with default settings
+3. Launch and complete the initial setup wizard
+
+When opening a project, wait for indexing to finish, then start coding.
+Now, IDEA may say "No JDK configured" at the top of the source file you have.
+In that case, you can click Download JDK and choose JetBrains JDK 25.
+
+<Callout type="success">
+  If IDEA opened the project without errors, your environment is ready.
+</Callout>
+
+More details by [JetBrains](https://www.jetbrains.com/help/idea/2026.1/run-for-the-first-time.html)
+help page, where we recommend that you also check the
+[SDK configuration](https://www.jetbrains.com/help/idea/2026.1/sdk.html) guide.
+
+<Callout type="info">
+  We recommened following
+  [TheNullicorn's](https://gist.github.com/TheNullicorn/90a619796c40f20ae1fcf13094c1a57d) guide to ensure
+  you are using the correct `Nonnull` in your projects.
+</Callout>
+
+#### What the IDE Does for You
+
+When opened in IntelliJ IDEA, the project automatically:
+
+- Detects and configures Gradle or Maven
+- Downloads all dependencies
+- Sets up project structure and classpaths
+- Configures run/build tasks
+
+You do **not** need to manually install or configure Maven or Gradle if you stay inside the IDE.
+
+Skip to the [Setting Up Your Workspace](#setting-up-your-workspace).
+
+### Manual Setup: Java Development Kit (JDK)
+
+For any other setup, you will need to install and configure your system to have and load Java.
 Hytale modding requires Java 25 or later. We recommend using OpenJDK.
 
-#### Windows
+#### Windows via Installer
 
 1. Download OpenJDK 25 from [Adoptium](https://adoptium.net/)
 2. Run the installer with default settings
+   - Optionally enable feature `Set or Override JAVA_HOME variable` to resolve version related build issues with your project.
 3. Verify installation by opening Command Prompt and running:
 
+#### Windows via Scoop
+
+1. Install Scoop via PowerShell using [scoop.sh](https://scoop.sh/)
+2. Install OpenJDK 25:
+
 ```bash
-java -version
+scoop bucket add java
+scoop install java/openjdk25
 ```
 
 #### macOS
 
+1. Install Brew via Terminal using [brew.sh](https://brew.sh)
+2. Install JDK via Homebrew:
+
 ```bash
-# Using Homebrew
 brew install openjdk@25
 ```
 
@@ -51,22 +104,41 @@ brew install openjdk@25
 
 #### Linux (Ubuntu/Debian)
 
+1. Install JDK via the built-in package repository:
+
 ```bash
 sudo apt update
 sudo apt install openjdk-25-jdk
 ```
 
-### 2. Integrated Development Environment (IDE)
+### Verify installation:
 
-We recommend IntelliJ IDEA Community Edition for Hytale modding.
+Run the following command to see what version of Java you have:
 
-1. Download from [JetBrains website](https://www.jetbrains.com/idea/download/)
-2. Install with default settings
-3. Launch and complete the initial setup wizard
+```bash
+java -version
+```
+
+### Java Build Tool (Optional)
+
+We recommend using a Gradle Wrapper for managing dependencies and building your Hytale plugins. It provides benefits by eliminating the need for a system-wide Gradle installation and ensuring consistent Gradle versions across different environments. (Alternatively you can use Maven, but this guide focuses on Gradle since it is the default for our plugin template.)
+
+The plugin template in the following sections includes a Gradle Wrapper, so you can skip this step if you plan to use the template.
+
+#### Choosing Gradle (if not using the template)
+
+If you prefer to install Gradle manually, follow these steps:
 
-### 3) Java Build Tool
+1. Visit the official website: https://gradle.org/releases/
+2. Download the newest gradle binary: `gradle-9.3.1-bin.zip` (Binary zip archive)
+3. Unzip it
+4. Add the `gradle-9.3.1/bin/` folder to your PATH
+
+You can now try the command `gradle -version` to verify Gradle is installed correctly. Make sure to do this in a fresh new terminal instead of one you had opened from before!
+
+#### Choosing Maven (if not using the template)
 
-We recommend using Apache Maven for managing dependencies and building your Hytale plugins. (Alternatively you can use Gradle, but this guide focuses on Maven.)
+If you prefer to use Maven instead of Gradle, follow these steps to install Maven:
 
 1. Visit the official website: https://maven.apache.org/download.cgi
 2. Download this file: `apache-maven-3.9.12-bin.zip` (Binary zip archive)
@@ -89,22 +161,61 @@ cd MyFirstMod
 
 If you don't have Git installed, you can download the ZIP file from the repository page and extract it to a folder named `MyFirstMod`.
 
-### 2. Open Plugin in your IDEA
+### 2. Open Plugin in your IDE
 
-1. Open IntelliJ IDEA
+1. Open Your IDE (e.g., IntelliJ IDEA)
 2. Click "Open" and navigate to your `MyFirstMod` directory
-3. IntelliJ will automatically detect it as a Maven project
+3. Most IDEs like IntelliJ will automatically detect it as a Gradle project
 4. Wait for the project to index and dependencies to download
 
-<Callout type="info">
-  We recommened following [this](https://gist.github.com/TheNullicorn/90a619796c40f20ae1fcf13094c1a57d) guide to ensure you are using the correct `Nonnull` in your projects.
-</Callout>
+## Alternate Approach: Hytale Dependency
+
+If you prefer to set up your project from scratch without using the template and importing the hytale dependencies manually, ensure your build configuration includes the Hytale repositories and dependencies:
+
+For Gradle, add the following to your `build.gradle.kts`:
+
+```kotlin
+repositories {
+    mavenCentral()
+    maven {
+        name = "hytale"
+        url = uri("https://maven.hytale.com/release") // Or "hytale-pre-release" for pre-release versions
+    }
+}
+dependencies {
+    // + here means the latest version, but you can hard-wire any known version!
+    implementation("com.hypixel.hytale:Server:+")
+}
+```
+
+For Maven, add the following to your `pom.xml`:
+
+```xml
+<project>
+    <repositories>
+        <repository>
+            <id>hytale-release</id> <!-- Or "hytale-pre-release" for pre-release versions -->
+            <url>https://maven.hytale.com/release</url> <!-- Or "https://maven.hytale.com/pre-release" -->
+        </repository>
+    </repositories>
+
+    <dependencies>
+        <dependency>
+            <groupId>com.hypixel.hytale</groupId>
+            <artifactId>Server</artifactId>
+            <!-- Replace with latest version, Hytale provides jars for the last five releases -->
+            <version>LATEST_VERSION_HERE</version>
+            <scope>provided</scope>
+        </dependency>
+    </dependencies>
+</project>
+```
 
 ## Next Steps
 
 Now that you have your development environment set up with the plugin template:
 
-1. **Customize the template** - Edit the `pom.xml` and `manifest.json` file to change your mod's name and details
+1. **Customize the template** - Edit the `settings.gradle.kts`, `build.gradle.kts` and `manifest.json` file to change your mod's name and details
 2. **Explore the code structure** - Familiarize yourself with the template's organization
 3. **Start modding** - Begin writing your first Hytale plugin!
 
diff --git a/content/docs/tr-TR/guides/plugin/spawning-entities.mdx b/content/docs/tr-TR/guides/plugin/spawning-entities.mdx
index e12c0aea..15be2fb3 100644
--- a/content/docs/tr-TR/guides/plugin/spawning-entities.mdx
+++ b/content/docs/tr-TR/guides/plugin/spawning-entities.mdx
@@ -36,7 +36,7 @@ Store<EntityStore> store = world.getEntityStore().getStore();
 
 ## Creating Entities
 
-Once you have the `EntityStore` instance, you can start to create a entity and give it components. Entities are just instances of `Holder<EntityStore>` with several components attached to them.
+Once you have the `EntityStore` instance, you can start to create an entity and give it components. Entities are just instances of `Holder<EntityStore>` with several components attached to them.
 
 <Callout type="warning">
   To interact with the `World` instance, some methods require you to run the code inside the world's execution context.
@@ -118,3 +118,48 @@ Finally, we can add the entity to the world by calling the `addEntity` method on
 ```java
 store.addEntity(holder, AddReason.SPAWN);
 ```
+
+## Making the entity persist
+
+Hytale automatically saves all entities, but the `NetworkId` component (required for players to be able to see the entity) needs to be manually added every time the entity is loaded.
+
+### Using a system
+
+If you have a component that is unique to your entities, this can be done by creating and registering a custom system as follows:
+
+```java
+public class AddNetworkIdToMyEntitySystem extends HolderSystem<EntityStore> {
+    private final ComponentType<EntityStore, MyEntityComponent> myEntityComponentType = MyEntityComponent.getComponentType();
+    private final ComponentType<EntityStore, NetworkId> networkIdComponentType = NetworkId.getComponentType();
+    private final Query<EntityStore> query = Query.and(this.myEntityComponentType, Query.not(this.networkIdComponentType));
+
+    @Override
+    public void onEntityAdd(@NotNull Holder<EntityStore> holder, @NotNull AddReason reason, @NotNull Store<EntityStore> store) {
+        if (!holder.getArchetype().contains(NetworkId.getComponentType())) {
+            holder.addComponent(NetworkId.getComponentType(), new NetworkId(store.getExternalData().takeNextNetworkId()));
+        }
+    }
+
+    @Override
+    public void onEntityRemoved(@NotNull Holder<EntityStore> holder, @NotNull RemoveReason reason, @NotNull Store<EntityStore> store) {}
+
+    @Override
+    public @Nullable Query<EntityStore> getQuery() {
+        return query;
+    }
+}
+```
+
+In your plugin's `setup()` function
+
+```java
+this.getEntityStoreRegistry().registerSystem(new AddNetworkIdToMyEntitySystem())
+```
+
+### Using PropComponent
+
+Alternatively you can add `PropComponent` to your entity. Hytale adds `PropComponent` to entities spawned with the Entity Tool, and such entities automatically get `NetworkId` and `PrefabCopyableComponent` (which makes the entity work with prefabs).
+
+<Callout type="warning">
+  There is no guarantee, that Hytale will not add some other behavior to this component in the future, which may break your entity, so be careful if you decide to rely on it.
+</Callout>
diff --git a/content/docs/tr-TR/guides/plugin/store-persistent-data.mdx b/content/docs/tr-TR/guides/plugin/store-persistent-data.mdx
new file mode 100644
index 00000000..1071dff3
--- /dev/null
+++ b/content/docs/tr-TR/guides/plugin/store-persistent-data.mdx
@@ -0,0 +1,171 @@
+---
+title: Storing Persistent Data on the Player
+description: Learn how to save and load persistent data using Components
+authors:
+  - name: Neil Revin
+    url: https://itsneil.dev/
+  - name: ArcticDev
+    url: https://github.com/ArcticRaven
+  - name: oskarscot
+    url: https://oskar.scot
+  - name: JammingEng
+    url: https://github.com/JammingEnd
+---
+
+Here is how to store persistent data using a custom component on a Player.
+
+## Build your Component Class
+
+Creating a custom component class leverages the Component system made with the ECS architecture in mind. For more information on Components, check out the [ECS Guide](../ecs/hytale-ecs-theory#components).
+
+Start by creating your custom component class. This will be extremely similar to how regular components are created, however we'll setup a custom Codec so the server can translate this data to BSON, or the server's internal json encoder.
+
+<Callout type="info">
+  Each variable you want to store in your component must have its own Codec field defined in the BuilderCodec.
+  For more information on how to create custom Codecs, check out the [ECS Codec Guide](../ecs/hytale-ecs-theory#codec).
+</Callout>
+
+```java
+public class YourPlayerData implements Component<EntityStore> {
+
+    // define some vars!
+    private int someInteger;
+    private String someString;
+    private Map<String, String> someMap;
+
+    public static final BuilderCodec<YourPlayerData> CODEC =
+            BuilderCodec.builder(YourPlayerData.class, YourPlayerData::new)
+            .append(new KeyedCodec<>("SomeInteger", Codec.INTEGER),
+                    (data, value) -> data.someInteger = value, // setter
+                    data -> data.someInteger) // getter
+            .addValidator(Validators.nonNull())
+            .add()
+            .append(new KeyedCodec<>("SomeString", Codec.STRING),
+                    (data, value) -> data.someString = value, // setter
+                    data -> data.someString) // getter
+            .add()
+            .append(new KeyedCodec<>("SomeMap",
+                            new MapCodec<>(Codec.STRING, HashMap::new, false)),
+                    (data, value) -> data.someMap = value, // setter
+                    data -> data.someMap) // getter
+            .add()
+            .build();
+
+
+
+    // Getters and Setters are for the purpose of this example omitted.
+
+    // constructor
+    public YourPlayerData() {
+        this.someInteger = 0;
+        this.someString = "";
+        this.someMap = new HashMap<>();
+    }
+
+    // copy constructor for cloning
+    public YourPlayerData(YourPlayerData clone) {
+        this.someInteger = clone.someInteger;
+        this.someString = clone.someString;
+        this.someMap = clone.someMap;
+    }
+
+    @Nonnull
+    @Override
+    public Component<EntityStore> clone() {
+        return new YourPlayerData(this);
+    }
+}
+```
+
+## Register your Component
+
+Inside your main class's `setup()` method, register your new Component.
+
+```java
+public class YourPlugin extends JavaPlugin {
+
+    private ComponentType<EntityStore, YourPlayerData> yourPlayerDataComponent;
+
+    public YourPlugin(@Nonnull JavaPluginInit init) {
+        super(init);
+    }
+
+    @Override
+    protected void setup(){
+        this.yourPlayerDataComponent = this.getEntityStoreRegistry().registerComponent(
+            YourPlayerData.class,
+            "YourPlayerDataComponent",
+            YourPlayerData.CODEC
+        );
+    }
+
+    public ComponentType<EntityStore, YourPlayerData> getYourPlayerDataComponent() {
+        return this.yourPlayerDataComponent;
+    }
+}
+```
+
+## Using your Component
+
+To use your newly created component, you can add the Component to a player using the `addComponent` method, although this only adds it temporarily, meaning when the player/entity leaves the world, the component is removed. You can use `putComponent` to ensure the component persists between sessions.
+
+```java
+// You will need the Ref and Store to apply components
+private void someEntryMethod(@Nonnull Ref<EntityStore> ref, @Nonnull Store<EntityStore> store)
+{
+       // Any entity will work, for now we will use the player
+      Player player = (Player) store.getComponent(ref, Player.getComponentType());
+
+      // since we're using putComponent, it could be useful to check if it already exists on the player in case we want to update it
+     if(store.getComponent(ref, YourPlugin.instance().getYourPlayerDataComponent()) != null)
+     {
+          // here we implement logic that updates the component
+         var comp = store.getComponent(ref, YourPlugin.instance().getYourPlayerDataComponent())
+         // declare public fields or methods in the component class
+         comp.SomeString = "An Updated Field";
+     } else {
+          // Here we put the component
+          var myCustomComp = new CustomComponent();
+          // declare public fields or methods in the component class
+          myCustomComp.SomeString = "Edited String";
+
+          // putComponent allows you to insert declared objects
+          store.putComponent(ref, YourPlugin.instance().getYourPlayerDataComponent(), myCustomComp);
+     }
+}
+```
+
+## Using your Data
+
+Your component will be stored within the `Store<EntityStore>` when added to the player. In the provided example,
+we'll fetch this data off the player using the `ensureAndGetComponent()` method, which will add the component to
+the player if it does not exist with the default values.
+
+```java
+public class IncompleteCustomCommand extends AbstractPlayerCommand {
+
+    public IncompleteCustomCommand() {
+        super("nope", "don't use this command");
+    }
+
+    @Override
+    protected void execute(
+        @NonNullDecl CommandContext commandContext,
+        @NonNullDecl Store<EntityStore> store,
+        @NonNullDecl Ref<EntityStore> ref,
+        @NonNullDecl PlayerRef playerRef,
+        @NonNullDecl World world
+    ) {
+        YourPlayerData customData = store.ensureAndGetComponent(ref, YourPlugin.instance().getYourPlayerDataComponent());
+        // ensureAndGetComponent adds the component to the ref, with the default values defined inside your component.
+ 		// use your data
+    }
+}
+```
+
+And that's it! Your data will now be saved and loaded automatically with the player.
+
+Using custom components to store persistent data on players is a powerful way to maintain state across sessions.
+By following the steps outlined above, you can easily create, register, and utilize your own data structures within the Hytale ECS framework.
+This approach ensures that your data is seamlessly integrated with the game's existing systems.
+For more information about Hytale's Entity Component System visit the [Hytale ECS Theory](https://hytalemodding.dev/en/docs/guides/ecs/hytale-ecs-theory) guide.
diff --git a/content/docs/tr-TR/guides/plugin/teleporting-players.mdx b/content/docs/tr-TR/guides/plugin/teleporting-players.mdx
index 57cee77f..32ce0435 100644
--- a/content/docs/tr-TR/guides/plugin/teleporting-players.mdx
+++ b/content/docs/tr-TR/guides/plugin/teleporting-players.mdx
@@ -1,26 +1,32 @@
 ---
 title: Teleporting the player
 description: Learn how to teleport the player.
+authors:
+  - name: oskarscot
+    url: https://oskar.scot
 ---
 
-To teleport players in Hytale, you will need to get a `World` object so we can safely run the teleport on the world thread. The world thread manages all entity updates, so modifying entities off-thread can crash the server or cause inconsistent state.
-Next, we get the entity store and make a `Teleport` object.
-We add a `Teleport` component to the player’s entity reference in the entity store. This triggers the teleportation logic for that player.
+Teleporting players in Hytale works by simply attaching a `Teleport` component to a player with the desired world and transform.
+You can only trigger teleports from a world where the player is currently present.
+Teleport itself is a component but it also provides factory methods to configure the Teleport. Just as with any entity component, an EntityStore and a Ref to the EntityStore is required
+
+We can create a simple teleport utility like this:
 
 ```java
-public static void teleportPlayer(Player player, int x, int y, int z) {
-        World world = player.getWorld();
-        if (world == null) return;
-        world.execute(() -> {
-            if (player.getReference() == null) return;
-            Store<EntityStore> store = player.getReference().getStore();
-            Teleport teleport = Teleport.createForPlayer(world,
-                new Vector3d(x ,y, z), // Target position
-                new Vector3f(0, 0, 0)  // Target rotation (pitch, yaw, roll)
-            );
+public static void teleportPlayer(Ref<EntityStore> ref, Store<EntityStore> store, World targetWorld, double x, double y, double z) {                                                                                       
+    Transform transform = new Transform(x, y, z);                                                                                                                           
+    Teleport teleport = Teleport.createForPlayer(targetWorld, transform);                                                                                                   
+    store.addComponent(ref, Teleport.getComponentType(), teleport);                                                                                                         
+}  
+```
 
-            store.addComponent(player.getReference(), Teleport.getComponentType(), teleport);
-        });
+A `Transform` is a representation of a position Vector3d and rotation Vector3f which works in the following way:
 
-}
+```java
+Transform transform = new Transform(
+    new Vector3d(x, y, z),      // Position
+    new Rotation(yaw, pitch, 0) // Rotation, last value seems to always be 0
+);
+Teleport teleport = Teleport.createForPlayer(targetWorld, transform);
+store.addComponent(ref, Teleport.getComponentType(), teleport);
 ```
diff --git a/content/docs/tr-TR/guides/plugin/tracking-mod-analytics-with-hstats.mdx b/content/docs/tr-TR/guides/plugin/tracking-mod-analytics-with-hstats.mdx
new file mode 100644
index 00000000..45c022e0
--- /dev/null
+++ b/content/docs/tr-TR/guides/plugin/tracking-mod-analytics-with-hstats.mdx
@@ -0,0 +1,65 @@
+---
+title: Tracking Mod Analytics with HStats
+description: Learn how you can track Analytics for your Hytale Mod for Free using hstats.dev
+authors:
+  - name: Al3x
+    url: https://hstats.dev
+---
+
+In this guide, you will learn how to integrate HStats into your Plugin/Mod which will allow you to track how many Servers are using it along with other stats.
+
+<Callout type="info">
+  HStats is a third-party tool and is not affiliated with HytaleModding or Hypixel Studios
+</Callout>
+
+# Step 1: Register your Mod to HStats
+
+Before you touch any code, you will need to add your mod to the HStats website which will give you a UUID for your mod.
+
+- Create or Login to an Account on https://hstats.dev
+- Navigate to the dashboard page (https://hstats.dev/dashboard)
+- On the left, type in your mod's name and click "Add Mod"
+- Keep note of the UUID generated for later.
+
+# Step 2: Add the HStats Class to Your Project
+
+To keep things simple, HStats uses a single Java class file that handles everything for you.
+
+- Download / Copy the File from the GitHub page (https://github.com/hstats-dev/HStatsExamplePlugin/blob/main/src/main/java/com/al3x/HStats.java)
+- Paste into your Project. You should now have a HStats.java file somewhere in your projects directory.
+- Update the package name from com.al3x to whatever fits your project.
+
+# Step 3: Initialize HStats in your code
+
+You only need to add one line of code to your mod's setup method in your main class to start tracking.
+
+`new HStats("YOUR-MOD-UUID", "1.0.0");`
+
+Replace `YOUR-MOD-UUID` with the Mod UUID we made note of earlier and change the `1.0.0` version to whatever version your mod is currently on.
+
+Your setup method should now look something like this:
+
+```java
+@Override
+protected void setup() {
+  super.setup();
+  new HStats("c34a2b2a-afd8-4d6a-821e-7a63e12c5ea6", "1.0.0");
+}
+```
+
+# Extras
+
+Your done! Your mod should now be listed under the Mods page (https://hstats.dev/mods) as well as under your dashboard.
+
+Servers using your mod should now post updates about every minute to HStats which you can view in the Dashboard.
+
+### Embeds
+
+HStats allows you to generate an Embed Card that you can place on your CurseForge or GitHub page. This is useful for server owners to be able to see how many other servers are using your mod.
+
+- In your dashboard, scroll down to the Embed Card section.
+- Customize the appearance (Light/Dark mode, layout, etc).
+- Copy the generated URL to display your "Active Servers" and "Players Online" live on your mod's description page
+
+Heres an example of what they look like:
+![HStats Example](https://api.hstats.dev/api/embed/d52fa672-6966-47b2-b501-1a11bddebac3/card.svg?theme=light\&layout=compact\&size=md\&show_id=true\&dark=false)
diff --git a/content/docs/tr-TR/guides/plugin/world-gen.mdx b/content/docs/tr-TR/guides/plugin/world-gen.mdx
index 4c23b0c9..7b193ffd 100644
--- a/content/docs/tr-TR/guides/plugin/world-gen.mdx
+++ b/content/docs/tr-TR/guides/plugin/world-gen.mdx
@@ -100,7 +100,7 @@ Biome biome = biomeGen.generateBiomeAt(zoneResult, seed, x, z);
 
 ### Zone & Cave Integration
 
-Each zone defines it's own cave patterns:
+Each zone defines its own cave patterns:
 
 ```java
 Zone zone = /* ... */;
diff --git a/content/docs/tr-TR/guides/prefabs.mdx b/content/docs/tr-TR/guides/prefabs.mdx
index 08404b30..b1a55109 100644
--- a/content/docs/tr-TR/guides/prefabs.mdx
+++ b/content/docs/tr-TR/guides/prefabs.mdx
@@ -14,7 +14,7 @@ Prefabs are Hytale's way of creating reusable structures.
 There are a few fundamental concepts to understand about prefabs:
 
 - Users interact with prefabs via a prefab editing world.
-- Prefabs the physical structures in the game world, and are saved as JSON files.
+- Prefabs are the physical structures in the game world, and are saved as JSON files.
 
 ## How to Create a Prefab
 
diff --git a/content/docs/tr-TR/official-documentation/custom-ui/common-styling.mdx b/content/docs/tr-TR/official-documentation/custom-ui/common-styling.mdx
new file mode 100644
index 00000000..c36e3e3a
--- /dev/null
+++ b/content/docs/tr-TR/official-documentation/custom-ui/common-styling.mdx
@@ -0,0 +1,50 @@
+---
+title: Common Styling
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# Common Styling
+
+## Common UI Styling Library
+
+This document describes the shared UI components and styles defined in `Common.ui`.
+
+---
+
+### Styles
+
+We are providing some styles that can be re-used in any custom UI that, provide a cohesive UI experience with the core game UI. These styles are available in the `Common.ui` file.
+
+You can find a list of all the styles defined with live examples by running the `/ui-gallery` command ingame.
+
+<Callout type="warning">
+  This command is not available yet, but will be in a future patch.
+</Callout>
+
+![Gallery](/assets/official-documentation/ui/gallery.png)
+
+### Importing
+
+To use these styles in your UI file:
+
+```
+$Common = "Common.ui";
+
+// Then reference styles and components:
+$Common.@TextButton { @Text = "My Button"; }
+$Common.@Container { ... }
+```
+
+<Callout type="info">
+  The `Common.ui` file is at `Common/UI/Custom/Common.ui` within the Hytale pack. If your custom ui document is in a subfolder of `Common/UI/Custom/`, reference it via relative path traversal:
+
+  ```
+  $Common = "../Common.ui";
+  ```
+
+  You can find more info about paths [here](markup#path).
+</Callout>
diff --git a/content/docs/tr-TR/official-documentation/custom-ui/index.mdx b/content/docs/tr-TR/official-documentation/custom-ui/index.mdx
new file mode 100644
index 00000000..f94c4e88
--- /dev/null
+++ b/content/docs/tr-TR/official-documentation/custom-ui/index.mdx
@@ -0,0 +1,125 @@
+---
+title: Custom UI
+icon: LayoutDashboard
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# Custom UI
+
+## What is Custom UI?
+
+Custom UI is Hytale's framework for creating **custom user interfaces** controlled by the game server. Unlike the built-in Client UI (which is part of the game client and cannot be modified), Server UI allows you to create interactive screens and HUD overlays through Java plugins and asset packs.
+
+As a modder, Custom UI gives you the power to:
+
+- **Create custom interactive pages** - Shop interfaces, quest dialogs, server settings menus, admin panels
+- **Add custom HUD overlays** - Quest trackers, status displays, custom health bars, server information
+- **Design with markup** - Use `.ui` files to define reusable UI templates
+- **Handle user interactions** - Respond to button clicks, form submissions, and other events
+- **Localize your UI** - Support multiple languages using the game's translation system
+
+## How Custom UI Fits Into Hytale's UI
+
+Hytale's user interface is divided into two main categories:
+
+### Client UI (Not Moddable)
+
+Built-in interfaces controlled by the C# game client:
+
+- Main menu and settings
+- Character creation
+- Built-in HUD (health, hotbar, chat)
+- Inventory and crafting screens
+- Development tools
+
+**You cannot modify these** - they are part of the core game client.
+
+### In-Game UI (Moddable via Server)
+
+Server-controlled interfaces that you can create and customize:
+
+#### Custom Pages
+
+Full-screen interactive overlays that appear during gameplay:
+
+- Can be dismissed by the player (ESC key)
+- Capture all input (keyboard and mouse)
+- Support loading states while waiting for server responses
+- Perfect for: shops, dialogs, menus, configuration screens
+
+#### Custom HUDs
+
+Persistent overlay elements drawn on top of the game world:
+
+- Display-only (no user interaction)
+- Always visible during gameplay
+- Lightweight and non-intrusive
+- Perfect for: quest objectives, status indicators, server info panels
+
+## Architecture Overview
+
+Server UI uses a **command-based architecture**:
+
+```
+┌─────────────────────┐         ┌──────────────────────┐
+│   Java Server       │         │    C# Client         │
+│   (Your Plugin)     │         │    (Game)            │
+├─────────────────────┤         ├──────────────────────┤
+│                     │         │                      │
+│ InteractiveCustomUI │         │   CustomPage or      │
+│ Page                │         │   CustomHud          │
+│   ↓ build()         ├────────→│     ↓ Apply          │
+│ UICommandBuilder    │         │   Element Tree       │
+│   - append()        │         │     ↓ Layout         │
+│   - set()           │         │   Rendered UI        │
+│   - clear()         │         │                      │
+│                     │         │                      │
+│ ↓ handleDataEvent() │← Events │   User Interaction   │
+│   Process input     │         │   (click, type, etc) │
+│   sendUpdate()      │         │                      │
+└─────────────────────┘         └──────────────────────┘
+```
+
+**The flow:**
+
+1. Your Java code builds UI using `UICommandBuilder`
+2. Commands are sent to the client as data
+3. Client parses `.ui` markup files and creates visual elements
+4. User interacts with the UI
+5. Events are sent back to your Java code
+6. You process events and send updates back
+
+## Key Principles
+
+### Declarative, Not Imperative
+
+You don't create UI objects directly. Instead, you send **commands** that describe what you want:
+
+- "Append this button template to that container"
+- "Set this label's text to 'Hello World'"
+- "Clear all children from this list"
+
+### Asset-Driven
+
+UI structure is defined in `.ui` markup files (assets), not hardcoded in Java. This enables:
+
+- Designers to modify layouts without touching code
+- Reusable UI components
+- Consistent visual language
+
+### Event-Driven
+
+User interactions trigger events that flow back to your server code. You register event bindings and handle them in `handleDataEvent()`.
+
+### Selector-Based
+
+You target specific UI elements using **selectors:**
+
+- `#MyButton` - Element with ID "MyButton"
+- `#List[0]` - First child of element "List"
+- `#List[0] #Title` - Element with ID "Title" in the first child of element "List"
+- `#Label.TextColor` - The TextColor property of element "Label"
diff --git a/content/docs/tr-TR/official-documentation/custom-ui/layout.mdx b/content/docs/tr-TR/official-documentation/custom-ui/layout.mdx
new file mode 100644
index 00000000..0a24ca09
--- /dev/null
+++ b/content/docs/tr-TR/official-documentation/custom-ui/layout.mdx
@@ -0,0 +1,492 @@
+---
+title: Layout
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# Layout
+
+The layout system determines how UI elements are positioned and sized on screen. Understanding layout is crucial for creating well-structured, responsive interfaces.
+
+## Layout Fundamentals
+
+Every UI element has:
+
+- **Container Rectangle** - The space allocated by the parent
+- **Anchor** - How the element positions/sizes itself within the container
+- **Padding** - Inner spacing that affects child layout
+- **LayoutMode** - How the element arranges its children (if it's a container)
+
+```
+┌─────────────────────────────────────┐
+│  Container Rectangle (from parent)  │
+│  ┌───────────────────────────────┐  │
+│  │  Anchored Rectangle           │  │
+│  │  ┌─────────────────────────┐  │  │
+│  │  │ Padding                 │  │  │
+│  │  │  ┌───────────────────┐  │  │  │
+│  │  │  │  Content Area     │  │  │  │
+│  │  │  └───────────────────┘  │  │  │
+│  │  └─────────────────────────┘  │  │
+│  └───────────────────────────────┘  │
+└─────────────────────────────────────┘
+```
+
+## Anchor
+
+`Anchor` controls how an element positions and sizes itself within its container rectangle.
+
+### Fixed Size
+
+```
+Button {
+    Anchor: (Width: 200, Height: 40);
+}
+```
+
+Creates a 200×40 pixel button.
+
+### Positioning
+
+```
+Label {
+    Anchor: (Top: 10, Left: 20, Width: 100, Height: 30);
+}
+```
+
+- **Top**: 10 pixels from container's top edge
+- **Left**: 20 pixels from container's left edge
+- **Width**: 100 pixels wide
+- **Height**: 30 pixels tall
+
+### Anchoring to Edges
+
+```
+Button {
+    Anchor: (Bottom: 10, Right: 10, Width: 100, Height: 30);
+}
+```
+
+Anchors the button to the bottom-right corner, 10 pixels from each edge.
+
+### Stretching
+
+```
+Group {
+    Anchor: (Top: 0, Bottom: 0, Left: 0, Right: 0);
+}
+```
+
+Stretches to fill the entire container (all edges at 0 pixels).
+
+**Shorthand:**
+
+```
+Group {
+    Anchor: (Full: 0);
+}
+```
+
+### Mixed Anchoring
+
+```
+Panel {
+    Anchor: (Top: 10, Bottom: 10, Left: 20, Width: 300);
+}
+```
+
+- Fixed width of 300 pixels
+- Stretches vertically between top and bottom edges
+- 10 pixels from top and bottom
+- 20 pixels from left
+
+## Padding
+
+`Padding` creates inner spacing, affecting where children are positioned.
+
+### Uniform Padding
+
+```
+Group {
+    Padding: (Full: 20);
+}
+```
+
+20 pixels of padding on all sides.
+
+### Directional Padding
+
+```
+Group {
+    Padding: (Top: 10, Bottom: 20, Left: 15, Right: 15);
+}
+```
+
+Different padding per edge.
+
+### Shorthand
+
+```
+// Horizontal and vertical
+Group {
+    Padding: (Horizontal: 20, Vertical: 10);
+}
+
+// Equivalent to:
+// Top: 10, Bottom: 10, Left: 20, Right: 20
+```
+
+### Effect on Children
+
+```
+Group {
+    Anchor: (Width: 200, Height: 100);
+    Padding: (Full: 10);
+
+    Label {
+        Anchor: (Full: 0);
+    }
+}
+```
+
+The label fills the group, but there's a 10-pixel gap on all sides due to padding.
+
+```
+┌──────────────────────┐
+│ Group (200×100)      │
+│  ┌────────────────┐  │
+│  │ Label          │  │ ← 10px padding all around
+│  │                │  │
+│  └────────────────┘  │
+└──────────────────────┘
+```
+
+## LayoutMode
+
+`LayoutMode` determines how a container arranges its children.
+
+### Top (Vertical Stack)
+
+```
+Group {
+    LayoutMode: Top;
+
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+}
+```
+
+Children stack vertically from top to bottom:
+
+```
+┌──────────┐
+│ Button 1 │
+├──────────┤
+│ Button 2 │
+├──────────┤
+│ Button 3 │
+└──────────┘
+
+
+```
+
+Each child's `Anchor.Bottom` adds spacing between elements:
+
+```
+Button { Anchor: (Height: 30, Bottom: 10); }  // 10px gap after this button
+```
+
+### Bottom (Vertical Stack)
+
+```
+Group {
+    LayoutMode: Bottom;
+
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+}
+```
+
+Children stack vertically from top to bottom but aligned to the bottom edge of the parent:
+
+```
+
+
+
+┌──────────┐
+│ Button 1 │
+├──────────┤
+│ Button 2 │
+├──────────┤
+│ Button 3 │
+└──────────┘
+```
+
+### Left (Horizontal Stack)
+
+```
+Group {
+    LayoutMode: Left;
+
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+}
+```
+
+Children arrange horizontally from left to right:
+
+```
+┌────────┬────────┬────────┐
+│ Button │ Button │ Button │
+│   1    │   2    │   3    │
+└────────┴────────┴────────┘
+```
+
+Use `Anchor.Right` for spacing between elements.
+
+### Right (Horizontal Stack)
+
+```
+Group {
+    LayoutMode: Right;
+
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+}
+```
+
+Children arrange horizontally from left to right but aligned to the right side of the parent:
+
+```
+                                                                 ┌────────┬────────┬────────┐
+                                                                 │ Button │ Button │ Button │
+                                                                 │   1    │   2    │   3    │
+                                                                 └────────┴────────┴────────┘
+```
+
+### Center
+
+```
+Group {
+    LayoutMode: Center;
+
+    Group #Dialog {
+        Anchor: (Width: 400, Height: 300);
+    }
+}
+```
+
+Centers the children horizontally.
+
+### Middle
+
+```
+Group {
+    LayoutMode: Middle;
+
+    Group #Dialog {
+        Anchor: (Width: 400, Height: 300);
+    }
+}
+```
+
+Centers the children vertically.
+
+### CenterMiddle (Horizontal Stack, Fully Centered)
+
+```
+Group {
+    LayoutMode: CenterMiddle;
+
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+}
+```
+
+Children stack horizontally from left to right, centered both horizontally and vertically within the parent:
+
+```
+┌────────────────────────────────────────────┐
+│                                            │
+│                                            │
+│         ┌──────┐ ┌──────┐ ┌──────┐         │
+│         │  B1  │ │  B2  │ │  B3  │         │
+│         └──────┘ └──────┘ └──────┘         │
+│                                            │
+│                                            │
+└────────────────────────────────────────────┘
+```
+
+---
+
+### MiddleCenter (Vertical Stack, Fully Centered)
+
+```
+Group {
+    LayoutMode: MiddleCenter;
+
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+}
+```
+
+Children stack vertically from top to bottom, centered both horizontally and vertically within the parent:
+
+```
+┌────────────────────────────────────────────┐
+│                                            │
+│              ┌──────────┐                  │
+│              │ Button 1 │                  │
+│              ├──────────┤                  │
+│              │ Button 2 │                  │
+│              ├──────────┤                  │
+│              │ Button 3 │                  │
+│              └──────────┘                  │
+│                                            │
+└────────────────────────────────────────────┘
+```
+
+---
+
+### Full
+
+```
+Group {
+    LayoutMode: Full;
+
+    Label {
+        Anchor: (Top: 20, Left: 20, Width: 100, Height: 30);
+    }
+}
+```
+
+Children use absolute positioning via their `Anchor` properties.
+
+### TopScrolling
+
+```
+Group {
+    LayoutMode: TopScrolling;
+    ScrollbarStyle: $Common.@DefaultScrollbar;
+
+    // ... many children
+}
+```
+
+Like `Top`, but adds a scrollbar if content exceeds container height.
+
+Or use `BottomScrolling` for bottom-aligned content.
+
+### LeftScrolling
+
+```
+Group {
+    LayoutMode: LeftScrolling;
+    ScrollbarStyle: $Common.@DefaultScrollbar;
+
+    // ... many children
+}
+```
+
+Like `Left`, but adds a scrollbar for horizontal scrolling.
+
+Or use `RightScrolling` for right-aligned content.
+
+### LeftCenterWrap (Wrapping Horizontal Stack, Horizontally Centered)
+
+```
+Group {
+    LayoutMode: LeftCenterWrap;
+
+    Button { Anchor: (Width: 80, Height: 30); }
+    Button { Anchor: (Width: 80, Height: 30); }
+    Button { Anchor: (Width: 80, Height: 30); }
+    Button { Anchor: (Width: 80, Height: 30); }
+    Button { Anchor: (Width: 80, Height: 30); }
+}
+```
+
+Children flow left to right. When there's no more horizontal space, they wrap to the next row. Each row is horizontally centered within the parent:
+
+```
+┌────────────────────────────────────────────┐
+│                                            │
+│       ┌──────┐ ┌──────┐ ┌──────┐           │
+│       │  B1  │ │  B2  │ │  B3  │           │
+│       └──────┘ └──────┘ └──────┘           │
+│            ┌──────┐ ┌──────┐               │
+│            │  B4  │ │  B5  │               │
+│            └──────┘ └──────┘               │
+│                                            │
+└────────────────────────────────────────────┘
+```
+
+## FlexWeight
+
+`FlexWeight` distributes remaining space among children.
+
+```
+Group {
+    LayoutMode: Left;
+    Anchor: (Width: 400);
+
+    Button {
+        Anchor: (Width: 100);
+    }
+
+    Group {
+        FlexWeight: 1;  // Takes all remaining space
+    }
+
+    Button {
+        Anchor: (Width: 100);
+    }
+}
+```
+
+Result:
+
+- First button: 100px
+- Middle group: 200px (400 - 100 - 100 = 200)
+- Last button: 100px
+
+### Multiple FlexWeights
+
+```
+Group {
+    LayoutMode: Left;
+    Anchor: (Width: 600);
+
+    Group { FlexWeight: 1; }
+    Group { FlexWeight: 2; }
+    Group { FlexWeight: 1; }
+}
+```
+
+Remaining space (600px) is split:
+
+- First group: 600 × (1/4) = 150px
+- Second group: 600 × (2/4) = 300px
+- Third group: 600 × (1/4) = 150px
+
+## Visibility
+
+```
+Button #HiddenButton {
+    Visible: false;
+}
+```
+
+**Effect:**
+
+- Element and its children are not displayed
+- Element is **not included in layout** (doesn't take up space)
diff --git a/content/docs/tr-TR/official-documentation/custom-ui/markup.mdx b/content/docs/tr-TR/official-documentation/custom-ui/markup.mdx
new file mode 100644
index 00000000..564110ed
--- /dev/null
+++ b/content/docs/tr-TR/official-documentation/custom-ui/markup.mdx
@@ -0,0 +1,226 @@
+---
+title: Markup
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# Markup
+
+## Markup
+
+An element is the basic building block of a user interface. There are various types of elements with different properties, which are documented below.
+
+Here's what the syntax looks like:
+
+```
+// Basic declaration of an element
+// with its Anchor property set to attach on all sides of its parent
+// with 10 pixels of margin
+Group { Anchor: (Left: 10, Top: 10, Right: 10, Bottom: 10); }
+
+Group { Anchor: (Full: 10); } // More concise version
+
+// Declaration of a Label with a name
+// (can be used to access the element from game code)
+Label #MyLabel {
+  Style: LabelStyle(FontSize: 16); // or just Style: (FontSize: 16), type can be inferred.
+  Text: "Hi! I am text.";
+}
+
+// Declaration of a Group containing 2 children
+// You can use FlexWeight to distribute any left-over space after explicit widths/heights have been subtracted
+Group {
+  LayoutMode: Left;
+  Label { Text: "Child 1"; FlexWeight: 2; }
+  Label { Text: "Child 2"; FlexWeight: 1; }
+}
+```
+
+### Documents
+
+A UI document (_.ui_ file) contains trees of elements. There can be multiple root elements.
+
+### Named Expressions
+
+Named expressions can be declared at any level of a document (including at the root) and will be scoped to that subtree, though they need to be declared at the top of the block.
+
+```
+// Example of named expressions, declared and used with @ prefix
+@Title = "Hytale";
+@ExtraSpacing = 5;
+
+Label {
+  Text: @Title;
+  Style: (LetterSpacing: 2 + @ExtraSpacing);
+}
+```
+
+You can use the spread operator `...` to reuse a named expression while overriding some of its fields:
+
+```
+@MyBaseStyle = LabelStyle(FontSize: 24, LetterSpacing: 2);
+
+Label {
+  Style: (...@MyBaseStyle, FontSize: 36);
+}
+```
+
+You can even layer multiple named expressions like so:
+
+```
+@TitleStyle = LabelStyle(FontSize: 24, HorizontalAlignment: Center);
+@SpacedTextStyle = LabelStyle(LetterSpacing: 2);
+
+Label {
+  Style: (...@BigTextStyle, ...@SpacedTextStyle);
+}
+```
+
+#### Document references
+
+A document can reference another document and access its named expressions.
+
+```
+// Document references are defined with $ prefix
+$Common = "../Common.ui";
+
+TextButton {
+  Style: $Common.@DefaultButtonStyle;
+}
+```
+
+### Templates
+
+You can declare a reusable bit of interface as a named expression and then instantiate it as many times as you want in the tree while customizing it.
+
+You can override local named expressions as well as insert additional children at any point in the template tree. However, local named expressions must be defined at the very top of the block, before properties and child elements.
+
+```
+// This is the template
+@Row = Group {
+  Anchor: (Height: 50);
+  Label #Label { Anchor: (Left: 0, Width: 100); Text: @LabelText; }
+  Group #Content { Anchor: (Left: 100); }
+};
+
+// Here we'll be using it twice in the document tree
+Group #Rows {
+  LayoutMode: TopScrolling;
+
+  @Row #MyFirstRow {
+    @LabelText = "First row";
+    #Content { TextInput {} }
+  }
+
+  @Row #MySecondRow {
+    @LabelText = "Second row";
+  }
+}
+```
+
+### Property Types
+
+#### Basic Types
+
+- **Boolean**
+  - `Visible: false;`
+  - `Visible: true;`
+- **Int**
+  - `Height: 20;`
+- **Float, Double, Decimal**
+  - `Min: 0.2;`
+- **String**
+  - `Text: "Hi!";`
+- **Char**
+  - `PasswordChar: "*";`
+  - _Note: The syntax is the same as a string, however a value of this type cannot contain more than one character!_
+- **Color**
+  - `Background: #ffffff;`&#x20;
+- **Objects**
+  - `Style: (Background: #ffffff)`
+- **Array**&#x20;
+  - `TextSpans: [(Text: "Hi", IsBold: true)]`
+
+#### Translations
+
+Translation keys can be referenced anywhere in markup where you can provide a string, and they are then converted to a string when an element gets instantiated.
+
+**Example:**
+
+```
+Label {
+  Text: %ui.general.cancel;
+}
+```
+
+#### Colors
+
+A color literal can be written as follows:
+
+- `#rrggbb`: 6-digit hexadecimal representation for red, green, blue (fully opaque)
+- `#rrggbb(a.a)`: 6-digit hexadecimal representation for red, green, blue with alpha between 0 and 1
+- `#rrggbbaa`: 8-digit hexadecimal representation for red, green, blue and alpha
+
+```
+Group {
+  Background: #000000(0.3);
+}
+```
+
+<Callout>
+  The `#rrggbb(a.a)` format is prefered over the `#rrggbbaa` format for
+  readability reasons.
+</Callout>
+
+#### Font Name
+
+Font names can be referenced directly by their string ID. Internally this is using a custom type called `UIFontName`, however strings will be converted automatically to this type in markup.
+
+```
+Label {
+  Text: "Hi";
+  Style: (FontName: "Secondary");
+}
+```
+
+**Available Font Names**
+
+- _Default_ - This is the default font that is used for most text and is always used unless a different option has been specified
+- _Secondary_ - This font is mostly used for headlines or elements that are supposed to stick out
+- _Mono_ - This is only used for development; For things such as profiling or error overlays.
+
+#### Path
+
+We can reference other UI assets with the `UIPath` type. Similar to `UIFontName`_,_ Strings are automatically converted to a `UIPath`. Paths are always relative to the file where they have been declared in. Looking up _MyButton.png_ in _Menu/MyAwesomeMenu.ui_ will result in _Menu/MyButton.png_. If you want to reference a file that is in a parent folder you can go back one directory by writing two dots (_../MyButton.png_).
+
+The markup syntax of a `UIPath` is the same as a String. (e.g. `Path: "Test.png"`)
+
+Here are some more examples:
+
+| UIPath             | .ui File                              | Resulting Path    |
+| ------------------ | ------------------------------------- | ----------------- |
+| MyButton.png       | Menu/MyAwesomeMenu.ui                 | Menu/MyButton.png |
+| ../MyButton.png    | Menu/MyAwesomeMenu.ui                 | MyButton.png      |
+| ../../MyButton.png | Menu/Popup/Templates/MyAwesomeMenu.ui | Menu/MyButton.png |
+
+#### Objects
+
+Objects contain a set of properties. In this example we are assigning an Anchor object to the _Anchor_ property:
+
+```
+Group {
+  Anchor: (
+   Height: 10,
+   Width: 20
+ );
+}
+```
+
+You can find all objects that can be used in markup [here](type-documentation#elements).
+
+## Visual Studio Code Extension
+
+There is an official extension for Visual Studio Code which adds syntax highlighting for .ui files. You can find it [here](https://marketplace.visualstudio.com/items?itemName=HypixelStudiosCanadaInc.vscode-hytaleui).
diff --git a/content/docs/tr-TR/official-documentation/custom-ui/type-documentation/index.mdx b/content/docs/tr-TR/official-documentation/custom-ui/type-documentation/index.mdx
new file mode 100644
index 00000000..69cea406
--- /dev/null
+++ b/content/docs/tr-TR/official-documentation/custom-ui/type-documentation/index.mdx
@@ -0,0 +1,127 @@
+---
+title: Type Documentation
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# Type Documentation
+
+This is a generated list of UI elements accessible by markup. More information about the User Interface framework can be found in the main documentation.
+
+## Elements
+
+- [ActionButton](type-documentation/elements/actionbutton)
+- [AssetImage](type-documentation/elements/assetimage)
+- [BackButton](type-documentation/elements/backbutton)
+- [BlockSelector](type-documentation/elements/blockselector)
+- [Button](type-documentation/elements/button)
+- [CharacterPreviewComponent](type-documentation/elements/characterpreviewcomponent)
+- [CheckBox](type-documentation/elements/checkbox)
+- [CheckBoxContainer](type-documentation/elements/checkboxcontainer)
+- [CircularProgressBar](type-documentation/elements/circularprogressbar)
+- [CodeEditor](type-documentation/elements/codeeditor)
+- [ColorOptionGrid](type-documentation/elements/coloroptiongrid)
+- [ColorPicker](type-documentation/lements/colorpicker)
+- [ColorPickerDropdownBox](type-documentation/elements/colorpickerdropdownbox)
+- [CompactTextField](type-documentation/elements/compacttextfield)
+- [DropdownBox](type-documentation/elements/dropdownbox)
+- [DropdownEntry](type-documentation/elements/dropdownentry)
+- [DynamicPane](type-documentation/elements/dynamicpane)
+- [DynamicPaneContainer](type-documentation/elements/dynamicpanecontainer)
+- [FloatSlider](type-documentation/elements/floatslider)
+- [FloatSliderNumberField](type-documentation/elements/floatslidernumberfield)
+- [Group](type-documentation/elements/group)
+- [HotkeyLabel](type-documentation/elements/hotkeylabel)
+- [ItemGrid](type-documentation/elements/itemgrid)
+- [ItemIcon](type-documentation/elements/itemicon)
+- [ItemPreviewComponent](type-documentation/elements/itempreviewcomponent)
+- [ItemSlot](type-documentation/elements/itemslot)
+- [ItemSlotButton](type-documentation/elements/itemslotbutton)
+- [Label](type-documentation/elements/label)
+- [LabeledCheckBox](type-documentation/elements/labeledcheckbox)
+- [MenuItem](type-documentation/elements/menuitem)
+- [MultilineTextField](type-documentation/elements/multilinetextfield)
+- [NumberField](type-documentation/elements/numberfield)
+- [Panel](type-documentation/elements/panel)
+- [ProgressBar](type-documentation/elements/progressbar)
+- [ReorderableList](type-documentation/elements/reorderablelist)
+- [ReorderableListGrip](type-documentation/elements/reorderablelistgrip)
+- [SceneBlur](type-documentation/elements/sceneblur)
+- [Slider](type-documentation/elements/slider)
+- [SliderNumberField](type-documentation/elements/slidernumberfield)
+- [Sprite](type-documentation/elements/sprite)
+- [TabButton](type-documentation/elements/tabbutton)
+- [TabNavigation](type-documentation/elements/tabnavigation)
+- [TextButton](type-documentation/elements/textbutton)
+- [TextField](type-documentation/elements/textfield)
+- [TimerLabel](type-documentation/elements/timerlabel)
+- [ToggleButton](type-documentation/elements/togglebutton)
+
+## Property Types
+
+- [Anchor](type-documentation/property-types/anchor)
+- [BlockSelectorStyle](type-documentation/property-types/blockselectorstyle)
+- [ButtonSounds](type-documentation/property-types/buttonsounds)
+- [ButtonStyle](type-documentation/property-types/buttonstyle)
+- [ButtonStyleState](type-documentation/property-types/buttonstylestate)
+- [CheckBoxStyle](type-documentation/property-types/checkboxstyle)
+- [CheckBoxStyleState](type-documentation/property-types/checkboxstylestate)
+- [ClientItemStack](type-documentation/property-types/clientitemstack)
+- [ColorOptionGridStyle](type-documentation/property-types/coloroptiongridstyle)
+- [ColorPickerDropdownBoxStateBackground](type-documentation/property-types/colorpickerdropdownboxstatebackground)
+- [ColorPickerDropdownBoxStyle](type-documentation/property-types/colorpickerdropdownboxstyle)
+- [ColorPickerStyle](type-documentation/property-types/colorpickerstyle)
+- [DropdownBoxSearchInputStyle](type-documentation/property-types/dropdownboxsearchinputstyle)
+- [DropdownBoxSounds](type-documentation/property-types/dropdownboxsounds)
+- [DropdownBoxStyle](type-documentation/property-types/dropdownboxstyle)
+- [InputFieldButtonStyle](type-documentation/property-types/inputfieldbuttonstyle)
+- [InputFieldDecorationStyle](type-documentation/property-types/inputfielddecorationstyle)
+- [InputFieldDecorationStyleState](type-documentation/property-types/inputfielddecorationstylestate)
+- [InputFieldIcon](type-documentation/property-types/inputfieldicon)
+- [InputFieldStyle](type-documentation/property-types/inputfieldstyle)
+- [ItemGridSlot](type-documentation/property-types/itemgridslot)
+- [ItemGridStyle](type-documentation/property-types/itemgridstyle)
+- [LabeledCheckBoxStyle](type-documentation/property-types/labeledcheckboxstyle)
+- [LabeledCheckBoxStyleState](type-documentation/property-types/labeledcheckboxstylestate)
+- [LabelSpan](type-documentation/property-types/labelspan)
+- [LabelStyle](type-documentation/property-types/labelstyle)
+- [NumberFieldFormat](type-documentation/property-types/numberfieldformat)
+- [Padding](type-documentation/property-types/padding)
+- [PatchStyle](type-documentation/property-types/patchstyle)
+- [PopupStyle](type-documentation/property-types/popupstyle)
+- [ScrollbarStyle](type-documentation/property-types/scrollbarstyle)
+- [SliderStyle](type-documentation/property-types/sliderstyle)
+- [SoundStyle](type-documentation/property-types/soundstyle)
+- [SpriteFrame](type-documentation/property-types/spriteframe)
+- [SubMenuItemStyle](type-documentation/property-types/submenuitemstyle)
+- [SubMenuItemStyleState](type-documentation/property-types/submenuitemstylestate)
+- [Tab](type-documentation/property-types/tab)
+- [TabNavigationStyle](type-documentation/property-types/tabnavigationstyle)
+- [TabStyle](type-documentation/property-types/tabstyle)
+- [TabStyleState](type-documentation/property-types/tabstylestate)
+- [TextButtonStyle](type-documentation/property-types/textbuttonstyle)
+- [TextButtonStyleState](type-documentation/property-types/textbuttonstylestate)
+- [TextTooltipStyle](type-documentation/property-types/texttooltipstyle)
+- [ToggleButtonStyle](type-documentation/property-types/togglebuttonstyle)
+- [ToggleButtonStyleState](type-documentation/property-types/togglebuttonstylestate)
+
+## Enums
+
+- [ActionButtonAlignment](type-documentation/enums/actionbuttonalignment)
+- [CodeEditorLanguage](type-documentation/enums/codeeditorlanguage)
+- [ColorFormat](type-documentation/enums/colorformat)
+- [DropdownBoxAlign](type-documentation/enums/dropdownboxalign)
+- [InputFieldButtonSide](type-documentation/enums/inputfieldbuttonside)
+- [InputFieldIconSide](type-documentation/enums/inputfieldiconside)
+- [ItemGridInfoDisplayMode](type-documentation/enums/itemgridinfodisplaymode)
+- [LabelAlignment](type-documentation/enums/labelalignment)
+- [LayoutMode](type-documentation/enums/layoutmode)
+- [MouseWheelScrollBehaviourType](type-documentation/enums/mousewheelscrollbehaviourtype)
+- [ProgressBarAlignment](type-documentation/enums/progressbaralignment)
+- [ProgressBarDirection](type-documentation/enums/progressbardirection)
+- [ResizeType](type-documentation/enums/resizetype)
+- [TimerDirection](type-documentation/enums/timerdirection)
+- [TooltipAlignment](type-documentation/enums/tooltipalignment)
diff --git a/content/docs/tr-TR/official-documentation/npc/2-getting-started-with-templates.mdx b/content/docs/tr-TR/official-documentation/npc/2-getting-started-with-templates.mdx
index 91081ca1..99d078e0 100644
--- a/content/docs/tr-TR/official-documentation/npc/2-getting-started-with-templates.mdx
+++ b/content/docs/tr-TR/official-documentation/npc/2-getting-started-with-templates.mdx
@@ -9,7 +9,7 @@ authors:
 
 There are no hard and fast rules for making a start on a template. I like to duplicate **BlankTemplate** and start from there because it already provides the basic structure of the file.
 
-This leaves me with the following template (`Template_Goblin_Ogre.json`): (note: the file could be looking different in the current version of the game)
+This leaves me with the following template (`Template_Goblin_Ogre.json`): (**note: the file could be looking different in the current version of the game**)
 
 ```json
 {
@@ -33,7 +33,7 @@ This leaves me with the following template (`Template_Goblin_Ogre.json`): (note:
     }
   },
   "Appearance": { "Compute": "Appearance" },
-  "DropList": { "Compute": "Droplist" },
+  "DropList": { "Compute": "DropList" },
   "MaxHealth": { "Compute": "MaxHealth" },
   "MotionControllerList": [
     {
@@ -65,10 +65,10 @@ And the following variant (`Goblin_Ogre.json`) next to the template. There's a t
   "Type": "Variant",
   "Reference": "Template_Goblin_Ogre",
   "Modify": {
-    "Appearance": "Goblin_Ogre",
+    "Appearance": "Goblin",
     "MaxHealth": 124
   }
 }
 ```
 
-Our artists have defined the `Goblin_Ogre` appearance already so I'm going to use that.
+Our artists have not yet finished animations for the `Goblin_Ogre`, for that sake of the tutorial I am going to use appearance `Goblin`, because it offers a more complete set of animations that we will need.
diff --git a/content/docs/tr-TR/official-documentation/worldgen/pack-tutorial/asset-packs.mdx b/content/docs/tr-TR/official-documentation/worldgen/pack-tutorial/asset-packs.mdx
index 38809fad..dcf1f3b9 100644
--- a/content/docs/tr-TR/official-documentation/worldgen/pack-tutorial/asset-packs.mdx
+++ b/content/docs/tr-TR/official-documentation/worldgen/pack-tutorial/asset-packs.mdx
@@ -9,13 +9,13 @@ authors:
 
 <OfficialDocumentationNotice />
 
-# How to modify Hytale
+# How to modify Hytale?
 
-## What's an Asset Pack
+## What's an Asset Pack?
 
-Hytales gameplay is driven by assets in the game that can be modified by creators. Asset Packs are our solution to let you override or add features to the base game with your own work. These can in the form of zip files of folders, which contain a custom set of assets. This is not the only way for a creator to change Hytale but this is the most accessible form.;
+Hytales gameplay is driven by assets in the game that can be modified by creators. Asset Packs are our solution to let you override or add features to the base game with your own work. These can be the form of zip files of folders, which contain a custom set of assets. This is not the only way for a creator to change Hytale but this is the most accessible form.;
 
-### How do I make an Asset Pack
+### How do I make an Asset Pack?
 
 <video controls className="my-6 aspect-video w-full rounded-lg border">
   <source src="https://cdn.internal.hytalemodding.dev/guides/official/how-to-asset-pack.mp4" type="video/mp4" />
@@ -48,7 +48,7 @@ An asset pack is typically a zip or folder, with a `manifest.json` inside. This
 }
 ```
 
-### Where are they stored
+### Where are they stored?
 
 Asset Packs are stored with other mods in the Mods folder.
 
@@ -76,7 +76,7 @@ C:\Users\<user>\AppData\Roaming\Hytale\UserData\Saves\New World 5\mods
 
 When you have Asset Packs or Mods installed, these will appear in the New World menu under the Options menu.;
 
-### How do I change an existing asset
+### How do I change an existing asset?
 
 <video controls className="my-6 aspect-video w-full rounded-lg border">
   <source src="https://cdn.internal.hytalemodding.dev/guides/official/how-to-asset.mp4" type="video/mp4" />
diff --git a/content/docs/tr-TR/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx b/content/docs/tr-TR/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx
index 44528376..24e628b5 100644
--- a/content/docs/tr-TR/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx
+++ b/content/docs/tr-TR/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx
@@ -106,7 +106,7 @@ If a BaseHeight is provided, the TopY and BottomY values are relative to the Bas
 
 Applies a Material Provider slot on a set of horizontal stripes of blocks of varying thickness and position. Below is an example image of basalt stripes into a stone cliff.
 
-{/* ![](https://540086904-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F7KAmBkOg6d13nZCkf9ku%2Fuploads%2FbcxO9LpArn8gPCaBwFg5%2Funknown.png?alt=media&token=1c72b67a-8253-4d03-8c64-1ad5f6830050) */}
+![Example of basalt stripes](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/basalt-stripes-example.png)
 
 #### Parameters:
 
diff --git a/content/docs/tr-TR/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx b/content/docs/tr-TR/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx
index 5e34acd4..a4418473 100644
--- a/content/docs/tr-TR/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx
+++ b/content/docs/tr-TR/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx
@@ -294,7 +294,7 @@ Combines all the positions into a single Positioins field.
 
 ---
 
-### SimpleHoritontal
+### SimpleHorizontal
 
 Keeps only the positions that are within the provided range.
 
diff --git a/content/docs/tr-TR/official-documentation/worldgen/worldgen-tutorial/README.mdx b/content/docs/tr-TR/official-documentation/worldgen/worldgen-tutorial/README.mdx
new file mode 100644
index 00000000..5f66d245
--- /dev/null
+++ b/content/docs/tr-TR/official-documentation/worldgen/worldgen-tutorial/README.mdx
@@ -0,0 +1,166 @@
+---
+title: How to edit and create Biomes
+description: Explores where world generation assets can be found and how to edit them.
+---
+
+### Where are the Assets
+
+World generation assets are kept in the HytaleGenerator directory within the assets.
+
+```
+/Server/HytaleGenerator/
+```
+
+<div className="flex flex-row rounded-lg border p-4">
+  <div className="flex-1/2 border-r pr-4">
+    ```
+    /Biomes
+    ```
+
+    Biome assets, with content configurations.
+  </div>
+
+  <div className="flex-1/2 pl-4">
+    ```
+    /WorldStructure
+    ```
+
+    Generator files that define which biomes spawn together.
+  </div>
+</div>
+
+<div className="flex flex-row rounded-lg border p-4">
+  <div className="flex-1/2 border-r pr-4">
+    ```
+    /Density
+    ```
+
+    Density assets that can be referenced by any other assets.
+  </div>
+
+  <div className="flex-1/2 pl-4">
+    ```
+    /Assignments
+    ```
+
+    Prop assets that can be referenced by any Biome assets.
+  </div>
+</div>
+
+***
+
+An example of this structure can be found bellow, packed in an asset pack with the instance configuration.
+
+[https://drive.google.com/file/d/1sIz_CluANIIe3n8vNiOi-4PQdeqCO0qY/view?usp=drive_link](https://drive.google.com/file/d/1sIz_CluANIIe3n8vNiOi-4PQdeqCO0qY/view?usp=drive_link)
+
+<Callout>
+  Ensure you place your asset pack in the correct directory, under Mods.
+</Callout>
+
+### How to visit our worlds
+
+https://drive.google.com/file/d/1BJurxyj-taE-PXWm04bk7Dl6X7ZHTH92/view?usp=sharing
+
+#### Requirements
+
+- You must be an **Operator** in the world.
+  - To do this, run <mark style="color:$danger;">`/op self`</mark>
+- You must be in **Creative mode**.
+  - Press the <mark style="color:$danger;">`O`</mark> key, O for Orange.&#x20;
+
+The generation assets define a set of generators but on their own you cannot visit these. Currently you require an Instance with a generator that will allow you to visit your work.
+
+```
+/Server/Instances/
+```
+
+Instances are separate worlds that players can join using the `/instances` command. Each instance has an `Instance.bson` configuration asset that specifies which generator to use, among other worldly settings.
+
+```json
+{
+  "WorldGen": {
+    "Type": "HytaleGenerator",
+    "WorldStructure": "Basic",
+    "playerSpawn" : {
+      "X" : 123,
+      "Y" : 480,
+      "Z" : 10000,
+      "Pitch" : 0,
+      "Yaw" : 0,
+      "Roll" : 0
+    }
+  }
+}
+```
+
+<Callout>
+  You can create custom instances for different world structures and biomes as you need them.
+</Callout>
+
+### How to edit Biomes
+
+<video>
+  <source src="https://cdn.internal.hytalemodding.dev/guides/official/How-to-edit-Biomes.mp4" type="video/mp4" />
+</video>
+
+We currently use the Hytale Node Editor when editing world generation assets. This can be accessed while in-game from the Content Creation menu when pressing B. The node editor is then found under the asset editor dropdown on the upper left.&#x20;
+
+![Node Editor 1](/assets/official-documentation/worldgen/worldgen-tutorial/biomes/node-editor-1.png)
+
+Once you have the Hytale Node Editor open, through the file menu you can open Biomes by navigating to the Biomes directory and selecting one from your pack.&#x20;
+
+```
+/Server/HytaleGenerator/Biomes/
+```
+
+### Biome Asset Structure
+
+Every Biome has a root Biome node, this node splits into 5 structures. This is covered briefly but more information on each field can be found on the World Generation Concepts page.
+
+![Node Editor 2](/assets/official-documentation/worldgen/worldgen-tutorial/biomes/node-editor-2.png)
+
+<Callout>
+  Each biome is for the most part self contained, meaning it has control over what appears with the biome. The only exception to this are Base Heights.
+</Callout>
+
+<Tabs>
+  <Tab value="Terrain">
+    Mathematical function nodes that calculate the physical shape of the Biome's terrain.
+  </Tab>
+
+  <Tab value="Materials">
+    Logical nodes that determine what materials (blocks) make up a Biome's terrain.
+  </Tab>
+
+  <Tab value="Props">
+    Function nodes that add objects like prefabs and decorations to the terrain.
+  </Tab>
+
+  <Tab value="Environments">
+    Logical nodes that determine the environment asset at a given coordinate within the biome. This asset determines things like weather, NPC spawns, and sounds.
+  </Tab>
+
+  <Tab value="Tints">
+    Logical function nodes that determine a colour code that can be used by certain blocks in the world. Typically this will be grasses and soils.
+  </Tab>
+</Tabs>
+
+### How to preview your work
+
+[https://drive.google.com/file/d/1mNcHn9LhFnWDF0DzWFH6_YllmKAUvUry/view?t=6](https://drive.google.com/file/d/1mNcHn9LhFnWDF0DzWFH6_YllmKAUvUry/view?t=6)
+
+Once you are in an Instance world with the Hytale Generator active you will only be able to see your work by generating new chunks. There are a few ways to do this.
+
+The viewport command selects an area around the Player that will live reload as you make changes to the generator.&#x20;
+
+```
+/viewport --radius 5 
+```
+
+You can also create a new world to show your changes.&#x20;
+
+```
+/instances spawn <instance> 
+```
+
+The last option is to simply fly south, new chunks will generate with the changes made.
diff --git a/content/docs/tr-TR/quick-start.mdx b/content/docs/tr-TR/quick-start.mdx
index 653644f4..249d803a 100644
--- a/content/docs/tr-TR/quick-start.mdx
+++ b/content/docs/tr-TR/quick-start.mdx
@@ -9,3 +9,8 @@ Welcome to the Hytale modding documentation! Here you'll find everything you nee
 * [Setting up your dev environment](./guides/plugin/setting-up-env)
 * [Entity Component System (ECS)](./guides/ecs/entity-component-system)
 * [Publishing your mod](./publishing)
+
+### Useful Links
+
+* [Kaupenjoe's Modding Videos](https://www.youtube.com/@ModdingByKaupenjoe)
+* [TroubleDEV's Modding Videos](https://www.youtube.com/@TroubleDEV)
diff --git a/content/docs/tr-TR/server/argtypes.mdx b/content/docs/tr-TR/server/argtypes.mdx
new file mode 100644
index 00000000..e54a442e
--- /dev/null
+++ b/content/docs/tr-TR/server/argtypes.mdx
@@ -0,0 +1,61 @@
+---
+title: ArgTypes
+description: Available ArgTypes
+icon: List
+full: true
+authors:
+  - name: Valeena
+---
+
+| Name                        | Target Class                           | Description                                                                                                                               |   |
+| :-------------------------- | :------------------------------------- | :---------------------------------------------------------------------------------------------------------------------------------------- | - |
+| Boolean                     | java.lang.Boolean                      | A 'true' or 'false' input                                                                                                                 |   |
+| Integer                     | java.lang.Integer                      | A whole number                                                                                                                            |   |
+| String                      | java.lang.String                       | Words, text, numbers, letters. To input more than one word at a time, you may need to wrap it with double quotes (`"my fancy sentence"`). |   |
+| Float                       | java.lang.Float                        | A floating-pointer number                                                                                                                 |   |
+| Double                      | java.lang.Double                       | A decimal number                                                                                                                          |   |
+| UUID                        | java.util.UUID                         | A UUID (Universally Unique IDentifier)                                                                                                    |   |
+| Player_UUID                 | java.util.UUID                         | A UUID or an online player username                                                                                                       |   |
+| Game_Profile_Lookup_Async   | ProfileServiceClient.PublicGameProfile | A player UUID or username. If not found locally, performs a remote lookup via the Profile Service.                                        |   |
+| Relative_Double_Coord       | Coord                                  | An x, y, or z coordinate as a decimal, optionally relative by specifying a tilde (~) in front of the number                               |   |
+| Relative_Int_Coord          | IntCoord                               | An x, y, or z coordinate as a whole number, optionally relative by specifying a tilde (~) in front of the number                          |   |
+| Relative_Integer            | RelativeInteger                        | A tilde to mark an integer relative to a base                                                                                             |   |
+| Relative_Float              | RelativeFloat                          | A tilde to mark a float relative to a base                                                                                                |   |
+| Player_Ref                  | PlayerRef                              | A UUID or an online player's username                                                                                                     |   |
+| World                       | World                                  | A world folder name                                                                                                                       |   |
+| Model_Asset                 | ModelAsset                             | A reference to an Asset of type Model                                                                                                     |   |
+| Weather_Asset               | Weather                                | A reference to an Asset of type Weather                                                                                                   |   |
+| Interaction_Asset           | Interaction                            | A reference to an Asset of type Interaction                                                                                               |   |
+| Root_Interaction_Asset      | RootInteraction                        | A reference to an Asset of type Root Interaction                                                                                          |   |
+| Effect_Asset                | EntityEffect                           | A refernece to an Asset of type EntityEffect                                                                                              |   |
+| Environment_Asset           | Environment                            | A reference to an Asset of type Environment                                                                                               |   |
+| Item_Asset                  | Item                                   | A reference to an Asset of type Item                                                                                                      |   |
+| Block_Type_Asset            | BlockType                              | A reference to an Asset of type BlockType                                                                                                 |   |
+| Particle_System             | ParticleSystem                         | A reference to an Asset of type ParticleSystem                                                                                            |   |
+| Hitbox_Collision_Config     | HitboxCollisionConfig                  | A reference to an Asset of type HitboxCollisionConfig                                                                                     |   |
+| Repulsion_Config            | RepulsionConfig                        | A reference to an Asset of type RepulsionConfig                                                                                           |   |
+| Sound_Event_Asset           | SoundEvent                             | A reference to an Asset of type SoundEvent                                                                                                |   |
+| Ambiance_Fx_Asset           | AmbianceFX                             | A reference to an Asset of type AmbianceFX                                                                                                |   |
+| Sound_Category              | SoundCategory                          | A sound category (sfx, music, ambient, ui)                                                                                                |   |
+| Entity_ID                   | `ArgWrapper<EntityWrappedArg, UUID>`   | A UUID representing an entity id                                                                                                          |   |
+| Integer_Comparison_Operator | IntegerComparisonOperator              | A mathematical sign for integer comparison                                                                                                |   |
+| Integer_Operation           | IntegerOperation                       | A mathematical sign for performing an operation                                                                                           |   |
+| Int_Range                   | `Pair<Integer, Integer>`               | Two integers representing a minimum and maximum of a range                                                                                |   |
+| Relative_Int_Range          | RelativeIntRange                       | Two integers representing a minimum and maximum of a range                                                                                |   |
+| Vector2I                    | Vector2i                               | Two integers, generally corresponding to x/z axis                                                                                         |   |
+| Vector3I                    | Vector3i                               | Three integers, generally corresponding to x/y/z axis                                                                                     |   |
+| Relative_Vector3I           | RelativeVector3i                       | Three optionally relative integers, generally corresponding to x/y/z axis                                                                 |   |
+| Relative_Block_Position     | RelativeIntPosition                    | A position with three integer coordinates, representing a block's location in world space.                                                |   |
+| Relative_Position           | Relative                               | A position with three decimal coordinates, representing a location in world space.                                                        |   |
+| Relative_Chunk_Position     | RealtiveChunkPosition                  | A position with two integer coordinates (x, z), representing a chunk's location.                                                          |   |
+| Rotation                    | Vector3f                               | A rotation with three coordinates, representing the pitch, yaw, and roll respectively                                                     |   |
+| Block_Type_Key              | String                                 | A block type                                                                                                                              |   |
+| Block_ID                    | Integer                                | A block type, converted to an int id                                                                                                      |   |
+| Color                       | Integer                                | A color value in hex format, hex integer, or decimal integer                                                                              |   |
+| Weighted_Block_Type         | `Pair<Integer, String>`                | A weight corresponding to a blocktype                                                                                                     |   |
+| Weighted_Block_Entry        | String                                 | A block with optional weight prefix                                                                                                       |   |
+| Block_Pattern               | BlockPattern                           | A list of blocks with optional weights                                                                                                    |   |
+| Individual_Block_Mask       | BlockMask                              | Create a block mask using symbols and block names                                                                                         |   |
+| Block_Mask                  | BlockMask                              | A tick rate value (e.g., 30tps, 33ms, or 30)                                                                                              |   |
+| Tick_Rate                   | Integer                                | A list of block masks that combine together                                                                                               |   |
+| Game_Mode                   | GameMode                               | GameMode                                                                                                                                  |   |
diff --git a/content/docs/tr-TR/server/interaction-reference.mdx b/content/docs/tr-TR/server/interaction-reference.mdx
new file mode 100644
index 00000000..6c0d01b3
--- /dev/null
+++ b/content/docs/tr-TR/server/interaction-reference.mdx
@@ -0,0 +1,1586 @@
+---
+title: Interactions
+description: A list of most Interaction types provided by Hypixel, along with the meaning of their fields, and how they fit together.
+icon: List
+authors:
+  - name: Stephen Baynham
+    url: https://github.com/cannibalvox
+---
+
+### The Interaction Base Type
+
+All interactions of every type below are inherited from Interaction and have these fields.
+
+**Interaction Fields**
+
+| Field Name                | Type                                                                 | Required? | Notes                                                                                                                                                                                                                       |
+| ------------------------- | -------------------------------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| ViewDistance              | `Double`<br />(Default: 96.0)                                        | **No**    | Distance in blocks at which other players can see the effects from this interaction.                                                                                                                                        |
+| Effects                   | `InteractionEffects`                                                 | **No**    | Sound, animations, and particle effects that should trigger when this interaction begins executing.                                                                                                                         |
+| HorizontalSpeedMultiplier | `Float`<br />(Default: 1.0)                                          | **No**    | Multiplier applied to the User entity's movement speed while this interaction is executing                                                                                                                                  |
+| RunTime                   | `Float`                                                              | **No**    | If provided, this interaction will continue executing for at least this long before the interaction chain moves onto the next interaction.                                                                                  |
+| CancelOnItemChange        | `Boolean`<br />(Default: true)                                       | **No**    | If true, this interaction will be cancelled if the User entity's held item changes during execution. This can happen either due to the selected hotbar slot changing or the contents of the item's inventory slot changing. |
+| Rules                     | `InteractionRules`                                                   | **Yes**   | If provided, adds additional limitations and cancellation conditions to this interaction.                                                                                                                                   |
+| Settings                  | `Map`<br />(Key Type: `GameMode`, Value Type: `InteractionSettings`) | **No**    | If provided, adds additional per-GameMode settings to the interaction.                                                                                                                                                      |
+| Camera                    | `InteractionCameraSettings`                                          | **No**    | Arrays of camera motion keyframes for cutscenes and reveals.                                                                                                                                                                |
+
+**GameMode Values**
+
+- `Creative`: The game is currently in Creative Mode
+- `Adventure`: The game is currently in Adventure Mode
+
+**InteractionEffects Fields**
+
+| Field Name               | Type                                              | Required? | Notes                                                                                                                                                 |
+| ------------------------ | ------------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Particles                | `Array`<br />(Element Type: `ModelParticle`)      | **No**    | Particle systems to activate when this interaction begins if the player is in third-person mode.                                                      |
+| FirstPersonParticles     | `Array`<br />(Element Type: `ModelParticle`)      | **No**    | Particle systems to activate when this interaction begins if the player is in first-person mode.                                                      |
+| WorldSoundEventId        | `Asset`<br />(Asset Type: `SoundEvent`)           | **No**    | A sound to play in the world at the User entity's location when this interaction begins.<br />**The SoundEvent must be single-channel (mono) sound.** |
+| LocalSoundEventId        | `Asset`<br />(Asset Type: `SoundEvent`)           | **No**    | A 2D sound to play for the User entity when this interaction begins. Ignored if the User entity is not a player.                                      |
+| Trails                   | `Array`<br />(Element Type: `ModelTrail`)         | **No**    | Trail effects to activate on the User entity when this interaction begins.                                                                            |
+| WaitForAnimationToFinish | `Boolean`<br />(Default: false)                   | **No**    | If true, this interaction will continue executing for at least the length of any animations in this InteractionEffects object.                        |
+| ItemPlayerAnimationsId   | `Asset`<br />(Asset Type: `ItemPlayerAnimations`) | **No**    | If provided, the User entity will use this ItemPlayerAnimations set while this interaction is executing.                                              |
+| ItemAnimationId          | `String`                                          | **No**    | Id of an animation to trigger when this interaction begins executing.<br />**This animation id is not validated on server start.**                    |
+| ClearAnimationOnFinish   | `Boolean`<br />(Default: false)                   | **No**    | If true, animations triggered by this interaction will be halted when the interaction completes.                                                      |
+| ClearSoundEventOnFinish  | `Boolean`<br />(Default: false)                   | **No**    | If true, sounds triggered by this interaction will be halted when the interaction completes.                                                          |
+| CameraEffect             | `Asset`<br />(Asset Type: `CameraEffect` )        | **No**    | If provided, the CameraEffect will be applied while this interaction is executing.                                                                    |
+| MovementEffects          | `MovementEffects`                                 | **No**    | If provided, apply the movement effects to the User entity while this interaction is executing.                                                       |
+| StartDelay               | `Float`<br />(Default: 0.0f)                      | **No**    | The interaction will wait this many seconds before triggering the effects in this object.                                                             |
+
+**InteractionRules Fields**
+
+| Field Name          | Type                                                                                                | Required? | Notes                                                                                                                                                                                                                                     |
+| ------------------- | --------------------------------------------------------------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| BlockedBy           | `Array`<br />(Element Type: `InteractionType`)<br />(Default: Based on the chain's InteractionType) | **No**    | If provided, this RootInteraction cannot be executed while interaction chains of the provided types are executing.<br />**This field only functions for rules attached to a RootInteraction. It has no effect on an Interaction.**        |
+| Blocking            | `Array`<br />(Element Type: `InteractionType`)                                                      | **No**    | If provided, interaction chains with the specified InteractionTypes cannot be executed while this interaction is executing.                                                                                                               |
+| InterruptedBy       | `Array`<br />(Element Type: `InteractionType`)                                                      | **No**    | If provided, interaction chains with the specified InteractionTypes will cancel this interaction chain when they execute.<br />**This field only functions for rules attached to a RootInteraction. It has no effect on an Interaction.** |
+| Interrupting        | `Array`<br />(Element Type: `InteractionType`)                                                      | **No**    | If provided, interaction chains with the specified InteractionTypes will be canceled when this interaction begins.                                                                                                                        |
+| BlockedByBypass     | `String`                                                                                            | **No**    | If provided, this RootInteraction cannot be blocked by interaction chains whose RootInteraction has this value as an asset tag.                                                                                                           |
+| BlockingBypass      | `String`                                                                                            | **No**    | If provided, this interaction will not block RootInteractions that have the this value as an asset tag.                                                                                                                                   |
+| InterruptedByBypass | `String`                                                                                            | **No**    | If provided, this RootInteraction cannot be canceled by RootInteractions that have this value as an asset tag.                                                                                                                            |
+| InterruptingBypass  | `String`                                                                                            | **No**    | If provided, this interaction will not cancel interaction chains whose RootInteraction has this value as an asset tag.                                                                                                                    |
+
+**InteractionType Values**
+
+- `Primary`
+- `Secondary`
+- `Ability1`
+- `Ability2`
+- `Ability3`
+- `Use`
+- `Pick`
+- `Pickup`
+- `CollisionEnter`
+- `CollisionLeave`
+- `Collision`
+- `EntityStatEffect`
+- `SwapTo`
+- `SwapFrom`
+- `Death`
+- `Wielding`
+- `ProjectileSpawn`
+- `ProjectileHit`
+- `ProjectileMiss`
+- `ProjectileBounce`
+- `Held`
+- `HeldOffhand`
+- `Equipped`
+- `Dodge`
+- `GameModeSwap`
+
+**InteractionSettings Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                        |
+| ---------------- | ------------------------------- | --------- | -------------------------------------------------------------------------------------------- |
+| AllowSkipOnClick | `Boolean`<br />(Default: false) | **No**    | If true, the user will be able to skip this interaction by clicking shortly after it starts. |
+
+**InteractionCameraSettings Fields**
+
+| Field Name  | Type                                             | Required? | Notes                                                                                                                                                           |
+| ----------- | ------------------------------------------------ | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| FirstPerson | `Array`<br />(Element Type: `InteractionCamera`) | **No**    | A list of camera keyframes to be played if the player is in first-person.<br />**The time of each keyframe must be after the keyframe before it in the array.** |
+| ThirdPerson | `Array`<br />(Element Type: `InteractionCamera`) | **No**    | A list of camera keyframes to be played if the player is in third-person.<br />**The time of each keyframe must be after the keyframe before it in the array.** |
+
+**InteractionCamera Fields**
+
+| Field Name | Type                         | Required? | Notes                                                                                                                                       |
+| ---------- | ---------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------- |
+| Time       | `Float`<br />(Default: 0.1f) | **No**    | How long after the interaction begins executing that the camera should arrive at this keyframe.<br />**Cannot be less than or equal to 0.** |
+| Position   | `Vector3`                    | **Yes**   | Where the camera should be located when it arrives at this keyframe.                                                                        |
+| Rotation   | `Direction`                  | **Yes**   | Where the camera should be pointing when it arrives at this keyframe.                                                                       |
+
+### SimpleInteraction
+
+Most interaction types below are inherited from SimpleInteraction and have these
+fields.  If a type does not have these fields, the documentation will mention it.
+
+The purpose of SimpleInteraction is to facilitate Interaction chaining by taking different paths
+based on whether the Interaction succeeded or failed.  The circumstances under which
+a given Interaction fails are generally type-specific (and described in the documentation
+below), but all interactions will be marked failed if they are cancelled via one of the
+many, many mechanisms for doing so.
+
+It is valid to create an interaction asset of type "Simple", which can be valuable when you want to use the
+interaction fields with no additional functionality.
+
+**SimpleInteraction Fields**
+
+| Field Name | Type                                     | Required? | Notes                                                                                          |
+| ---------- | ---------------------------------------- | --------- | ---------------------------------------------------------------------------------------------- |
+| Next       | `Asset`<br />(Asset Type: `Interaction`) | **No**    | After this Interaction has finished, "Next" will be executed if this Interaction did not fail. |
+| Failed     | `Asset`<br />(Asset Type: `Interaction`) | **No**    | After this Interaction has finished, "Failed" will be executed if this Interaction failed.     |
+
+## Flow Control
+
+These are interaction types used to control the flow of an interaction chain and allow interactions
+to be composed into more complex behaviors.  These interaction types generally do not pertain to
+the game and instead pertain to the interaction system itself.
+
+### Condition
+
+This interaction will fail if one of the fields is provided but does not match the current state.
+
+**Condition Fields**
+
+| Field Name       | Type       | Required? | Notes                                                                                                                                                                                    |
+| ---------------- | ---------- | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| RequiredGameMode | `GameMode` | **No**    | If provided, the interaction will fail if the current GameMode does not match the provided value.                                                                                        |
+| Jumping          | `Boolean`  | **No**    | If provided, the interaction will fail if the player's Jumping state does not match the provided value. (i.e. if True, the player must be jumping, if False, the player must not be)     |
+| Swimming         | `Boolean`  | **No**    | If provided, the interaction will fail if the player's Swimming state does not match the provided value. (i.e. if True, the player must be swimming, if False, the player must not be)   |
+| Crouching        | `Boolean`  | **No**    | If provided, the interaction will fail if the player's Crouching state does not match the provided value. (i.e. if True, the player must be crouching, if False, the player must not be) |
+| Running          | `Boolean`  | **No**    | If provided, the interaction will fail if the player's Running state does not match the provided value. (i.e. if True, the player must be running, if False, the player must not be)     |
+| Flying           | `Boolean`  | **No**    | If provided, the interaction will fail if the player's Flying state does not match the provided value. (i.e. if True, the player must be flying, if False, the player must not be)       |
+
+**GameMode Values**
+
+- `Creative`: The game is currently in Creative Mode
+- `Adventure`: The game is currently in Adventure Mode
+
+### FirstClick
+
+This interaction does not inherit from SimpleInteraction and therefore has no Next or Failed fields.
+
+This interaction has two fields that each contain a reference to an Interaction: Click and Hold.  If the root interaction
+of the chain was initiated by a client button/key press (or simulated NPC input) and the input was a tap, then
+the Click interaction is run. if it was a longer press, then the Hold interaction is run.
+
+As a minor implementation detail, this interaction is internally marked as failed when the Hold path is followed.
+This generally shouldn't matter.  If the interaction was not initiated by a key press at all, the Click path will be followed,
+but it seems risky to rely on that behavior.
+
+**FirstClick Fields**
+
+| Field Name | Type                                     | Required? | Notes                                                                                                                                                    |
+| ---------- | ---------------------------------------- | --------- | -------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Click      | `Asset`<br />(Asset Type: `Interaction`) | **No**    | If provided and the root interaction of the chain was initiated by button/key press, this interaction is executed next if the press was a quick tap.     |
+| Hold       | `Asset`<br />(Asset Type: `Interaction`) | **No**    | If provided and the root interaction of the chain was initiated by a button/key press, this interaction is executed next if the press was a longer hold. |
+
+### Interrupt
+
+This interaction can be used to cancel one or more running interaction chains on an entity and **all forked interaction
+chains those chains have spawned that are still currently running**.  All interaction chains canceled in this manner will be marked as
+Failed, which may have additional implications if the canceled chains are themselves forked from
+other chains that are still running.
+
+**Interrupt Fields**
+
+| Field Name     | Type                                           | Required? | Notes                                                                                                                                                                                               |
+| -------------- | ---------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Entity         | `InteractionTarget`<br />(Default: User)       | **Yes**   | The entity that is the owner of the target interaction chains.  This field can indicate the Owner, User, or Target of this interaction chain.                                                       |
+| InterruptTypes | `Array`<br />(Element Type: `InteractionType`) | **No**    | A set of InteractionTypes that are to be interrupted. Only interactions of these types are affected. If null, all types will be interrupted.<br />**(Note: An empty set will interrupt NO TYPES.)** |
+| RequiredTag    | `String`                                       | **No**    | An asset tag that, if provided, the RootInteraction of the interaction chain must have in order to be canceled.                                                                                     |
+| ExcludedTag    | `String`                                       | **No**    | An asset tag that, if provided, the RootInteraction of the interaction chain must not have in order to be canceled.                                                                                 |
+
+**InteractionTarget Values**
+
+- `User` - The user of this interaction chain. The entity whose actions caused this interaction chain to be executed. This is usually the same as the Owner.
+- `Owner` - The owner of this interaction chain. The entity upon whom this interaction chain is executing.
+- `Target` - The entity target of this interaction chain, if any.  This value is mutable (and can therefore come from many places) but most commonly, it is an entity the User was targeting when this interaction chain began executing.
+
+**InteractionType Values**
+
+- `Primary`
+- `Secondary`
+- `Ability1`
+- `Ability2`
+- `Ability3`
+- `Use`
+- `Pick`
+- `Pickup`
+- `CollisionEnter`
+- `CollisionLeave`
+- `Collision`
+- `EntityStatEffect`
+- `SwapTo`
+- `SwapFrom`
+- `Death`
+- `Wielding`
+- `ProjectileSpawn`
+- `ProjectileHit`
+- `ProjectileMiss`
+- `ProjectileBounce`
+- `Held`
+- `HeldOffhand`
+- `Equipped`
+- `Dodge`
+- `GameModeSwap`
+
+### Parallel
+
+This interaction does not inherit from SimpleInteraction and therefore has no Next or Failed fields.
+
+This interaction has a field `Interactions` that is an array of RootInteraction assets. The list must contain at least
+two RootInteractions.  This interaction will fork all of its children except for the first into their
+own interaction chains and immediately complete. After this interaction completes, this interaction chain will
+execute the first RootInteraction in the `Interactions` list.
+
+This interaction does not have any failure conditions and is indifferent to the fate of the forked interaction chains.
+
+**Parallel Fields**
+
+| Field Name   | Type                                                | Required? | Notes                                                         |
+| ------------ | --------------------------------------------------- | --------- | ------------------------------------------------------------- |
+| Interactions | `AssetArray`<br />(Element Type: `RootInteraction`) | **Yes**   | An array of RootInteractions that will be forked or executed. |
+
+### Repeat
+
+This interaction has a field `ForkInteractions` that is an asset of type RootInteraction. This interaction will fork that
+RootInteraction into its own interaction chain and then wait for it to complete. If the RootInteraction fails, this
+interaction will complete immediately and be marked failed. Otherwise, the RootInteraction will be forked and run again,
+up to a specified total number of times.
+
+**Repeat Fields**
+
+| Field Name       | Type                                                                                   | Required? | Notes                                                                                                                                                                                                              |
+| ---------------- | -------------------------------------------------------------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| ForkInteractions | `Asset`<br />(Asset Type: `RootInteraction`)                                           | **Yes**   | A RootInteraction that will be forked.                                                                                                                                                                             |
+| Repeat           | `Integer`<br />(Default: 1)<br />**Must be -1 or a positive integer. 0 is not valid.** | **No**    | The total number of times to fork ForkInteractions. If -1 is provided, ForkInteractions will continue being forked and executed indefinitely, until this interaction is cancelled or until ForkInteractions fails. |
+
+### Replace
+
+This interaction does not inherit from SimpleInteraction and therefore has no Next or Failed fields.
+
+This interaction uses the InteractionVars system that is avaiable for items. InteractionVars are RootInteractions that
+can be attached to an Item asset with a name.
+
+This interaction specifies a var name, and if this interaction chain was executed through
+an item and that item has an InteractionVar of the same name, then this interaction will immediately execute
+the RootInteraction on the var.  Otherwise, it will execute the default RootInteraction specified in this interaction.
+If no default is specified, then this interaction will be marked as failed.
+
+**Replace Fields**
+
+| Field Name   | Type                                         | Required? | Notes                                                                                                                                                                                                           |
+| ------------ | -------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Var          | `String`                                     | **Yes**   | The name of the InteractionVar to execute.                                                                                                                                                                      |
+| DefaultValue | `Asset`<br />(Asset Type: `RootInteraction`) | **No**    | The RootInteraction to execute if the owning item does not have an InteractionVar by the specified name. If not provided, the interaction will be marked as failed instead.                                     |
+| DefaultOk    | `Boolean`<br />(Default: false)              | **No**    | If false, then an angry message will be printed to the server logs if the owning item does not have an InteractionVar by the specified name.  The functioning of this interaction will be otherwise unaffected. |
+
+### RunRootInteraction
+
+This interaction immediately executes the provided RootInteraction as part of this interaction chain. This interaction
+does not have any failure conditions.
+
+**RunRootInteraction Fields**
+
+| Field Name      | Type                                         | Required? | Notes                           |
+| --------------- | -------------------------------------------- | --------- | ------------------------------- |
+| RootInteraction | `Asset`<br />(Asset Type: `RootInteraction`) | **Yes**   | The RootInteraction to execute. |
+
+### Selector
+
+This interaction will execute a Selector to find entities and/or blocks (depending on the Selector) and fork off an
+interaction chain for each located entity or block. This interaction will not wait for those interaction chains
+to complete and is indifferent to their fate. The forked interaction chains will use the located entity/block as
+their target entity/target block. Each entity or block will only fork one interaction chain over the life of this
+interaction.  The Selector is guaranteed to run once for each execution of this interaction, but some Selectors
+are intended to be run over a period of time and sweep across an area to locate targets. In order to use those Selectors
+properly, you will need to extend the execution time of this interaction using `RunTime` or `WaitForAnimationToFinish`.
+The Selector will be executed repeatedly over the lifetime of the interaction.
+
+If the Selector is configured to locate entities, you can add additional sets of entity matching rules. If a located entity
+matches one of the rules, the matching RootInteraction will be forked instead of the standard `HitEntity` RootInteraction.
+
+Entities located by the Selector will be ignored if they do not have a NetworkId, if they are dead, or if they are invulnerable.
+The only exception to this rule is that players in Creative Mode that are marked to receive hits will not be ignored.
+
+This interaction's failure conditions are configurable via the `FailOn` field. You can configure this interaction to never
+fail, to fail if the Selector does not locate any blocks before this interaction finishes executing, to fail if the
+Selector does not locate any entities before this interaction finishes executing, or to fail in either case.
+
+**Selector Fields**
+
+| Field Name     | Type                                         | Required? | Notes                                                                                                                                                                                                                                     |
+| -------------- | -------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Selector       | `Selector`                                   | **Yes**   | The Selector is executed at least once and may be executed repeatedly to locate blocks and/or entities in an area.                                                                                                                        |
+| HitEntity      | `Asset`<br />(Asset Type: `RootInteraction`) | **No**    | If included and the `Selector` locates an entity that does not match any `HitEntityRules`, this RootInteraction will be forked into a new interaction chain with the located entity as the target entity.                                 |
+| HitEntityRules | `Array`<br />(Element Type: `HitEntity`)     | **No**    | If included, these rules will be matched against any entity located by the `Selector`. If an entity matches a set of rules, the RootInteraction associated with the rules will be forked instead of the standard `HitEntity` interaction. |
+| HitBlock       | `Asset`<br />(Asset Type: `RootInteraction`) | **No**    | If included and the `Selector` locates a block, this RootInteraction will be forked into a new interaction chain with the located block as the block target.                                                                              |
+| FailOn         | `FailOnType`<br />(Default: `Neither`)       | **No**    | Defines under what circumstances this interaction will fail.  It can be marked to fail when it completes without locating any blocks, it can be marked to fail when it completes without locating any entities, both, or neither.         |
+| IgnoreOwner    | `Boolean`<br />(Default: true)               | **No**    | If true, the Selector will not locate the User entity of this interaction.                                                                                                                                                                |
+
+**HitEntity Fields**
+
+| Field Name | Type                                         | Required? | Notes                                                                                                 |
+| ---------- | -------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------- |
+| Matchers   | `Array`<br />(Element Type: `EntityMatcher`) | **Yes**   | A set of rules that an entity must match. An entity must successful match all rules to be considered. |
+| Next       | `Asset`<br />(Asset Type: `RootInteraction`) | **Yes**   | The RootInteraction to fork if an entity matches all rules.                                           |
+
+**EntityMatcher Fields**
+
+| Field Name | Type                            | Required? | Notes                                                                                                     |
+| ---------- | ------------------------------- | --------- | --------------------------------------------------------------------------------------------------------- |
+| Type       | `String`                        | **Yes**   | If provided, specifies a type of EntityMatcher to use. Each matcher type may come with additional fields. |
+| Invert     | `Boolean`<br />(Default: false) | **No**    | If true, an entity must fail this rule for it to be marked as succeeded.                                  |
+
+**EntityMatcher Type: Player**
+
+This EntityMatcher will succesfully match the entity only if they are a player.
+
+**EntityMatcher Type: Vulnerable**
+
+This Entitymatcher will successfully match the entity only if they are not marked as invulnerable.
+
+**FailOnType Values**
+
+- `Neither`
+- `Entity`
+- `Block`
+- `Either`
+
+### Serial
+
+This interaction does not inherit from SimpleInteraction and therefore has no Next or Failed fields.
+
+This interaction has a field `Interactions` which is a list of Interaction assets. This interaction immediately
+completes and the interaction chain continues by executing the interactions in the list one at a time. This
+interaction does not have any failure conditions.
+
+**Serial Fields**
+
+| Field Name   | Type                                            | Required? | Notes                                      |
+| ------------ | ----------------------------------------------- | --------- | ------------------------------------------ |
+| Interactions | `AssetArray`<br />(Element Type: `Interaction`) | **Yes**   | An array of Interaction assets to execute. |
+
+## Cooldowns
+
+RootInteractions interface with a complex cooldown system that can be used for a variety of purposes. Aside from simply
+adding an important aspect of resource management to your game design, cooldowns can be used to ensure that click-activated
+interaction chains don't repeatedly spam if the player holds down the input.
+
+By default, every RootInteraction has a cooldown timer that is keyed to the RootInteraction name, and by default, it
+will launch a cooldown of 0.35 seconds when activated by client input.  Otherwise, no cooldown will be activated.  However,
+by configuring your RootInteraction, you can change the key for the cooldown (so that multiple RootInteractions can share
+a single cooldown), set the cooldown timer to whatever you like, and configure multiple charges that can build up over time
+to allow the entity to activate the RootInteraction multiple times before being forced to pause.
+
+One important concept to keep in mind is the difference between **cooldown** and **charge time**.  The cooldown, if any,
+is activated each time a RootInteraction triggers, even if the player has more available charges. If the RootInteraction
+is configured to use charges, then they will gradually build up over time. In order for a RootInteraction to be activated,
+the cooldown (if any) must be expired, and the RootInteraction must have at least one charge (if it has been
+configured to use charges).
+
+Bear in mind that the entire Cooldown configuration is shared between different RootInteractions with the same cooldown id.
+If you activate an ability with 5 charges and a short cooldown and then another ability with a much longer cooldown and no
+charges, the second ability will use the cooldown properties of the first ability until/unless the first ability finishes
+charging and is cleared from the system.  You should generally only have multiple RootInteractions share a cooldown id
+if they have the same configuration.
+
+The interactions below interact with the cooldown system to allow you to manipulate cooldowns via the interaction system. By
+using these interactions, you can have several interaction chains with different cooldown configurations share cooldowns
+that are checked and activated as part of the interaction chain itself, or have some components of an interaction change
+use a second cooldown separate from the main one.
+
+### CooldownCondition
+
+**CooldownCondition Fields**
+
+This interaction will fail if the specified cooldown id is on cooldown for the User entity.  This interaction will only
+function for players- the interaction will always succeed for NPCs.  In order for this interaction to succeed, the
+cooldown, if any, must have expired and at least one charge, if any, must have filled.
+
+| Field Name | Type     | Required? | Notes                     |
+| ---------- | -------- | --------- | ------------------------- |
+| Id         | `String` | **Yes**   | The cooldown id to check. |
+
+### IncrementCooldown
+
+**IncrementCooldown Fields**
+
+This interaction will modify a cooldown that is currently active on the User entity, allowing charges and remaining
+cooldown to be modified.
+Despite its name, this interaction can be used to reduce a cooldown as well as increase it. If the cooldown is not
+currently active, this interaction will have no effect. The interaction has no special failure conditions.
+
+| Field Name        | Type                        | Required? | Notes                                                                                                                                                                                                                                                                                     |
+| ----------------- | --------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Id                | `String`                    | **No**    | If provided, the cooldown id of the cooldown to be manipulated. If not provided, the cooldown id of the current chain's RootInteraction will be used.                                                                                                                                     |
+| Time              | `Float`<br />(Default: 0.0) | **No**    | The amount to increase the remaining cooldown by. Can be negative. The remaining cooldown time will not be reduced below zero or increased above the maximum cooldown time.                                                                                                               |
+| ChargeTime        | `Float`<br />(Default: 0.0) | **No**    | The amount to increase the remaining time until the next charge is filled by. Can be negative. The remaining charge time cannot be reduced below zero or increased above the maximum cooldown time. **This will not work on abilities that have a maximum of 1 charge, for some reason.** |
+| Charge            | `Integer`<br />(Default: 0) | **No**    | The amount to increase the number of charges by. Can be negative. The number of charges cannot be reduced below 0 or increased above the maximum.                                                                                                                                         |
+| InterruptRecharge | `Boolean`(Default: false)   | **No**    | If true and `Charge` is not 0, will reset the remaining time to the next charge to the maximum value after changing the charge count.                                                                                                                                                     |
+
+### ResetCooldown
+
+This interaction will trigger a cooldown on the User entity with a specified configuration. The charges will be refilled
+but the cooldown will be immediately triggered.  The mechanisms for deciding on the configuration are a little bit complicated.
+You may specify a cooldown configuration via the `Cooldown` field. If you do not include an `Id` field, then the
+interaction chain's RootInteraction will be used for any field not specified in the configuration. If there is an active
+cooldown under the specified `Id` (or under the RootInteraction's cooldown id if none is specified) then the fields
+from that active cooldown will overwrite data in the RootInteraction's cooldown, but not data in your `Cooldown` field.
+
+**ResetCooldown Fields**
+
+| Field Name | Type                  | Required? | Notes                                                        |
+| ---------- | --------------------- | --------- | ------------------------------------------------------------ |
+| Cooldown   | `InteractionCooldown` | **No**    | A cooldown configuration to use for the new, reset cooldown. |
+
+**InteractionCooldown Fields**
+
+| Field Name        | Type                                 | Required? | Notes                                                                                                                                                                                                 |
+| ----------------- | ------------------------------------ | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Id                | `String`                             | **No**    | The cooldown id to use for this cooldown. If not provided, the RootInteraction's cooldown id will be used, if any.                                                                                    |
+| Cooldown          | `Float`<br />(Default: 0.0)          | **No**    | The duration of the cooldown, in seconds.                                                                                                                                                             |
+| Charges           | `Array`<br />(Element Type: `Float`) | **No**    | If provided, a list of how many charges this cooldown can build, and how long each charge takes to build, in seconds.                                                                                 |
+| InterruptRecharge | `Boolean`<br />(Default: false)      | **No**    | If true, the charge time will be reset when the number of charges changes.                                                                                                                            |
+| ClickBypass       | `Boolean`<br />(Default: false)      | **No**    | If true, RootInteractions keyed to this cooldown can still be activated when it is on cooldown provided that the RootInteraction was triggered by a distinct key or mouse button press on the client. |
+
+### TriggerCooldown
+
+This interaction is similar to ResetCooldown, except instead of refilling the cooldown's charges, one charge will be deducted
+as normal.
+
+**TriggerCooldown Fields**
+
+| Field Name | Type                  | Required? | Notes                                                        |
+| ---------- | --------------------- | --------- | ------------------------------------------------------------ |
+| Cooldown   | `InteractionCooldown` | **No**    | A cooldown configuration to use for the new, reset cooldown. |
+
+**InteractionCooldown Fields**
+
+| Field Name        | Type                                 | Required? | Notes                                                                                                                                                                                                 |
+| ----------------- | ------------------------------------ | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Id                | `String`                             | **No**    | The cooldown id to use for this cooldown. If not provided, the RootInteraction's cooldown id will be used, if any.                                                                                    |
+| Cooldown          | `Float`<br />(Default: 0.0)          | **No**    | The duration of the cooldown, in seconds.                                                                                                                                                             |
+| Charges           | `Array`<br />(Element Type: `Float`) | **No**    | If provided, a list of how many charges this cooldown can build, and how long each charge takes to build, in seconds.                                                                                 |
+| InterruptRecharge | `Boolean`<br />(Default: false)      | **No**    | If true, the charge time will be reset when the number of charges changes.                                                                                                                            |
+| ClickBypass       | `Boolean`<br />(Default: false)      | **No**    | If true, RootInteractions keyed to this cooldown can still be activated when it is on cooldown provided that the RootInteraction was triggered by a distinct key or mouse button press on the client. |
+
+## Combo Chains
+
+Hytale additionally comes with a rich "combo chaining" system, which allows several inputs in a row to result in different
+attacks and special moves.  Rather than being attached to the RootInteraction like the cooldown system, these are
+primarily driven by the `Chaining` interaction.
+
+### Chaining
+
+This interaction does not inherit from SimpleInteraction and therefore has no Failed field. Its Next field works differently
+from most interaction types.
+
+Chaining is a type of flow control interaction- each time a Chaining interaction with the same `ChainId` is called, a single
+interaction in the `Next` list is chosen and the others are ignored. The first time the `ChainId` is used, the first
+interaction in the list is chosen, the next time the second, etc. Once the end of the list is reached, the first
+interaction will be chosen again.
+
+Bear in mind: the progress through the Next list is based on the **ChainId**, not the interaction!  That means that two
+different Chaining interactions can share a single combo chain. You could have a pair of daggers that attacks with
+the left when the left mouse button is clicked and with the right when the right mouse button is clicked.  You could give
+both interaction chains a Chaining interaction with the same `ChainId` and three `Next` entries that do a light-light-heavy
+combo.  Each specific hit would occur with either the left or the right knife based on which button you clicked, but
+the combo would be otherwise identical regardless of which you chose.
+
+The Chaining interaction also has a concept called "flags".  It is possible to attach named flags to a `ChainId` by using
+the ChainFlag interaction.  Then, you specify the flag name in Chaining's `Flags` field. If a Flag is active when the
+Chaining interaction is run, the Flag's interaction will be run instead of the appropriate interaction in `Next`.
+Bear in mind: the entity's progress through the `Next` list still advances, the resulting `Next` interaction is just not
+run.  Only one flag can be active at a time.
+
+Lastly, it is possible to cancel the entity's progress through the combo chain and reset them to the first interaction in
+the list. This can be done with the CancelChain interaction, but it will also happen automatically if the player does
+not trigger an interaction with the ChainId for the specified ChainingAllowance.  When either of these happen, all flags will be
+canceled as well.
+
+All of these effects are triggered on the User entity only. Non-players can use the chaining system, but Flags do not currently
+work for non-players.  This interaction has no special failure conditions.
+
+**Chaining Fields**
+
+| Field Name        | Type                                                       | Required? | Notes                                                                                                                                                                                                                       |
+| ----------------- | ---------------------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| ChainId           | `String`                                                   | **No**    | If provided, acts as a key that multiple Chaining interactions can use to share combo chain progress and flags. If not provided, a unique ChainId will be generated for this interaction.                                   |
+| ChainingAllowance | `Double`<br />(Default: 0.0)                               | **No**    | If, at the time this interaction is triggered, it has been this long in seconds since the last time a Chaining interaction with the same ChainId was executed, all state for this ChainId will be cleared before execution. |
+| Next              | `AssetArray`<br />(Element Type: `Interaction`)            | **Yes**   | A list of interactions to cycle between each time this interaction is run.                                                                                                                                                  |
+| Flags             | `Map`<br />(Key Type: `String`, Value Type: `Interaction`) | **No**    | A map of flag names to interactions to run if the flag is active when this interaction executes.                                                                                                                            |
+
+### CancelChain
+
+This interaction resets all progress and flag data on the User entity for the provided `ChainId`.  The next time a Chaining
+interaction is called for the provided `ChainId`, it will begin at the first interaction in the `Next` list. This
+interaction has no special failure conditions.
+
+**CancelChain Fields**
+
+| Field Name | Type     | Required? | Notes                                 |
+| ---------- | -------- | --------- | ------------------------------------- |
+| ChainId    | `String` | **Yes**   | A ChainId whose data should be reset. |
+
+### ChainFlag
+
+This interaction activates a flag on the User entity for the provided `ChainId`, which can be used to change behavior the
+next time a Chaining interaction with this `ChainId` is run. This will overwrite any flag that has
+already been raised. This interaction will have no effect for non-players. This interaction has no special failure
+conditions.
+
+| Field Name | Type     | Required? | Notes                                        |
+| ---------- | -------- | --------- | -------------------------------------------- |
+| ChainId    | `String` | **Yes**   | A ChainId on whom the flag should be raised. |
+| Flag       | `String` | **Yes**   | The name of the flag to raise.               |
+
+## Charging
+
+A unique flow-control interaction that is frequently used is the Charging interaction.  It is a flow-control interaction
+that delays while the input button used to trigger the interaction chain is held.  When it is released (or the interaction
+is forced to end), the interaction chain can continue with a different interaction based on how long the input was held
+for.
+
+These interactions are all related by either being the Charging interaction, or other interaction types that inherit the
+Charging interaction's behavior.
+
+### Charging
+
+This interaction does not inherit from SimpleInteraction and therefore its Next field works different from most interactions.
+This interaction adds its own Failed field which works the same way that SimpleInteraction's does.
+
+This interaction only works properly when its interaction chain was triggered by a client key or button press (or
+NPC-simulated equivalent). This interaction will continue executing for as long as the key or button press is held (with
+some exceptions, covered below) by the User entity.  Like other interactions, it has a `Next` field indicating which interaction to execute
+after this one, but the field is a map from `Float` values to `Interaction` assets. When this interaction ends, either
+due to the input being released or the charge duration completing, this interaction will determine the largest `Float` key that is less
+than the amount of time in seconds that the interaction was executing for.  The Interaction mapped to that key will be
+executed next.
+
+The interaction includes some cancellation conditions that are specific to this interaction. For instance, the interaction
+has a `CancelOnOtherClick` field that matches the field on RootInteraction. If it is active on this interaction but not
+the RootInteraction, then clicking while charging will cancel this interaction (and execute the `Failed` interaction rather
+than any of the `Next` interactions) but otherwise continue the interaction chain.
+
+Another valuable feature Charging has is the `Forks` field.  For input-triggered interactions that are triggered while the
+Charging interaction is executing, you can add an entry for the relevant InteractionType to this field and instead of
+triggering the usual interaction chain based on held item, targeted block, etc. the RootInteraction specified in the
+`Forks` field will be triggered.  This can unlock rich attack modes and behaviors. For instance, having a shield bash attack
+triggered off left click while blocking, or a special attack that triggers when both mouse buttons are pressed at the
+same time.
+
+There are two modes of operation for the Charging interaction. One is to have the ability charge for as long
+as the input is held and only end execution when the entity releases the input.  Bows in the main Hytale game work
+that way.  That is accomplished by setting `AllowIndefiniteHold` to true.  Another mode of operation is to have the
+interaction complete execution when the execution time has surpassed the largest key value in the `Next` field and
+immediately begin executing the Interaction mapped to that key.  Food in the main Hytale game work like this.  It
+is accomplished by setting `AllowIndefiniteHold` to false.
+
+One pitfall to be careful of when setting `AllowIndefiniteHold` to false is the way it interacts with cooldowns.\
+Normally, input-initiated interaction chains start a 0.35s cooldown on the triggered RootInteraction that prevents
+holding the mouse button from immediately spamming a new interaction when the first one completes.  However, if the
+duration of a Charging interaction is longer than 0.35s, then the cooldown will have already completed when the
+interaction chain finishes, which will often result in a new execution beginning immediately before the player can
+stop pressing the mouse button.  One solution for this problem is to add a `Simple` interaction to the end of your
+interaction chain with a `RunTime` of 0.35s to simulate the cooldown.  Alternatively, you can add a longer cooldown
+(the maximum duration of your Charging interaction plus 0.35s) to the RootInteraction. However, the longer cooldown is
+not always desirable, as the interaction may have ended prematurely, resulting in an unusually long lockout between
+executions.
+
+**Charging Fields**
+
+| Field Name                         | Type                                                                    | Required? | Notes                                                                                                                                                                                                                                                                                                                                                                                       |
+| ---------------------------------- | ----------------------------------------------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| FailOnDamage                       | `Boolean`<br />(Default: false)                                         | **No**    | If true, this interaction will fail and end immediately if the User entity takes any damage while it is executing.                                                                                                                                                                                                                                                                          |
+| CancelOnOtherClick                 | `Boolean`<br />(Default: true)                                          | **No**    | If true, this interaction will fail and end immediately if the User entity sends another button or key press while it is executing.                                                                                                                                                                                                                                                         |
+| Forks                              | `Map`<br />(Key Type: `InteractionType`, Value Type: `RootInteraction`) | **No**    | A map of InteractionType to RootInteraction. If entity input triggers the InteractionType while this interaction is executing, the mapped RootInteraction will be forked into its own interaction chain. This will happen instead of the usual handling for that InteractionType.  This fork will occur even if `CancelOnOtherClick` is set to true.                                        |
+| Failed                             | `Asset`<br />(Asset Type: `Interaction`)                                | **No**    | After this Interaction has finished, "Failed" will be executed if this Interaction failed.                                                                                                                                                                                                                                                                                                  |
+| AllowIndefiniteHold                | `Boolean`<br />(Default: false)                                         | **No**    | If true, this interaction will continue executing for as long as the User entity continues to hold the input. If false, execution will end as soon as the execution time in seconds reaches the largest key value in the `Next` map.                                                                                                                                                        |
+| DisplayProgress                    | `Boolean`<br />(Default: true)                                          | **No**    | If true, players executing this interaction will see a progress bar will be displayed below their cursor indicating how close to reaching the highest key value in `Next` they are.                                                                                                                                                                                                         |
+| Next                               | `Map`<br />(Key Type: `Float`, Value Type: `Interaction`)               | **No**    | A map from `Float` to `Interaction`.  When this interaction successfully finishes executing (either because the input was released or because the maximum duration was reached), this interaction will find the `Float` value with the largest duration in seconds that is less than the amount of time this interaction executed for. That key's mapped Interaction will then be executed. |
+| MouseSensitivityAdjustmentTarget   | `Float`<br />(Default: 1.0)                                             | **No**    | While charging, this mouse sensitivity multiplier will gradually be applied.                                                                                                                                                                                                                                                                                                                |
+| MouseSensitivityAdjustmentDuration | `Float`<br />(Default: 1.0)                                             | **No**    | Duration in seconds. After this many seconds, `MouseSensitivityAdjustmentTarget` will be fully applied to the mouse sensitivity.                                                                                                                                                                                                                                                            |
+| Delay                              | `ChargingDelay`                                                         | **No**    | Settings that allow charging progress to be pushed back when the User entity takes damage.                                                                                                                                                                                                                                                                                                  |
+
+**ChargingDelay Fields**
+
+| Field Name    | Type                        | Required? | Notes                                                                                                                                                                                                                                                                     |
+| ------------- | --------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| MinHealth     | `Float`<br />(Default: 0.0) | **No**    | Damage taken as a percentage of entity health (0.0-1.0). If a hit deals less than this much damage, no pushback will be applied.  If a hit deals exactly this much damage, `MinDelay` seconds worth of pushback will be applied.                                          |
+| MaxHealth     | `Float`<br />(Default: 0.0) | **No**    | Damage taken as a percentage of entity health (0.0-1.0). If a hit deals at least this much damage, `MaxDelay` seconds worth of pushback will be applied.                                                                                                                  |
+| MinDelay      | `Float`<br />(Default: 0)   | **No**    | The amount of pushback, in seconds, to apply if the entity takes a hit that deals `MinHealth` damage. The amount of pushback applied by a hit is a gradiant between `MinDelay` and `MaxDelay` based on the amount of damage between `MinHealth` and `MaxHealth`.          |
+| MaxDelay      | `Float`<br />(Default: 0)   | **No**    | The amount of pushback, in seconds, to apply if the entity takes a hit that deals at least `MaxHealth` damage. The amount of pushback applied by a hit is a gradiant between `MinDelay` and `MaxDelay` based on the amount of damage between `MinHealth` and `MaxHealth`. |
+| MaxTotalDelay | `Float`<br />(Deault: 0)    | **No**    | The maximum amount of pushback the entity can receive over the course of a single charge, regardless of how many times they are hit.                                                                                                                                      |
+
+**InteractionType Values**
+
+- `Primary`
+- `Secondary`
+- `Ability1`
+- `Ability2`
+- `Ability3`
+- `Use`
+- `Pick`
+- `Pickup`
+- `CollisionEnter`
+- `CollisionLeave`
+- `Collision`
+- `EntityStatEffect`
+- `SwapTo`
+- `SwapFrom`
+- `Death`
+- `Wielding`
+- `ProjectileSpawn`
+- `ProjectileHit`
+- `ProjectileMiss`
+- `ProjectileBounce`
+- `Held`
+- `HeldOffhand`
+- `Equipped`
+- `Dodge`
+- `GameModeSwap`
+
+### Wielding
+
+This interaction is inherited from Charging rather than SimpleInteraction.  However, its `Failed` and `Next` fields function
+identically to SimpleInteraction.  It does not inherit all fields from Charging, so be sure to pay close attention to
+the field list below.
+
+This interaction drives most blocking behavior in the game. While this interaction is executing, attacks made against
+the Owner entity will (conditionally) trigger effects defined in this interaction.  Unlike the Charging interaction,
+this interaction can always execute indefinitely and will only end when it fails or when the input is released.
+
+One option available in Wielding is `AngledWielding`, which allows damage and knockback modifiers to only be applied
+depending on the direction the attack against the Owner entity is coming from.  The AngledWielding type has a
+field `Angle` which determines which direction the protection points relative to the player (0 is the player's
+front), and `AngleDistance` which determines how wide the cone of protection extends around the player.  Block effects
+from this interaction (such as `BlockedEffects`, `BlockedInteractions`, and `StaminaCost`) will only apply if
+the DamageCause matches `DamageModifiers` OR if the DamageCause matches `AngledWielding.DamageModifiers` and
+the source of the damage matches `Angle` and `AngleDistance`.  It is possible for damage and knockback multipliers
+specified on both this interaction's modifier fields and `AngledWielding`'s modifier fields to stack, if both
+have entries for the same DamageCause.
+
+This interaction will only have an effect on damage taken by one of the DamageCause entries in `DamageModifiers` or
+`AngledWielding.DamageModifiers`.  If a DamageCause is in `DamageModifiers`, then the block effect will be triggered
+and the damage modifier applied regardless of what direction the Owner entity is attacked from.  If a DamageCause is in
+`AngledWielding.DamageModifiers`, then the damage modifier is only applied if the
+
+\*\* Wielding Fields\*\*
+
+| Field Name          | Type                                                                    | Required? | Notes                                                                                                                                                                                                                                                                                                                                                                                                      |
+| ------------------- | ----------------------------------------------------------------------- | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| FailOnDamage        | `Boolean`<br />(Default: false)                                         | **No**    | If true, this interaction will fail and end immediately if the User entity takes any damage while it is executing.                                                                                                                                                                                                                                                                                         |
+| CancelOnOtherClick  | `Boolean`<br />(Default: true)                                          | **No**    | If true, this interaction will fail and end immediately if the User entity sends another button or key press while it is executing.                                                                                                                                                                                                                                                                        |
+| Forks               | `Map`<br />(Key Type: `InteractionType`, Value Type: `RootInteraction`) | **No**    | A map of InteractionType to RootInteraction. If entity input triggers the InteractionType while this interaction is executing, the mapped RootInteraction will be forked into its own interaction chain. This will happen instead of the usual handling for that InteractionType.  This fork will occur even if `CancelOnOtherClick` is set to true (after which this interaction chain will be canceled). |
+| Next                | `Asset`<br />(Asset Type: `Interaction`)                                | **No**    | After this interaction has finished, "Next" will be executed if this interaction did not fail.                                                                                                                                                                                                                                                                                                             |
+| Failed              | `Asset`<br />(Asset Type: `Interaction`)                                | **No**    | After this interaction has finished, "Failed" will be executed if this interaction failed.                                                                                                                                                                                                                                                                                                                 |
+| DamageModifiers     | `Map`<br />(Key Type: `DamageCause`, Value Type: `Float`)               | **No**    | A map from DamageCause to Float, where the Float is multiplied against any damage received from the mapped DamageCause while this interaction is executing.                                                                                                                                                                                                                                                |
+| KnockbackModifiers  | `Map`<br />(Key Type: `DamageCause`, Value Type: `Float`)               | **No**    | A map from DamageCause to Float, where the Float is multiplied against any knockback force received from the mapped DamageCause while this interaction is executing.                                                                                                                                                                                                                                       |
+| AngledWielding      | `AngledWielding`                                                        | **No**    | Configuration to only trigger block effects from certain angles.                                                                                                                                                                                                                                                                                                                                           |
+| StaminaCost         | `StaminaCost`                                                           | **No**    | If the Owner entity receives damage that matches `DamageModifiers` or `AngledWielding` while this interaction is executing, then the entity's stamina will be deducted according to this configuration.                                                                                                                                                                                                    |
+| BlockedEffects      | `DamageEffects`                                                         | **No**    | If the Owner entity receives damage that matches `DamageModifiers` or `AngledWielding` while this interaction is executing, then these effects will be applied to the instance of damage.                                                                                                                                                                                                                  |
+| BlockedInteractions | `Asset`<br />(Asset Type: `RootInteraction`)                            | **No**    | If the Owner entity receives damage that matches `DamageModifiers` or `AngledWielding` while this interaction is executing, then this RootInteraction will be launched as a brand new interaction chain with the Owner entity as both Owner and User, and the attacker as the Target entity.  This new interaction chain is, notably, brand new, **not** forked from the current one.                      |
+
+**AngledWielding Fields**
+
+| Field Name         | Type                                                      | Required? | Notes                                                                                                                                                                                                            |
+| ------------------ | --------------------------------------------------------- | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Angle              | `Float`<br />(Default: 0.0)                               | **No**    | Angle in degrees relative to the Owner entity where the angled protection is centered. 0.0 means pointed towards the front of the Owner entity.                                                                  |
+| AngleDistance      | `Float`<br />(Default: 0.0)                               | **No**    | Angle in degrees indicating how wide the cone of protection is.                                                                                                                                                  |
+| DamageModifiers    | `Map`<br />(Key Type: `DamageCause`, Value Type: `Float`) | **No**    | A map from DamageCause to Float, where the Float is multiplied against any damage received from the mapped DamageCause received from within the cone of protection while this interaction is executing.          |
+| KnockbackModifiers | `Map`<br />(Key Type: `DamageCause`, Value Type: `Float`) | **No**    | A map from DamageCause to Float, where the Float is multiplied against any knockback force received from the mapped DamageCause received from within the cone of protection while this interaction is executing. |
+
+**StaminaCost Fields**
+
+| Field Name | Type                                             | Required? | Notes                                                                                                                                                                                                                                                |
+| ---------- | ------------------------------------------------ | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| CostType   | `CostType`<br />(Default: `MaxHealthPercentage`) | **No**    | How to calculate stamina consumed by blocking from the raw pre-block damage. If `Damage`, then the stamina consumed will be `rawDamage / Value`. If `MaxHealthPercentage`, then the stamina consumed will be `rawDamage / (EntityMaxHealth * Value)` |
+| Value      | `Float`<br />(Default: 0.04)                     | **No**    | The value to use in the `CostType` formula.                                                                                                                                                                                                          |
+
+**DamageEffects Fields**
+
+| Field Name             | Type                                         | Required? | Notes                                                                           |
+| ---------------------- | -------------------------------------------- | --------- | ------------------------------------------------------------------------------- |
+| ModelParticles         | `Array`<br />(Element Type: `ModelParticle`) | **No**    | Particle systems to trigger in the first-person view.                           |
+| WorldParticles         | `Array`<br />(Element Type: `WorldParticle`) | **No**    | Particle systems to trigger in the third-person view.                           |
+| LocalSoundEventId      | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | 2D sound to play locally to the attacking entity if they are a player.          |
+| WorldSoundEventId      | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | Sound to play in the world at the Owner entity's location.                      |
+| PlayerSoundEventId     | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | 2D sound to play locally to the Owner entity if they are a player.              |
+| ViewDistance           | `Double`<br />(Default: 75.0)                | **No**    | Distance at which these effects should play for other players.                  |
+| Knockback              | `Knockback`                                  | **No**    | The properties of the knockback that will be applied.                           |
+| CameraEffect           | `Asset`<br />(Asset Type: `CameraEffect`)    | **No**    | CameraEffect to briefly apply locally to the Owner entity if they are a player. |
+| StaminaDrainMultiplier | `Float`<br />(Default: 1.0)                  | **No**    | This multiplier is applied to the `StaminaCost`, if any.                        |
+
+**Knockback Fields**
+
+| Field Name     | Type                                       | Required? | Notes                                                                                                                      |
+| -------------- | ------------------------------------------ | --------- | -------------------------------------------------------------------------------------------------------------------------- |
+| Type           | `String`                                   | **No**    | If provided, specifies a type of knockback to use. Each knockback type may come with additional fields.                    |
+| Force          | `Double`<br />(Default: 0.0)               | **No**    | The amount of force to apply to the Owner entity.                                                                          |
+| Duration       | `Double`<br />(Default: 0.0)               | **No**    | If 0.0, apply the force as a single impulse.  If more, continuously apply the force over a period of time.                 |
+| VelocityType   | `ChangeVelocityType`<br />(Default: `Add`) | **No**    | How to apply the force, either adding it to the entity's current velocity, or setting the velocity to the knockback force. |
+| VelocityConfig | `VelocityConfig`                           | **No**    | Characteristics of friction as the Owner entity is thrown by this knockback.                                               |
+
+**Knockback Type: Force**
+
+Apply the calculated knockback force along the provided direction.
+
+| Field Name | Type                         | Required? | Notes                                                                                |
+| ---------- | ---------------------------- | --------- | ------------------------------------------------------------------------------------ |
+| Direction  | `Vector3`<br />(Default: Up) | **No**    | Which direction the player should be flung, relative to the direction of the attack. |
+
+**Knockback Type: Point**
+
+Apply the calculated knockback force laterally along the XZ plane, plus provided Y velocity.
+
+| Field Name | Type                        | Required? | Notes                                                                                                   |
+| ---------- | --------------------------- | --------- | ------------------------------------------------------------------------------------------------------- |
+| OffsetX    | `Integer`<br />(Default: 0) | **No**    | Offset the source position of the knockback left or right perpendicular to the direction of the attack. |
+| OffsetZ    | `Integer`<br />(Default: 0) | **No**    | Offset the source position of the knockback, forward or backward along the directon of the attack.      |
+| RotateY    | `Integer`<br />(Default: 0) | **No**    | Rotate the knockback direction around the Y axis, where 0 is the default attack direction.              |
+| VelocityY  | `Float`<br />(Default: 0.0) | **No**    | Add vertical velocity to the knockback force after the direction and force has been calculated.         |
+
+**Knockback Type: Directional**
+
+Apply the calculated knockback force along the attack direction, removing any vertical component and replacing it with a provided Y velocity.
+
+| Field Name | Type                      | Required? | Notes                                                                                                                                            |
+| ---------- | ------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------ |
+| RelativeX  | `Float`<br />(Default: 0) | **No**    | Apply additional force left or right perpendicular to the direction of the attack. The additional force is multiplied by the knockback strength. |
+| RelativeZ  | `Float`<br />(Default: 0) | **No**    | Apply additional force forward or backward along the attack direction. The additional force is multiplied by the knockback strength.             |
+| VelocityY  | `Float`<br />(Default: 0) | **No**    | Replace the vertical velocity of the knockback with this value.  This value is not multiplied by knockback strength.                             |
+
+**VelocityConfig Fields**
+
+| Field Name          | Type                                              | Required? | Notes                                                                                                                                                                                           |
+| ------------------- | ------------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| GroundResistance    | `Float`<br />(Default: 0.82)                      | **No**    | The minimum amount of friction applied when the entity is in contact with the ground.  1.0 = no friction, 0.0 = total friction                                                                  |
+| GroundResistanceMax | `Float`<br />(Default: 0.0)                       | **No**    | The maximum amount of friction applied when the entity is in contact with the ground.  1.0 = no friction, 0.0 = total friction                                                                  |
+| AirResistance       | `Float`<br />(Default: 0.96)                      | **No**    | The minimum amount of friction applied when the entity is in the air. 1.0 = no friction, 0.0 = total friction                                                                                   |
+| AirResistanceMax    | `Float`<br />(Default: 0.0)                       | **No**    | The maximum amount of friction applied when the entity is in the air. 1.0 = no friction, 0.0 = total friction                                                                                   |
+| Threshold           | `Float`<br />(Default: 1.0)                       | **No**    | The speed at which the maximum amount of friction will be applied to the entity. The amount of friction applied will increase from minimum to maximum as the entity moves from 0 to this speed. |
+| Style               | `VelocityThresholdStyle`<br />(Default: `Linear`) | **No**    | The curve that friction follows as the entity's speed increases toward the `Threshold`.                                                                                                         |
+
+**CostType Values**
+
+- `MaxHealthPercentage`
+- `Damage`
+
+**ChangeVelocityType Values**
+
+- `Add`
+- `Set`
+
+**VelocityThresholdStyle Values**
+
+- `Linear`
+- `Exp`
+
+## Blocks
+
+These are interaction types meant to reason about and modify blocks in the world.  The most important concept unique
+to these interactions is the Block Target.  Like the Entity Target, it is mutable and can come from many places.
+However, for interaction chains initiated by the client, the block target will initially be the block that the player's cursor was
+over, if any.
+
+Additionally, for interaction chains initiated by the client, the client will send along which face of the block is targeted,
+which is used by a few block-related interactions.
+It is left up to each interaction type that cares about block faces as to how to handle this behavior for simulated input
+(i.e. NPCs initiating chains that are normally initated by the client).  At the time of this writing, all block-related
+interactions choose the top face where relevant in simulated input.
+
+### BlockCondition
+
+This interaction has a field `Matchers` which specifies certain conditions, such as block type, state, etc.  This
+interaction fails if the current target block does not match all of them.
+
+**BlockCondition Fields**
+
+| Field Name       | Type                                        | Required? | Notes                                                                                                                                                                                                                                                                                                                                   |
+| ---------------- | ------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false)             | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction.                                                                                                                                                                                                       |
+| Matchers         | `Array`<br />(Element Type: `BlockMatcher`) | **Yes**   | A list of conditions that the target block must match or this condition will fail.<br />**Note: This field is technically not required but there is a bug that makes it dangerous to not provide at the time of this writing.**<br />**Note: If no conditions are added to this array, the interaction will fail, counterintuitively.** |
+
+**BlockMatcher Fields**
+
+| Field Name | Type                       | Required? | Notes                                                                          |
+| ---------- | -------------------------- | --------- | ------------------------------------------------------------------------------ |
+| Block      | `BlockIdMatcher`           | **No**    | If provided, requires the block itself match some set of conditions.           |
+| Face       | `BlockFace`                | **No**    | If provided and not 'None', requires a specific block face be targeted.        |
+| StaticFace | `Boolean` (Default: false) | **No**    | If false, the face condition will be adjusted by the block's current rotation. |
+
+**BlockFace Values**
+
+- `Up`
+- `Down`
+- `North`
+- `South`
+- `East`
+- `West`
+- `None`
+
+**BlockIdMatcher Fields**
+
+| Field Name | Type                                   | Required? | Notes                                                                      |
+| ---------- | -------------------------------------- | --------- | -------------------------------------------------------------------------- |
+| Id         | `Asset`<br />(Asset Type: `BlockType`) | **No**    | If provided, the block must match the specified `BlockType`.               |
+| State      | `String`                               | **No**    | If provided, the block's current state must match the provided state name. |
+| Tag        | `String`                               | **No**    | If provided, the block type's asset tags must contain the provided tag.    |
+
+### DestroyCondition
+
+This interaction fails if the current User entity cannot destroy the current target blcok.
+
+**DestroyCondition Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+
+### PlacementCountCondition
+
+This interaction accepts the name of a BlockType that has the TrackedPlacement BlockEntity. The interaction will fail if the number of
+blocks of the provided BlockType in the world do not match the provided condition.
+
+**PlacementCountCondition Fields**
+
+| Field Name | Type                           | Required? | Notes                                                                                                                                                                                                                                                           |
+| ---------- | ------------------------------ | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Block      | `String`                       | **Yes**   | The BlockType to examine. The number of instances of the BlockType in the world will be compared to Value.<br />**Note: The specified BlockType must have the TrackedPlacement BlockEntity. Otherwise, the number of blocks in the world will always be zero.** |
+| Value      | `Integer`<br />(Default: 0)    | **No**    | The value to compare the number of blocks in the world with.                                                                                                                                                                                                    |
+| LessThan   | \`Boolean<br />(Default: true) | **No**    | If true, the interaction will fail if the number of blocks in the world is greater than or equal to Value. If false, the interaction will fail if the number of blocks in the world is less than or equal to Value.                                             |
+
+### BreakBlock
+
+This interaction attempts to break the target block while acting as the User entity. The User entity must be a player. It
+is not guaranteed to work, depending on world settings and the User entity's current state, it may not work.  If it
+fails, it will fail the interaction under some circumstances, but not others.
+
+**Note: In particular, if `Harvest`=false and the player is in Survival mode, the player will simply execute a damage operation
+against the block. Even when the Tool field is specified, the player's currently-held item can impact the results in unintuitive
+ways.**
+
+This interaction will fail if there is no block target, if `Harvest`=true and the
+block is not harvestable, or if the world settings prevent the Harvest/Break operation.
+It will generally not fail otherwise, even if the block was not broken or damaged.
+The block will generally break every time if `Harvest`=true or the player is in
+Creative mode.
+
+**BreakBlock Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                                                                                                                                                                                                  |
+| ---------------- | ------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction.                                                                                                                                                                      |
+| Harvest          | `Boolean` (Default: false)      | **No**    | If true, harvest the block and deposit the drops in the player's inventory. This operation will generally always succeed.  If false, this interaction will effectively perform whatever action would have occurred if the player had left-clicked the block.                                           |
+| Tool             | `String`                        | **No**    | If `Harvest`=true, the player is in Survival mode, and this field is provided, then the break operation will be performed as though with this tool type.<br />**This field mostly doesn't work.  Your held item will be used for most block damage calculations regardless of this field's contents.** |
+| MatchTool        | `Boolean` (Default: false)      | **No**    | If true, `Harvest`=true, the player is in Survival mode, and `Tool` is provided, block breaking will be prevented unless `Tool` is a valid gathering tool for the target block. The interaction will not be failed, even if block breaking is prevented in this manner.                                |
+
+### ChangeBlock
+
+This interaction requires a mapping from one or more current BlockTypes to one or more target BlockTypes.  If the
+target block is one of the key BlockTypes, then it will be changed to the mapped target BlockType.  If the current
+BlockType of the target block does not appear as a key in the Changes field, then this interaction fails.
+
+**ChangeBlock Fields**
+
+| Field Name        | Type                                                        | Required? | Notes                                                                                                                             |
+| ----------------- | ----------------------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget  | `Boolean`<br />(Default: false)                             | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+| Changes           | `Map`<br />(Key Type: `BlockType`, Value Type: `BlockType`) | **No**    | A list of potential block type changes, with each entry having a current and new BlockType id.                                    |
+| WorldSoundEventId | `Asset`<br />(Asset Type: `SoundEvent`)                     | **No**    | If provided, this SoundEvent is played in the world at the position of the block if the block successfully changes.               |
+| RequireNotBroken  | `Boolean`<br />(Default: false)                             | **No**    | If true, this interaction will fail if the player's held item is broken (durability 0), and the block change will not take place. |
+
+### ChangeState
+
+This interaction requires a mapping from one or more current block state names to one or more state names. If the
+target block is in one of the key block states, then it will be changed to the mapped target blocks tate. If the
+current block state of the target block does nto appear as a key in the Changes field, then this interaction fails.
+
+All blocks start out with a null state by default.  This null state can be referenced by the key "default" and the block
+can be returned to that state with the value "default".
+
+**ChangeState Fields**
+
+| Field Name       | Type                                                  | Required? | Notes                                                                                                                                          |
+| ---------------- | ----------------------------------------------------- | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false)                       | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction.              |
+| Changes          | `Map`<br />(Key Type: `String`, Value Type: `String`) | **No**    | A list of potential block state changes, with each entry having a current and new state name.                                                  |
+| UpdateBlockState | `Boolean`<br />(Default: false)                       | **No**    | If true, performs a full refresh of the block's BlockEntity component and notifies nearby players as though a full block type change occurred. |
+
+### CycleBlockGroup
+
+This interaction will attempt to change the target block to the next block type in one of the BlockGroups it belongs to.
+If the block type belongs to multiple BlockGroups, which one is used is effectively arbitrary. The User entity must be
+a player. If the block cannot be changed for any reason (entity not a player, no block target, block does not belong
+to a BlockGroup, etc.). If the block is the only entry in the BlockGroup, this interaction will succeed and the block
+will be considered changed despite nothing happening.  Unlike most other block-changing interactions, this one will
+fail if the world settings prevent players from breaking blocks.
+
+**This interaction always reduces the player's held item's durability by a single 'hit' worth of damage if the block
+changes. There is no way to prevent it. The block type will change and the interaction will succeed even if the player's
+held item is broken, however.**
+
+**CycleBlockGroup Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+
+### DestroyBlock
+
+This interaction destroys the target block without dropping anything.  It will successfully destroy the block if the
+target block exists and this interaction has no failure conditions.
+
+**This interaction has no additional fields.**
+
+### PickBlock
+
+This interaction is effectively equivalent to using the middle mouse button in creative mode. In survival mode, the
+block's item will be moved to the user's current active hotbar slot if it is in the player's inventory.  This
+interaction is performed entirely on the client and cannot be performed by non-players.  It is unclear if this
+interaction has failure conditions.
+
+**PickBlock Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+
+### PlaceBlock
+
+This interaction is effectively identical to a right clicking while holding a block in their hand, with some
+additional options. For one, it can be executed with any LivingEntity as the User entity. For another, it has some
+useful fields.  For the most part, though, it follows the same behaviors and rules as any ordinary block placement
+by a player.
+
+It's not clear under what circumstances this interaction can fail. The server will not fail the interaction under any
+special circumstances (including when there is no target block, or when `BlockTypeToPlace` is not provided and the
+LivingEntity is not holding a block). However, the client is very involved with the function of this interaction and
+its behavior is unknown.
+
+**PlaceBlock Fields**
+
+| Field Name         | Type                                   | Required? | Notes                                                                                                                                                                                                                                                                                                                                                           |
+| ------------------ | -------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| BlockTypeToPlace   | `Asset`<br />(Asset Type: `BlockType`) | **No**    | If provided, the block placed by this interaction will be the specified BlockType. If not provided, the User entity's held item will be used, instead, if it is a block.                                                                                                                                                                                        |
+| RemoveItemInHand   | `Boolean`<br />(Default: True)         | **No**    | If true and the User entity is not a player in Creative mode, the item in the player's hand must match the block being placed and one quantity will be removed for each block placed. If the item does not match, the block cannot be placed.  If false, the player's hand item is ignored entirely.\*\*                                                        |
+| AllowDragPlacement | `Boolean`<br />(Default: True)         | **No**    | If true and the interaction was triggered on the client by a player, then the player can hold the input that was used to activate this interaction chain and move the mouse around in order to execute this interaction repeatedly and place several blocks. The interaction chain will not move onto the next interaction until the player releases the input. |
+
+### RunOnBlockTypes
+
+This interaction retrieves all blocks within a provided radius of the User entity. For each block that matches any of
+the provided BlockSets, a new interaction chain will be forked that uses the matching block as the target block.
+This interaction will continue executing until all forked interaction chains have completed.  The interaction will fail if no
+blocks within the radius match the provided BlockSets or if all of the forked interaction chains fail.
+
+**RunOnBlockTypes Fields**
+
+| Field Name   | Type                                         | Required?        | Notes                                                                                                                                                                                                                                                                                      |
+| ------------ | -------------------------------------------- | ---------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| Range        | `Integer`                                    | **Yes**          | The spherical radius around the User entity to search for blocks. Must be at least 1.                                                                                                                                                                                                      |
+| BlockSets    | `AssetArray`<br />(Element Type: `BlockSet`) | **No**           | A list of BlockSets to match nearby blocks again. Only blocks that match any of the BlockSets will have interaction chains forked for them.                                                                                                                                                |
+| MaxCount     | `Integer`                                    | **Yes**          | The maximum number of blocks that will be located with the search. Further blocks will be ignored. If there are more matching blocks within the radius than this number, the specific set of blocks that will be found is completely arbitrary and may change from execution to execution. |
+| Interactions | `Asset`<br />(Asset Type: `RootInteraction`) | **No, but yes.** | The RootInteraction that will be forked for each matching block.  This interaction will not fail to validate if it is missing, but every execution of this interaction will fail.                                                                                                          |
+
+### UseBlock
+
+If the target block has an interaction for this interaction chain's interaction type, execute it immediately as part of
+this interaction chain. The execution will be wrapped in UseBlockEvent.Pre and UseBlockEvent.Post events, and cancellations
+of the UserBlockEvent.Pre event are respected. The User entity is considered the triggering entity for both events.
+
+If the target block does not have an interaction for this interaction chain's interaction type, this interaction fails.
+
+**This interaction has no additional fields.**
+
+## Items
+
+These are interactions intended to interface with an entity's inventory. There is no concept of an "item target",
+unfortunately, so these generally either interact with the entity's held item or the entity's inventory at a high level.
+
+### AddItem
+
+Adds a specified quantity of a specified item to the User entity's inventory, preferring to add it to the
+entity's hotbar where possible. This interaction will have no effect on User entities that are not LivingEntities.
+This interaction has no failure states.
+
+**Note: This interaction has a bug in its field validators that will cause interactions that reference items declared
+in the same mod to fail validation on startup.  Additionally, this interaction has a bug that will cause it to
+fail and have no effect if the User entity has no block target. Use ModifyInventory instead.**
+
+**AddItem Fields**
+
+| Field Name       | Type                              | Required? | Notes                                                                                                                             |
+| ---------------- | --------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false)   | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+| ItemId           | `Asset`<br />(Asset Type: `Item`) | **Yes**   | The item id of the item to add to the player's inventory.                                                                         |
+| Quantity         | `Integer`<br />(Default: 0)       | **No**    | The quantity of the item to add to the player's inventory.                                                                        |
+
+### CheckUniqueItemUsage
+
+This interaction will check whether it has run once for the User entity with their currently-held item before. If it hasn't,
+it will succeed. If it has, it will fail. It will also fail if the User entity is not a player. The interaction will record
+the item id of the User entity's currently-held item on success, ensuring it cannot be successfully run with that player
+and item id combination again.
+
+**This interaction has no additional fields.**
+
+### ChangeActiveSlot
+
+This interaction does not inherit from SimpleInteraction and therefore has no Next or Failed fields.  The `CancelOnItemChange`
+field is ignored for this interaction and is always treated as false. This interaction will set the User entity's currently-
+active hotbar slot to the specified slot index. If none is specified, the interaction chain's target slot will be used,
+if any. Otherwise, slot 0 will be used.  If a slot is specified and it is already active, then this interaction will
+have no effect, but if no slot is specified and the interaction chain's target slot is already active, the logic in
+the next paragraph will still be executed. This interaction will also have no effect if the User entity is not a
+LivingEntity.
+
+Once the slot has changed, a new SwapTo interaction chain will be forked off for the selected slot.
+If a target slot was specified, then the interaction chain's current target slot will be set to the specified slot, as will
+the forked SwapTo interaction chain. If this interaction chain was initiated by a player swapping an item into or out of
+an occupied active hotbar slot, then the swap will be executed after the slot is changed and before the SwapTo
+interaction is forked. Not running this interaction in the resulting SwapFrom interaction chain is a way for the server
+to cancel players performing these sorts of swap interactions. The default behavior for these swap interactions is that
+the SwapFrom interaction chain will be initiated with the currently-active-slot as the target slot. As a result, the
+target slot will usually not change when this interaction runs, it merely exists as a signal for the server to continue the
+item swap.
+
+**ChangeActiveSlot Fields**
+
+| Field Name | Type      | Required? | Notes                                                                                                                                                                                                     |
+| ---------- | --------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| TargetSlot | `Integer` | **No**    | If not provided, indicates the slot the player's active hotbar slot should be changed to.  Otherwise, the interaction chain's target slot will be used (which is usually the already-active hotbar slot). |
+
+### EquipItem
+
+This interaction will equip the User entity's currently-held item into the appropriate armor slot, if it is armor. The
+interaction will fail if the item is armor but it cannot be equipped for some reason. The interaction will succeed but
+take no action if the User entity cannot equip armor or if the item is not armor.
+
+**This interaction has no additional fields.**
+
+### IncreaseBackpackCapacity
+
+This interaction will increase the User entity's backpack size by the provided amount.  **It will additionally remove one
+quantity from the player's currently-held item. There is no way to prevent this.**  This interaction will have no effect
+if the User entity is not a player.  This interaction has no special failure conditions, even if the User entity
+is not a player, or the player is not currently holding an item.
+
+| Field Name | Type                        | Required? | Notes                                                                                   |
+| ---------- | --------------------------- | --------- | --------------------------------------------------------------------------------------- |
+| Capacity   | `Integer`<br />(Default: 1) | **No**    | The additional backpack capacity to add to the player. **Must be between 1 and 32767.** |
+
+### ModifyInventory
+
+This interaction attempts to perform one or more inventory-modifying actions against the User entity. The User entity must
+be a player. If they are not, no actions will be performed, but the interaction will not fail. Any item removals performed
+by this interaction, either as a result of `ItemToRemove` or `AdjustHeldItemQuantity`, are both atomic (meaning the entire
+quantity must be removed, or none) and required (meaning that the interaction will fail and no further actions taken if
+the removal fails for any reason).  Item additions performed by this interaction, either as a result of `ItemToAdd` or
+`AdjustHeldItemQuantity` will drop excess items on the ground near the player if necesary and continue on.
+
+This interaction first executes the item removal in `ItemToRemove`, if any, then adjusts the held item as specified by
+`AdjustHeldItemQuantity`, if provided, then executes the item addition in `ItemToAdd`, if any, and then finally executes
+the damage/healing of the held item in `AdjustHeldItemDurability`, if provided.
+
+**ModifyDurability Fields**
+
+| Field Name               | Type                            | Required? | Notes                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
+| ------------------------ | ------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| RequiredGameMode         | `GameMode`                      | **No**    | If provided, only execute the inventory-modifying actions if the player is in the provided GameMode. The interaction will not fail if the GameMode doesn't match.                                                                                                                                                                                                                                                                                                                                                                               |
+| ItemToRemove             | `ItemStack`                     | **No**    | If provided, a matching item will be removed in the provided quantity. If there is no matching item in the player inventory in the required quantity, then the interaction will fail and further actions will not be executed.                                                                                                                                                                                                                                                                                                                  |
+| AdjustHeldItemQuantity   | `Integer`<br />(Default: 0)     | **No**    | The player's held item, if any, will have its quantity will be modified by the provided amount- subtracted from if this number is negative or added to if this item is positive.  If the player has no held item, then this field will have no effect regardless of its value and the interaction will NOT fail.  If the player's inventory does not have sufficient quantity of items to support the removal, this interaction will fail and further actions will not be executed. Excess items will be dropped on the ground near the player. |
+| ItemToAdd                | `ItemStack`                     | **No**    | If provided, the ItemStack will be added to the player's inventory. Excess items will be dropped on the ground near the player.                                                                                                                                                                                                                                                                                                                                                                                                                 |
+| AdjustHeldItemDurability | `Double`<br />(Default: 0.0)    | **No**    | The player's held item, if any, will have its durability adjusted by the specified amount.  The durability cannot go below 0 or raise above the item's maximum durability. Invalid durability values in this field will not cause the interaction to fail. Neither will it fail if the player has no held item.                                                                                                                                                                                                                                 |
+| BrokenItem               | `String`                        | **No**    | This field should contain an ItemId, but it is not validated by the server on startup, so be careful.  This field can have the value of "Empty" to specify no item, or an empty hand. If specified and the `AdjustHeldItemDurability` operation reduces the player's held item to 0 durability, the player's held item is changed to this ItemId. If the inventory replacement fails, this interaction will fail.                                                                                                                               |
+| NotifyOnBreak            | `Boolean`<br />(Default: false) | **No**    | If true and the `AdjustHeldItemDurability` operation reduces the player's held item to 0 durability, this interaction will perform the usual audiovisual feedback of a broken tool. It will play the usual tool breaking sound and send the player a text message in chat that their item has broken.                                                                                                                                                                                                                                           |
+| NotifyOnBreakMessage     | `String`                        | **No**    | If provided, and `NotifyOnBreak` is true, when the player is notified of a broken tool by this interaction, the message sent to their chat will instead be the translation key specified by this field. The translation key supports the templating parameter `{itemName}`. See the translation key `server.general.repair.itemBroken_Hoe` for an example.                                                                                                                                                                                      |
+
+**GameMode Values**
+
+- `Creative`: The game is currently in Creative Mode
+- `Adventure`: The game is currently in Adventure Mode
+
+**ItemStack Fields**
+
+| Field Name                   | Type                              | Required? | Notes                                                                                |
+| ---------------------------- | --------------------------------- | --------- | ------------------------------------------------------------------------------------ |
+| Id                           | `Asset`<br />(Asset Type: `Item`) | **Yes**   | The id of the Item asset this stack contains.                                        |
+| Quantity                     | `Integer`<br />(Default: 1)       | **No**    | The number of items in this stack.<br />**Must be greater than 0.**                  |
+| Durability                   | `Double`<br />(Default: 0.0)      | **No**    | The durability of the item stack.<br />**Cannot be negative.**                       |
+| MaxDurability                | `Double`<br />(Default: 0.0)      | **No**    | The maximum durability of the item this stack contains.<br />**Cannot be negative.** |
+| Metadata                     | `Bson Document`                   | **No**    | If provided, applies the bson to the item stack metadata.                            |
+| OverrideDroppedItemAnimation | `Boolean`\*(Default: false)       | **No**    | ???                                                                                  |
+
+### PickupItem
+
+This interaction will attempt to pick up the User entity's current target entity and add it to their inventory. It will
+fail if the User entity is not a player, if they do not have a target entity, or if the target entity is not an item
+located in the world.  It will not fail if the player simply cannot pick up the item.
+
+**This interaction has no additional fields.**
+
+### RefillContainer
+
+This interaction will fail if the User entity is not a player. The interaction will draw a ray from the player's head
+down their look direction until the edge of the player's held item's interaction range or until the first solid block.
+The nearest fluid block of a type listed in this interaction's `States` map will result in the one of the player's
+currently-held items being converted to the fluid's related item state.  If the `States` map indicates a durability
+for the new item state, then the converted item will use that durability. If the item is already in the fluid's related
+item state, then this interaction will fail if the player's held item is already at maximum durability (unless the
+`States` map indicates a durability value greater than the item's maximum, in which case the interaction will succeed
+but the item will not change).  Otherwise, the durability listed for the fluid in the `States` map will be added to the
+item's current durability.
+
+If the interaction has not failed by this point, the fluid block in the world may be transformed to a different type if one is listed
+in the `States` map.
+
+If any part of this process does not proceed for any reason (for instance, if the player is not holding an item),
+then this interaction will fail.
+
+**RefillContainer Fields**
+
+| Field Name | Type                                                       | Required? | Notes                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| ---------- | ---------------------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| States     | `Map`<br />(Key Type: `String`, Value Type: `RefillState`) | **Yes**   | A map from item state names to `RefillState` objects, which contain information such as acceptable fluid block types, durability increases, and what fluid type to convert the targeted fluid block to after refill, if any. If the player targets a fluid block that matches one of the fluid types in the `RefillState`, the item will be converted to the keyed item state and the `RefillState` will be used to decide what happens next. |
+
+**RefillState Fields**
+
+| Field Name     | Type                                  | Required? | Notes                                                                                                                                                                                                                                                                                                                           |
+| -------------- | ------------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| AllowedFluids  | `Array`<br />(Element Type: `String`) | **Yes**   | If any of these fluids are targeted by the player, the player's held item will be converted to the keyed item state and `Durability` and `TransformFluid` will be used.                                                                                                                                                         |
+| Durability     | `Double`<br />(Default: -1.0)         | **No**    | If the player's held item changes item states, this value is the new item's durability, unless it is negative, in which case the item will begin at full durability. If the player's held item is already in the item state, and the item is not already at full durability, this value will be added to the item's durability. |
+| TransformFluid | `String`                              | **No**    | If provided, this field is a fluid id that the targeted fluid block should be transformed to if the player's held item is successfully updated.                                                                                                                                                                                 |
+
+## Entities
+
+### DamageEntity
+
+This interaction does not inherit from SimpleInteraction, but adds its own Next and Failed fields that
+work similarly.
+
+This interaction will cause the User entity to damage the Target entity.  It has the capability to apply different
+damage based on the direction of the attack or what body part was targeted by the User entity, with each possibility
+providing different damage calculations, effects, and Next interaction. If multiple entires match the attack, `TargetedDamage`
+(body part damage) takes highest priority, then the first matching `AngledDamage` in the list, then the default
+damage in the base interaction fields.  It is possible for elements of these different damage priorities to be taken peacemeal if higher-priority
+damage fields do not overwrite lower-priority damage fields. For instance,
+damage calculation could be taken from `TargetedDamage`, the damage effects could be taken from the first matching
+`AngledDamage`, and the Next interaction coming from the default damage field.
+
+If all damage dealt by this interaction is cancelled, then this interaction will fail, and the `Failed` interaction
+will be executed next in the chain. If any damage dealt by this interaction is blocked, then this interaction will
+succeed, but the `Blocked` interaction wil lbe executed next in the chain. Otherwise, the highest-precedent matching
+`Next` interaction that you provide will be executed.  For instance, if you provide `Next` interactions for all
+`TargetedDamage` and `AngledDamage` entries, and one in the interaction's `Next` field, then a headshot could result
+in a unique `Next` interaction being executed, even if there is a matching `AngledDamage` entry. However, if you leave
+the `Next` interaction out of your `TargetedDamage` entries, a special `Next` interaction for backstabs could be
+executed.  Otherwise, the `Next` field in the root of the interaction will be executed instead.
+
+DamageEntity has an unusual relationship with `RunTime`. This interaction always ends immediately after its first tick,
+regardless of the status of `RunTime` or `WaitForAnimationToFinish`.  However, if damage dealt by this interaction is
+calculated as `DamageCalculatorType` `Dps`, then the `RunTime` will be used to determine the precise amount of damage to
+deal. If `RunTime` is 0, then no damage will be dealt.
+
+**DamageEntity Fields**
+
+| Field Name       | Type                                                          | Required?                                                                                                                    | Notes                                                                                                                                                                                                                                                                                                                                                                         |
+| ---------------- | ------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| DamageCalculator | `DamageCalculator`                                            | **No**                                                                                                                       | If provided, describes the damage amounts and types to apply to the Target entity.                                                                                                                                                                                                                                                                                            |
+| DamageEffects    | `DamageEffects`                                               | **No**                                                                                                                       | If provided, describes particles, sounds, knockback, etc. to apply to the target entity on damage.                                                                                                                                                                                                                                                                            |
+| Next             | `Asset`<br />(Asset Type: `Interaction`)                      | **No**  After this interaction has finished, "Next" will be executed if damage was dealt to the target and none was blocked. |                                                                                                                                                                                                                                                                                                                                                                               |
+| AngledDamage     | `Array`<br />(Element Type: `AngledDamage`)                   | **No**                                                                                                                       | If provided, allows alternative `DamageCalculator`, `DamageEffects`, and `Next` entries for attacks that approach the target from certain angles.                                                                                                                                                                                                                             |
+| TargetedDamage   | `Map`<br />(Key Type: `String`, Value Type: `TargetedDamage`) | **Yes**                                                                                                                      | This field must be provided, but is not required to have any entries.  This is a map from body part names to `TargetedDamage` values. Hypixel only uses one body part name: `Head`, and it is not clear whether there are others.  If provided, allows alternative `DamageCalculator`, `DamageEffects`, and `Next` entries for attacks that damage specific enemy body parts. |
+| EntityStatsOnHit | `Array`<br />(Element Type: `EntityStatOnHit`)                | **No**                                                                                                                       | If provided, allows this attack to reduce enemy stats other than health.  Each individual damage application dealt by the same ability will apply stat reductions, at diminishing returns. All damage dealt in interaction chains forked by a Selector interaction will share the number of hits across all targets.                                                          |
+| Failed           | `Asset`<br />(Asset Type: `Interaction`)                      | **No**                                                                                                                       | After this interaction has finished, "Failed" will be executed if no damage hits were applied to the player, or if all damage hits were cancelled.                                                                                                                                                                                                                            |
+| Blocked          | `Asset`<br />(Asset Type: `Interaction`)                      | **No**                                                                                                                       | After this interaction has finished, "Blocked" will be executed if any damage hits were blocked by the target.                                                                                                                                                                                                                                                                |
+
+**DamageCalculator Fields**
+
+| Field Name                | Type                                                      | Required? | Notes                                                                                                                                                                                                                                                 |
+| ------------------------- | --------------------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Type                      | `DamageCalculatorType`<br />(Default: Absolute)           | **No**    | Whether the damage being applied is `Absolute` or \`Dps'.                                                                                                                                                                                             |
+| Class                     | `DamageClass`<br />(Default: Unknown)                     | **No**    | The type of attack producing the damage. Some weapon systems apply equipment modifiers based on this value.                                                                                                                                           |
+| BaseDamage                | `Map`<br />(Key Type: `DamageCause`, Value Type: `Float`) | **No**    | A set of DamageCauses and how much base damage is dealt for each.                                                                                                                                                                                     |
+| SequentialModifierStep    | `Float`<br />(Default: 0.0)                               | **No**    | Value between 0.0-1.0. Each additional hit from a single ability will have its damage reduced by this much as a percentage. All damage dealt in interaction chains forked by a Selector interaction will share the number of hits across all targets. |
+| SequentialModifierMinimum | `Float`<br />(Default: 0.0)                               | **No**    | Value between 0.0-1.0. `SequentialModifierStep` cannot reduce damage below this percentage regardless of the number of hits.                                                                                                                          |
+| RandomPercentageModifier  | `Float`<br />(Default: 0.0)                               | **No**    | A random value between +/- this amount multiplied by the base damage will be added to the base damage.                                                                                                                                                |
+
+**DamageEffects Fields**
+
+| Field Name             | Type                                         | Required? | Notes                                                                                   |
+| ---------------------- | -------------------------------------------- | --------- | --------------------------------------------------------------------------------------- |
+| ModelParticles         | `Array`<br />(Element Type: `ModelParticle`) | **No**    | Particle systems to trigger in the first-person view.                                   |
+| WorldParticles         | `Array`<br />(Element Type: `WorldParticle`) | **No**    | Particle systems to trigger in the third-person view.                                   |
+| LocalSoundEventId      | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | 2D sound to play locally to the attacking entity if they are a player.                  |
+| WorldSoundEventId      | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | Sound to play in the world at the Target entity's location.                             |
+| PlayerSoundEventId     | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | 2D sound to play locally to the Target entity if they are a player.                     |
+| ViewDistance           | `Double`<br />(Default: 75.0)                | **No**    | Distance at which these effects should play for other players.                          |
+| Knockback              | `Knockback`                                  | **No**    | The properties of the knockback that will be applied.                                   |
+| CameraEffect           | `Asset`<br />(Asset Type: `CameraEffect`)    | **No**    | CameraEffect to briefly apply locally to the Target entity if they are a player.        |
+| StaminaDrainMultiplier | `Float`<br />(Default: 1.0)                  | **No**    | This multiplier is applied to the stamina cost incurred by the target blocking, if any. |
+
+**AngledDamage Fields**
+
+| Field Name       | Type                                     | Required? | Notes                                                                                                                                                                                                     |
+| ---------------- | ---------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| AngleDistance    | `Float`<br />(Default: 0)                | **No**    | The width in degrees of the matching arc around the Target entity. If the attack against the Target originates from within the arc, then the properties below will be applied to the attack, if provided. |
+| Angle            | `Float`<br />(Default: 0.0)              | **No**    | The angle in degrees around the Target entity at which the matching arc is centered.                                                                                                                      |
+| DamageCalculator | `DamageCalculator`                       | **No**    | If provided and the attack against the Target entity originates from within the provided arc, this DamageCalculator will override the interaction's `DamageCalculator` field.                             |
+| DamageEffects    | `DamageEffects`                          | **No**    | If provided and the attack against the Target entity originates from within the provided arc, this DamageEffects will override the interaction's `DamageEffects` field.                                   |
+| Next             | `Asset`<br />(Asset Type: `Interaction`) | **No**    | If provided and the attack against the Target entity originates from within the provided arc, this Interaction will override the interaction's `Next` field.                                              |
+
+**TargetedDamage Fields**
+
+| Field Name       | Type                                     | Required? | Notes                                                                                                                                                                                            |
+| ---------------- | ---------------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| DamageCalculator | `DamageCalculator`                       | **No**    | If provided and this TargetedDamage was matched, this DamageCalculator will override the interaction's `DamageCalculator` field and the `DamageCalculator` field of any matching `AngledDamage`. |
+| DamageEffects    | `DamageEffects`                          | **No**    | If provided and this TargetedDamage was matched, this DamageEffects will override the interaction's `DamageEffects` field and the `DamageEffects` field of any matching `AngledDamage`.          |
+| Next             | `Asset`<br />(Asset Type: `Interaction`) | **No**    | If provided and this TargetedDamage was matched, this Interaction will override the interaction's `Next` field and the `Next` field of any matching `AngledDamage`.                              |
+
+**EntityStatOnHit Fields**
+
+| Field Name                  | Type                                                                       | Required? | Notes                                                                                                                                                                                                                                                                                        |
+| --------------------------- | -------------------------------------------------------------------------- | --------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| EntityStatId                | `Asset`<br />(AssetType: `EntityStatType`)                                 | **Yes**   | Which entity stat to affect.                                                                                                                                                                                                                                                                 |
+| Amount                      | `Float`<br />(Default: 0.0)                                                | **No**    | How much of the stat to apply for each damage application. Use negative numbers to reduce stats.                                                                                                                                                                                             |
+| MultipliersPerEntitiesHit   | `Array`<br />(Element Type: `Float`, Default: `[1.0, 0.6, 0.4, 0.2, 0.1]`) | **No**    | The diminishing returns curve to be applied for multiple damage applications by the same ability. Each hit's stat impact will be multiplied by the next value in the list.  If there are more hits than array elements, subsequent hits will be multiplied by `MultiplierPerExtraEntityHit`. |
+| MultiplierPerExtraEntityHit | `Float`<br />(Default: 0.05)                                               | **No**    | If an ability carries out more damage applications than there are elements in the `MultipliersPerEntitiesHit` array, then subsequent stat values will be multiplied by this number.                                                                                                          |
+
+**Knockback Fields**
+
+| Field Name     | Type                                       | Required? | Notes                                                                                                                      |
+| -------------- | ------------------------------------------ | --------- | -------------------------------------------------------------------------------------------------------------------------- |
+| Type           | `String`                                   | **No**    | If provided, specifies a type of knockback to use. Each Target type may come with additional fields.                       |
+| Force          | `Double`<br />(Default: 0.0)               | **No**    | The amount of force to apply to the Owner entity.                                                                          |
+| Duration       | `Double`<br />(Default: 0.0)               | **No**    | If 0.0, apply the force as a single impulse.  If more, continuously apply the force over a period of time.                 |
+| VelocityType   | `ChangeVelocityType`<br />(Default: `Add`) | **No**    | How to apply the force, either adding it to the entity's current velocity, or setting the velocity to the knockback force. |
+| VelocityConfig | `VelocityConfig`                           | **No**    | Characteristics of friction as the Owner entity is thrown by this knockback.                                               |
+
+**Knockback Type: Force**
+
+Apply the calculated knockback force along the provided direction.
+
+| Field Name | Type                         | Required? | Notes                                                                                |
+| ---------- | ---------------------------- | --------- | ------------------------------------------------------------------------------------ |
+| Direction  | `Vector3`<br />(Default: Up) | **No**    | Which direction the entity should be flung, relative to the direction of the attack. |
+
+**Knockback Type: Point**
+
+Apply the calculated knockback force laterally along the XZ plane, plus provided Y velocity.
+
+| Field Name | Type                        | Required? | Notes                                                                                                   |
+| ---------- | --------------------------- | --------- | ------------------------------------------------------------------------------------------------------- |
+| OffsetX    | `Integer`<br />(Default: 0) | **No**    | Offset the source position of the knockback left or right perpendicular to the direction of the attack. |
+| OffsetZ    | `Integer`<br />(Default: 0) | **No**    | Offset the source position of the knockback, forward or backward along the directon of the attack.      |
+| RotateY    | `Integer`<br />(Default: 0) | **No**    | Rotate the knockback direction around the Y axis, where 0 is the default attack direction.              |
+| VelocityY  | `Float`<br />(Default: 0.0) | **No**    | Add vertical velocity to the knockback force after the direction and force has been calculated.         |
+
+**Knockback Type: Directional**
+
+Apply the calculated knockback force along the attack direction, removing any vertical component and replacing it with a provided Y velocity.
+
+| Field Name | Type                      | Required? | Notes                                                                                                                                            |
+| ---------- | ------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------ |
+| RelativeX  | `Float`<br />(Default: 0) | **No**    | Apply additional force left or right perpendicular to the direction of the attack. The additional force is multiplied by the knockback strength. |
+| RelativeZ  | `Float`<br />(Default: 0) | **No**    | Apply additional force forward or backward along the attack direction. The additional force is multiplied by the knockback strength.             |
+| VelocityY  | `Float`<br />(Default: 0) | **No**    | Replace the vertical velocity of the knockback with this value.  This value is not multiplied by knockback strength.                             |
+
+**VelocityConfig Fields**
+
+| Field Name          | Type                                              | Required? | Notes                                                                                                                                                                                           |
+| ------------------- | ------------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| GroundResistance    | `Float`<br />(Default: 0.82)                      | **No**    | The minimum amount of friction applied when the entity is in contact with the ground.  1.0 = no friction, 0.0 = total friction                                                                  |
+| GroundResistanceMax | `Float`<br />(Default: 0.0)                       | **No**    | The maximum amount of friction applied when the entity is in contact with the ground.  1.0 = no friction, 0.0 = total friction                                                                  |
+| AirResistance       | `Float`<br />(Default: 0.96)                      | **No**    | The minimum amount of friction applied when the entity is in the air. 1.0 = no friction, 0.0 = total friction                                                                                   |
+| AirResistanceMax    | `Float`<br />(Default: 0.0)                       | **No**    | The maximum amount of friction applied when the entity is in the air. 1.0 = no friction, 0.0 = total friction                                                                                   |
+| Threshold           | `Float`<br />(Default: 1.0)                       | **No**    | The speed at which the maximum amount of friction will be applied to the entity. The amount of friction applied will increase from minimum to maximum as the entity moves from 0 to this speed. |
+| Style               | `VelocityThresholdStyle`<br />(Default: `Linear`) | **No**    | The curve that friction follows as the entity's speed increases toward the `Threshold`.                                                                                                         |
+
+**DamageCalculatorType Values**
+
+- `Absolute`
+- `Dps`
+
+**DamageClass Values**
+
+- `Unknown`
+- `Light`
+- `Charged`
+- `Signature`
+
+**ChangeVelocityType Values**
+
+- `Add`
+- `Set`
+
+**VelocityThresholdStyle Values**
+
+- `Linear`
+- `Exp`
+
+### LaunchProjectile
+
+This is just a worse version of Projectile and is slated to be removed.  Use Projectile.
+
+### Projectile
+
+This interaction will spawn a new projectile at the User entity's eye position that will travel in its look direction.
+
+| Field Name | Type                                          | Required? | Notes                                                  |
+| ---------- | --------------------------------------------- | --------- | ------------------------------------------------------ |
+| Config     | `Asset`<br />(Asset Type: `ProjectileConfig`) | **No**    | Configuration describing the projectile to be spawned. |
+
+### RemoveEntity
+
+Despawns the specified entity from the world. This interaction will have no effect if the specified entity is a player. This
+interaction has no special failure conditions.
+
+| Field Name | Type                                     | Required? | Notes                  |
+| ---------- | ---------------------------------------- | --------- | ---------------------- |
+| Entity     | `InteractionTarget`<br />(Default: User) | **No**    | The entity to despawn. |
+
+**InteractionTarget Values**
+
+- `User` - The user of this interaction chain. The entity whose actions caused this interaction chain to be executed. This is usually the same as the Owner.
+- `Owner` - The owner of this interaction chain. The entity upon whom this interaction chain is executing.
+- `Target` - The entity target of this interaction chain, if any.  This value is mutable (and can therefore come from many places) but most commonly, it is an entity the User was targeting when this interaction chain began executing.
+
+### SendMessage
+
+This interaction sends a message to the Owner entity if that entity can receive messages.  Otherwise, the message
+is written to the server logs.  If the entity is a player, the message will appear in the player's chat window.
+
+\*\*SendMessage
+
+| Field Name | Type     | Required? | Notes                                                                                                                 |
+| ---------- | -------- | --------- | --------------------------------------------------------------------------------------------------------------------- |
+| Message    | `String` | **No**    | A text message to be sent to the Owner entity.  If this field is not provided, `Key` is used instead.                 |
+| Key        | `String` | **No**    | A translation key for a message to be sent to the Owner entity. If `Message` is provided, then this field is ignored. |
+
+### UseEntity
+
+This interaction is not in use by Hypixel and has some unusual qualities that mean it probably won't do what you want it
+to.  Do not use it.
+
+This interaction will retrieve the entity currently targeted by the client (NOT the interaction chain's current Target
+entity) and execute that entity's RootInteraction for this interaction chain's current interaction type. The
+RootInteraction will be executed as part of this current interaction chain. None of the properties of this interaction
+chain will be modified.
+
+This interaction will fail if the client is not currently targeting an entity, or if no interaction for the current
+interaction type exists on the entity.
+
+## Stats
+
+Hytale's resource system has been written about fairly extensively.  You can use these interactions to modify stats in
+response to actions or use stats as a cost for abilities.
+
+### ChangeStat
+
+This interaction applies a set of raw stat changes to the User entity. It has no special failure conditions.
+
+| Field Name    | Type                                                         | Required? | Notes                                                                                                                                                                                                                      |
+| ------------- | ------------------------------------------------------------ | --------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| StatModifiers | `Map`<br />(Key Type: `EntityStatType`, Value Type: `Float`) | **Yes**   | A set of stats to modify and what value to apply to them.                                                                                                                                                                  |
+| ValueType     | `ValueType`<br />(Default: Absolute)                         | **No**    | Whether the values in the `StatModifiers` map represent flat values to apply to the stat total, or percentages (0.0-100.0). Percentage values are percentage of the difference between the maximum and minimum stat value. |
+| Behaviour     | `ChangeStatBehavior`<br />(Default: Add)                     | **No**    | Whether the values in the `StatModifiers` map represent deltas to add into the User entity's current stat values, or fixed values to set the entity's stats to.                                                            |
+
+**ValueType Values**
+
+- `Absolute`
+- `Percent`
+
+**ChangeStatBehaviour Values**
+
+- `Add`
+- `Set`
+
+### ChangeStatWithModifier
+
+This interaction is like ChangeStat, except an armor stat modifier can be chosen which will apply bonuses and penalties
+to a stat from the User entity's equipped armor before it is applied.
+
+| Field Name            | Type                                                         | Required? | Notes                                                                                                                                                                                                                      |
+| --------------------- | ------------------------------------------------------------ | --------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| StatModifiers         | `Map`<br />(Key Type: `EntityStatType`, Value Type: `Float`) | **Yes**   | A set of stats to modify and what value to apply to them.                                                                                                                                                                  |
+| ValueType             | `ValueType`<br />(Default: Absolute)                         | **No**    | Whether the values in the `StatModifiers` map represent flat values to apply to the stat total, or percentages (0.0-100.0). Percentage values are percentage of the difference between the maximum and minimum stat value. |
+| Behaviour             | `ChangeStatBehavior`<br />(Default: Add)                     | **No**    | Whether the values in the `StatModifiers` map represent deltas to add into the User entity's current stat values, or fixed values to set the entity's stats to.                                                            |
+| InteractionModifierId | `InteractionModifierId`                                      | **Yes**   | The armor interaction modifier to apply bonuses and penalties for.                                                                                                                                                         |
+
+**ValueType Values**
+
+- `Absolute`
+- `Percent`
+
+**ChangeStatBehaviour Values**
+
+- `Add`
+- `Set`
+
+**InteractionModifierId Values**
+
+- `Dodge`
+
+### StatsCondition
+
+This interaction will fail if the User entity cannot afford the specified stats costs, or if it does not have the
+requested stats.
+
+| Field Name | Type                                                         | Required? | Notes                                                                                                                                                                                    |
+| ---------- | ------------------------------------------------------------ | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Costs      | `Map`<br />(Key Type:` EntityStatType`, Value Type: `Float`) | **Yes**   | A set of costs that the User entity needs to be able to afford for this interaction to succeed.                                                                                          |
+| ValueType  | `ValueType`<br />(Default: Absolute)                         | **No**    | Whether the values in the `Costs` map represetn flat values or percentages (0.0-100.0).  Percentage values are percentage of the difference between the maximum and minimum value.       |
+| LessThan   | `Boolean`<br />(Default: false)                              | **No**    | If true, this interaction will fail unless the User entity's current stat values are at or **below** the specified levels.  If false, they must be at or **above** the specified levels. |
+| Lenient    | `Boolean`<br />(Default: false)                              | **No**    | If true and `LessThan` is true, and a player's minimum stat value is below zero, then the player can afford a stat cost if the current value of a stat if above 0.                       |
+
+**ValueType Values**
+
+- `Absolute`
+- `Percent`
+
+### StatsConditionWithModifier
+
+This interaction is like StatsCondition, except an armor stat modifier can be chosen which will apply bonuses and penalties
+to a stat's cost from the User entity's equipped armor before it is compared.
+
+| Field Name            | Type                                                         | Required? | Notes                                                                                                                                                                                    |
+| --------------------- | ------------------------------------------------------------ | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Costs                 | `Map`<br />(Key Type:` EntityStatType`, Value Type: `Float`) | **Yes**   | A set of costs that the User entity needs to be able to afford for this interaction to succeed.                                                                                          |
+| ValueType             | `ValueType`<br />(Default: Absolute)                         | **No**    | Whether the values in the `Costs` map represetn flat values or percentages (0.0-100.0).  Percentage values are percentage of the difference between the maximum and minimum value.       |
+| LessThan              | `Boolean`<br />(Default: false)                              | **No**    | If true, this interaction will fail unless the User entity's current stat values are at or **below** the specified levels.  If false, they must be at or **above** the specified levels. |
+| Lenient               | `Boolean`<br />(Default: false)                              | **No**    | If true and `LessThan` is true, and a player's minimum stat value is below zero, then the player can afford a stat cost if the current value of a stat if above 0.                       |
+| InteractionModifierId | `InteractionModifierId`                                      | **Yes**   | The armor interaction modifier to apply bonuses and penalties for.                                                                                                                       |
+
+**ValueType Values**
+
+- `Absolute`
+- `Percent`
+
+**InteractionModifierId Values**
+
+- `Dodge`
+
+## EntityEffects
+
+EntityEffects are buff or debuff effects that can be applied to a LivingEntity.  These can have a variety of effects from
+movement speed changes to periodic damage.
+
+### EffectCondition
+
+This interaction will fail if the specified entity's EntityEffects do not match the provided conditions.
+
+**EffectCondition Fields**
+
+| Field Name      | Type                                             | Required? | Notes                                                                                                                                                                                                             |
+| --------------- | ------------------------------------------------ | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Entity          | `InteractionTarget`<br />(Default: User)         | **Yes**   | The entity to examine for EntityEffects. This field can indicate the Owner, User, or Target of this interaction chain.                                                                                            |
+| Match           | `Match`<br />(Default: All)                      | **No**    | If `All`, then this interaction will fail if any EntityEffect in the `EntityEffectIds` is not on the specified entity. If `None`, then this interaction will fail if any EntityEffect IS on the specified entity. |
+| EntityEffectIds | `AssetArray`<br />(Element Type: `EntityEffect`) | **Yes**   | The set of EntityEffects to check against the specified entity and `Match`.                                                                                                                                       |
+
+**InteractionTarget Values**
+
+- `User` - The user of this interaction chain. The entity whose actions caused this interaction chain to be executed. This is usually the same as the Owner.
+- `Owner` - The owner of this interaction chain. The entity upon whom this interaction chain is executing.
+- `Target` - The entity target of this interaction chain, if any.  This value is mutable (and can therefore come from many places) but most commonly, it is an entity the User was targeting when this interaction chain began executing.
+
+**Match Values**
+
+- `All` - All EntityEffects must be on the specified entity for this interaction to succeed.
+- `None` - None of the EntityEffects must be on the specified entity for this interaction to succeed.
+
+### ApplyEffect
+
+This interaction will apply the specified EntityEffect to the specified Entity.  It has no special failure conditions.
+
+**ApplyEffect Fields**
+
+| Field Name | Type                                      | Required? | Notes                                                                                                                  |
+| ---------- | ----------------------------------------- | --------- | ---------------------------------------------------------------------------------------------------------------------- |
+| Entity     | `InteractionTarget`<br />(Default: User)  | **Yes**   | The entity to apply the EntityEffect to. This field can indicate the Owner, User, or Target of this interaction chain. |
+| EffectId   | `Asset`<br />(Asset Type: `EntityEffect`) | **Yes**   | The effect to apply.                                                                                                   |
+
+**InteractionTarget Values**
+
+- `User` - The user of this interaction chain. The entity whose actions caused this interaction chain to be executed. This is usually the same as the Owner.
+- `Owner` - The owner of this interaction chain. The entity upon whom this interaction chain is executing.
+- `Target` - The entity target of this interaction chain, if any.  This value is mutable (and can therefore come from many places) but most commonly, it is an entity the User was targeting when this interaction chain began executing.
+
+### ClearEntityEffect
+
+This interaction will remove the specified EntityEffect from the specified Entity. It has no special failure conditions.
+It will not fail if the Entity does not have the EntityEffect.
+
+**ClearEntityEffect Fields**
+
+| Field Name | Type                                      | Required? | Notes                                                                                                                     |
+| ---------- | ----------------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------- |
+| Entity     | `InteractionTarget`<br />(Default: User)  | **Yes**   | The entity to remove the EntityEffect from. This field can indicate the Owner, User, or Target of this interaction chain. |
+| EffectId   | `Asset`<br />(Asset Type: `EntityEffect`) | **Yes**   | The effect to remove.                                                                                                     |
+
+**InteractionTarget Values**
+
+- `User` - The user of this interaction chain. The entity whose actions caused this interaction chain to be executed. This is usually the same as the Owner.
+- `Owner` - The owner of this interaction chain. The entity upon whom this interaction chain is executing.
+- `Target` - The entity target of this interaction chain, if any.  This value is mutable (and can therefore come from many places) but most commonly, it is an entity the User was targeting when this interaction chain began executing.
+
+## Farming
+
+These are interaction types built to support the in-game farming system in Hytale. They are mostly block-related interactions
+with a few exceptions.
+
+### ChangeFarmingStage
+
+If the target block is a farming block, this interaction will attempt to modify the current farming stage in one of
+three ways.  The interaction can optionally specify which StageSet to use for the new stage. If it is not specified,
+the current StageSet will be used. If any part of the the process of changing the growth stage fails, this interaction
+will fail, with the one exception that attempting to set the stage to the crop's existing stage will have no effect but
+still succeed.
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                                                                                                                                                                          |
+| ---------------- | ------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction.                                                                                                                                              |
+| StageSet         | `String`                        | **No**    | If provided, set the block's current stage to one in the provided StageSet. Otherwise, use the crop's current StageSet.                                                                                                                                                        |
+| Increase         | `Integer`                       | **No**    | If provided, increase the current stage by the specified amount. If the specified stage does not exist, the block will be set to the closest extant stage.                                                                                                                     |
+| Decrease         | `Integer`                       | **No**    | If provided and `Increase` is not provided, decrease the current stage by the specified amount. If the specified stage does not exist, the block will be set to the closest extant stage.                                                                                      |
+| Stage            | `Integer`<br />(Default: -1)    | **No**    | If provided and `Increase`/`Decrease` are not provided, set the current stage to the specified stage. If this value is less than 0, set the current stage to the final growth stage. If the specified stage does not exist, the block will be set to the closest extant stage. |
+
+### FertilizeSoil
+
+If the target block is unfertilized tilled soil or a farming block on top of unfertilized tilled soil, fertilizes the soil.
+The interaction will fail otherwise.
+
+**FertilizeSoil Fields**
+
+| Field Name       | Type                                  | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false)       | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+| RefreshModifiers | `Array`<br />(Element Type: `String`) | **No**    | Does nothing.                                                                                                                     |
+
+### HarvestCrop
+
+This interaction will attempt to execute the harvest action on the current block target and add the crop's drops to the User entity's
+inventory.  The block will either be destroyed or set to its post-harvest growth stage, depending on the farming
+configuration of the block.  This will happen (and the player will receive the full harvest drops) regardless of the
+block's current growth stage. This interaction has no special failure conditions, even if the block target isn't a
+farming block or gathering isn't permitted in the current world, but nothing will occur in those cases.
+
+**HarvestCrop Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+
+### UseWateringCan
+
+If the target block is tilled soil or a farming block on top of tilled soil, waters the soil for the specified duration.
+The interaction will fail otherwise.
+
+**UseWateringCan Fields**
+
+| Field Name       | Type                                  | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false)       | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+| Duration         | `Integer`<br />(Default: 0)           | **No**    | The duration in seconds to water the soil for.                                                                                    |
+| RefreshModifiers | `Array`<br />(Element Type: `String`) | **No**    | Does nothing.                                                                                                                     |
diff --git a/content/docs/uk-UA/contributing/pr-guidelines.mdx b/content/docs/uk-UA/contributing/pr-guidelines.mdx
index c77be572..f6ceb1f7 100644
--- a/content/docs/uk-UA/contributing/pr-guidelines.mdx
+++ b/content/docs/uk-UA/contributing/pr-guidelines.mdx
@@ -1,13 +1,13 @@
 ---
 title: Настанови запиту на злиття
-description: Настанови, які критики та меценати повинні слідувати під час публікації й перегляду запитів на злиття.
+description: Настанови, які критики та помічники повинні слідувати під час публікації й перегляду запитів на злиття.
 ---
 
 # Настанови запиту на злиття
 
-Для забезпечення процесу плавної та ефективної перевірки, як меценати, так і критики, повинні дотримуватися наступних рекомендацій під час подання та перегляду запитів на злиття.
+Для забезпечення процесу плавної та ефективної перевірки, як помічники, так і критики, повинні дотримуватися наступних рекомендацій під час подання та перегляду запитів на злиття.
 
-## Для меценатів
+## Для помічників
 
 1. **Наочні заголовок та опис**
    - Використовуйте чіткі та лаконічні заголовки, які узагальнюють зміни.
@@ -19,6 +19,8 @@ description: Настанови, які критики та меценати п
 4. **Якість коду**
    - Переконайтеся, що ваш код дотримується стандартів кодування та найкращих практик проєкту.
    - Вносьте коментарі, де необхідно пояснити складну логіку.
+   - Завжди тестуйте зміни локально, перш ніж надсилати запит на злиття, щоб виявити будь-які проблеми на ранній стадії.
+   - Форматуйте свій код за допомогою `bun format`, щоб забезпечити узгодженість у всій кодовій базі.
 5. **Тестування**
    - Перевірте свої зміни перед надсиланням запиту на злиття.
    - Якщо можливо, додайте модульні або інтеграційні тести для перевірки ваших змін.
diff --git a/content/docs/uk-UA/contributing/translate.mdx b/content/docs/uk-UA/contributing/translate.mdx
new file mode 100644
index 00000000..b3a1bcc8
--- /dev/null
+++ b/content/docs/uk-UA/contributing/translate.mdx
@@ -0,0 +1,74 @@
+---
+title: Переклад
+description: Як перекласти HytaleModding українською
+---
+
+# Переклад HytaleModding
+
+HytaleModding перекладено за допомогою спільноти, за допомогою **Crowdin**. Якщо ви хочете допомогти з перекладом або покращити наявні переклади, то це саме те місце.
+
+## Кроки для перекладу
+
+Усі переклади здійснюються **через Crowdin**.
+
+1. Відвідайте [наш проєкт Crowdin](https://crowdin.com/project/hytalemodding) та увійдіть, якщо потрібно.
+2. Натисніть на українську.
+3. Натисніть на файл/статтю, яку ви хочете перекласти. Ми рекомендуємо почати з офіційної документації, а потім з документації плагінів сервера.
+4. Почніть перекладати!
+5. Затверджені переклади з'являться на вебсайті.
+
+### Відеоінструкція
+
+<iframe src="https://www.youtube.com/embed/NHiG1rDRgks" allowFullScreen />
+
+## Як обговорювати
+
+Ви завжди можете повідомляти про проблеми або обговорювати певні теми безпосередньо на Crowdin, але ми рекомендуємо використовувати Discord замість системи коментарів Crowdin, щоб усе було організовано в одному місці.
+
+1. Приєднуйтесь до [нашого Discord](https://discord.gg/hytalemodding)
+2. Відкрийте канал `#translations`. Тут ви можете обговорити або поставити запитання, які не пов'язані з конкретною мовою.
+3. Якщо ви хочете приєднатися до теми обговорення, вам потрібно виконати тут команду `/translator Ukrainian` Бот додасть вас до гілки української мови.
+
+## Настанови перекладу
+
+- Ви повинні бути впевнені в тому, що перекладаєте. Ви повинні прочитати щойно перекладений текст і дуже легко зрозуміти його значення.
+- Слід використовувати якомога простішу мову. Використовуйте англійські слова, якщо переклад невідомий більшості у вашій країні.
+- Використовуйте свою уяву, довіртеся собі. Не соромтеся змінювати будь-який контекст на свій розсуд, головне, щоб він доносив ту саму думку та був зрозумілим.
+- Ці настанови важливіші, ніж настанови щодо української мови, але менш важливі, ніж термінологія та правила Hytale.
+
+## Що не перекладати
+
+Ми просимо вас усіх не перекладати ці конкретні розділи вебсайту:
+
+### Типи виносок
+
+Виноски – це поля, які містять важливу інформацію. Просимо вас не перекладати ці типи, оскільки вони працюють лише англійською мовою.
+
+**Приклад:**
+
+```mdx
+<Callout type="warning" title="Перекладіть цю назву!">
+Перекладіть текст у виносці!
+</Callout>
+```
+
+У цьому прикладі, будь ласка, не перекладайте слово «warning», решту ви можете перекласти.
+
+### Значки
+
+Назви значків не можна перекладати.
+Це технічні ідентифікатори, безпосередньо пов'язані з існуючими значками. Їх переклад порушить відображення значків.
+
+```mdx
+icon: Globe
+```
+
+---
+
+{/* 
+Для перекладачів, які редагуватимуть цю сторінку:
+
+- Ви повинні перекладати настанови в міру їх змін.
+- Загальні настанови слід перекладати, але не редагувати.
+- Дізнайтеся, як використовувати Markdown, з writing_guides.mdx
+*/}
diff --git a/content/docs/uk-UA/contributing/writing-guides.mdx b/content/docs/uk-UA/contributing/writing-guides.mdx
index 590f1358..999ed640 100644
--- a/content/docs/uk-UA/contributing/writing-guides.mdx
+++ b/content/docs/uk-UA/contributing/writing-guides.mdx
@@ -32,7 +32,7 @@ authors:
 
 Відступи на передньому плані важливі, тому переконайтеся, що вони як у прикладі.
 
-## Структура контенту
+## Структура вмісту
 
 Потрібно структурувати зміст свого керівництва чітким і організованим. Ось кілька порад про те, як це зробити:
 
diff --git a/content/docs/uk-UA/established-information/developer-qa-insights.mdx b/content/docs/uk-UA/established-information/developer-qa-insights.mdx
index 3c7ee3cb..128bbbbd 100644
--- a/content/docs/uk-UA/established-information/developer-qa-insights.mdx
+++ b/content/docs/uk-UA/established-information/developer-qa-insights.mdx
@@ -1,86 +1,86 @@
 ---
-title: Developer Q&A Technical Insights
-description: Комплексний огляд технічних ідей розробників Hytale, що охоплюють архітектуру, модинг, ігрові системи та філософію розробки.
+title: Запитання та відповіді розробників з технічної інформації
+description: Комплексний огляд технічних ідей розробників Hytale, що охоплюють архітектуру, модифікування, ігрові системи та філософію розробки.
 ---
 
-# Developer Q&A Technical Insights
+# Запитання та відповіді розробників з технічної інформації
 
 Ця розширена сесія запитань і відповідей з розробниками Hytale розкриває важливі технічні деталі щодо архітектури гри, філософії модингу, ігрових систем та підходу до розробки.
 
-## Technical Architecture
+## Технічна архітектура
 
-### Network & Infrastructure
+### Мережа та інфраструктура
 
-* **Protocol**: Uses QUIC (reliable UDP with unreliable channels) instead of TCP
-* **Server Compatibility**: Runs on any platform supporting Java 25
-* **Connection Method**: Direct IP initially, server discovery planned post-launch
-* **Data Layer**: Current custom serialization format will be replaced post-launch
-* **Performance**: Multi-core support - each world has main thread + parallel execution
-* **Rendering**: OpenGL 3.3 for Mac compatibility, potential future Vulkan/Metal migration
-* **Tick Model**: Base server tick rate is 30 TPS by default; can be changed using server plugins.
+* **Протокол**: Використовує QUIC (надійний UDP з ненадійними каналами) замість TCP
+* **Сумісність із сервером**: Працює на будь-якій платформі, що підтримує Java 25
+* **Спосіб підключення**: Спочатку пряма IP-адреса, виявлення сервера планується після запуску
+* **Рівень даних**: Поточний формат користувацької серіалізації буде замінено після запуску
+* **Продуктивність**: Підтримка багатоядерних процесорів — кожен світ має головний потік + паралельне виконання
+* **Візуалізація**: OpenGL 3.3 для сумісності з Mac, можлива майбутня міграція на Vulkan/Metal
+* **Модель тактів**: Базова частота тактів сервера за замовчуванням становить 30 TPS; її можна змінити за допомогою плагінів сервера.
 
-### Security & Distribution
+### Безпека та розповсюдження
 
-* **No Client-Side Code Execution**: Prevents remote code execution exploits
-* **Downloads Limited To**: Configuration files and assets only
-* **Mod Distribution**: Community platforms (CurseForge, Modrinth), no immediate in-game marketplace
-* **Server Hosting**: Available day 1, no business agreements required (just EULA/TOS)
+* **Без виконання коду на стороні клієнта**: Запобігає лазівкам віддаленого виконання коду
+* **Обмеження завантажень**: Тільки файли конфігурації та ресурси
+* **Розповсюдження модифікацій**: Платформи спільноти (CurseForge, Modrinth), немає безпосереднього ігрового ринку
+* **Хостинг сервера**: Доступний з першого дня, жодних ділових угод не потрібно (лише ліцензійна угода/умови використання)
 
-## Можливості модингу
+## Можливості модифікування
 
-### Server-Side Power
+### Серверне живлення
 
-* **Full Java Access**: Database connections, web requests, any Java functionality
-* **Custom Libraries**: Can create Lua scripting, ML frameworks, or any Java library
-* **Server Modification**: Shared source code allows heavy server modifications
-* **Hot Reload**: Supported for most asset types
-* **Documentation**: Public GitBook planned, though initially sparse
+* **Повний доступ до Java**: підключення до бази даних, вебзапити, будь-які функції Java
+* **Користувацькі бібліотеки**: Можна створювати скрипти Lua, фреймворки машинного навчання або будь-яку бібліотеку Java
+* **Модифікація сервера**: Спільний вихідний код дозволяє суттєві модифікації сервера
+* **Гаряче перезавантаження**: Підтримується для більшості типів ресурсів
+* **Документація**: Публічний GitBook планується, хоча спочатку його небагато
 
-### Content Creation (No Code Required)
+### Створення контенту (код не потрібен)
 
-* **World Generation**: Custom biomes and maps without Java
-* **NPCs & Items**: JSON-based configuration
-* **Crafting Recipes**: Data-driven system
-* **Visual Scripting**: Replaces command blocks, fully sandboxed
-* **Prefab System**: Sophisticated building blocks with in-game editor
+* **Генерація світу**: Власні біоми та карти без Java
+* **NPC та предмети**: конфігурація на основі JSON
+* **Рецепти створення**: Система, керована даними
+* **Візуальне написання сценаріїв**: Замінює блоки команд, повністю ізольоване програмне забезпечення
+* **Система префабів**: Складні будівельні блоки з ігровим редактором
 
-### Advanced Modding
+### Розширене програмування
 
-* **Combat System**: Data-driven interaction system for attack chains and abilities
-* **Sub-Hitboxes**: Support for complex boss mechanics (needs improvement)
-* **Status Effects**: Buff/debuff system with custom effects and stats
-* **Custom UI**: NoesisGUI transition enables powerful interface customization
-* **Block Physics**: Selective system (trees fall, but placed blocks don't)
+* **Бойова система**: Система взаємодії на основі даних для ланцюжків атак та здібностей
+* **Підхітбокси**: Підтримка складної механіки босів (потребує покращення)
+* **Ефекти статусу**: Система посилення/послаблення з власними ефектами та характеристиками
+* **Налаштовуваний інтерфейс**: перехід NoesisGUI забезпечує потужне налаштування інтерфейсу
+* **Фізика блоків**: Вибіркова система (дерева падають, але розміщені блоки не падають)
 
-## Gameplay Systems
+## Ігрові системи
 
-### Core Mechanics
+### Основна механіка
 
-* **Stamina System**: No hunger by default (can be modded in)
-* **Gravity**: Selective block physics - trees collapse, buildings can float
-* **Lighting**: Major overhaul to fix model/voxel inconsistencies
-* **World Height**: Currently limited, may change with voxel storage updates
-* **Automation**: No redstone equivalent at launch (moddable)
+* **Система витривалості**: Голод відсутній за замовчуванням (можна модифікувати)
+* **Гравітація**: Фізика вибіркових блоків — дерева руйнуються, будівлі можуть плавати
+* **Освітлення**: Основні перебудови для виправлення невідповідності моделі / вокселів
+* **Висота світу**: Наразі обмежена, може змінитися після оновлення сховища вокселів
+* **Автоматизація**: Немає чогось рівноцінного до редстоуну на момент запуску (модифікується)
 
-### Player Systems
+### Системи гравця
 
-* **Character Models**: Humans by default, changeable in creative mode
-* **Multiplayer Avatars**: Server-controlled (no custom models in multiplayer)
-* **Skins**: Full customization possible ("mod yourself into a potato")
-* **Shapeshifting**: Transformation potions exist for fun/modding
+* **Моделі персонажів**: Люди за замовчуванням, їх можна змінити у режимі творчости
+* **Аватари для багатьох гравців**: Керуються сервером (без користувацьких моделей у багатокористувацькому режимі)
+* **Скіни**: Можливість повної кастомізації («перетворіть себе на картоплину»)
+* **Перетворення**: Зілля трансформації існують для розваги/модифікації
 
-### World & NPCs
+### Світ та NPC
 
-* **Faction System**: Living world with dynamic NPC interactions
-* **Village Systems**: Planned dynamic villages with relationships and behaviors
-* **Chunk Loading**: Entities unload when out of all players' render distance
-* **Seeds**: Shareable world generation seeds supported
+* **Система фракцій**: Живий світ з динамічною взаємодією з NPC
+* **Системи сіл**: Заплановані динамічні села з взаємовідносинами та моделями поведінки
+* **Завантаження фрагментів**: Сутності вивантажуються, коли перебувають поза зоною візуалізації всіх гравців.
+* **Сід**: Підтримуються спільні сіди для генерації світу
 
-## Development Philosophy
+## Філософія розвитку
 
-### Release Strategy
+### Стратегія випуску
 
-* **Base Game Priority**: Adventure mode is primary focus, modding architecture supports it
+* **Пріоритет базової гри**: Режим пригод є основним, архітектура модифікацій підтримує його
 * **Tech Debt**: Acknowledged as necessary for release, commitment to improvement
 * **Update Frequency**: Very frequent updates planned, especially post-launch
 * **Version Policy**: Always latest version, but servers can run modified versions
diff --git a/content/docs/uk-UA/established-information/server/content-categories/art-assets.mdx b/content/docs/uk-UA/established-information/server/content-categories/art-assets.mdx
index fe2d3f54..16f56f8d 100644
--- a/content/docs/uk-UA/established-information/server/content-categories/art-assets.mdx
+++ b/content/docs/uk-UA/established-information/server/content-categories/art-assets.mdx
@@ -14,7 +14,7 @@ Hytale надає комплексну підтримку для 3D-моделю
 Hytale використовує **Blockbench** як основний інструмент для 3D-моделювання та анімації:
 
 * **Офіційна підтримка**: Використовується для «створення моделей, текстур та анімації Hytale».
-* **Спеціальний плагін**: Hytale матиме спеціальний плагін Blockbench.
+* **Special plugin**: Hytale has a dedicated [Blockbench Plugin](https://www.blockbench.net/plugins/hytale_plugin).
 * **Пряма сумісність**: Плагін дозволяє творцям «створювати моделі, текстури та анімацію, сумісні з Hytale, безпосередньо в Blockbench».
 * **Заміна застарілих інструментів**: Повна заміна старого Створювача Моделей Hytale для кращої підтримки встановлених у спільноті творчих робочих процесів
 * **Функції безпеки**: Дозволяє додавати лише матеріали, сумісні з движком, тож вам не потрібно турбуватися про можливі збої.
diff --git a/content/docs/uk-UA/guides/ecs/block-components.mdx b/content/docs/uk-UA/guides/ecs/block-components.mdx
new file mode 100644
index 00000000..ca68b38a
--- /dev/null
+++ b/content/docs/uk-UA/guides/ecs/block-components.mdx
@@ -0,0 +1,247 @@
+---
+title: Block Components
+description: Learn how to use the block components.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+  - name: oskarscot
+    link: https://oskar.scot
+---
+
+# Overview
+
+In this guide, you'll learn how to use block components to create a ticking block.
+
+<Callout>
+  For a more complete reference, you may also want to review FarmingSystems.Ticking, as much of the underlying logic is based on its implementation.
+</Callout>
+
+## Steps
+
+### 1. ExampleBlock - holds block behavior
+
+```java
+public class ExampleBlock implements Component<ChunkStore> {
+
+    public static final BuilderCodec CODEC = BuilderCodec.builder(ExampleBlock.class, ExampleBlock::new).build();
+
+    // Components usually require a copy constructor as well but since we don't actually hold any data in this component this is not neccessary
+    public ExampleBlock() { }
+
+    public static ComponentType getComponentType() {
+        return ExamplePlugin.get().getExampleBlockComponentType();
+    }
+
+    @Nullable
+    public Component<ChunkStore> clone() {
+        return new ExampleBlock();
+    }
+}
+```
+
+ExampleBlock is a custom component that stores the behavior and data for your ticking block. Here, it simply places an Ice Block at x + 1 relative to its current position when it ticks.
+
+---
+
+### 2. ExampleInitializer - marks blocks as ticking when placed
+
+```java
+public class ExampleInitializer extends RefSystem {
+
+    @Override
+    public void onEntityAdded(@Nonnull Ref ref, @Nonnull AddReason reason, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+        BlockModule.BlockStateInfo info = (BlockModule.BlockStateInfo) commandBuffer.getComponent(ref, BlockModule.BlockStateInfo.getComponentType());
+        if (info == null) return;
+
+        ExampleBlock generator = (ExampleBlock) commandBuffer.getComponent(ref, ExamplePlugin.get().getExampleBlockComponentType());
+        if (generator != null) {
+            int x = ChunkUtil.xFromBlockInColumn(info.getIndex());
+            int y = ChunkUtil.yFromBlockInColumn(info.getIndex());
+            int z = ChunkUtil.zFromBlockInColumn(info.getIndex());
+
+            WorldChunk worldChunk = (WorldChunk) commandBuffer.getComponent(info.getChunkRef(), WorldChunk.getComponentType());
+            if (worldChunk != null) {
+				worldChunk.setTicking(x, y, z, true);
+            }
+        }
+    }
+
+    @Override
+    public void onEntityRemove(@Nonnull Ref ref, @Nonnull RemoveReason reason, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+    }
+
+    @Override
+    public Query getQuery() {
+        return Query.and(BlockModule.BlockStateInfo.getComponentType(), ExamplePlugin.get().getExampleBlockComponentType());
+    }
+}
+```
+
+ExampleInitializer is a RefSystem that reacts when block entities with the ExampleBlock component are added or removed. This is crucial for marking blocks as ticking when they're first placed.
+
+**Key Points:**
+
+- Tells the game that this block should tick, allowing `ExampleSystem` to process it.
+
+```java
+worldChunk.setTicking(x, y, z, true);
+```
+
+---
+
+### 3. ExampleSystem - handles ticking
+
+```java
+public class ExampleSystem extends EntityTickingSystem {
+
+    public void tick(float dt, int index, @Nonnull ArchetypeChunk archetypeChunk, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+        BlockSection blocks = (BlockSection) archetypeChunk.getComponent(index, BlockSection.getComponentType());
+
+        assert blocks != null;
+
+        if (blocks.getTickingBlocksCountCopy() != 0) {
+            ChunkSection section = (ChunkSection) archetypeChunk.getComponent(index, ChunkSection.getComponentType());
+
+            assert section != null;
+
+            BlockComponentChunk blockComponentChunk = (BlockComponentChunk) commandBuffer.getComponent(section.getChunkColumnReference(), BlockComponentChunk.getComponentType());
+
+            assert blockComponentChunk != null;
+
+            blocks.forEachTicking(blockComponentChunk, commandBuffer, section.getY(), (blockComponentChunk1, commandBuffer1, localX, localY, localZ, blockId) -> {
+                Ref<ChunkStore> blockRef = blockComponentChunk.getEntityReference(ChunkUtil.indexBlockInColumn(localX, localY, localZ));
+                if (blockRef == null) {
+                    return BlockTickStrategy.IGNORED;
+                } else {
+                    ExampleBlock exampleBlock = (ExampleBlock) commandBuffer1.getComponent(blockRef, ExampleBlock.getComponentType());
+                    if (exampleBlock != null) {
+                        WorldChunk worldChunk = (WorldChunk) commandBuffer.getComponent(section.getChunkColumnReference(), WorldChunk.getComponentType());
+                        World world = worldChunk.getWorld();
+
+                        int globalX = localX + (worldChunk.getX() * 32);
+                        int globalZ = localZ + (worldChunk.getZ() * 32);
+
+                        // We need to execute setBlock on the world thread as you cannot call store functions from a system
+                        // This is because of the architecture of the server, depending on your needs you can also use the CommandBuffer
+                        world.execute(() -> {
+                            world.setBlock(globalX + 1, localY, globalZ, "Rock_Ice");
+                        });
+
+                        return BlockTickStrategy.CONTINUE;
+
+                    } else {
+                        return BlockTickStrategy.IGNORED;
+                    }
+                }
+            });
+        }
+    }
+
+    @Nullable
+    public Query getQuery() {
+        return Query.and(BlockSection.getComponentType(), ChunkSection.getComponentType());;
+    }
+}
+```
+
+ExampleSystem is an EntityTickingSystem that runs every tick to execute the logic for all ticking blocks with the ExampleBlock component.
+
+**Key Points:**
+
+- **Get the block component**
+
+```java
+ExampleBlock exampleBlock = (ExampleBlock) commandBuffer.getComponent(blockRef, ExampleBlock.getComponentType());
+```
+
+- **Convert local chunk coordinates to world coordinates**
+
+```java
+int globalX = localX + (worldChunk.getX() * 32);
+int globalZ = localZ + (worldChunk.getZ() * 32);
+```
+
+- **Run the block logic**
+
+```java
+exampleBlock.runBlockAction(globalX, localY, globalZ, worldChunk.getWorld());
+```
+
+- **Keep the block ticking in the next tick**
+
+```java
+return BlockTickStrategy.CONTINUE;
+```
+
+---
+
+### 4. ExamplePlugin - registers components and systems
+
+```java
+public class ExamplePlugin extends JavaPlugin {
+    protected static ExamplePlugin instance;
+    private static final HytaleLogger LOGGER = HytaleLogger.forEnclosingClass();
+    private ComponentType exampleBlockComponentType;
+
+    public static ExamplePlugin get() {
+        return instance;
+    }
+
+    public ExamplePlugin(@Nonnull JavaPluginInit init) {
+        super(init);
+        LOGGER.atInfo().log("Hello from " + this.getName() + " version " + this.getManifest().getVersion().toString());
+    }
+
+    @Override
+    protected void setup() {
+        instance = this;
+        LOGGER.atInfo().log("Setting up plugin " + this.getName());
+        this.exampleBlockComponentType = this.getChunkStoreRegistry().registerComponent(ExampleBlock.class, "ExampleBlock", ExampleBlock.CODEC);
+    }
+	
+	@Override
+	protected void start() {
+		this.getChunkStoreRegistry().registerSystem(new ExampleSystem());
+		this.getChunkStoreRegistry().registerSystem(new ExampleInitializer());
+	}
+
+    public ComponentType getExampleBlockComponentType() {
+        return this.exampleBlockComponentType;
+    }
+}
+```
+
+---
+
+### 5. Configure In-Game
+
+![block-component-1](/assets/guides/block-component-1.png)
+
+![block-component-2](/assets/guides/block-component-2.png)
+
+With this logic, the block will now continuously place an Ice Block at the coordinates x + 1 relative to its current position every time it ticks.
+
+---
+
+## Common Issues
+
+### NullPointerException on Startup
+
+**Error message:**
+
+```java
+java.lang.NullPointerException: Cannot invoke "com.hypixel.hytale.component.query.Query.validateRegistry(com.hypixel.hytale.component.ComponentRegistry)" because "query" is null
+```
+
+**Cause:**
+This error occurs when your module is loaded **before** the required Hytale modules.
+
+**Fix:**
+Add `EntityModule` and `BlockModule` as dependencies in your `manifest.json` to ensure proper load order.
+
+```json
+"Dependencies": {
+  "Hytale:EntityModule": "*",
+  "Hytale:BlockModule": "*"
+}
+```
diff --git a/content/docs/uk-UA/guides/ecs/hytale-ecs-theory.mdx b/content/docs/uk-UA/guides/ecs/hytale-ecs-theory.mdx
index 20c3a94d..52d8b1f5 100644
--- a/content/docs/uk-UA/guides/ecs/hytale-ecs-theory.mdx
+++ b/content/docs/uk-UA/guides/ecs/hytale-ecs-theory.mdx
@@ -29,7 +29,7 @@ for now this is the basic understanding for the `ChunkStore`. You can use it to
 
 ## Holder
 
-A Holder is essentially a blueprint for an entity. Before an entity exists in the Store (and thus in the world), is exists as a `Holder`. It collects and holds all the necessary components (data). You can compare it analogous to shopping cart. You grab all components you need and once you have everything, check out at the store which will take your cart and create a valid entity ID and hand you back a receipt (a Ref).
+A Holder is essentially a blueprint for an entity. Before an entity exists in the Store (and thus in the world), it exists as a `Holder`. It collects and holds all the necessary components (data). You can compare it analogous to shopping cart. You grab all components you need and once you have everything, check out at the store which will take your cart and create a valid entity ID and hand you back a receipt (a Ref).
 
 Let's take a look at an example: initializing players. In `Universe`, the `addPlayer` method demonstrates it perfectly.
 When a player connects, we don't immediately throw them into the ECS. We first construct their data in a Holder.
@@ -167,7 +167,7 @@ MyComponent comp = commandBuffer.getComponent(ref, componentType);
 
 Codecs handle serialization and deserialization of components. Hytale uses them to save and load entity data to and from disk as well as sending component data over the network. When creating a custom component, you must also create a corresponding Codec.
 
-There are mutliple Codec types already implemented in the default Codec Interface:
+There are multiple Codec types already implemented in the default Codec Interface:
 
 - Codec.STRING
 - Codec.BOOLEAN
@@ -215,7 +215,7 @@ This might seem tedious at first but it ensures that your component can be corre
   KeyedCodec<Integer> exampleInt = new KeyedCodec<Integer>("ExampleIntIdForCodec", Codec.INTEGER);
   ```
 
-- **Setter Function**: This is a lambda function that takes an instance of your component and returns the value of the field you want to serialize. For example, if you have a field called `myCustomField` in your custom component, your getter function would look like this:
+- **Setter Function**: This is a lambda function that takes an instance of your component + the value to set and sets the field value on the component. For example, if you have a field called `myCustomField` in your custom component, your setter function would look like this:
   ```java
   (data, value) -> data.myCustomField = value
   ```
@@ -276,7 +276,7 @@ public class PoisonComponent implements Component<EntityStore> {
 
 You can also add validators to your Codec fields to ensure that the data being serialized/deserialized meets certain criteria. For example, if you want to ensure that the `damagePerTick` field is always non-negative or the poison name is never null, you can add a validator like this:
 
-````java
+```java
 .append(
     new KeyedCodec<Float>("DamagePerTick", Codec.FLOAT),
     (data, value) -> data.damagePerTick = value,
@@ -292,14 +292,15 @@ You can also add validators to your Codec fields to ensure that the data being s
 )
 .addValidator(Validators.nonNull())
 .add()
+```
 
 ### Complex Codec Examples
 
-If you want to have a map inside your component, you can use the MapCodec class to build a KeyedCoded for it. Here's an example of how to create a Codec for a Map field:
+If you want to have a map inside your component, you can use the MapCodec class to build a KeyedCodec for it. Here's an example of how to create a Codec for a Map field:
 
 ```java
 var damagePerTick = new KeyedCodec<>("DamagePerTick", new MapCodec<>(Codec.FLOAT, HashMap<String, Float>::new));
-````
+```
 
 <Callout type="info">
   This also works with custom Objects as long as you have a Codec defined for the Object type.
diff --git a/content/docs/uk-UA/guides/java-basics/00-introduction.mdx b/content/docs/uk-UA/guides/java-basics/00-introduction.mdx
index 8d3f1204..acd37954 100644
--- a/content/docs/uk-UA/guides/java-basics/00-introduction.mdx
+++ b/content/docs/uk-UA/guides/java-basics/00-introduction.mdx
@@ -7,7 +7,7 @@ Welcome to your journey into Java Programming! This guide is designed to introdu
 
 ## Що таке Java?
 
-Java is a powerful, object-oriented programming language created in 1995. It's one of the most popular programming languages in the world and is used for everything from mobile apps to enterprise software. Найважливіше для нас, що це мова, яку Hytale використовує для своїх серверів та API модифікацій.
+Java is a powerful, object-oriented programming language created in 1995. It's one of the most popular programming languages in the world and is used for everything from mobile apps to enterprise software. Most importantly for us, it's the language Hytale uses for its servers & modding API.
 
 ## Про що ви дізнаєтесь
 
diff --git a/content/docs/uk-UA/guides/java-basics/02-operators.mdx b/content/docs/uk-UA/guides/java-basics/02-operators.mdx
index a132b1c0..18634665 100644
--- a/content/docs/uk-UA/guides/java-basics/02-operators.mdx
+++ b/content/docs/uk-UA/guides/java-basics/02-operators.mdx
@@ -119,7 +119,7 @@ String greetingWithName = "Hello, " + name + "!"; // "Hello, Alice!"
 
 ## Operator Precedence
 
-Operator Precendence means which operator gets evaluated first in an line of code. Think of it like BODMAS/PEMDAS in math!
+Operator Precedence means which operator gets evaluated first in an line of code. Think of it like BODMAS/PEMDAS in math!
 
 ```java
 int result = 10 + 5 * 2; // result is 20, not 30
diff --git a/content/docs/uk-UA/guides/java-basics/03-control-flow-if.mdx b/content/docs/uk-UA/guides/java-basics/03-control-flow-if.mdx
index b9d6c479..af2d1c22 100644
--- a/content/docs/uk-UA/guides/java-basics/03-control-flow-if.mdx
+++ b/content/docs/uk-UA/guides/java-basics/03-control-flow-if.mdx
@@ -7,7 +7,7 @@ Programs need to make decisions. If statements let your code choose different pa
 
 ## Basic If Statement
 
-The simplest form checks one condition;
+The simplest form checks one condition:
 
 ```java
 int health = 20;
diff --git a/content/docs/uk-UA/guides/java-basics/08-access-modifiers.mdx b/content/docs/uk-UA/guides/java-basics/08-access-modifiers.mdx
index af560932..da2bf33b 100644
--- a/content/docs/uk-UA/guides/java-basics/08-access-modifiers.mdx
+++ b/content/docs/uk-UA/guides/java-basics/08-access-modifiers.mdx
@@ -484,7 +484,7 @@ class Data {
     // Static member:
     // cannot access to non-static variables
     public static void bar() {
-        x = 100; // Error: non-static variable x cannot be renference from a static context
+        x = 100; // Error: non-static variable x cannot be referenced from a static context
         y = 100; // OK
     }
 }
@@ -504,7 +504,7 @@ Data.x = 1000; // Error: cannot access instanced variables in a static context
 
 ### Static Fields
 
-A static field represents a data member owned by the class type rather then the object. Static fields are also stored in a specific memory location that's been shared between all the object instances that are created.
+A static field represents a data member owned by the class type rather than the object. Static fields are also stored in a specific memory location that's been shared between all the object instances that are created.
 
 It is declared as following:
 
diff --git a/content/docs/uk-UA/guides/plugin/animated-block-textures.mdx b/content/docs/uk-UA/guides/plugin/animated-block-textures.mdx
new file mode 100644
index 00000000..42bfa51f
--- /dev/null
+++ b/content/docs/uk-UA/guides/plugin/animated-block-textures.mdx
@@ -0,0 +1,101 @@
+---
+title: Animated Block Textures
+description: Learn how to attach a .blockyanim to a block
+authors:
+  - name: Burkino
+---
+
+import { File, Folder, Files } from 'fumadocs-ui/components/files';
+
+So, you want to make your blocks feel more alive through animations, do you?\
+Now for the most part this is the exact same as [Creating custom blocks](./creating-block).
+![blue fire gif](/assets/guides/blue_fire.gif)
+
+## Prerequisites
+
+This is NOT a guide on animating or texturing or even using BlockBench, why? Because I don't know how to do that.\
+The only thing we will be doing is taking the fire texture, changing the color, and applying it to our new fire block.
+
+## Setup
+
+To start, you're obviously going to want to grab the `Common/VFX/Fire/Fire.png` file. How you do it is up to you, in the Asset Editor you'll need to switch to the Common tab.\
+I'll assume you know how colorize or change the hue of an image, so go ahead and do that now and save it as `Blue_Fire.png`.
+
+The other assets used in this guide are `Common/VFX/Fire/Fire.blockymodel` and `Common/Blocks/Animations/Fire/Fire_Burn.blockyanim` (both renamed to `Blue_Fire`) but since we won't be changing them it's probably fine to leave them. I will reference the `Blue_Fire` versions as a way to point out what should be custom assets.\
+I will also duplicate `Server/Item/Item/Deco/Deco_Fire.json` and call it `Deco_Blue_Fire.json`.
+
+## Applying the changes
+
+The `Deco_Blue_Fire` block is actually just a particle emitter, however we will not be using particles, so lets start by removing them in `Block > Particles`.\
+Next we want to set the Block Model (called `CustomModel` in JSON) to `VFX/Blue_Fire/Blue_Fire.blockymodel` and Block Model Textures (`CustomModelTexture` in JSON) to
+
+```json
+[
+    {
+        "Texture": "VFX/Blue_Fire/Blue_Fire.png",
+        "Weight": 1
+    }
+]
+```
+
+Finally, we will apply the .blockyanim to our model, this is done through the Block Model Animation property (`CustomModelAnimation` in JSON) and the value should be `Blocks/Animations/Blue_Fire/Blue_Fire_Burn.blockyanim`.
+
+## Final Code
+
+With that your new blue fire should be done. Here is the minimal JSON for our blue fire.\
+There is an additional `Looping` and `RequiresAlphaBlending` property that I have not gone over, however I hope it is self-explanatory.
+
+```json
+{
+  "BlockType": {
+    "DrawType": "Model",
+    "CustomModel": "VFX/Blue_Fire/Blue_Fire.blockymodel",
+    "CustomModelAnimation": "Blocks/Animations/Blue_Fire/Blue_Fire_Burn.blockyanim",
+    "CustomModelTexture": [
+      {
+        "Texture": "VFX/Blue_Fire/Blue_Fire.png",
+        "Weight": 1
+      }
+    ],
+    "Looping": true,
+    "RequiresAlphaBlending": false
+  },
+  "PlayerAnimationsId": "Block"
+}
+```
+
+<Files>
+  <Folder name="resources" defaultOpen>
+    <Folder name="Server" defaultOpen>
+      <Folder name="Item" defaultOpen>
+        <Folder name="Items" defaultOpen>
+          <Folder name="Deco" defaultOpen>
+            <File name="Deco_Blue_Fire.json" />
+          </Folder>
+        </Folder>
+      </Folder>
+    </Folder>
+
+    <Folder name="Common" defaultOpen>
+      <Folder name="Blocks" defaultOpen>
+        <Folder name="Animations" defaultOpen>
+          <Folder name="Blue_Fire" defaultOpen>
+            <File name="Blue_Fire_Burn.blockyanim" />
+          </Folder>
+        </Folder>
+      </Folder>
+
+      <Folder name="VFX" defaultOpen>
+        <Folder name="Blue_Fire" defaultOpen>
+          <File name="Blue_Fire.blockymodel" />
+
+          <File name="Blue_Fire.png" />
+        </Folder>
+      </Folder>
+    </Folder>
+  </Folder>
+</Files>
+
+## Next steps
+
+Now that you know how to attach an animation to a block, try adding it to a block state.
diff --git a/content/docs/uk-UA/guides/plugin/build-and-test.mdx b/content/docs/uk-UA/guides/plugin/build-and-test.mdx
index 0e7fe7eb..f37534c3 100644
--- a/content/docs/uk-UA/guides/plugin/build-and-test.mdx
+++ b/content/docs/uk-UA/guides/plugin/build-and-test.mdx
@@ -9,18 +9,18 @@ If you followed along with the [Setting Up Your Development Environment](./setti
 
 ## Building Your Mod
 
-In our case, we've **Maven** as the build system. Maven is a powerful build automation tool that manages dependencies, compiles your code, and packages everything into a distributable JAR file.
+In our case, we've **Gradle** as the build system. Gradle is a powerful build automation tool that manages dependencies, compiles your code, and packages everything into a distributable JAR file.
 
-### Understanding Maven
+### Understanding Gradle
 
-Maven uses a `pom.xml` file (Project Object Model) to define your project's configuration, dependencies, and build settings. You can learn more about Maven at the [official Apache Maven website](https://maven.apache.org/).
+Gradle can use a `build.gradle.kts` file (Kotlin DSL) to define your project's configuration, dependencies, and build settings. You can learn more about Gradle at the [official Gradle website](https://gradle.org/).
 
-### Building with Maven
+### Building with Gradle
 
 To build your mod, open a terminal in your project directory and run:
 
 ```bash
-mvn package
+./gradlew build
 ```
 
 This command will:
@@ -29,16 +29,35 @@ This command will:
 2. Run any tests (if present)
 3. Package everything into a JAR file
 
+<Callout type="info">
+  If you are using the plugin template from the [Setting Up Your Development Environment](./setting-up-env) guide, then the build script is already set up for you. It includes paths to your Hytale game library and handles the packaging of your mod, managing hytale dependencies and manifest changes.
+
+  If you have a different path to your Hytale installation, you may receive the following error:
+
+  ```bash
+  FAILURE: Build failed with an exception.
+
+  * What went wrong:
+  Failed to find Hytale at the expected location. Please make sure you have installed the game. The expected location can be changed using the hytale.home_path property. Currently looking in 'C:\Path\To\Hytale'
+  ```
+
+  You can change the path by adding a property to your `gradle.properties` file (if it doesn't exist, create it in the root of your project):
+
+  ```properties
+  hytale.home_path=C:\Correct\Path\To\Hytale
+  ```
+</Callout>
+
 ### Build Output
 
-Once the build completes successfully, your mod will be located in the `target` directory and named:
+Once the build completes successfully, your mod will be located in the `build/libs` directory and named:
 
 ```
-ExamplePlugin-1.0-SNAPSHOT.jar
+ExamplePlugin-1.0.jar
 ```
 
 <Callout type="info">
-  The exact name may vary depending on what you configured in your `pom.xml` file. Check the `artifactId` and `version` fields to see what your JAR will be named.
+  The exact name may vary depending on what you configured in your `build.gradle.kts` and `settings.gradle.kts` file. Check the `rootProject.name` and `version` fields to see what your JAR will be named.
 </Callout>
 
 ## Testing Your Mod
@@ -49,11 +68,11 @@ Now that you've built your mod, it's time to test it in Hytale!
 
 First, you need to find Hytale's mods directory:
 
-1. Press **Win + R** on your keyboard
-2. Type `%appdata%` and press Enter
-3. Navigate to: `Hytale\UserData\Mods`
+1. Go to your Hytale installation directory (The default location is usually in your AppData folder)
+   > On Windows, you can access it by clicking `windows + R` and typing `%appdata%`.
+2. Navigate to: `/UserData/Mods`
 
-The full path should look like:
+The default path would look like:
 
 ```
 C:\Users\YourUsername\AppData\Roaming\Hytale\UserData\Mods
@@ -65,7 +84,7 @@ C:\Users\YourUsername\AppData\Roaming\Hytale\UserData\Mods
 
 ### 2. Copy Your Mod
 
-Copy the `ExamplePlugin-1.0-SNAPSHOT.jar` file from your project's `target` directory into the `Mods` folder you just located.
+Copy the `ExamplePlugin-1.0.jar` file from your project's `build/libs` directory into the `Mods` folder you just located.
 
 ### 3. Launch Hytale and Verify
 
@@ -84,7 +103,7 @@ If your mod doesn't appear in the mods list:
 - Make sure the JAR file is in the correct `Mods` folder
 - Check that your `manifest.json` file is properly configured
 - Look for any error messages in the Hytale logs
-- Verify that you're using the correct version of Java and Maven
+- Verify that you're using the correct version of Java and Gradle
 
 ## Next Steps
 
diff --git a/content/docs/uk-UA/guides/plugin/creating-commands.mdx b/content/docs/uk-UA/guides/plugin/creating-commands.mdx
index d33597f3..08572f16 100644
--- a/content/docs/uk-UA/guides/plugin/creating-commands.mdx
+++ b/content/docs/uk-UA/guides/plugin/creating-commands.mdx
@@ -8,6 +8,8 @@ authors:
     url: https://oskar.scot
   - name: jacobwojoski
     url: https://github.com/jacobwojoski
+  - name: Marcel-TO
+    url: https://marcel-to.net
 ---
 
 In this guide, you will learn how to create custom commands for your Hytale mod.
@@ -36,7 +38,7 @@ The most basic command is an `AbstractAsyncCommand`. It has very minimal data av
   `AbstractAsyncCommand` runs on its own background thread. This means its execute is not tied to any world instance and because of this it can not edit any **Stores** or **Refs** without getting the desired world first. To access this data any of the other command types would be preferred and are likely what you will want to use instead.
 </Callout>
 
-The main purpose for a command like this would be for something that can happen everywhere and is not tied to a specific world. For example a `serverRules` command to tell the user thats running the command in chat what the servers rules are nomatter what world they are in.
+The main purpose for a command like this would be for something that can happen everywhere and is not tied to a specific world. For example a `serverRules` command to tell the user that's running the command in chat what the server's rules are no matter what world they are in.
 
 ```java
 // Command that can be run that lists the server rules in chat to the player
@@ -49,7 +51,7 @@ public class ServerRulesCommand extends AbstractAsyncCommand {
     }
 
     // Run the command
-    // conetext - info about who ran the command. Server console?, Some player?
+    // context - info about who ran the command. Server console?, Some player?
     @Override
     protected CompletableFuture<Void> executeAsync(@Nonnull CommandContext context) {
         context.sendMessage(Message.raw("The only rule is there are no rules."));
@@ -134,7 +136,7 @@ Uses a Ray to see what the player is looking at and tries to run the command on
 
 ## Adding Arguments
 
-Arguments are additional fields that the user can input when running a command. The different types of arguments along with small snipits and a large example can be seen below.
+Arguments are additional fields that the user can input when running a command. The different types of arguments along with small snippets and a large example can be seen below.
 
 ### Command Argument Types
 
@@ -163,14 +165,14 @@ this.messageArg = this.withOptionalArg("message", "Message to print while healin
 
 ### Default Arguments
 
-Adding a default argument has two additional arguemnt for the default value and default value description. You need to use `withDefaultArg` method.
+Adding a default argument has two additional argument for the default value and default value description. You need to use `withDefaultArg` method.
 
 ```java
 // args <Command String> <Description> <Default Value> <Desc of default value>
 this.healthArg = this.withDefaultArg("health", "Amount to heal player", ArgTypes.FLOAT, (float)100, "Desc of Default: 100");
 ```
 
-### Flag Arguemnts
+### Flag Arguments
 
 Similar as above but the flags return is either true if it exists or false if it does not. You need to use `withFlagArg` method.
 
@@ -181,20 +183,13 @@ this.debugArg = this.withFlagArg("debug", "Add debug logs");
 
 ### ArgTypes
 
-The following ArgTypes are available (only lists common types):
-
-- `ArgTypes.STRING`
-- `ArgTypes.INTEGER`
-- `ArgTypes.BOOLEAN`
-- `ArgTypes.FLOAT`
-- `ArgTypes.DOUBLE`
-- `ArgTypes.UUID`
+You can find all the available argument types on the [ArgTypes](../../argtypes) page.
 
 ### Example Command Arg Types
 
-Shows all Command arguemnt types with different various input types.
+Shows all Command argument types with different various input types.
 
-**NOTE:** When getting the value of an argument during execute you need to pass the context with `someArg.get(commandContext)`. Where `commandContext` is the first variable in the execute funtion.
+**NOTE:** When getting the value of an argument during execute you need to pass the context with `someArg.get(commandContext)`. Where `commandContext` is the first variable in the execute function.
 
 ```java
 // Example usage: /healplayer --health 50 --message "Feels Good" --debug
@@ -204,7 +199,7 @@ public class HealPlayerCommand extends AbstractTargetPlayerCommand {
     private final FlagArg debugArg;
 
     public HealPlayerCommand() {
-        super("healplayer", "Healing a player for an <input> ammount of HP (default: 100)");
+        super("healplayer", "Healing a player for an <input> amount of HP (default: 100)");
 
         // Abstract TargetPlayerCommand passes the player that ran the command by default and implements
         // the use of `--player <value>` to specify someone else
@@ -213,10 +208,10 @@ public class HealPlayerCommand extends AbstractTargetPlayerCommand {
         this.healthArg = this.withDefaultArg("health", "Amount to heal player", ArgTypes.FLOAT, (float)100, "Desc of Default: 100");
 
         // Or you could do the following making the health value required instead of with a default.
-        //    You would need to change the decleration to RequiredArg<Float>
+        //    You would need to change the declaration to RequiredArg<Float>
         // this.healthArg = this.withRequiredArg("health", "Amount to heal player", ArgTypes.FLOAT);
 
-        // Optional args reguare the user the input `--<key> <value>` so the following would require `--message "Good Luck"`
+// Optional args require the user the input `--<key> <value>` so the following would require `--message "Good Luck"`
         this.messageArg = this.withOptionalArg("message", "Message to print while healing", ArgTypes.STRING);
 
         // No type needed due to being a bool
@@ -230,7 +225,7 @@ public class HealPlayerCommand extends AbstractTargetPlayerCommand {
             commandContext.sendMessage(Message.raw("We are debugging"));
         }
 
-        // Health is stored in a generic stat map to allowing mods/future contect to easily add more stats if desired.
+        // Health is stored in a generic stat map to allowing mods/future content to easily add more stats if desired.
         EntityStatMap stats = store.getComponent(ref, EntityStatMap.getComponentType());
         int healthIdx = DefaultEntityStatTypes.getHealth();
         EntityStatValue health = stats.get(healthIdx);
@@ -252,7 +247,7 @@ public class HealPlayerCommand extends AbstractTargetPlayerCommand {
 
 ## Argument Validators
 
-Argument validators are a way to check the command before the command gets executed. They are added with the `addValidator` method on an argument when calling `withXxxArg`. They provide a nice output to the user when an input value is invalid.
+Argument validators are a way to check the command before the command gets executed. They are added with the `addValidator` method on an argument when calling `withXxxArg`. They provide a nice output to the user when an input value is invalid. There are some common validators provided in the `Validators` class such as `greaterThan`, `lessThan`, and `or`, `max`, `range`, etc.
 
 ```java
 ...
@@ -260,18 +255,59 @@ Argument validators are a way to check the command before the command gets execu
     OptionalArg<Integer> healAmount = withOptionalArg("amount", "Heal Amount", ArgTypes.INTEGER)
         .addValidator(Validators.greaterThan(0))
         .addValidator(Validators.lessThan(1000));
-
-    // Custom check example
-    OptionalArg<Integer> healAmount = withOptionalArg("amount", "Heal Amount", ArgTypes.INTEGER)
-            .addValidator( value -> {
-                if (value != null && value <= 0) {
-                    return ValidationResult.error("ammount argument must be a positive number");
-                }
-                return ValidationResult.success();
-            });
 ...
 ```
 
+### Custom Validators
+
+You can also create custom validators by implementing the `com.hypixel.hytale.codec.validation.Validator` interface. The interfaces forces you to implement the `accept` and `updateSchema` method. The `accept` method takes in the argument value and validates it. If the validation fails, you can use the `fail` method of the `com.hypixel.hytale.codec.validation.ValidationResults` class to return an error message.
+The `updateSchema` method is used to update the schema of the command argument. This is used for commands that have dynamic schemas based on the input value. For example, if you have a command that takes in a player name as an argument, you can use the `updateSchema` method to update the schema to include a list of online players for validation.
+
+Here is an example of a custom validator that checks if a string value is equal to a banned word. In this example, the banned word is "badword". If the input value is "badword", the validator will fail and return an error message.
+
+```java
+import com.hypixel.hytale.codec.schema.SchemaContext;
+import com.hypixel.hytale.codec.schema.config.Schema;
+import com.hypixel.hytale.codec.validation.ValidationResults;
+import com.hypixel.hytale.codec.validation.Validator;
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+
+public class MyCustomValidator implements Validator<String> {
+    @Nonnull
+    private final String value;
+
+    public MyCustomValidator(@Nonnull String value) {
+        this.value = value;
+    }
+
+    @Override
+    public void accept(@Nullable String input, @Nonnull ValidationResults results) {
+        if (this.value.equalsIgnoreCase(input)) {
+            results.fail("The given role has been banned.");
+        }
+    }
+
+    @Override
+    public void updateSchema(SchemaContext context, @Nonnull Schema target) {
+        // This method can be used to update the schema of the command argument. This is useful for commands that have dynamic schemas based on the input value. For example, if you have a command that takes in a player name as an argument, you can use the `updateSchema` method to update the schema to include a list of online players for validation.
+        throw new UnsupportedOperationException("Not implemented yet.");
+    }
+}
+```
+
+After the custom validator is created, you can add it to an argument like the following example. In this example, we add the `MyCustomValidator` to a string argument called "role". If the user inputs "badword" as the role, the command will fail and return the error message defined in the `MyCustomValidator`.
+
+```java
+    ...
+    // Custom validator example
+    String bannedRole = "badword";
+
+    OptionalArg<String> roleArg = withOptionalArg("role", "Role to assign", ArgTypes.STRING)
+        .addValidator(new MyCustomValidator(bannedRole));
+    ...
+```
+
 ---
 
 ## Permissions
@@ -312,7 +348,7 @@ This allows the server to control who has access to specific commands. You add t
 
 If you want variants of the same command without doing argument parsing you can instead use `addUsageVariant(new OtherCommandClass())` in the original commands constructor.
 
-The only difference is in the `OtherCommandClass()` constrcutor you don't pass the command name to the super class.
+The only difference is in the `OtherCommandClass()` constructor you don't pass the command name to the super class.
 
 <Callout type="info">
   You can also use `addAliases("some_alias", "some_other_alias")` as a way to add shorthand or other ways to write the same command.
@@ -387,7 +423,7 @@ public class AdminCommand extends AbstractCommandCollection {
     public AdminCommand () {
         super("admin", "Admin commands");
         addSubCommand(new UserCommandCollection());
-        addSybCommand(new ServerCommandCollection);
+        addSubCommand(new ServerCommandCollection);
     }
 }
 ```
@@ -417,5 +453,5 @@ public class MyPlugin extends JavaPlugin {
 
 ## Video Link
 
-_Special Thanks to [TroubleDev](https://www.youtube.com/@TroubleDEV) for his excelent video guide on all of these features._
+_Special Thanks to [TroubleDev](https://www.youtube.com/@TroubleDEV) for his excellent video guide on all of these features._
 _Video Link: [TroubleDev - Hytale's Command API Explained](https://www.youtube.com/watch?v=KnmhG9MDMgo)_
diff --git a/content/docs/uk-UA/guides/plugin/creating-events.mdx b/content/docs/uk-UA/guides/plugin/creating-events.mdx
index 95863990..d3f0925d 100644
--- a/content/docs/uk-UA/guides/plugin/creating-events.mdx
+++ b/content/docs/uk-UA/guides/plugin/creating-events.mdx
@@ -1,6 +1,6 @@
 ---
-title: Creating Events
-description: Learn how to create custom events for your Hytale mod.
+title: Creating Events Listeners
+description: Learn how to create event listeners for your Hytale mod.
 authors:
   - name: Neil Revin
     url: https://itsneil.dev
@@ -10,7 +10,7 @@ authors:
 
 ## Event Class
 
-You can import a Event class and create a function with the Event as a argument. [Click here](../../server/events) to look at all available events.
+You can import an Event class and create a function with the Event as an argument. [Click here](../../server/events) to look at all available events.
 
 Example plugin when a player is ready (joins a server):
 
diff --git a/content/docs/uk-UA/guides/plugin/item-registry.mdx b/content/docs/uk-UA/guides/plugin/item-registry.mdx
new file mode 100644
index 00000000..9a0fd53a
--- /dev/null
+++ b/content/docs/uk-UA/guides/plugin/item-registry.mdx
@@ -0,0 +1,95 @@
+---
+title: Working with the Item Registry
+description: Learn how to access and query the game's item registry to list all items, check if items exist, and retrieve item properties.
+authors:
+  - name: Denis
+---
+
+In this guide, you'll learn how to work with Hytale's Item Registry system. This is useful when you need to programmatically list all available items, validate item IDs, or retrieve item properties at runtime.
+
+## Prerequisites
+
+Before diving in, you should be familiar with:
+
+- [Setting up your development environment](./setting-up-env)
+- [Creating commands](./creating-commands) (optional, for testing)
+
+## Required Imports
+
+To work with the Item Registry, you'll need the following imports:
+
+```java
+import com.hypixel.hytale.assetstore.map.DefaultAssetMap;
+import com.hypixel.hytale.server.core.asset.type.item.config.Item;
+```
+
+## Getting the Item Registry
+
+The Item Registry is accessed through the `Item.getAssetMap()` method, which returns a `DefaultAssetMap<String, Item>` containing all registered items in the game:
+
+```java
+DefaultAssetMap<String, Item> itemMap = Item.getAssetMap();
+```
+
+## Listing All Items
+
+To iterate through all items in the registry, you can get the underlying map and loop through its entries:
+
+```java
+DefaultAssetMap<String, Item> itemMap = Item.getAssetMap();
+var map = itemMap.getAssetMap();
+
+for (var entry : map.entrySet()) {
+    String itemId = String.valueOf(entry.getKey());
+    Item item = entry.getValue();
+    
+    // Do something with the item
+    LOGGER.atInfo().log("Item ID: " + itemId);
+}
+```
+
+You can also get the total count of registered items:
+
+```java
+int totalItems = map.size();
+```
+
+## Checking if an Item Exists
+
+To check if a specific item exists in the registry, use `getAsset()` and verify the result:
+
+```java
+public boolean itemExists(String itemId) {
+    var assetMap = Item.getAssetMap();
+    if (assetMap != null) {
+        Item item = assetMap.getAsset(itemId);
+        return item != null && item != Item.UNKNOWN;
+    }
+    return false;
+}
+```
+
+<Callout type="info">
+  The `Item.UNKNOWN` constant represents an invalid or unrecognized item. Always check for both `null` and `Item.UNKNOWN` when validating items.
+</Callout>
+
+## Accessing Item Properties
+
+Once you have an `Item` instance, you can access various properties:
+
+```java
+var assetMap = Item.getAssetMap();
+Item item = assetMap.getAsset("Soil_Grass");
+
+if (item != null && item != Item.UNKNOWN) {
+    String id = item.getId(); // Soil_Grass
+    int maxStack = item.getMaxStack(); // 100
+    boolean isBlock = item.hasBlockType(); // true
+    boolean isConsumable = item.isConsumable(); // false
+}
+```
+
+## Related Guides
+
+- [Inventory Management](./inventory-management) - Learn how to add and remove items from player inventories
+- [Create Custom Item and Interaction](./item-interaction) - Learn how to create your own custom items
diff --git a/content/docs/uk-UA/guides/plugin/permission-management.mdx b/content/docs/uk-UA/guides/plugin/permission-management.mdx
index 6b7cfd46..55f06101 100644
--- a/content/docs/uk-UA/guides/plugin/permission-management.mdx
+++ b/content/docs/uk-UA/guides/plugin/permission-management.mdx
@@ -10,132 +10,569 @@ authors:
     link: https://discord.com/users/292656109939064833
   - name: Ivan
     link: https://discord.com/users/505770451218333717
+  - name: ZenithDevHQ
+    link: https://github.com/ZenithDevHQ
 ---
 
-In this guide, you'll learn how to manage permission nodes and groups in your Hytale plugin.
+In this guide, you'll learn how to manage permission nodes and groups in your Hytale plugin. Permissions control what actions players can perform on your server, from basic commands to advanced administrative functions.
 
-## The `PermissionsModule` class
+## What Are Permissions?
 
-The `PermissionsModule` class is responsible for managing permission nodes and groups in your plugin. It provides methods to check, grant and revoke permissions and groups for players. It allows the following operations
+Permissions are string identifiers that control access to features and commands. When a player tries to perform an action (like using a command), the server checks if they have the required permission.
 
-- Add permissions to user
-- Remove permissions from user
-- Add permissions to group (this also creates the group if it doesn't exist)
-- Remove permissions from group
-- Add user to group
-- Remove user from group
-- List all groups for a user
-- Check if a user has a permission (it checks both user and group permissions for the given player UUID)
+**Example permission nodes:**
 
-With this class you cannot:
+- `hytale.command.gamemode` - Permission to use the gamemode command
+- `hytale.editor.brush.use` - Permission to use brush tools
+- `myplugin.teleport.home` - A custom permission for your plugin
 
-- List all defined groups
-- Remove a group
+Permissions follow a hierarchical naming pattern: `namespace.category.action`
 
-### Adding Permission Nodes
+## Key Concepts
 
-You need a `Set<String>` containing all the permission nodes you want to add, these are added on top of the already existing permission nodes the user may have, it is not a replacement.
+Before diving into code, let's understand the core concepts:
+
+| Concept             | Description                                                                |
+| ------------------- | -------------------------------------------------------------------------- |
+| **Permission Node** | A string like `myplugin.feature.use` that represents a specific permission |
+| **Group**           | A named collection of permissions (e.g., "Admin", "VIP", "Default")        |
+| **Provider**        | The backend that stores and retrieves permissions                          |
+| **Wildcard**        | A pattern like `*` or `myplugin.*` that matches multiple permissions       |
+
+### How Permissions Are Checked
+
+When checking if a player has a permission, Hytale follows this order:
+
+1. **User's direct permissions** - Permissions granted directly to the player
+2. **Group permissions** - Permissions from groups the player belongs to
+3. **Virtual groups** - Game-mode-based permissions (e.g., Creative mode grants builder tools)
+4. **Default value** - Falls back to `false` if no match found
+
+<Callout type="info">
+  The first definitive match wins. If a player has a permission granted at the user level, group permissions won't override it.
+</Callout>
+
+---
+
+## The `PermissionsModule` Class
+
+The `PermissionsModule` class is the central hub for managing permissions. Access it using the singleton pattern:
 
 ```java
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.addUserPermission(playerUUID, permissions);
 ```
 
-### Removing Permission Nodes
+### Available Operations
+
+The module supports these operations:
+
+| Operation                     | Method                                          |
+| ----------------------------- | ----------------------------------------------- |
+| Add permissions to user       | `addUserPermission(uuid, permissions)`          |
+| Remove permissions from user  | `removeUserPermission(uuid, permissions)`       |
+| Add permissions to group      | `addGroupPermission(groupName, permissions)`    |
+| Remove permissions from group | `removeGroupPermission(groupName, permissions)` |
+| Add user to group             | `addUserToGroup(uuid, groupName)`               |
+| Remove user from group        | `removeUserFromGroup(uuid, groupName)`          |
+| Get user's groups             | `getGroupsForUser(uuid)`                        |
+| Check permission              | `hasPermission(uuid, permissionNode)`           |
+
+<Callout type="warning">
+  The module does **not** support:
+
+  - Listing all defined groups
+  - Deleting a group entirely
+
+  Groups are implicitly created when you first add permissions to them.
+</Callout>
+
+---
 
-Same as above, we just use the `removeUserPermission` method instead to remove permission nodes.
+## Checking Permissions
+
+The most common operation is checking if a player has a permission.
+
+### Basic Permission Check
+
+```java
+// Returns true if player has the permission, false otherwise
+boolean canUse = PermissionsModule.get().hasPermission(playerUUID, "myplugin.feature.use");
+
+if (canUse) {
+    // Player has permission, allow the action
+} else {
+    // Player lacks permission, deny or show error
+}
+```
+
+### Permission Check with Default Value
+
+You can specify what to return when no permission is explicitly set:
+
+```java
+// Returns true by default if no explicit permission is found
+boolean canUse = PermissionsModule.get().hasPermission(playerUUID, "myplugin.feature.use", true);
+```
+
+This is useful for features that should be enabled by default but can be revoked.
+
+### Using PermissionHolder Interface
+
+Players and command senders implement `PermissionHolder`, allowing direct checks:
+
+```java
+// In a command or event handler where you have access to the player
+if (player.hasPermission("myplugin.admin.manage")) {
+    // Player has admin permission
+}
+```
+
+---
+
+## Managing User Permissions
+
+### Adding Permissions to a User
+
+Permissions are additive - new permissions are added on top of existing ones, not replaced.
+
+```java
+PermissionsModule perms = PermissionsModule.get();
+
+// Add a single permission
+perms.addUserPermission(playerUUID, Set.of("myplugin.vip.chat"));
+
+// Add multiple permissions at once
+Set<String> newPerms = Set.of(
+    "myplugin.vip.chat",
+    "myplugin.vip.fly",
+    "myplugin.vip.kit"
+);
+perms.addUserPermission(playerUUID, newPerms);
+```
+
+### Removing Permissions from a User
 
 ```java
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.removeUserPermission(playerUUID, permissions);
+
+// Remove specific permissions
+Set<String> toRemove = Set.of("myplugin.vip.fly");
+perms.removeUserPermission(playerUUID, toRemove);
 ```
 
-### Add permissions to group
+---
+
+## Managing Groups
+
+Groups let you assign a collection of permissions to multiple players. This is more manageable than assigning permissions individually.
+
+### Adding Permissions to a Group
+
+If the group doesn't exist, it will be created automatically.
 
 ```java
-String groupName = "testGroup";
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.addGroupPermission(groupName, permissions);
+
+// Create/update the "VIP" group with permissions
+Set<String> vipPerms = Set.of(
+    "myplugin.vip.chat",
+    "myplugin.vip.fly",
+    "myplugin.vip.kit"
+);
+perms.addGroupPermission("VIP", vipPerms);
 ```
 
-### Remove permissions from group
+### Removing Permissions from a Group
 
 ```java
-String groupName = "testGroup";
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.removeGroupPermission(groupName, permissions);
+
+// Remove specific permissions from the group
+Set<String> toRemove = Set.of("myplugin.vip.fly");
+perms.removeGroupPermission("VIP", toRemove);
 ```
 
-### Add user to group
+### Adding a User to a Group
 
 ```java
-String groupName = "testGroup";
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.addUserToGroup(playerUUID, groupName);
+
+// Add player to the VIP group - they now have all VIP permissions
+perms.addUserToGroup(playerUUID, "VIP");
 ```
 
-### Remove user from group
+### Removing a User from a Group
 
 ```java
-String groupName = "testGroup";
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.removeUserFromGroup(playerUUID, groupName);
+
+// Remove player from VIP group
+perms.removeUserFromGroup(playerUUID, "VIP");
 ```
 
-### List all groups for a user
+### Getting a User's Groups
 
 ```java
 PermissionsModule perms = PermissionsModule.get();
-perms.getGroupsForUser(playerUUID);
+
+// Get all groups the player belongs to
+Set<String> groups = perms.getGroupsForUser(playerUUID);
+
+for (String group : groups) {
+    System.out.println("Player is in group: " + group);
+}
 ```
 
-### Check Permission Nodes
+---
+
+## Built-in Groups
+
+Hytale includes two default groups:
+
+| Group     | Default Permissions   | Purpose                           |
+| --------- | --------------------- | --------------------------------- |
+| `OP`      | `*` (all permissions) | Server operators with full access |
+| `Default` | None                  | Base group for all players        |
+
+Players without any explicit group assignment are automatically part of the `Default` group.
 
-To check if a player has a specific permission node, you can use the `hasPermission` method.
+---
+
+## Wildcards
+
+Wildcards let you grant or deny multiple permissions with a single pattern.
+
+### Wildcard Patterns
+
+| Pattern             | Meaning                                          |
+| ------------------- | ------------------------------------------------ |
+| `*`                 | Grants **all** permissions                       |
+| `myplugin.*`        | Grants all permissions starting with `myplugin.` |
+| `-*`                | Denies **all** permissions                       |
+| `-myplugin.admin.*` | Denies all admin permissions in your plugin      |
+
+### Example: Admin Group with Wildcards
 
 ```java
-boolean hasPermission = PermissionsModule.hasPermission(playerUUID, "permission.node");
+// Grant all permissions to admins
+perms.addGroupPermission("Admin", Set.of("*"));
+
+// Grant all plugin permissions to moderators
+perms.addGroupPermission("Moderator", Set.of("myplugin.*"));
+
+// Grant all permissions except admin commands
+perms.addGroupPermission("Helper", Set.of(
+    "*",
+    "-myplugin.admin.*"  // Deny admin permissions
+));
 ```
 
-## Additional: Defining your own provider for permissions and groups
+<Callout type="warning">
+  Negation permissions (starting with `-`) take precedence at each level. Use them carefully to avoid accidentally blocking permissions.
+</Callout>
+
+---
+
+## Built-in Permission Nodes
+
+Hytale provides constants for common permissions in the `HytalePermissions` class:
+
+### Command Permissions
+
+```java
+// Generate permission for a command
+String perm = HytalePermissions.fromCommand("gamemode");
+// Result: "hytale.command.gamemode"
+
+// Generate permission for a subcommand
+String perm = HytalePermissions.fromCommand("gamemode", "creative");
+// Result: "hytale.command.gamemode.creative"
+```
+
+### Common Permission Nodes
+
+| Permission                    | Description                  |
+| ----------------------------- | ---------------------------- |
+| `hytale.command.op.add`       | Add players to OP group      |
+| `hytale.command.op.remove`    | Remove players from OP group |
+| `hytale.editor.brush.use`     | Use brush tools              |
+| `hytale.editor.prefab.use`    | Use prefabs                  |
+| `hytale.editor.selection.use` | Use selection tools          |
+| `hytale.editor.history`       | Undo/redo operations         |
+| `hytale.camera.flycam`        | Use fly camera mode          |
+
+---
+
+## Listening to Permission Events
+
+You can react to permission changes using Hytale's event system.
+
+### Available Events
+
+| Event                                            | Triggered When                   |
+| ------------------------------------------------ | -------------------------------- |
+| `PlayerPermissionChangeEvent.PermissionsAdded`   | Permissions added to a user      |
+| `PlayerPermissionChangeEvent.PermissionsRemoved` | Permissions removed from a user  |
+| `PlayerGroupEvent.Added`                         | User added to a group            |
+| `PlayerGroupEvent.Removed`                       | User removed from a group        |
+| `GroupPermissionChangeEvent.Added`               | Permissions added to a group     |
+| `GroupPermissionChangeEvent.Removed`             | Permissions removed from a group |
 
-The PermissionsModule also enables us to define our own PermissionProvider's, this can be useful for:
+### Example: Reacting to Permission Changes
 
-- Cross server permission systems
-- Implementing features missing in the `HytalePermissionsProvider` like permission expiry
+```java
+public class PermissionListener {
+
+    public static void onPermissionsAdded(PlayerPermissionChangeEvent.PermissionsAdded event) {
+        UUID playerUUID = event.getPlayerUuid();
+        Set<String> added = event.getAddedPermissions();
+
+        System.out.println("Permissions added to " + playerUUID + ": " + added);
 
-To implement our PermissionProvider, first we need to define a provider class that implements PermissionProvider:
+        // Maybe notify the player or update cached data
+    }
+
+    public static void onGroupAdded(PlayerGroupEvent.Added event) {
+        UUID playerUUID = event.getPlayerUuid();
+        String groupName = event.getGroupName();
+
+        System.out.println("Player " + playerUUID + " joined group: " + groupName);
+    }
+}
+```
+
+### Registering the Events
 
 ```java
-public class DatabasePermissionProvider implements PermissionProvider
+public class MyPlugin extends JavaPlugin {
+
+    @Override
+    public void setup() {
+        EventRegistry events = this.getEventRegistry();
+
+        events.registerGlobal(
+            PlayerPermissionChangeEvent.PermissionsAdded.class,
+            PermissionListener::onPermissionsAdded
+        );
+
+        events.registerGlobal(
+            PlayerGroupEvent.Added.class,
+            PermissionListener::onGroupAdded
+        );
+    }
+}
 ```
 
-Then we just implement the required methods using a database implementation.
+---
+
+## Creating a Custom Permission Provider
+
+For advanced use cases, you can create your own permission provider. This is useful for:
+
+- Database-backed permissions (MySQL, MongoDB, etc.)
+- Cross-server permission synchronization
+- Custom features like permission expiry or contexts
+
+### Implementing PermissionProvider
+
+```java
+public class DatabasePermissionProvider implements PermissionProvider {
+
+    @Nonnull
+    @Override
+    public String getName() {
+        return "DatabasePermissionProvider";
+    }
+
+    // User permission methods
+    @Override
+    public void addUserPermissions(@Nonnull UUID uuid, @Nonnull Set<String> permissions) {
+        // Save to your database
+    }
+
+    @Override
+    public void removeUserPermissions(@Nonnull UUID uuid, @Nonnull Set<String> permissions) {
+        // Remove from your database
+    }
+
+    @Override
+    public Set<String> getUserPermissions(@Nonnull UUID uuid) {
+        // Query your database
+        return Set.of();
+    }
+
+    // Group permission methods
+    @Override
+    public void addGroupPermissions(@Nonnull String group, @Nonnull Set<String> permissions) {
+        // Save to your database
+    }
+
+    @Override
+    public void removeGroupPermissions(@Nonnull String group, @Nonnull Set<String> permissions) {
+        // Remove from your database
+    }
+
+    @Override
+    public Set<String> getGroupPermissions(@Nonnull String group) {
+        // Query your database
+        return Set.of();
+    }
+
+    // User-group membership methods
+    @Override
+    public void addUserToGroup(@Nonnull UUID uuid, @Nonnull String group) {
+        // Save to your database
+    }
+
+    @Override
+    public void removeUserFromGroup(@Nonnull UUID uuid, @Nonnull String group) {
+        // Remove from your database
+    }
+
+    @Override
+    public Set<String> getGroupsForUser(@Nonnull UUID uuid) {
+        // Query your database
+        return Set.of("Default");
+    }
+}
+```
 
 <Callout type="warning">
-  Hytale will try to use the first available permissions provider to add/remove gamemode groups (i.e. `Creative`, `Adventure`).
+  Hytale automatically assigns players to game-mode groups (like `Creative` or `Adventure`) using the first available provider.
+
+  If your provider throws an error when the group doesn't exist, the player will be disconnected! Always handle missing groups gracefully.
+</Callout>
+
+### Registering Your Provider
 
-  If your provider throws an error (for instance, if the group does not exist) when the server is preparing the player, the player will be disconnected.
+```java
+public class MyPlugin extends JavaPlugin {
+
+    @Override
+    public void setup() {
+        // Add your provider alongside the default one
+        PermissionsModule.get().addProvider(new DatabasePermissionProvider());
+    }
+}
+```
+
+The `PermissionsModule` aggregates permissions from all registered providers. This means:
+
+- Permission checks query all providers
+- Write operations (add/remove) use the **first** provider
+
+### Replacing the Default Provider
+
+If you want full control, you can remove the default provider:
+
+```java
+public class MyPlugin extends JavaPlugin {
+
+    @Override
+    public void setup() {
+        PermissionsModule perms = PermissionsModule.get();
+
+        // Remove the default provider FIRST
+        perms.removeProvider(perms.getFirstPermissionProvider());
+
+        // Then add your provider
+        perms.addProvider(new DatabasePermissionProvider());
+    }
+}
+```
+
+<Callout type="info">
+  When you remove the default provider, the `/op self` command will stop working since it checks for provider tampering.
 </Callout>
 
-We can then register the provider using the built-in permission module:
+---
+
+## Best Practices
+
+### Permission Naming Conventions
+
+Follow the pattern: `namespace.category.action`
 
 ```java
-PermissionsModule.get().addProvider(new DatabasePermissionProvider());
+// Good - clear hierarchy
+"myplugin.admin.ban"
+"myplugin.user.teleport.home"
+"myplugin.vip.chat.color"
+
+// Bad - unclear structure
+"myplugin_ban"
+"teleport"
+"vipChatColor"
 ```
 
-Please note that the `HytalePermissionsProvider` will still be enabled alongside your provider.
-The `PermissionsModule` will aggregate groups and permissions from all available providers.
+### Use Constants for Permissions
 
-If you want to disable the default `HytalePermissionsProvider`, you can use:
+Define your permissions as constants to avoid typos:
 
 ```java
-// put this **before** you add your provider
-PermissionsModule.get().removeProvider(PermissionsModule.get().getFirstPermissionProvider());
+public final class MyPermissions {
+    public static final String ADMIN_BAN = "myplugin.admin.ban";
+    public static final String ADMIN_KICK = "myplugin.admin.kick";
+    public static final String USER_HOME = "myplugin.user.home";
+    public static final String VIP_FLY = "myplugin.vip.fly";
+}
+
+// Usage
+if (player.hasPermission(MyPermissions.ADMIN_BAN)) {
+    // ...
+}
 ```
+
+### Don't Over-Permission
+
+Only create permissions for actions that genuinely need access control. Not everything needs a permission check.
+
+### Thread Safety
+
+If you create a custom provider, ensure it's thread-safe. Permission checks can occur from multiple threads simultaneously. Use `ReadWriteLock` or `ConcurrentHashMap` for your data structures.
+
+---
+
+## In-Game Commands
+
+Hytale provides built-in commands for managing permissions:
+
+### `/op` Command
+
+| Command               | Description                                                        |
+| --------------------- | ------------------------------------------------------------------ |
+| `/op self`            | Toggle your own OP status (singleplayer or with `--allow-op` flag) |
+| `/op add <player>`    | Add a player to the OP group                                       |
+| `/op remove <player>` | Remove a player from the OP group                                  |
+
+### `/perm` Command
+
+Use `/perm --help` in-game for full usage. Common operations:
+
+| Command                                  | Description                   |
+| ---------------------------------------- | ----------------------------- |
+| `/perm user list <uuid>`                 | List user's permissions       |
+| `/perm user add <uuid> <perm>`           | Add permission to user        |
+| `/perm user remove <uuid> <perm>`        | Remove permission from user   |
+| `/perm user group list <uuid>`           | List user's groups            |
+| `/perm user group add <uuid> <group>`    | Add user to group             |
+| `/perm user group remove <uuid> <group>` | Remove user from group        |
+| `/perm group list <group>`               | List group's permissions      |
+| `/perm group add <group> <perm>`         | Add permission to group       |
+| `/perm group remove <group> <perm>`      | Remove permission from group  |
+| `/perm test <perm>`                      | Test if you have a permission |
+
+---
+
+## Summary
+
+You've learned how to:
+
+- **Check permissions** using `PermissionsModule.hasPermission()`
+- **Manage user permissions** with `addUserPermission()` and `removeUserPermission()`
+- **Work with groups** using `addGroupPermission()`, `addUserToGroup()`, etc.
+- **Use wildcards** like `*` and `myplugin.*` for bulk permissions
+- **Listen to events** for permission changes
+- **Create custom providers** for database-backed permissions
+
+For more advanced permission systems with features like inheritance, expiry, and contexts, we're looking into expanding this guide with advanced permission management techniques in the future.
diff --git a/content/docs/uk-UA/guides/plugin/setting-up-env.mdx b/content/docs/uk-UA/guides/plugin/setting-up-env.mdx
index 52b99e7e..0c851788 100644
--- a/content/docs/uk-UA/guides/plugin/setting-up-env.mdx
+++ b/content/docs/uk-UA/guides/plugin/setting-up-env.mdx
@@ -4,6 +4,10 @@ description: Learn how to set up your development environment for modding Hytale
 authors:
   - name: Neil Revin
     link: https://itsneil.dev
+  - name: Marcel-TO
+    url: https://marcel-to.net
+  - name: Ádám Liszkai
+    link: https://adaliszk.dev
 ---
 
 This guide will walk you through setting up a complete development environment for Hytale modding, including all necessary tools and dependencies.
@@ -19,24 +23,73 @@ Before we begin, make sure you have:
 
 ## Required Software
 
-### 1. Java Development Kit (JDK)
+### Integrated Development Environment (IDE)
 
+We recommend IntelliJ IDEA Community Edition for Hytale modding. If you use IntelliJ IDEA, **almost everything is built-in**. You can clone a template, open a new project, and start working right away!
+
+1. Download from [JetBrains website](https://www.jetbrains.com/idea/download/)
+2. Install with default settings
+3. Launch and complete the initial setup wizard
+
+When opening a project, wait for indexing to finish, then start coding.
+Now, IDEA may say "No JDK configured" at the top of the source file you have.
+In that case, you can click Download JDK and choose JetBrains JDK 25.
+
+<Callout type="success">
+  If IDEA opened the project without errors, your environment is ready.
+</Callout>
+
+More details by [JetBrains](https://www.jetbrains.com/help/idea/2026.1/run-for-the-first-time.html)
+help page, where we recommend that you also check the
+[SDK configuration](https://www.jetbrains.com/help/idea/2026.1/sdk.html) guide.
+
+<Callout type="info">
+  We recommened following
+  [TheNullicorn's](https://gist.github.com/TheNullicorn/90a619796c40f20ae1fcf13094c1a57d) guide to ensure
+  you are using the correct `Nonnull` in your projects.
+</Callout>
+
+#### What the IDE Does for You
+
+When opened in IntelliJ IDEA, the project automatically:
+
+- Detects and configures Gradle or Maven
+- Downloads all dependencies
+- Sets up project structure and classpaths
+- Configures run/build tasks
+
+You do **not** need to manually install or configure Maven or Gradle if you stay inside the IDE.
+
+Skip to the [Setting Up Your Workspace](#setting-up-your-workspace).
+
+### Manual Setup: Java Development Kit (JDK)
+
+For any other setup, you will need to install and configure your system to have and load Java.
 Hytale modding requires Java 25 or later. We recommend using OpenJDK.
 
-#### Windows
+#### Windows via Installer
 
 1. Download OpenJDK 25 from [Adoptium](https://adoptium.net/)
 2. Run the installer with default settings
+   - Optionally enable feature `Set or Override JAVA_HOME variable` to resolve version related build issues with your project.
 3. Verify installation by opening Command Prompt and running:
 
+#### Windows via Scoop
+
+1. Install Scoop via PowerShell using [scoop.sh](https://scoop.sh/)
+2. Install OpenJDK 25:
+
 ```bash
-java -version
+scoop bucket add java
+scoop install java/openjdk25
 ```
 
 #### macOS
 
+1. Install Brew via Terminal using [brew.sh](https://brew.sh)
+2. Install JDK via Homebrew:
+
 ```bash
-# Using Homebrew
 brew install openjdk@25
 ```
 
@@ -51,22 +104,41 @@ brew install openjdk@25
 
 #### Linux (Ubuntu/Debian)
 
+1. Install JDK via the built-in package repository:
+
 ```bash
 sudo apt update
 sudo apt install openjdk-25-jdk
 ```
 
-### 2. Integrated Development Environment (IDE)
+### Verify installation:
 
-We recommend IntelliJ IDEA Community Edition for Hytale modding.
+Run the following command to see what version of Java you have:
 
-1. Download from [JetBrains website](https://www.jetbrains.com/idea/download/)
-2. Install with default settings
-3. Launch and complete the initial setup wizard
+```bash
+java -version
+```
+
+### Java Build Tool (Optional)
+
+We recommend using a Gradle Wrapper for managing dependencies and building your Hytale plugins. It provides benefits by eliminating the need for a system-wide Gradle installation and ensuring consistent Gradle versions across different environments. (Alternatively you can use Maven, but this guide focuses on Gradle since it is the default for our plugin template.)
+
+The plugin template in the following sections includes a Gradle Wrapper, so you can skip this step if you plan to use the template.
+
+#### Choosing Gradle (if not using the template)
+
+If you prefer to install Gradle manually, follow these steps:
 
-### 3) Java Build Tool
+1. Visit the official website: https://gradle.org/releases/
+2. Download the newest gradle binary: `gradle-9.3.1-bin.zip` (Binary zip archive)
+3. Unzip it
+4. Add the `gradle-9.3.1/bin/` folder to your PATH
+
+You can now try the command `gradle -version` to verify Gradle is installed correctly. Make sure to do this in a fresh new terminal instead of one you had opened from before!
+
+#### Choosing Maven (if not using the template)
 
-We recommend using Apache Maven for managing dependencies and building your Hytale plugins. (Alternatively you can use Gradle, but this guide focuses on Maven.)
+If you prefer to use Maven instead of Gradle, follow these steps to install Maven:
 
 1. Visit the official website: https://maven.apache.org/download.cgi
 2. Download this file: `apache-maven-3.9.12-bin.zip` (Binary zip archive)
@@ -89,22 +161,61 @@ cd MyFirstMod
 
 If you don't have Git installed, you can download the ZIP file from the repository page and extract it to a folder named `MyFirstMod`.
 
-### 2. Open Plugin in your IDEA
+### 2. Open Plugin in your IDE
 
-1. Open IntelliJ IDEA
+1. Open Your IDE (e.g., IntelliJ IDEA)
 2. Click "Open" and navigate to your `MyFirstMod` directory
-3. IntelliJ will automatically detect it as a Maven project
+3. Most IDEs like IntelliJ will automatically detect it as a Gradle project
 4. Wait for the project to index and dependencies to download
 
-<Callout type="info">
-  We recommened following [this](https://gist.github.com/TheNullicorn/90a619796c40f20ae1fcf13094c1a57d) guide to ensure you are using the correct `Nonnull` in your projects.
-</Callout>
+## Alternate Approach: Hytale Dependency
+
+If you prefer to set up your project from scratch without using the template and importing the hytale dependencies manually, ensure your build configuration includes the Hytale repositories and dependencies:
+
+For Gradle, add the following to your `build.gradle.kts`:
+
+```kotlin
+repositories {
+    mavenCentral()
+    maven {
+        name = "hytale"
+        url = uri("https://maven.hytale.com/release") // Or "hytale-pre-release" for pre-release versions
+    }
+}
+dependencies {
+    // + here means the latest version, but you can hard-wire any known version!
+    implementation("com.hypixel.hytale:Server:+")
+}
+```
+
+For Maven, add the following to your `pom.xml`:
+
+```xml
+<project>
+    <repositories>
+        <repository>
+            <id>hytale-release</id> <!-- Or "hytale-pre-release" for pre-release versions -->
+            <url>https://maven.hytale.com/release</url> <!-- Or "https://maven.hytale.com/pre-release" -->
+        </repository>
+    </repositories>
+
+    <dependencies>
+        <dependency>
+            <groupId>com.hypixel.hytale</groupId>
+            <artifactId>Server</artifactId>
+            <!-- Replace with latest version, Hytale provides jars for the last five releases -->
+            <version>LATEST_VERSION_HERE</version>
+            <scope>provided</scope>
+        </dependency>
+    </dependencies>
+</project>
+```
 
 ## Next Steps
 
 Now that you have your development environment set up with the plugin template:
 
-1. **Customize the template** - Edit the `pom.xml` and `manifest.json` file to change your mod's name and details
+1. **Customize the template** - Edit the `settings.gradle.kts`, `build.gradle.kts` and `manifest.json` file to change your mod's name and details
 2. **Explore the code structure** - Familiarize yourself with the template's organization
 3. **Start modding** - Begin writing your first Hytale plugin!
 
diff --git a/content/docs/uk-UA/guides/plugin/spawning-entities.mdx b/content/docs/uk-UA/guides/plugin/spawning-entities.mdx
index e12c0aea..15be2fb3 100644
--- a/content/docs/uk-UA/guides/plugin/spawning-entities.mdx
+++ b/content/docs/uk-UA/guides/plugin/spawning-entities.mdx
@@ -36,7 +36,7 @@ Store<EntityStore> store = world.getEntityStore().getStore();
 
 ## Creating Entities
 
-Once you have the `EntityStore` instance, you can start to create a entity and give it components. Entities are just instances of `Holder<EntityStore>` with several components attached to them.
+Once you have the `EntityStore` instance, you can start to create an entity and give it components. Entities are just instances of `Holder<EntityStore>` with several components attached to them.
 
 <Callout type="warning">
   To interact with the `World` instance, some methods require you to run the code inside the world's execution context.
@@ -118,3 +118,48 @@ Finally, we can add the entity to the world by calling the `addEntity` method on
 ```java
 store.addEntity(holder, AddReason.SPAWN);
 ```
+
+## Making the entity persist
+
+Hytale automatically saves all entities, but the `NetworkId` component (required for players to be able to see the entity) needs to be manually added every time the entity is loaded.
+
+### Using a system
+
+If you have a component that is unique to your entities, this can be done by creating and registering a custom system as follows:
+
+```java
+public class AddNetworkIdToMyEntitySystem extends HolderSystem<EntityStore> {
+    private final ComponentType<EntityStore, MyEntityComponent> myEntityComponentType = MyEntityComponent.getComponentType();
+    private final ComponentType<EntityStore, NetworkId> networkIdComponentType = NetworkId.getComponentType();
+    private final Query<EntityStore> query = Query.and(this.myEntityComponentType, Query.not(this.networkIdComponentType));
+
+    @Override
+    public void onEntityAdd(@NotNull Holder<EntityStore> holder, @NotNull AddReason reason, @NotNull Store<EntityStore> store) {
+        if (!holder.getArchetype().contains(NetworkId.getComponentType())) {
+            holder.addComponent(NetworkId.getComponentType(), new NetworkId(store.getExternalData().takeNextNetworkId()));
+        }
+    }
+
+    @Override
+    public void onEntityRemoved(@NotNull Holder<EntityStore> holder, @NotNull RemoveReason reason, @NotNull Store<EntityStore> store) {}
+
+    @Override
+    public @Nullable Query<EntityStore> getQuery() {
+        return query;
+    }
+}
+```
+
+In your plugin's `setup()` function
+
+```java
+this.getEntityStoreRegistry().registerSystem(new AddNetworkIdToMyEntitySystem())
+```
+
+### Using PropComponent
+
+Alternatively you can add `PropComponent` to your entity. Hytale adds `PropComponent` to entities spawned with the Entity Tool, and such entities automatically get `NetworkId` and `PrefabCopyableComponent` (which makes the entity work with prefabs).
+
+<Callout type="warning">
+  There is no guarantee, that Hytale will not add some other behavior to this component in the future, which may break your entity, so be careful if you decide to rely on it.
+</Callout>
diff --git a/content/docs/uk-UA/guides/plugin/store-persistent-data.mdx b/content/docs/uk-UA/guides/plugin/store-persistent-data.mdx
new file mode 100644
index 00000000..1071dff3
--- /dev/null
+++ b/content/docs/uk-UA/guides/plugin/store-persistent-data.mdx
@@ -0,0 +1,171 @@
+---
+title: Storing Persistent Data on the Player
+description: Learn how to save and load persistent data using Components
+authors:
+  - name: Neil Revin
+    url: https://itsneil.dev/
+  - name: ArcticDev
+    url: https://github.com/ArcticRaven
+  - name: oskarscot
+    url: https://oskar.scot
+  - name: JammingEng
+    url: https://github.com/JammingEnd
+---
+
+Here is how to store persistent data using a custom component on a Player.
+
+## Build your Component Class
+
+Creating a custom component class leverages the Component system made with the ECS architecture in mind. For more information on Components, check out the [ECS Guide](../ecs/hytale-ecs-theory#components).
+
+Start by creating your custom component class. This will be extremely similar to how regular components are created, however we'll setup a custom Codec so the server can translate this data to BSON, or the server's internal json encoder.
+
+<Callout type="info">
+  Each variable you want to store in your component must have its own Codec field defined in the BuilderCodec.
+  For more information on how to create custom Codecs, check out the [ECS Codec Guide](../ecs/hytale-ecs-theory#codec).
+</Callout>
+
+```java
+public class YourPlayerData implements Component<EntityStore> {
+
+    // define some vars!
+    private int someInteger;
+    private String someString;
+    private Map<String, String> someMap;
+
+    public static final BuilderCodec<YourPlayerData> CODEC =
+            BuilderCodec.builder(YourPlayerData.class, YourPlayerData::new)
+            .append(new KeyedCodec<>("SomeInteger", Codec.INTEGER),
+                    (data, value) -> data.someInteger = value, // setter
+                    data -> data.someInteger) // getter
+            .addValidator(Validators.nonNull())
+            .add()
+            .append(new KeyedCodec<>("SomeString", Codec.STRING),
+                    (data, value) -> data.someString = value, // setter
+                    data -> data.someString) // getter
+            .add()
+            .append(new KeyedCodec<>("SomeMap",
+                            new MapCodec<>(Codec.STRING, HashMap::new, false)),
+                    (data, value) -> data.someMap = value, // setter
+                    data -> data.someMap) // getter
+            .add()
+            .build();
+
+
+
+    // Getters and Setters are for the purpose of this example omitted.
+
+    // constructor
+    public YourPlayerData() {
+        this.someInteger = 0;
+        this.someString = "";
+        this.someMap = new HashMap<>();
+    }
+
+    // copy constructor for cloning
+    public YourPlayerData(YourPlayerData clone) {
+        this.someInteger = clone.someInteger;
+        this.someString = clone.someString;
+        this.someMap = clone.someMap;
+    }
+
+    @Nonnull
+    @Override
+    public Component<EntityStore> clone() {
+        return new YourPlayerData(this);
+    }
+}
+```
+
+## Register your Component
+
+Inside your main class's `setup()` method, register your new Component.
+
+```java
+public class YourPlugin extends JavaPlugin {
+
+    private ComponentType<EntityStore, YourPlayerData> yourPlayerDataComponent;
+
+    public YourPlugin(@Nonnull JavaPluginInit init) {
+        super(init);
+    }
+
+    @Override
+    protected void setup(){
+        this.yourPlayerDataComponent = this.getEntityStoreRegistry().registerComponent(
+            YourPlayerData.class,
+            "YourPlayerDataComponent",
+            YourPlayerData.CODEC
+        );
+    }
+
+    public ComponentType<EntityStore, YourPlayerData> getYourPlayerDataComponent() {
+        return this.yourPlayerDataComponent;
+    }
+}
+```
+
+## Using your Component
+
+To use your newly created component, you can add the Component to a player using the `addComponent` method, although this only adds it temporarily, meaning when the player/entity leaves the world, the component is removed. You can use `putComponent` to ensure the component persists between sessions.
+
+```java
+// You will need the Ref and Store to apply components
+private void someEntryMethod(@Nonnull Ref<EntityStore> ref, @Nonnull Store<EntityStore> store)
+{
+       // Any entity will work, for now we will use the player
+      Player player = (Player) store.getComponent(ref, Player.getComponentType());
+
+      // since we're using putComponent, it could be useful to check if it already exists on the player in case we want to update it
+     if(store.getComponent(ref, YourPlugin.instance().getYourPlayerDataComponent()) != null)
+     {
+          // here we implement logic that updates the component
+         var comp = store.getComponent(ref, YourPlugin.instance().getYourPlayerDataComponent())
+         // declare public fields or methods in the component class
+         comp.SomeString = "An Updated Field";
+     } else {
+          // Here we put the component
+          var myCustomComp = new CustomComponent();
+          // declare public fields or methods in the component class
+          myCustomComp.SomeString = "Edited String";
+
+          // putComponent allows you to insert declared objects
+          store.putComponent(ref, YourPlugin.instance().getYourPlayerDataComponent(), myCustomComp);
+     }
+}
+```
+
+## Using your Data
+
+Your component will be stored within the `Store<EntityStore>` when added to the player. In the provided example,
+we'll fetch this data off the player using the `ensureAndGetComponent()` method, which will add the component to
+the player if it does not exist with the default values.
+
+```java
+public class IncompleteCustomCommand extends AbstractPlayerCommand {
+
+    public IncompleteCustomCommand() {
+        super("nope", "don't use this command");
+    }
+
+    @Override
+    protected void execute(
+        @NonNullDecl CommandContext commandContext,
+        @NonNullDecl Store<EntityStore> store,
+        @NonNullDecl Ref<EntityStore> ref,
+        @NonNullDecl PlayerRef playerRef,
+        @NonNullDecl World world
+    ) {
+        YourPlayerData customData = store.ensureAndGetComponent(ref, YourPlugin.instance().getYourPlayerDataComponent());
+        // ensureAndGetComponent adds the component to the ref, with the default values defined inside your component.
+ 		// use your data
+    }
+}
+```
+
+And that's it! Your data will now be saved and loaded automatically with the player.
+
+Using custom components to store persistent data on players is a powerful way to maintain state across sessions.
+By following the steps outlined above, you can easily create, register, and utilize your own data structures within the Hytale ECS framework.
+This approach ensures that your data is seamlessly integrated with the game's existing systems.
+For more information about Hytale's Entity Component System visit the [Hytale ECS Theory](https://hytalemodding.dev/en/docs/guides/ecs/hytale-ecs-theory) guide.
diff --git a/content/docs/uk-UA/guides/plugin/teleporting-players.mdx b/content/docs/uk-UA/guides/plugin/teleporting-players.mdx
index 57cee77f..32ce0435 100644
--- a/content/docs/uk-UA/guides/plugin/teleporting-players.mdx
+++ b/content/docs/uk-UA/guides/plugin/teleporting-players.mdx
@@ -1,26 +1,32 @@
 ---
 title: Teleporting the player
 description: Learn how to teleport the player.
+authors:
+  - name: oskarscot
+    url: https://oskar.scot
 ---
 
-To teleport players in Hytale, you will need to get a `World` object so we can safely run the teleport on the world thread. The world thread manages all entity updates, so modifying entities off-thread can crash the server or cause inconsistent state.
-Next, we get the entity store and make a `Teleport` object.
-We add a `Teleport` component to the player’s entity reference in the entity store. This triggers the teleportation logic for that player.
+Teleporting players in Hytale works by simply attaching a `Teleport` component to a player with the desired world and transform.
+You can only trigger teleports from a world where the player is currently present.
+Teleport itself is a component but it also provides factory methods to configure the Teleport. Just as with any entity component, an EntityStore and a Ref to the EntityStore is required
+
+We can create a simple teleport utility like this:
 
 ```java
-public static void teleportPlayer(Player player, int x, int y, int z) {
-        World world = player.getWorld();
-        if (world == null) return;
-        world.execute(() -> {
-            if (player.getReference() == null) return;
-            Store<EntityStore> store = player.getReference().getStore();
-            Teleport teleport = Teleport.createForPlayer(world,
-                new Vector3d(x ,y, z), // Target position
-                new Vector3f(0, 0, 0)  // Target rotation (pitch, yaw, roll)
-            );
+public static void teleportPlayer(Ref<EntityStore> ref, Store<EntityStore> store, World targetWorld, double x, double y, double z) {                                                                                       
+    Transform transform = new Transform(x, y, z);                                                                                                                           
+    Teleport teleport = Teleport.createForPlayer(targetWorld, transform);                                                                                                   
+    store.addComponent(ref, Teleport.getComponentType(), teleport);                                                                                                         
+}  
+```
 
-            store.addComponent(player.getReference(), Teleport.getComponentType(), teleport);
-        });
+A `Transform` is a representation of a position Vector3d and rotation Vector3f which works in the following way:
 
-}
+```java
+Transform transform = new Transform(
+    new Vector3d(x, y, z),      // Position
+    new Rotation(yaw, pitch, 0) // Rotation, last value seems to always be 0
+);
+Teleport teleport = Teleport.createForPlayer(targetWorld, transform);
+store.addComponent(ref, Teleport.getComponentType(), teleport);
 ```
diff --git a/content/docs/uk-UA/guides/plugin/tracking-mod-analytics-with-hstats.mdx b/content/docs/uk-UA/guides/plugin/tracking-mod-analytics-with-hstats.mdx
new file mode 100644
index 00000000..45c022e0
--- /dev/null
+++ b/content/docs/uk-UA/guides/plugin/tracking-mod-analytics-with-hstats.mdx
@@ -0,0 +1,65 @@
+---
+title: Tracking Mod Analytics with HStats
+description: Learn how you can track Analytics for your Hytale Mod for Free using hstats.dev
+authors:
+  - name: Al3x
+    url: https://hstats.dev
+---
+
+In this guide, you will learn how to integrate HStats into your Plugin/Mod which will allow you to track how many Servers are using it along with other stats.
+
+<Callout type="info">
+  HStats is a third-party tool and is not affiliated with HytaleModding or Hypixel Studios
+</Callout>
+
+# Step 1: Register your Mod to HStats
+
+Before you touch any code, you will need to add your mod to the HStats website which will give you a UUID for your mod.
+
+- Create or Login to an Account on https://hstats.dev
+- Navigate to the dashboard page (https://hstats.dev/dashboard)
+- On the left, type in your mod's name and click "Add Mod"
+- Keep note of the UUID generated for later.
+
+# Step 2: Add the HStats Class to Your Project
+
+To keep things simple, HStats uses a single Java class file that handles everything for you.
+
+- Download / Copy the File from the GitHub page (https://github.com/hstats-dev/HStatsExamplePlugin/blob/main/src/main/java/com/al3x/HStats.java)
+- Paste into your Project. You should now have a HStats.java file somewhere in your projects directory.
+- Update the package name from com.al3x to whatever fits your project.
+
+# Step 3: Initialize HStats in your code
+
+You only need to add one line of code to your mod's setup method in your main class to start tracking.
+
+`new HStats("YOUR-MOD-UUID", "1.0.0");`
+
+Replace `YOUR-MOD-UUID` with the Mod UUID we made note of earlier and change the `1.0.0` version to whatever version your mod is currently on.
+
+Your setup method should now look something like this:
+
+```java
+@Override
+protected void setup() {
+  super.setup();
+  new HStats("c34a2b2a-afd8-4d6a-821e-7a63e12c5ea6", "1.0.0");
+}
+```
+
+# Extras
+
+Your done! Your mod should now be listed under the Mods page (https://hstats.dev/mods) as well as under your dashboard.
+
+Servers using your mod should now post updates about every minute to HStats which you can view in the Dashboard.
+
+### Embeds
+
+HStats allows you to generate an Embed Card that you can place on your CurseForge or GitHub page. This is useful for server owners to be able to see how many other servers are using your mod.
+
+- In your dashboard, scroll down to the Embed Card section.
+- Customize the appearance (Light/Dark mode, layout, etc).
+- Copy the generated URL to display your "Active Servers" and "Players Online" live on your mod's description page
+
+Heres an example of what they look like:
+![HStats Example](https://api.hstats.dev/api/embed/d52fa672-6966-47b2-b501-1a11bddebac3/card.svg?theme=light\&layout=compact\&size=md\&show_id=true\&dark=false)
diff --git a/content/docs/uk-UA/guides/plugin/world-gen.mdx b/content/docs/uk-UA/guides/plugin/world-gen.mdx
index 4c23b0c9..7b193ffd 100644
--- a/content/docs/uk-UA/guides/plugin/world-gen.mdx
+++ b/content/docs/uk-UA/guides/plugin/world-gen.mdx
@@ -100,7 +100,7 @@ Biome biome = biomeGen.generateBiomeAt(zoneResult, seed, x, z);
 
 ### Zone & Cave Integration
 
-Each zone defines it's own cave patterns:
+Each zone defines its own cave patterns:
 
 ```java
 Zone zone = /* ... */;
diff --git a/content/docs/uk-UA/guides/prefabs.mdx b/content/docs/uk-UA/guides/prefabs.mdx
index 08404b30..b1a55109 100644
--- a/content/docs/uk-UA/guides/prefabs.mdx
+++ b/content/docs/uk-UA/guides/prefabs.mdx
@@ -14,7 +14,7 @@ Prefabs are Hytale's way of creating reusable structures.
 There are a few fundamental concepts to understand about prefabs:
 
 - Users interact with prefabs via a prefab editing world.
-- Prefabs the physical structures in the game world, and are saved as JSON files.
+- Prefabs are the physical structures in the game world, and are saved as JSON files.
 
 ## How to Create a Prefab
 
diff --git a/content/docs/uk-UA/official-documentation/custom-ui/common-styling.mdx b/content/docs/uk-UA/official-documentation/custom-ui/common-styling.mdx
new file mode 100644
index 00000000..c36e3e3a
--- /dev/null
+++ b/content/docs/uk-UA/official-documentation/custom-ui/common-styling.mdx
@@ -0,0 +1,50 @@
+---
+title: Common Styling
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# Common Styling
+
+## Common UI Styling Library
+
+This document describes the shared UI components and styles defined in `Common.ui`.
+
+---
+
+### Styles
+
+We are providing some styles that can be re-used in any custom UI that, provide a cohesive UI experience with the core game UI. These styles are available in the `Common.ui` file.
+
+You can find a list of all the styles defined with live examples by running the `/ui-gallery` command ingame.
+
+<Callout type="warning">
+  This command is not available yet, but will be in a future patch.
+</Callout>
+
+![Gallery](/assets/official-documentation/ui/gallery.png)
+
+### Importing
+
+To use these styles in your UI file:
+
+```
+$Common = "Common.ui";
+
+// Then reference styles and components:
+$Common.@TextButton { @Text = "My Button"; }
+$Common.@Container { ... }
+```
+
+<Callout type="info">
+  The `Common.ui` file is at `Common/UI/Custom/Common.ui` within the Hytale pack. If your custom ui document is in a subfolder of `Common/UI/Custom/`, reference it via relative path traversal:
+
+  ```
+  $Common = "../Common.ui";
+  ```
+
+  You can find more info about paths [here](markup#path).
+</Callout>
diff --git a/content/docs/uk-UA/official-documentation/custom-ui/index.mdx b/content/docs/uk-UA/official-documentation/custom-ui/index.mdx
new file mode 100644
index 00000000..f94c4e88
--- /dev/null
+++ b/content/docs/uk-UA/official-documentation/custom-ui/index.mdx
@@ -0,0 +1,125 @@
+---
+title: Custom UI
+icon: LayoutDashboard
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# Custom UI
+
+## What is Custom UI?
+
+Custom UI is Hytale's framework for creating **custom user interfaces** controlled by the game server. Unlike the built-in Client UI (which is part of the game client and cannot be modified), Server UI allows you to create interactive screens and HUD overlays through Java plugins and asset packs.
+
+As a modder, Custom UI gives you the power to:
+
+- **Create custom interactive pages** - Shop interfaces, quest dialogs, server settings menus, admin panels
+- **Add custom HUD overlays** - Quest trackers, status displays, custom health bars, server information
+- **Design with markup** - Use `.ui` files to define reusable UI templates
+- **Handle user interactions** - Respond to button clicks, form submissions, and other events
+- **Localize your UI** - Support multiple languages using the game's translation system
+
+## How Custom UI Fits Into Hytale's UI
+
+Hytale's user interface is divided into two main categories:
+
+### Client UI (Not Moddable)
+
+Built-in interfaces controlled by the C# game client:
+
+- Main menu and settings
+- Character creation
+- Built-in HUD (health, hotbar, chat)
+- Inventory and crafting screens
+- Development tools
+
+**You cannot modify these** - they are part of the core game client.
+
+### In-Game UI (Moddable via Server)
+
+Server-controlled interfaces that you can create and customize:
+
+#### Custom Pages
+
+Full-screen interactive overlays that appear during gameplay:
+
+- Can be dismissed by the player (ESC key)
+- Capture all input (keyboard and mouse)
+- Support loading states while waiting for server responses
+- Perfect for: shops, dialogs, menus, configuration screens
+
+#### Custom HUDs
+
+Persistent overlay elements drawn on top of the game world:
+
+- Display-only (no user interaction)
+- Always visible during gameplay
+- Lightweight and non-intrusive
+- Perfect for: quest objectives, status indicators, server info panels
+
+## Architecture Overview
+
+Server UI uses a **command-based architecture**:
+
+```
+┌─────────────────────┐         ┌──────────────────────┐
+│   Java Server       │         │    C# Client         │
+│   (Your Plugin)     │         │    (Game)            │
+├─────────────────────┤         ├──────────────────────┤
+│                     │         │                      │
+│ InteractiveCustomUI │         │   CustomPage or      │
+│ Page                │         │   CustomHud          │
+│   ↓ build()         ├────────→│     ↓ Apply          │
+│ UICommandBuilder    │         │   Element Tree       │
+│   - append()        │         │     ↓ Layout         │
+│   - set()           │         │   Rendered UI        │
+│   - clear()         │         │                      │
+│                     │         │                      │
+│ ↓ handleDataEvent() │← Events │   User Interaction   │
+│   Process input     │         │   (click, type, etc) │
+│   sendUpdate()      │         │                      │
+└─────────────────────┘         └──────────────────────┘
+```
+
+**The flow:**
+
+1. Your Java code builds UI using `UICommandBuilder`
+2. Commands are sent to the client as data
+3. Client parses `.ui` markup files and creates visual elements
+4. User interacts with the UI
+5. Events are sent back to your Java code
+6. You process events and send updates back
+
+## Key Principles
+
+### Declarative, Not Imperative
+
+You don't create UI objects directly. Instead, you send **commands** that describe what you want:
+
+- "Append this button template to that container"
+- "Set this label's text to 'Hello World'"
+- "Clear all children from this list"
+
+### Asset-Driven
+
+UI structure is defined in `.ui` markup files (assets), not hardcoded in Java. This enables:
+
+- Designers to modify layouts without touching code
+- Reusable UI components
+- Consistent visual language
+
+### Event-Driven
+
+User interactions trigger events that flow back to your server code. You register event bindings and handle them in `handleDataEvent()`.
+
+### Selector-Based
+
+You target specific UI elements using **selectors:**
+
+- `#MyButton` - Element with ID "MyButton"
+- `#List[0]` - First child of element "List"
+- `#List[0] #Title` - Element with ID "Title" in the first child of element "List"
+- `#Label.TextColor` - The TextColor property of element "Label"
diff --git a/content/docs/uk-UA/official-documentation/custom-ui/layout.mdx b/content/docs/uk-UA/official-documentation/custom-ui/layout.mdx
new file mode 100644
index 00000000..0a24ca09
--- /dev/null
+++ b/content/docs/uk-UA/official-documentation/custom-ui/layout.mdx
@@ -0,0 +1,492 @@
+---
+title: Layout
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# Layout
+
+The layout system determines how UI elements are positioned and sized on screen. Understanding layout is crucial for creating well-structured, responsive interfaces.
+
+## Layout Fundamentals
+
+Every UI element has:
+
+- **Container Rectangle** - The space allocated by the parent
+- **Anchor** - How the element positions/sizes itself within the container
+- **Padding** - Inner spacing that affects child layout
+- **LayoutMode** - How the element arranges its children (if it's a container)
+
+```
+┌─────────────────────────────────────┐
+│  Container Rectangle (from parent)  │
+│  ┌───────────────────────────────┐  │
+│  │  Anchored Rectangle           │  │
+│  │  ┌─────────────────────────┐  │  │
+│  │  │ Padding                 │  │  │
+│  │  │  ┌───────────────────┐  │  │  │
+│  │  │  │  Content Area     │  │  │  │
+│  │  │  └───────────────────┘  │  │  │
+│  │  └─────────────────────────┘  │  │
+│  └───────────────────────────────┘  │
+└─────────────────────────────────────┘
+```
+
+## Anchor
+
+`Anchor` controls how an element positions and sizes itself within its container rectangle.
+
+### Fixed Size
+
+```
+Button {
+    Anchor: (Width: 200, Height: 40);
+}
+```
+
+Creates a 200×40 pixel button.
+
+### Positioning
+
+```
+Label {
+    Anchor: (Top: 10, Left: 20, Width: 100, Height: 30);
+}
+```
+
+- **Top**: 10 pixels from container's top edge
+- **Left**: 20 pixels from container's left edge
+- **Width**: 100 pixels wide
+- **Height**: 30 pixels tall
+
+### Anchoring to Edges
+
+```
+Button {
+    Anchor: (Bottom: 10, Right: 10, Width: 100, Height: 30);
+}
+```
+
+Anchors the button to the bottom-right corner, 10 pixels from each edge.
+
+### Stretching
+
+```
+Group {
+    Anchor: (Top: 0, Bottom: 0, Left: 0, Right: 0);
+}
+```
+
+Stretches to fill the entire container (all edges at 0 pixels).
+
+**Shorthand:**
+
+```
+Group {
+    Anchor: (Full: 0);
+}
+```
+
+### Mixed Anchoring
+
+```
+Panel {
+    Anchor: (Top: 10, Bottom: 10, Left: 20, Width: 300);
+}
+```
+
+- Fixed width of 300 pixels
+- Stretches vertically between top and bottom edges
+- 10 pixels from top and bottom
+- 20 pixels from left
+
+## Padding
+
+`Padding` creates inner spacing, affecting where children are positioned.
+
+### Uniform Padding
+
+```
+Group {
+    Padding: (Full: 20);
+}
+```
+
+20 pixels of padding on all sides.
+
+### Directional Padding
+
+```
+Group {
+    Padding: (Top: 10, Bottom: 20, Left: 15, Right: 15);
+}
+```
+
+Different padding per edge.
+
+### Shorthand
+
+```
+// Horizontal and vertical
+Group {
+    Padding: (Horizontal: 20, Vertical: 10);
+}
+
+// Equivalent to:
+// Top: 10, Bottom: 10, Left: 20, Right: 20
+```
+
+### Effect on Children
+
+```
+Group {
+    Anchor: (Width: 200, Height: 100);
+    Padding: (Full: 10);
+
+    Label {
+        Anchor: (Full: 0);
+    }
+}
+```
+
+The label fills the group, but there's a 10-pixel gap on all sides due to padding.
+
+```
+┌──────────────────────┐
+│ Group (200×100)      │
+│  ┌────────────────┐  │
+│  │ Label          │  │ ← 10px padding all around
+│  │                │  │
+│  └────────────────┘  │
+└──────────────────────┘
+```
+
+## LayoutMode
+
+`LayoutMode` determines how a container arranges its children.
+
+### Top (Vertical Stack)
+
+```
+Group {
+    LayoutMode: Top;
+
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+}
+```
+
+Children stack vertically from top to bottom:
+
+```
+┌──────────┐
+│ Button 1 │
+├──────────┤
+│ Button 2 │
+├──────────┤
+│ Button 3 │
+└──────────┘
+
+
+```
+
+Each child's `Anchor.Bottom` adds spacing between elements:
+
+```
+Button { Anchor: (Height: 30, Bottom: 10); }  // 10px gap after this button
+```
+
+### Bottom (Vertical Stack)
+
+```
+Group {
+    LayoutMode: Bottom;
+
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+}
+```
+
+Children stack vertically from top to bottom but aligned to the bottom edge of the parent:
+
+```
+
+
+
+┌──────────┐
+│ Button 1 │
+├──────────┤
+│ Button 2 │
+├──────────┤
+│ Button 3 │
+└──────────┘
+```
+
+### Left (Horizontal Stack)
+
+```
+Group {
+    LayoutMode: Left;
+
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+}
+```
+
+Children arrange horizontally from left to right:
+
+```
+┌────────┬────────┬────────┐
+│ Button │ Button │ Button │
+│   1    │   2    │   3    │
+└────────┴────────┴────────┘
+```
+
+Use `Anchor.Right` for spacing between elements.
+
+### Right (Horizontal Stack)
+
+```
+Group {
+    LayoutMode: Right;
+
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+}
+```
+
+Children arrange horizontally from left to right but aligned to the right side of the parent:
+
+```
+                                                                 ┌────────┬────────┬────────┐
+                                                                 │ Button │ Button │ Button │
+                                                                 │   1    │   2    │   3    │
+                                                                 └────────┴────────┴────────┘
+```
+
+### Center
+
+```
+Group {
+    LayoutMode: Center;
+
+    Group #Dialog {
+        Anchor: (Width: 400, Height: 300);
+    }
+}
+```
+
+Centers the children horizontally.
+
+### Middle
+
+```
+Group {
+    LayoutMode: Middle;
+
+    Group #Dialog {
+        Anchor: (Width: 400, Height: 300);
+    }
+}
+```
+
+Centers the children vertically.
+
+### CenterMiddle (Horizontal Stack, Fully Centered)
+
+```
+Group {
+    LayoutMode: CenterMiddle;
+
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+}
+```
+
+Children stack horizontally from left to right, centered both horizontally and vertically within the parent:
+
+```
+┌────────────────────────────────────────────┐
+│                                            │
+│                                            │
+│         ┌──────┐ ┌──────┐ ┌──────┐         │
+│         │  B1  │ │  B2  │ │  B3  │         │
+│         └──────┘ └──────┘ └──────┘         │
+│                                            │
+│                                            │
+└────────────────────────────────────────────┘
+```
+
+---
+
+### MiddleCenter (Vertical Stack, Fully Centered)
+
+```
+Group {
+    LayoutMode: MiddleCenter;
+
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+}
+```
+
+Children stack vertically from top to bottom, centered both horizontally and vertically within the parent:
+
+```
+┌────────────────────────────────────────────┐
+│                                            │
+│              ┌──────────┐                  │
+│              │ Button 1 │                  │
+│              ├──────────┤                  │
+│              │ Button 2 │                  │
+│              ├──────────┤                  │
+│              │ Button 3 │                  │
+│              └──────────┘                  │
+│                                            │
+└────────────────────────────────────────────┘
+```
+
+---
+
+### Full
+
+```
+Group {
+    LayoutMode: Full;
+
+    Label {
+        Anchor: (Top: 20, Left: 20, Width: 100, Height: 30);
+    }
+}
+```
+
+Children use absolute positioning via their `Anchor` properties.
+
+### TopScrolling
+
+```
+Group {
+    LayoutMode: TopScrolling;
+    ScrollbarStyle: $Common.@DefaultScrollbar;
+
+    // ... many children
+}
+```
+
+Like `Top`, but adds a scrollbar if content exceeds container height.
+
+Or use `BottomScrolling` for bottom-aligned content.
+
+### LeftScrolling
+
+```
+Group {
+    LayoutMode: LeftScrolling;
+    ScrollbarStyle: $Common.@DefaultScrollbar;
+
+    // ... many children
+}
+```
+
+Like `Left`, but adds a scrollbar for horizontal scrolling.
+
+Or use `RightScrolling` for right-aligned content.
+
+### LeftCenterWrap (Wrapping Horizontal Stack, Horizontally Centered)
+
+```
+Group {
+    LayoutMode: LeftCenterWrap;
+
+    Button { Anchor: (Width: 80, Height: 30); }
+    Button { Anchor: (Width: 80, Height: 30); }
+    Button { Anchor: (Width: 80, Height: 30); }
+    Button { Anchor: (Width: 80, Height: 30); }
+    Button { Anchor: (Width: 80, Height: 30); }
+}
+```
+
+Children flow left to right. When there's no more horizontal space, they wrap to the next row. Each row is horizontally centered within the parent:
+
+```
+┌────────────────────────────────────────────┐
+│                                            │
+│       ┌──────┐ ┌──────┐ ┌──────┐           │
+│       │  B1  │ │  B2  │ │  B3  │           │
+│       └──────┘ └──────┘ └──────┘           │
+│            ┌──────┐ ┌──────┐               │
+│            │  B4  │ │  B5  │               │
+│            └──────┘ └──────┘               │
+│                                            │
+└────────────────────────────────────────────┘
+```
+
+## FlexWeight
+
+`FlexWeight` distributes remaining space among children.
+
+```
+Group {
+    LayoutMode: Left;
+    Anchor: (Width: 400);
+
+    Button {
+        Anchor: (Width: 100);
+    }
+
+    Group {
+        FlexWeight: 1;  // Takes all remaining space
+    }
+
+    Button {
+        Anchor: (Width: 100);
+    }
+}
+```
+
+Result:
+
+- First button: 100px
+- Middle group: 200px (400 - 100 - 100 = 200)
+- Last button: 100px
+
+### Multiple FlexWeights
+
+```
+Group {
+    LayoutMode: Left;
+    Anchor: (Width: 600);
+
+    Group { FlexWeight: 1; }
+    Group { FlexWeight: 2; }
+    Group { FlexWeight: 1; }
+}
+```
+
+Remaining space (600px) is split:
+
+- First group: 600 × (1/4) = 150px
+- Second group: 600 × (2/4) = 300px
+- Third group: 600 × (1/4) = 150px
+
+## Visibility
+
+```
+Button #HiddenButton {
+    Visible: false;
+}
+```
+
+**Effect:**
+
+- Element and its children are not displayed
+- Element is **not included in layout** (doesn't take up space)
diff --git a/content/docs/uk-UA/official-documentation/custom-ui/markup.mdx b/content/docs/uk-UA/official-documentation/custom-ui/markup.mdx
new file mode 100644
index 00000000..564110ed
--- /dev/null
+++ b/content/docs/uk-UA/official-documentation/custom-ui/markup.mdx
@@ -0,0 +1,226 @@
+---
+title: Markup
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# Markup
+
+## Markup
+
+An element is the basic building block of a user interface. There are various types of elements with different properties, which are documented below.
+
+Here's what the syntax looks like:
+
+```
+// Basic declaration of an element
+// with its Anchor property set to attach on all sides of its parent
+// with 10 pixels of margin
+Group { Anchor: (Left: 10, Top: 10, Right: 10, Bottom: 10); }
+
+Group { Anchor: (Full: 10); } // More concise version
+
+// Declaration of a Label with a name
+// (can be used to access the element from game code)
+Label #MyLabel {
+  Style: LabelStyle(FontSize: 16); // or just Style: (FontSize: 16), type can be inferred.
+  Text: "Hi! I am text.";
+}
+
+// Declaration of a Group containing 2 children
+// You can use FlexWeight to distribute any left-over space after explicit widths/heights have been subtracted
+Group {
+  LayoutMode: Left;
+  Label { Text: "Child 1"; FlexWeight: 2; }
+  Label { Text: "Child 2"; FlexWeight: 1; }
+}
+```
+
+### Documents
+
+A UI document (_.ui_ file) contains trees of elements. There can be multiple root elements.
+
+### Named Expressions
+
+Named expressions can be declared at any level of a document (including at the root) and will be scoped to that subtree, though they need to be declared at the top of the block.
+
+```
+// Example of named expressions, declared and used with @ prefix
+@Title = "Hytale";
+@ExtraSpacing = 5;
+
+Label {
+  Text: @Title;
+  Style: (LetterSpacing: 2 + @ExtraSpacing);
+}
+```
+
+You can use the spread operator `...` to reuse a named expression while overriding some of its fields:
+
+```
+@MyBaseStyle = LabelStyle(FontSize: 24, LetterSpacing: 2);
+
+Label {
+  Style: (...@MyBaseStyle, FontSize: 36);
+}
+```
+
+You can even layer multiple named expressions like so:
+
+```
+@TitleStyle = LabelStyle(FontSize: 24, HorizontalAlignment: Center);
+@SpacedTextStyle = LabelStyle(LetterSpacing: 2);
+
+Label {
+  Style: (...@BigTextStyle, ...@SpacedTextStyle);
+}
+```
+
+#### Document references
+
+A document can reference another document and access its named expressions.
+
+```
+// Document references are defined with $ prefix
+$Common = "../Common.ui";
+
+TextButton {
+  Style: $Common.@DefaultButtonStyle;
+}
+```
+
+### Templates
+
+You can declare a reusable bit of interface as a named expression and then instantiate it as many times as you want in the tree while customizing it.
+
+You can override local named expressions as well as insert additional children at any point in the template tree. However, local named expressions must be defined at the very top of the block, before properties and child elements.
+
+```
+// This is the template
+@Row = Group {
+  Anchor: (Height: 50);
+  Label #Label { Anchor: (Left: 0, Width: 100); Text: @LabelText; }
+  Group #Content { Anchor: (Left: 100); }
+};
+
+// Here we'll be using it twice in the document tree
+Group #Rows {
+  LayoutMode: TopScrolling;
+
+  @Row #MyFirstRow {
+    @LabelText = "First row";
+    #Content { TextInput {} }
+  }
+
+  @Row #MySecondRow {
+    @LabelText = "Second row";
+  }
+}
+```
+
+### Property Types
+
+#### Basic Types
+
+- **Boolean**
+  - `Visible: false;`
+  - `Visible: true;`
+- **Int**
+  - `Height: 20;`
+- **Float, Double, Decimal**
+  - `Min: 0.2;`
+- **String**
+  - `Text: "Hi!";`
+- **Char**
+  - `PasswordChar: "*";`
+  - _Note: The syntax is the same as a string, however a value of this type cannot contain more than one character!_
+- **Color**
+  - `Background: #ffffff;`&#x20;
+- **Objects**
+  - `Style: (Background: #ffffff)`
+- **Array**&#x20;
+  - `TextSpans: [(Text: "Hi", IsBold: true)]`
+
+#### Translations
+
+Translation keys can be referenced anywhere in markup where you can provide a string, and they are then converted to a string when an element gets instantiated.
+
+**Example:**
+
+```
+Label {
+  Text: %ui.general.cancel;
+}
+```
+
+#### Colors
+
+A color literal can be written as follows:
+
+- `#rrggbb`: 6-digit hexadecimal representation for red, green, blue (fully opaque)
+- `#rrggbb(a.a)`: 6-digit hexadecimal representation for red, green, blue with alpha between 0 and 1
+- `#rrggbbaa`: 8-digit hexadecimal representation for red, green, blue and alpha
+
+```
+Group {
+  Background: #000000(0.3);
+}
+```
+
+<Callout>
+  The `#rrggbb(a.a)` format is prefered over the `#rrggbbaa` format for
+  readability reasons.
+</Callout>
+
+#### Font Name
+
+Font names can be referenced directly by their string ID. Internally this is using a custom type called `UIFontName`, however strings will be converted automatically to this type in markup.
+
+```
+Label {
+  Text: "Hi";
+  Style: (FontName: "Secondary");
+}
+```
+
+**Available Font Names**
+
+- _Default_ - This is the default font that is used for most text and is always used unless a different option has been specified
+- _Secondary_ - This font is mostly used for headlines or elements that are supposed to stick out
+- _Mono_ - This is only used for development; For things such as profiling or error overlays.
+
+#### Path
+
+We can reference other UI assets with the `UIPath` type. Similar to `UIFontName`_,_ Strings are automatically converted to a `UIPath`. Paths are always relative to the file where they have been declared in. Looking up _MyButton.png_ in _Menu/MyAwesomeMenu.ui_ will result in _Menu/MyButton.png_. If you want to reference a file that is in a parent folder you can go back one directory by writing two dots (_../MyButton.png_).
+
+The markup syntax of a `UIPath` is the same as a String. (e.g. `Path: "Test.png"`)
+
+Here are some more examples:
+
+| UIPath             | .ui File                              | Resulting Path    |
+| ------------------ | ------------------------------------- | ----------------- |
+| MyButton.png       | Menu/MyAwesomeMenu.ui                 | Menu/MyButton.png |
+| ../MyButton.png    | Menu/MyAwesomeMenu.ui                 | MyButton.png      |
+| ../../MyButton.png | Menu/Popup/Templates/MyAwesomeMenu.ui | Menu/MyButton.png |
+
+#### Objects
+
+Objects contain a set of properties. In this example we are assigning an Anchor object to the _Anchor_ property:
+
+```
+Group {
+  Anchor: (
+   Height: 10,
+   Width: 20
+ );
+}
+```
+
+You can find all objects that can be used in markup [here](type-documentation#elements).
+
+## Visual Studio Code Extension
+
+There is an official extension for Visual Studio Code which adds syntax highlighting for .ui files. You can find it [here](https://marketplace.visualstudio.com/items?itemName=HypixelStudiosCanadaInc.vscode-hytaleui).
diff --git a/content/docs/uk-UA/official-documentation/custom-ui/type-documentation/index.mdx b/content/docs/uk-UA/official-documentation/custom-ui/type-documentation/index.mdx
new file mode 100644
index 00000000..69cea406
--- /dev/null
+++ b/content/docs/uk-UA/official-documentation/custom-ui/type-documentation/index.mdx
@@ -0,0 +1,127 @@
+---
+title: Type Documentation
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# Type Documentation
+
+This is a generated list of UI elements accessible by markup. More information about the User Interface framework can be found in the main documentation.
+
+## Elements
+
+- [ActionButton](type-documentation/elements/actionbutton)
+- [AssetImage](type-documentation/elements/assetimage)
+- [BackButton](type-documentation/elements/backbutton)
+- [BlockSelector](type-documentation/elements/blockselector)
+- [Button](type-documentation/elements/button)
+- [CharacterPreviewComponent](type-documentation/elements/characterpreviewcomponent)
+- [CheckBox](type-documentation/elements/checkbox)
+- [CheckBoxContainer](type-documentation/elements/checkboxcontainer)
+- [CircularProgressBar](type-documentation/elements/circularprogressbar)
+- [CodeEditor](type-documentation/elements/codeeditor)
+- [ColorOptionGrid](type-documentation/elements/coloroptiongrid)
+- [ColorPicker](type-documentation/lements/colorpicker)
+- [ColorPickerDropdownBox](type-documentation/elements/colorpickerdropdownbox)
+- [CompactTextField](type-documentation/elements/compacttextfield)
+- [DropdownBox](type-documentation/elements/dropdownbox)
+- [DropdownEntry](type-documentation/elements/dropdownentry)
+- [DynamicPane](type-documentation/elements/dynamicpane)
+- [DynamicPaneContainer](type-documentation/elements/dynamicpanecontainer)
+- [FloatSlider](type-documentation/elements/floatslider)
+- [FloatSliderNumberField](type-documentation/elements/floatslidernumberfield)
+- [Group](type-documentation/elements/group)
+- [HotkeyLabel](type-documentation/elements/hotkeylabel)
+- [ItemGrid](type-documentation/elements/itemgrid)
+- [ItemIcon](type-documentation/elements/itemicon)
+- [ItemPreviewComponent](type-documentation/elements/itempreviewcomponent)
+- [ItemSlot](type-documentation/elements/itemslot)
+- [ItemSlotButton](type-documentation/elements/itemslotbutton)
+- [Label](type-documentation/elements/label)
+- [LabeledCheckBox](type-documentation/elements/labeledcheckbox)
+- [MenuItem](type-documentation/elements/menuitem)
+- [MultilineTextField](type-documentation/elements/multilinetextfield)
+- [NumberField](type-documentation/elements/numberfield)
+- [Panel](type-documentation/elements/panel)
+- [ProgressBar](type-documentation/elements/progressbar)
+- [ReorderableList](type-documentation/elements/reorderablelist)
+- [ReorderableListGrip](type-documentation/elements/reorderablelistgrip)
+- [SceneBlur](type-documentation/elements/sceneblur)
+- [Slider](type-documentation/elements/slider)
+- [SliderNumberField](type-documentation/elements/slidernumberfield)
+- [Sprite](type-documentation/elements/sprite)
+- [TabButton](type-documentation/elements/tabbutton)
+- [TabNavigation](type-documentation/elements/tabnavigation)
+- [TextButton](type-documentation/elements/textbutton)
+- [TextField](type-documentation/elements/textfield)
+- [TimerLabel](type-documentation/elements/timerlabel)
+- [ToggleButton](type-documentation/elements/togglebutton)
+
+## Property Types
+
+- [Anchor](type-documentation/property-types/anchor)
+- [BlockSelectorStyle](type-documentation/property-types/blockselectorstyle)
+- [ButtonSounds](type-documentation/property-types/buttonsounds)
+- [ButtonStyle](type-documentation/property-types/buttonstyle)
+- [ButtonStyleState](type-documentation/property-types/buttonstylestate)
+- [CheckBoxStyle](type-documentation/property-types/checkboxstyle)
+- [CheckBoxStyleState](type-documentation/property-types/checkboxstylestate)
+- [ClientItemStack](type-documentation/property-types/clientitemstack)
+- [ColorOptionGridStyle](type-documentation/property-types/coloroptiongridstyle)
+- [ColorPickerDropdownBoxStateBackground](type-documentation/property-types/colorpickerdropdownboxstatebackground)
+- [ColorPickerDropdownBoxStyle](type-documentation/property-types/colorpickerdropdownboxstyle)
+- [ColorPickerStyle](type-documentation/property-types/colorpickerstyle)
+- [DropdownBoxSearchInputStyle](type-documentation/property-types/dropdownboxsearchinputstyle)
+- [DropdownBoxSounds](type-documentation/property-types/dropdownboxsounds)
+- [DropdownBoxStyle](type-documentation/property-types/dropdownboxstyle)
+- [InputFieldButtonStyle](type-documentation/property-types/inputfieldbuttonstyle)
+- [InputFieldDecorationStyle](type-documentation/property-types/inputfielddecorationstyle)
+- [InputFieldDecorationStyleState](type-documentation/property-types/inputfielddecorationstylestate)
+- [InputFieldIcon](type-documentation/property-types/inputfieldicon)
+- [InputFieldStyle](type-documentation/property-types/inputfieldstyle)
+- [ItemGridSlot](type-documentation/property-types/itemgridslot)
+- [ItemGridStyle](type-documentation/property-types/itemgridstyle)
+- [LabeledCheckBoxStyle](type-documentation/property-types/labeledcheckboxstyle)
+- [LabeledCheckBoxStyleState](type-documentation/property-types/labeledcheckboxstylestate)
+- [LabelSpan](type-documentation/property-types/labelspan)
+- [LabelStyle](type-documentation/property-types/labelstyle)
+- [NumberFieldFormat](type-documentation/property-types/numberfieldformat)
+- [Padding](type-documentation/property-types/padding)
+- [PatchStyle](type-documentation/property-types/patchstyle)
+- [PopupStyle](type-documentation/property-types/popupstyle)
+- [ScrollbarStyle](type-documentation/property-types/scrollbarstyle)
+- [SliderStyle](type-documentation/property-types/sliderstyle)
+- [SoundStyle](type-documentation/property-types/soundstyle)
+- [SpriteFrame](type-documentation/property-types/spriteframe)
+- [SubMenuItemStyle](type-documentation/property-types/submenuitemstyle)
+- [SubMenuItemStyleState](type-documentation/property-types/submenuitemstylestate)
+- [Tab](type-documentation/property-types/tab)
+- [TabNavigationStyle](type-documentation/property-types/tabnavigationstyle)
+- [TabStyle](type-documentation/property-types/tabstyle)
+- [TabStyleState](type-documentation/property-types/tabstylestate)
+- [TextButtonStyle](type-documentation/property-types/textbuttonstyle)
+- [TextButtonStyleState](type-documentation/property-types/textbuttonstylestate)
+- [TextTooltipStyle](type-documentation/property-types/texttooltipstyle)
+- [ToggleButtonStyle](type-documentation/property-types/togglebuttonstyle)
+- [ToggleButtonStyleState](type-documentation/property-types/togglebuttonstylestate)
+
+## Enums
+
+- [ActionButtonAlignment](type-documentation/enums/actionbuttonalignment)
+- [CodeEditorLanguage](type-documentation/enums/codeeditorlanguage)
+- [ColorFormat](type-documentation/enums/colorformat)
+- [DropdownBoxAlign](type-documentation/enums/dropdownboxalign)
+- [InputFieldButtonSide](type-documentation/enums/inputfieldbuttonside)
+- [InputFieldIconSide](type-documentation/enums/inputfieldiconside)
+- [ItemGridInfoDisplayMode](type-documentation/enums/itemgridinfodisplaymode)
+- [LabelAlignment](type-documentation/enums/labelalignment)
+- [LayoutMode](type-documentation/enums/layoutmode)
+- [MouseWheelScrollBehaviourType](type-documentation/enums/mousewheelscrollbehaviourtype)
+- [ProgressBarAlignment](type-documentation/enums/progressbaralignment)
+- [ProgressBarDirection](type-documentation/enums/progressbardirection)
+- [ResizeType](type-documentation/enums/resizetype)
+- [TimerDirection](type-documentation/enums/timerdirection)
+- [TooltipAlignment](type-documentation/enums/tooltipalignment)
diff --git a/content/docs/uk-UA/official-documentation/npc/2-getting-started-with-templates.mdx b/content/docs/uk-UA/official-documentation/npc/2-getting-started-with-templates.mdx
index 91081ca1..99d078e0 100644
--- a/content/docs/uk-UA/official-documentation/npc/2-getting-started-with-templates.mdx
+++ b/content/docs/uk-UA/official-documentation/npc/2-getting-started-with-templates.mdx
@@ -9,7 +9,7 @@ authors:
 
 There are no hard and fast rules for making a start on a template. I like to duplicate **BlankTemplate** and start from there because it already provides the basic structure of the file.
 
-This leaves me with the following template (`Template_Goblin_Ogre.json`): (note: the file could be looking different in the current version of the game)
+This leaves me with the following template (`Template_Goblin_Ogre.json`): (**note: the file could be looking different in the current version of the game**)
 
 ```json
 {
@@ -33,7 +33,7 @@ This leaves me with the following template (`Template_Goblin_Ogre.json`): (note:
     }
   },
   "Appearance": { "Compute": "Appearance" },
-  "DropList": { "Compute": "Droplist" },
+  "DropList": { "Compute": "DropList" },
   "MaxHealth": { "Compute": "MaxHealth" },
   "MotionControllerList": [
     {
@@ -65,10 +65,10 @@ And the following variant (`Goblin_Ogre.json`) next to the template. There's a t
   "Type": "Variant",
   "Reference": "Template_Goblin_Ogre",
   "Modify": {
-    "Appearance": "Goblin_Ogre",
+    "Appearance": "Goblin",
     "MaxHealth": 124
   }
 }
 ```
 
-Our artists have defined the `Goblin_Ogre` appearance already so I'm going to use that.
+Our artists have not yet finished animations for the `Goblin_Ogre`, for that sake of the tutorial I am going to use appearance `Goblin`, because it offers a more complete set of animations that we will need.
diff --git a/content/docs/uk-UA/official-documentation/worldgen/pack-tutorial/asset-packs.mdx b/content/docs/uk-UA/official-documentation/worldgen/pack-tutorial/asset-packs.mdx
index 38809fad..dcf1f3b9 100644
--- a/content/docs/uk-UA/official-documentation/worldgen/pack-tutorial/asset-packs.mdx
+++ b/content/docs/uk-UA/official-documentation/worldgen/pack-tutorial/asset-packs.mdx
@@ -9,13 +9,13 @@ authors:
 
 <OfficialDocumentationNotice />
 
-# How to modify Hytale
+# How to modify Hytale?
 
-## What's an Asset Pack
+## What's an Asset Pack?
 
-Hytales gameplay is driven by assets in the game that can be modified by creators. Asset Packs are our solution to let you override or add features to the base game with your own work. These can in the form of zip files of folders, which contain a custom set of assets. This is not the only way for a creator to change Hytale but this is the most accessible form.;
+Hytales gameplay is driven by assets in the game that can be modified by creators. Asset Packs are our solution to let you override or add features to the base game with your own work. These can be the form of zip files of folders, which contain a custom set of assets. This is not the only way for a creator to change Hytale but this is the most accessible form.;
 
-### How do I make an Asset Pack
+### How do I make an Asset Pack?
 
 <video controls className="my-6 aspect-video w-full rounded-lg border">
   <source src="https://cdn.internal.hytalemodding.dev/guides/official/how-to-asset-pack.mp4" type="video/mp4" />
@@ -48,7 +48,7 @@ An asset pack is typically a zip or folder, with a `manifest.json` inside. This
 }
 ```
 
-### Where are they stored
+### Where are they stored?
 
 Asset Packs are stored with other mods in the Mods folder.
 
@@ -76,7 +76,7 @@ C:\Users\<user>\AppData\Roaming\Hytale\UserData\Saves\New World 5\mods
 
 When you have Asset Packs or Mods installed, these will appear in the New World menu under the Options menu.;
 
-### How do I change an existing asset
+### How do I change an existing asset?
 
 <video controls className="my-6 aspect-video w-full rounded-lg border">
   <source src="https://cdn.internal.hytalemodding.dev/guides/official/how-to-asset.mp4" type="video/mp4" />
diff --git a/content/docs/uk-UA/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx b/content/docs/uk-UA/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx
index 44528376..24e628b5 100644
--- a/content/docs/uk-UA/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx
+++ b/content/docs/uk-UA/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx
@@ -106,7 +106,7 @@ If a BaseHeight is provided, the TopY and BottomY values are relative to the Bas
 
 Applies a Material Provider slot on a set of horizontal stripes of blocks of varying thickness and position. Below is an example image of basalt stripes into a stone cliff.
 
-{/* ![](https://540086904-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F7KAmBkOg6d13nZCkf9ku%2Fuploads%2FbcxO9LpArn8gPCaBwFg5%2Funknown.png?alt=media&token=1c72b67a-8253-4d03-8c64-1ad5f6830050) */}
+![Example of basalt stripes](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/basalt-stripes-example.png)
 
 #### Parameters:
 
diff --git a/content/docs/uk-UA/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx b/content/docs/uk-UA/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx
index 5e34acd4..a4418473 100644
--- a/content/docs/uk-UA/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx
+++ b/content/docs/uk-UA/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx
@@ -294,7 +294,7 @@ Combines all the positions into a single Positioins field.
 
 ---
 
-### SimpleHoritontal
+### SimpleHorizontal
 
 Keeps only the positions that are within the provided range.
 
diff --git a/content/docs/uk-UA/official-documentation/worldgen/worldgen-tutorial/README.mdx b/content/docs/uk-UA/official-documentation/worldgen/worldgen-tutorial/README.mdx
new file mode 100644
index 00000000..5f66d245
--- /dev/null
+++ b/content/docs/uk-UA/official-documentation/worldgen/worldgen-tutorial/README.mdx
@@ -0,0 +1,166 @@
+---
+title: How to edit and create Biomes
+description: Explores where world generation assets can be found and how to edit them.
+---
+
+### Where are the Assets
+
+World generation assets are kept in the HytaleGenerator directory within the assets.
+
+```
+/Server/HytaleGenerator/
+```
+
+<div className="flex flex-row rounded-lg border p-4">
+  <div className="flex-1/2 border-r pr-4">
+    ```
+    /Biomes
+    ```
+
+    Biome assets, with content configurations.
+  </div>
+
+  <div className="flex-1/2 pl-4">
+    ```
+    /WorldStructure
+    ```
+
+    Generator files that define which biomes spawn together.
+  </div>
+</div>
+
+<div className="flex flex-row rounded-lg border p-4">
+  <div className="flex-1/2 border-r pr-4">
+    ```
+    /Density
+    ```
+
+    Density assets that can be referenced by any other assets.
+  </div>
+
+  <div className="flex-1/2 pl-4">
+    ```
+    /Assignments
+    ```
+
+    Prop assets that can be referenced by any Biome assets.
+  </div>
+</div>
+
+***
+
+An example of this structure can be found bellow, packed in an asset pack with the instance configuration.
+
+[https://drive.google.com/file/d/1sIz_CluANIIe3n8vNiOi-4PQdeqCO0qY/view?usp=drive_link](https://drive.google.com/file/d/1sIz_CluANIIe3n8vNiOi-4PQdeqCO0qY/view?usp=drive_link)
+
+<Callout>
+  Ensure you place your asset pack in the correct directory, under Mods.
+</Callout>
+
+### How to visit our worlds
+
+https://drive.google.com/file/d/1BJurxyj-taE-PXWm04bk7Dl6X7ZHTH92/view?usp=sharing
+
+#### Requirements
+
+- You must be an **Operator** in the world.
+  - To do this, run <mark style="color:$danger;">`/op self`</mark>
+- You must be in **Creative mode**.
+  - Press the <mark style="color:$danger;">`O`</mark> key, O for Orange.&#x20;
+
+The generation assets define a set of generators but on their own you cannot visit these. Currently you require an Instance with a generator that will allow you to visit your work.
+
+```
+/Server/Instances/
+```
+
+Instances are separate worlds that players can join using the `/instances` command. Each instance has an `Instance.bson` configuration asset that specifies which generator to use, among other worldly settings.
+
+```json
+{
+  "WorldGen": {
+    "Type": "HytaleGenerator",
+    "WorldStructure": "Basic",
+    "playerSpawn" : {
+      "X" : 123,
+      "Y" : 480,
+      "Z" : 10000,
+      "Pitch" : 0,
+      "Yaw" : 0,
+      "Roll" : 0
+    }
+  }
+}
+```
+
+<Callout>
+  You can create custom instances for different world structures and biomes as you need them.
+</Callout>
+
+### How to edit Biomes
+
+<video>
+  <source src="https://cdn.internal.hytalemodding.dev/guides/official/How-to-edit-Biomes.mp4" type="video/mp4" />
+</video>
+
+We currently use the Hytale Node Editor when editing world generation assets. This can be accessed while in-game from the Content Creation menu when pressing B. The node editor is then found under the asset editor dropdown on the upper left.&#x20;
+
+![Node Editor 1](/assets/official-documentation/worldgen/worldgen-tutorial/biomes/node-editor-1.png)
+
+Once you have the Hytale Node Editor open, through the file menu you can open Biomes by navigating to the Biomes directory and selecting one from your pack.&#x20;
+
+```
+/Server/HytaleGenerator/Biomes/
+```
+
+### Biome Asset Structure
+
+Every Biome has a root Biome node, this node splits into 5 structures. This is covered briefly but more information on each field can be found on the World Generation Concepts page.
+
+![Node Editor 2](/assets/official-documentation/worldgen/worldgen-tutorial/biomes/node-editor-2.png)
+
+<Callout>
+  Each biome is for the most part self contained, meaning it has control over what appears with the biome. The only exception to this are Base Heights.
+</Callout>
+
+<Tabs>
+  <Tab value="Terrain">
+    Mathematical function nodes that calculate the physical shape of the Biome's terrain.
+  </Tab>
+
+  <Tab value="Materials">
+    Logical nodes that determine what materials (blocks) make up a Biome's terrain.
+  </Tab>
+
+  <Tab value="Props">
+    Function nodes that add objects like prefabs and decorations to the terrain.
+  </Tab>
+
+  <Tab value="Environments">
+    Logical nodes that determine the environment asset at a given coordinate within the biome. This asset determines things like weather, NPC spawns, and sounds.
+  </Tab>
+
+  <Tab value="Tints">
+    Logical function nodes that determine a colour code that can be used by certain blocks in the world. Typically this will be grasses and soils.
+  </Tab>
+</Tabs>
+
+### How to preview your work
+
+[https://drive.google.com/file/d/1mNcHn9LhFnWDF0DzWFH6_YllmKAUvUry/view?t=6](https://drive.google.com/file/d/1mNcHn9LhFnWDF0DzWFH6_YllmKAUvUry/view?t=6)
+
+Once you are in an Instance world with the Hytale Generator active you will only be able to see your work by generating new chunks. There are a few ways to do this.
+
+The viewport command selects an area around the Player that will live reload as you make changes to the generator.&#x20;
+
+```
+/viewport --radius 5 
+```
+
+You can also create a new world to show your changes.&#x20;
+
+```
+/instances spawn <instance> 
+```
+
+The last option is to simply fly south, new chunks will generate with the changes made.
diff --git a/content/docs/uk-UA/quick-start.mdx b/content/docs/uk-UA/quick-start.mdx
index 6750cd64..055e3b23 100644
--- a/content/docs/uk-UA/quick-start.mdx
+++ b/content/docs/uk-UA/quick-start.mdx
@@ -7,5 +7,10 @@ description: Налаштування стандартного проєкту Hy
 
 * [Основи Java](./guides/java-basics/00-introduction)
 * [Налаштування середовища розробки](./guides/plugin/setting-up-env)
-* [Entity Component System (ECS)](./guides/ecs/entity-component-system)
-* [Publishing your mod](./publishing)
+* [Entity Component System (ECS)](./guides/ecs)
+* [Публікація вашої модифікації](guides/publishing)
+
+### Корисні посилання
+
+* [Відео з модифікування від Kaupenjoe](https://www.youtube.com/@ModdingByKaupenjoe)
+* [Відео з модифікування від TroubleDEV](https://www.youtube.com/@TroubleDEV)
diff --git a/content/docs/uk-UA/server/argtypes.mdx b/content/docs/uk-UA/server/argtypes.mdx
new file mode 100644
index 00000000..e54a442e
--- /dev/null
+++ b/content/docs/uk-UA/server/argtypes.mdx
@@ -0,0 +1,61 @@
+---
+title: ArgTypes
+description: Available ArgTypes
+icon: List
+full: true
+authors:
+  - name: Valeena
+---
+
+| Name                        | Target Class                           | Description                                                                                                                               |   |
+| :-------------------------- | :------------------------------------- | :---------------------------------------------------------------------------------------------------------------------------------------- | - |
+| Boolean                     | java.lang.Boolean                      | A 'true' or 'false' input                                                                                                                 |   |
+| Integer                     | java.lang.Integer                      | A whole number                                                                                                                            |   |
+| String                      | java.lang.String                       | Words, text, numbers, letters. To input more than one word at a time, you may need to wrap it with double quotes (`"my fancy sentence"`). |   |
+| Float                       | java.lang.Float                        | A floating-pointer number                                                                                                                 |   |
+| Double                      | java.lang.Double                       | A decimal number                                                                                                                          |   |
+| UUID                        | java.util.UUID                         | A UUID (Universally Unique IDentifier)                                                                                                    |   |
+| Player_UUID                 | java.util.UUID                         | A UUID or an online player username                                                                                                       |   |
+| Game_Profile_Lookup_Async   | ProfileServiceClient.PublicGameProfile | A player UUID or username. If not found locally, performs a remote lookup via the Profile Service.                                        |   |
+| Relative_Double_Coord       | Coord                                  | An x, y, or z coordinate as a decimal, optionally relative by specifying a tilde (~) in front of the number                               |   |
+| Relative_Int_Coord          | IntCoord                               | An x, y, or z coordinate as a whole number, optionally relative by specifying a tilde (~) in front of the number                          |   |
+| Relative_Integer            | RelativeInteger                        | A tilde to mark an integer relative to a base                                                                                             |   |
+| Relative_Float              | RelativeFloat                          | A tilde to mark a float relative to a base                                                                                                |   |
+| Player_Ref                  | PlayerRef                              | A UUID or an online player's username                                                                                                     |   |
+| World                       | World                                  | A world folder name                                                                                                                       |   |
+| Model_Asset                 | ModelAsset                             | A reference to an Asset of type Model                                                                                                     |   |
+| Weather_Asset               | Weather                                | A reference to an Asset of type Weather                                                                                                   |   |
+| Interaction_Asset           | Interaction                            | A reference to an Asset of type Interaction                                                                                               |   |
+| Root_Interaction_Asset      | RootInteraction                        | A reference to an Asset of type Root Interaction                                                                                          |   |
+| Effect_Asset                | EntityEffect                           | A refernece to an Asset of type EntityEffect                                                                                              |   |
+| Environment_Asset           | Environment                            | A reference to an Asset of type Environment                                                                                               |   |
+| Item_Asset                  | Item                                   | A reference to an Asset of type Item                                                                                                      |   |
+| Block_Type_Asset            | BlockType                              | A reference to an Asset of type BlockType                                                                                                 |   |
+| Particle_System             | ParticleSystem                         | A reference to an Asset of type ParticleSystem                                                                                            |   |
+| Hitbox_Collision_Config     | HitboxCollisionConfig                  | A reference to an Asset of type HitboxCollisionConfig                                                                                     |   |
+| Repulsion_Config            | RepulsionConfig                        | A reference to an Asset of type RepulsionConfig                                                                                           |   |
+| Sound_Event_Asset           | SoundEvent                             | A reference to an Asset of type SoundEvent                                                                                                |   |
+| Ambiance_Fx_Asset           | AmbianceFX                             | A reference to an Asset of type AmbianceFX                                                                                                |   |
+| Sound_Category              | SoundCategory                          | A sound category (sfx, music, ambient, ui)                                                                                                |   |
+| Entity_ID                   | `ArgWrapper<EntityWrappedArg, UUID>`   | A UUID representing an entity id                                                                                                          |   |
+| Integer_Comparison_Operator | IntegerComparisonOperator              | A mathematical sign for integer comparison                                                                                                |   |
+| Integer_Operation           | IntegerOperation                       | A mathematical sign for performing an operation                                                                                           |   |
+| Int_Range                   | `Pair<Integer, Integer>`               | Two integers representing a minimum and maximum of a range                                                                                |   |
+| Relative_Int_Range          | RelativeIntRange                       | Two integers representing a minimum and maximum of a range                                                                                |   |
+| Vector2I                    | Vector2i                               | Two integers, generally corresponding to x/z axis                                                                                         |   |
+| Vector3I                    | Vector3i                               | Three integers, generally corresponding to x/y/z axis                                                                                     |   |
+| Relative_Vector3I           | RelativeVector3i                       | Three optionally relative integers, generally corresponding to x/y/z axis                                                                 |   |
+| Relative_Block_Position     | RelativeIntPosition                    | A position with three integer coordinates, representing a block's location in world space.                                                |   |
+| Relative_Position           | Relative                               | A position with three decimal coordinates, representing a location in world space.                                                        |   |
+| Relative_Chunk_Position     | RealtiveChunkPosition                  | A position with two integer coordinates (x, z), representing a chunk's location.                                                          |   |
+| Rotation                    | Vector3f                               | A rotation with three coordinates, representing the pitch, yaw, and roll respectively                                                     |   |
+| Block_Type_Key              | String                                 | A block type                                                                                                                              |   |
+| Block_ID                    | Integer                                | A block type, converted to an int id                                                                                                      |   |
+| Color                       | Integer                                | A color value in hex format, hex integer, or decimal integer                                                                              |   |
+| Weighted_Block_Type         | `Pair<Integer, String>`                | A weight corresponding to a blocktype                                                                                                     |   |
+| Weighted_Block_Entry        | String                                 | A block with optional weight prefix                                                                                                       |   |
+| Block_Pattern               | BlockPattern                           | A list of blocks with optional weights                                                                                                    |   |
+| Individual_Block_Mask       | BlockMask                              | Create a block mask using symbols and block names                                                                                         |   |
+| Block_Mask                  | BlockMask                              | A tick rate value (e.g., 30tps, 33ms, or 30)                                                                                              |   |
+| Tick_Rate                   | Integer                                | A list of block masks that combine together                                                                                               |   |
+| Game_Mode                   | GameMode                               | GameMode                                                                                                                                  |   |
diff --git a/content/docs/uk-UA/server/interaction-reference.mdx b/content/docs/uk-UA/server/interaction-reference.mdx
new file mode 100644
index 00000000..6c0d01b3
--- /dev/null
+++ b/content/docs/uk-UA/server/interaction-reference.mdx
@@ -0,0 +1,1586 @@
+---
+title: Interactions
+description: A list of most Interaction types provided by Hypixel, along with the meaning of their fields, and how they fit together.
+icon: List
+authors:
+  - name: Stephen Baynham
+    url: https://github.com/cannibalvox
+---
+
+### The Interaction Base Type
+
+All interactions of every type below are inherited from Interaction and have these fields.
+
+**Interaction Fields**
+
+| Field Name                | Type                                                                 | Required? | Notes                                                                                                                                                                                                                       |
+| ------------------------- | -------------------------------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| ViewDistance              | `Double`<br />(Default: 96.0)                                        | **No**    | Distance in blocks at which other players can see the effects from this interaction.                                                                                                                                        |
+| Effects                   | `InteractionEffects`                                                 | **No**    | Sound, animations, and particle effects that should trigger when this interaction begins executing.                                                                                                                         |
+| HorizontalSpeedMultiplier | `Float`<br />(Default: 1.0)                                          | **No**    | Multiplier applied to the User entity's movement speed while this interaction is executing                                                                                                                                  |
+| RunTime                   | `Float`                                                              | **No**    | If provided, this interaction will continue executing for at least this long before the interaction chain moves onto the next interaction.                                                                                  |
+| CancelOnItemChange        | `Boolean`<br />(Default: true)                                       | **No**    | If true, this interaction will be cancelled if the User entity's held item changes during execution. This can happen either due to the selected hotbar slot changing or the contents of the item's inventory slot changing. |
+| Rules                     | `InteractionRules`                                                   | **Yes**   | If provided, adds additional limitations and cancellation conditions to this interaction.                                                                                                                                   |
+| Settings                  | `Map`<br />(Key Type: `GameMode`, Value Type: `InteractionSettings`) | **No**    | If provided, adds additional per-GameMode settings to the interaction.                                                                                                                                                      |
+| Camera                    | `InteractionCameraSettings`                                          | **No**    | Arrays of camera motion keyframes for cutscenes and reveals.                                                                                                                                                                |
+
+**GameMode Values**
+
+- `Creative`: The game is currently in Creative Mode
+- `Adventure`: The game is currently in Adventure Mode
+
+**InteractionEffects Fields**
+
+| Field Name               | Type                                              | Required? | Notes                                                                                                                                                 |
+| ------------------------ | ------------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Particles                | `Array`<br />(Element Type: `ModelParticle`)      | **No**    | Particle systems to activate when this interaction begins if the player is in third-person mode.                                                      |
+| FirstPersonParticles     | `Array`<br />(Element Type: `ModelParticle`)      | **No**    | Particle systems to activate when this interaction begins if the player is in first-person mode.                                                      |
+| WorldSoundEventId        | `Asset`<br />(Asset Type: `SoundEvent`)           | **No**    | A sound to play in the world at the User entity's location when this interaction begins.<br />**The SoundEvent must be single-channel (mono) sound.** |
+| LocalSoundEventId        | `Asset`<br />(Asset Type: `SoundEvent`)           | **No**    | A 2D sound to play for the User entity when this interaction begins. Ignored if the User entity is not a player.                                      |
+| Trails                   | `Array`<br />(Element Type: `ModelTrail`)         | **No**    | Trail effects to activate on the User entity when this interaction begins.                                                                            |
+| WaitForAnimationToFinish | `Boolean`<br />(Default: false)                   | **No**    | If true, this interaction will continue executing for at least the length of any animations in this InteractionEffects object.                        |
+| ItemPlayerAnimationsId   | `Asset`<br />(Asset Type: `ItemPlayerAnimations`) | **No**    | If provided, the User entity will use this ItemPlayerAnimations set while this interaction is executing.                                              |
+| ItemAnimationId          | `String`                                          | **No**    | Id of an animation to trigger when this interaction begins executing.<br />**This animation id is not validated on server start.**                    |
+| ClearAnimationOnFinish   | `Boolean`<br />(Default: false)                   | **No**    | If true, animations triggered by this interaction will be halted when the interaction completes.                                                      |
+| ClearSoundEventOnFinish  | `Boolean`<br />(Default: false)                   | **No**    | If true, sounds triggered by this interaction will be halted when the interaction completes.                                                          |
+| CameraEffect             | `Asset`<br />(Asset Type: `CameraEffect` )        | **No**    | If provided, the CameraEffect will be applied while this interaction is executing.                                                                    |
+| MovementEffects          | `MovementEffects`                                 | **No**    | If provided, apply the movement effects to the User entity while this interaction is executing.                                                       |
+| StartDelay               | `Float`<br />(Default: 0.0f)                      | **No**    | The interaction will wait this many seconds before triggering the effects in this object.                                                             |
+
+**InteractionRules Fields**
+
+| Field Name          | Type                                                                                                | Required? | Notes                                                                                                                                                                                                                                     |
+| ------------------- | --------------------------------------------------------------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| BlockedBy           | `Array`<br />(Element Type: `InteractionType`)<br />(Default: Based on the chain's InteractionType) | **No**    | If provided, this RootInteraction cannot be executed while interaction chains of the provided types are executing.<br />**This field only functions for rules attached to a RootInteraction. It has no effect on an Interaction.**        |
+| Blocking            | `Array`<br />(Element Type: `InteractionType`)                                                      | **No**    | If provided, interaction chains with the specified InteractionTypes cannot be executed while this interaction is executing.                                                                                                               |
+| InterruptedBy       | `Array`<br />(Element Type: `InteractionType`)                                                      | **No**    | If provided, interaction chains with the specified InteractionTypes will cancel this interaction chain when they execute.<br />**This field only functions for rules attached to a RootInteraction. It has no effect on an Interaction.** |
+| Interrupting        | `Array`<br />(Element Type: `InteractionType`)                                                      | **No**    | If provided, interaction chains with the specified InteractionTypes will be canceled when this interaction begins.                                                                                                                        |
+| BlockedByBypass     | `String`                                                                                            | **No**    | If provided, this RootInteraction cannot be blocked by interaction chains whose RootInteraction has this value as an asset tag.                                                                                                           |
+| BlockingBypass      | `String`                                                                                            | **No**    | If provided, this interaction will not block RootInteractions that have the this value as an asset tag.                                                                                                                                   |
+| InterruptedByBypass | `String`                                                                                            | **No**    | If provided, this RootInteraction cannot be canceled by RootInteractions that have this value as an asset tag.                                                                                                                            |
+| InterruptingBypass  | `String`                                                                                            | **No**    | If provided, this interaction will not cancel interaction chains whose RootInteraction has this value as an asset tag.                                                                                                                    |
+
+**InteractionType Values**
+
+- `Primary`
+- `Secondary`
+- `Ability1`
+- `Ability2`
+- `Ability3`
+- `Use`
+- `Pick`
+- `Pickup`
+- `CollisionEnter`
+- `CollisionLeave`
+- `Collision`
+- `EntityStatEffect`
+- `SwapTo`
+- `SwapFrom`
+- `Death`
+- `Wielding`
+- `ProjectileSpawn`
+- `ProjectileHit`
+- `ProjectileMiss`
+- `ProjectileBounce`
+- `Held`
+- `HeldOffhand`
+- `Equipped`
+- `Dodge`
+- `GameModeSwap`
+
+**InteractionSettings Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                        |
+| ---------------- | ------------------------------- | --------- | -------------------------------------------------------------------------------------------- |
+| AllowSkipOnClick | `Boolean`<br />(Default: false) | **No**    | If true, the user will be able to skip this interaction by clicking shortly after it starts. |
+
+**InteractionCameraSettings Fields**
+
+| Field Name  | Type                                             | Required? | Notes                                                                                                                                                           |
+| ----------- | ------------------------------------------------ | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| FirstPerson | `Array`<br />(Element Type: `InteractionCamera`) | **No**    | A list of camera keyframes to be played if the player is in first-person.<br />**The time of each keyframe must be after the keyframe before it in the array.** |
+| ThirdPerson | `Array`<br />(Element Type: `InteractionCamera`) | **No**    | A list of camera keyframes to be played if the player is in third-person.<br />**The time of each keyframe must be after the keyframe before it in the array.** |
+
+**InteractionCamera Fields**
+
+| Field Name | Type                         | Required? | Notes                                                                                                                                       |
+| ---------- | ---------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------- |
+| Time       | `Float`<br />(Default: 0.1f) | **No**    | How long after the interaction begins executing that the camera should arrive at this keyframe.<br />**Cannot be less than or equal to 0.** |
+| Position   | `Vector3`                    | **Yes**   | Where the camera should be located when it arrives at this keyframe.                                                                        |
+| Rotation   | `Direction`                  | **Yes**   | Where the camera should be pointing when it arrives at this keyframe.                                                                       |
+
+### SimpleInteraction
+
+Most interaction types below are inherited from SimpleInteraction and have these
+fields.  If a type does not have these fields, the documentation will mention it.
+
+The purpose of SimpleInteraction is to facilitate Interaction chaining by taking different paths
+based on whether the Interaction succeeded or failed.  The circumstances under which
+a given Interaction fails are generally type-specific (and described in the documentation
+below), but all interactions will be marked failed if they are cancelled via one of the
+many, many mechanisms for doing so.
+
+It is valid to create an interaction asset of type "Simple", which can be valuable when you want to use the
+interaction fields with no additional functionality.
+
+**SimpleInteraction Fields**
+
+| Field Name | Type                                     | Required? | Notes                                                                                          |
+| ---------- | ---------------------------------------- | --------- | ---------------------------------------------------------------------------------------------- |
+| Next       | `Asset`<br />(Asset Type: `Interaction`) | **No**    | After this Interaction has finished, "Next" will be executed if this Interaction did not fail. |
+| Failed     | `Asset`<br />(Asset Type: `Interaction`) | **No**    | After this Interaction has finished, "Failed" will be executed if this Interaction failed.     |
+
+## Flow Control
+
+These are interaction types used to control the flow of an interaction chain and allow interactions
+to be composed into more complex behaviors.  These interaction types generally do not pertain to
+the game and instead pertain to the interaction system itself.
+
+### Condition
+
+This interaction will fail if one of the fields is provided but does not match the current state.
+
+**Condition Fields**
+
+| Field Name       | Type       | Required? | Notes                                                                                                                                                                                    |
+| ---------------- | ---------- | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| RequiredGameMode | `GameMode` | **No**    | If provided, the interaction will fail if the current GameMode does not match the provided value.                                                                                        |
+| Jumping          | `Boolean`  | **No**    | If provided, the interaction will fail if the player's Jumping state does not match the provided value. (i.e. if True, the player must be jumping, if False, the player must not be)     |
+| Swimming         | `Boolean`  | **No**    | If provided, the interaction will fail if the player's Swimming state does not match the provided value. (i.e. if True, the player must be swimming, if False, the player must not be)   |
+| Crouching        | `Boolean`  | **No**    | If provided, the interaction will fail if the player's Crouching state does not match the provided value. (i.e. if True, the player must be crouching, if False, the player must not be) |
+| Running          | `Boolean`  | **No**    | If provided, the interaction will fail if the player's Running state does not match the provided value. (i.e. if True, the player must be running, if False, the player must not be)     |
+| Flying           | `Boolean`  | **No**    | If provided, the interaction will fail if the player's Flying state does not match the provided value. (i.e. if True, the player must be flying, if False, the player must not be)       |
+
+**GameMode Values**
+
+- `Creative`: The game is currently in Creative Mode
+- `Adventure`: The game is currently in Adventure Mode
+
+### FirstClick
+
+This interaction does not inherit from SimpleInteraction and therefore has no Next or Failed fields.
+
+This interaction has two fields that each contain a reference to an Interaction: Click and Hold.  If the root interaction
+of the chain was initiated by a client button/key press (or simulated NPC input) and the input was a tap, then
+the Click interaction is run. if it was a longer press, then the Hold interaction is run.
+
+As a minor implementation detail, this interaction is internally marked as failed when the Hold path is followed.
+This generally shouldn't matter.  If the interaction was not initiated by a key press at all, the Click path will be followed,
+but it seems risky to rely on that behavior.
+
+**FirstClick Fields**
+
+| Field Name | Type                                     | Required? | Notes                                                                                                                                                    |
+| ---------- | ---------------------------------------- | --------- | -------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Click      | `Asset`<br />(Asset Type: `Interaction`) | **No**    | If provided and the root interaction of the chain was initiated by button/key press, this interaction is executed next if the press was a quick tap.     |
+| Hold       | `Asset`<br />(Asset Type: `Interaction`) | **No**    | If provided and the root interaction of the chain was initiated by a button/key press, this interaction is executed next if the press was a longer hold. |
+
+### Interrupt
+
+This interaction can be used to cancel one or more running interaction chains on an entity and **all forked interaction
+chains those chains have spawned that are still currently running**.  All interaction chains canceled in this manner will be marked as
+Failed, which may have additional implications if the canceled chains are themselves forked from
+other chains that are still running.
+
+**Interrupt Fields**
+
+| Field Name     | Type                                           | Required? | Notes                                                                                                                                                                                               |
+| -------------- | ---------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Entity         | `InteractionTarget`<br />(Default: User)       | **Yes**   | The entity that is the owner of the target interaction chains.  This field can indicate the Owner, User, or Target of this interaction chain.                                                       |
+| InterruptTypes | `Array`<br />(Element Type: `InteractionType`) | **No**    | A set of InteractionTypes that are to be interrupted. Only interactions of these types are affected. If null, all types will be interrupted.<br />**(Note: An empty set will interrupt NO TYPES.)** |
+| RequiredTag    | `String`                                       | **No**    | An asset tag that, if provided, the RootInteraction of the interaction chain must have in order to be canceled.                                                                                     |
+| ExcludedTag    | `String`                                       | **No**    | An asset tag that, if provided, the RootInteraction of the interaction chain must not have in order to be canceled.                                                                                 |
+
+**InteractionTarget Values**
+
+- `User` - The user of this interaction chain. The entity whose actions caused this interaction chain to be executed. This is usually the same as the Owner.
+- `Owner` - The owner of this interaction chain. The entity upon whom this interaction chain is executing.
+- `Target` - The entity target of this interaction chain, if any.  This value is mutable (and can therefore come from many places) but most commonly, it is an entity the User was targeting when this interaction chain began executing.
+
+**InteractionType Values**
+
+- `Primary`
+- `Secondary`
+- `Ability1`
+- `Ability2`
+- `Ability3`
+- `Use`
+- `Pick`
+- `Pickup`
+- `CollisionEnter`
+- `CollisionLeave`
+- `Collision`
+- `EntityStatEffect`
+- `SwapTo`
+- `SwapFrom`
+- `Death`
+- `Wielding`
+- `ProjectileSpawn`
+- `ProjectileHit`
+- `ProjectileMiss`
+- `ProjectileBounce`
+- `Held`
+- `HeldOffhand`
+- `Equipped`
+- `Dodge`
+- `GameModeSwap`
+
+### Parallel
+
+This interaction does not inherit from SimpleInteraction and therefore has no Next or Failed fields.
+
+This interaction has a field `Interactions` that is an array of RootInteraction assets. The list must contain at least
+two RootInteractions.  This interaction will fork all of its children except for the first into their
+own interaction chains and immediately complete. After this interaction completes, this interaction chain will
+execute the first RootInteraction in the `Interactions` list.
+
+This interaction does not have any failure conditions and is indifferent to the fate of the forked interaction chains.
+
+**Parallel Fields**
+
+| Field Name   | Type                                                | Required? | Notes                                                         |
+| ------------ | --------------------------------------------------- | --------- | ------------------------------------------------------------- |
+| Interactions | `AssetArray`<br />(Element Type: `RootInteraction`) | **Yes**   | An array of RootInteractions that will be forked or executed. |
+
+### Repeat
+
+This interaction has a field `ForkInteractions` that is an asset of type RootInteraction. This interaction will fork that
+RootInteraction into its own interaction chain and then wait for it to complete. If the RootInteraction fails, this
+interaction will complete immediately and be marked failed. Otherwise, the RootInteraction will be forked and run again,
+up to a specified total number of times.
+
+**Repeat Fields**
+
+| Field Name       | Type                                                                                   | Required? | Notes                                                                                                                                                                                                              |
+| ---------------- | -------------------------------------------------------------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| ForkInteractions | `Asset`<br />(Asset Type: `RootInteraction`)                                           | **Yes**   | A RootInteraction that will be forked.                                                                                                                                                                             |
+| Repeat           | `Integer`<br />(Default: 1)<br />**Must be -1 or a positive integer. 0 is not valid.** | **No**    | The total number of times to fork ForkInteractions. If -1 is provided, ForkInteractions will continue being forked and executed indefinitely, until this interaction is cancelled or until ForkInteractions fails. |
+
+### Replace
+
+This interaction does not inherit from SimpleInteraction and therefore has no Next or Failed fields.
+
+This interaction uses the InteractionVars system that is avaiable for items. InteractionVars are RootInteractions that
+can be attached to an Item asset with a name.
+
+This interaction specifies a var name, and if this interaction chain was executed through
+an item and that item has an InteractionVar of the same name, then this interaction will immediately execute
+the RootInteraction on the var.  Otherwise, it will execute the default RootInteraction specified in this interaction.
+If no default is specified, then this interaction will be marked as failed.
+
+**Replace Fields**
+
+| Field Name   | Type                                         | Required? | Notes                                                                                                                                                                                                           |
+| ------------ | -------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Var          | `String`                                     | **Yes**   | The name of the InteractionVar to execute.                                                                                                                                                                      |
+| DefaultValue | `Asset`<br />(Asset Type: `RootInteraction`) | **No**    | The RootInteraction to execute if the owning item does not have an InteractionVar by the specified name. If not provided, the interaction will be marked as failed instead.                                     |
+| DefaultOk    | `Boolean`<br />(Default: false)              | **No**    | If false, then an angry message will be printed to the server logs if the owning item does not have an InteractionVar by the specified name.  The functioning of this interaction will be otherwise unaffected. |
+
+### RunRootInteraction
+
+This interaction immediately executes the provided RootInteraction as part of this interaction chain. This interaction
+does not have any failure conditions.
+
+**RunRootInteraction Fields**
+
+| Field Name      | Type                                         | Required? | Notes                           |
+| --------------- | -------------------------------------------- | --------- | ------------------------------- |
+| RootInteraction | `Asset`<br />(Asset Type: `RootInteraction`) | **Yes**   | The RootInteraction to execute. |
+
+### Selector
+
+This interaction will execute a Selector to find entities and/or blocks (depending on the Selector) and fork off an
+interaction chain for each located entity or block. This interaction will not wait for those interaction chains
+to complete and is indifferent to their fate. The forked interaction chains will use the located entity/block as
+their target entity/target block. Each entity or block will only fork one interaction chain over the life of this
+interaction.  The Selector is guaranteed to run once for each execution of this interaction, but some Selectors
+are intended to be run over a period of time and sweep across an area to locate targets. In order to use those Selectors
+properly, you will need to extend the execution time of this interaction using `RunTime` or `WaitForAnimationToFinish`.
+The Selector will be executed repeatedly over the lifetime of the interaction.
+
+If the Selector is configured to locate entities, you can add additional sets of entity matching rules. If a located entity
+matches one of the rules, the matching RootInteraction will be forked instead of the standard `HitEntity` RootInteraction.
+
+Entities located by the Selector will be ignored if they do not have a NetworkId, if they are dead, or if they are invulnerable.
+The only exception to this rule is that players in Creative Mode that are marked to receive hits will not be ignored.
+
+This interaction's failure conditions are configurable via the `FailOn` field. You can configure this interaction to never
+fail, to fail if the Selector does not locate any blocks before this interaction finishes executing, to fail if the
+Selector does not locate any entities before this interaction finishes executing, or to fail in either case.
+
+**Selector Fields**
+
+| Field Name     | Type                                         | Required? | Notes                                                                                                                                                                                                                                     |
+| -------------- | -------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Selector       | `Selector`                                   | **Yes**   | The Selector is executed at least once and may be executed repeatedly to locate blocks and/or entities in an area.                                                                                                                        |
+| HitEntity      | `Asset`<br />(Asset Type: `RootInteraction`) | **No**    | If included and the `Selector` locates an entity that does not match any `HitEntityRules`, this RootInteraction will be forked into a new interaction chain with the located entity as the target entity.                                 |
+| HitEntityRules | `Array`<br />(Element Type: `HitEntity`)     | **No**    | If included, these rules will be matched against any entity located by the `Selector`. If an entity matches a set of rules, the RootInteraction associated with the rules will be forked instead of the standard `HitEntity` interaction. |
+| HitBlock       | `Asset`<br />(Asset Type: `RootInteraction`) | **No**    | If included and the `Selector` locates a block, this RootInteraction will be forked into a new interaction chain with the located block as the block target.                                                                              |
+| FailOn         | `FailOnType`<br />(Default: `Neither`)       | **No**    | Defines under what circumstances this interaction will fail.  It can be marked to fail when it completes without locating any blocks, it can be marked to fail when it completes without locating any entities, both, or neither.         |
+| IgnoreOwner    | `Boolean`<br />(Default: true)               | **No**    | If true, the Selector will not locate the User entity of this interaction.                                                                                                                                                                |
+
+**HitEntity Fields**
+
+| Field Name | Type                                         | Required? | Notes                                                                                                 |
+| ---------- | -------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------- |
+| Matchers   | `Array`<br />(Element Type: `EntityMatcher`) | **Yes**   | A set of rules that an entity must match. An entity must successful match all rules to be considered. |
+| Next       | `Asset`<br />(Asset Type: `RootInteraction`) | **Yes**   | The RootInteraction to fork if an entity matches all rules.                                           |
+
+**EntityMatcher Fields**
+
+| Field Name | Type                            | Required? | Notes                                                                                                     |
+| ---------- | ------------------------------- | --------- | --------------------------------------------------------------------------------------------------------- |
+| Type       | `String`                        | **Yes**   | If provided, specifies a type of EntityMatcher to use. Each matcher type may come with additional fields. |
+| Invert     | `Boolean`<br />(Default: false) | **No**    | If true, an entity must fail this rule for it to be marked as succeeded.                                  |
+
+**EntityMatcher Type: Player**
+
+This EntityMatcher will succesfully match the entity only if they are a player.
+
+**EntityMatcher Type: Vulnerable**
+
+This Entitymatcher will successfully match the entity only if they are not marked as invulnerable.
+
+**FailOnType Values**
+
+- `Neither`
+- `Entity`
+- `Block`
+- `Either`
+
+### Serial
+
+This interaction does not inherit from SimpleInteraction and therefore has no Next or Failed fields.
+
+This interaction has a field `Interactions` which is a list of Interaction assets. This interaction immediately
+completes and the interaction chain continues by executing the interactions in the list one at a time. This
+interaction does not have any failure conditions.
+
+**Serial Fields**
+
+| Field Name   | Type                                            | Required? | Notes                                      |
+| ------------ | ----------------------------------------------- | --------- | ------------------------------------------ |
+| Interactions | `AssetArray`<br />(Element Type: `Interaction`) | **Yes**   | An array of Interaction assets to execute. |
+
+## Cooldowns
+
+RootInteractions interface with a complex cooldown system that can be used for a variety of purposes. Aside from simply
+adding an important aspect of resource management to your game design, cooldowns can be used to ensure that click-activated
+interaction chains don't repeatedly spam if the player holds down the input.
+
+By default, every RootInteraction has a cooldown timer that is keyed to the RootInteraction name, and by default, it
+will launch a cooldown of 0.35 seconds when activated by client input.  Otherwise, no cooldown will be activated.  However,
+by configuring your RootInteraction, you can change the key for the cooldown (so that multiple RootInteractions can share
+a single cooldown), set the cooldown timer to whatever you like, and configure multiple charges that can build up over time
+to allow the entity to activate the RootInteraction multiple times before being forced to pause.
+
+One important concept to keep in mind is the difference between **cooldown** and **charge time**.  The cooldown, if any,
+is activated each time a RootInteraction triggers, even if the player has more available charges. If the RootInteraction
+is configured to use charges, then they will gradually build up over time. In order for a RootInteraction to be activated,
+the cooldown (if any) must be expired, and the RootInteraction must have at least one charge (if it has been
+configured to use charges).
+
+Bear in mind that the entire Cooldown configuration is shared between different RootInteractions with the same cooldown id.
+If you activate an ability with 5 charges and a short cooldown and then another ability with a much longer cooldown and no
+charges, the second ability will use the cooldown properties of the first ability until/unless the first ability finishes
+charging and is cleared from the system.  You should generally only have multiple RootInteractions share a cooldown id
+if they have the same configuration.
+
+The interactions below interact with the cooldown system to allow you to manipulate cooldowns via the interaction system. By
+using these interactions, you can have several interaction chains with different cooldown configurations share cooldowns
+that are checked and activated as part of the interaction chain itself, or have some components of an interaction change
+use a second cooldown separate from the main one.
+
+### CooldownCondition
+
+**CooldownCondition Fields**
+
+This interaction will fail if the specified cooldown id is on cooldown for the User entity.  This interaction will only
+function for players- the interaction will always succeed for NPCs.  In order for this interaction to succeed, the
+cooldown, if any, must have expired and at least one charge, if any, must have filled.
+
+| Field Name | Type     | Required? | Notes                     |
+| ---------- | -------- | --------- | ------------------------- |
+| Id         | `String` | **Yes**   | The cooldown id to check. |
+
+### IncrementCooldown
+
+**IncrementCooldown Fields**
+
+This interaction will modify a cooldown that is currently active on the User entity, allowing charges and remaining
+cooldown to be modified.
+Despite its name, this interaction can be used to reduce a cooldown as well as increase it. If the cooldown is not
+currently active, this interaction will have no effect. The interaction has no special failure conditions.
+
+| Field Name        | Type                        | Required? | Notes                                                                                                                                                                                                                                                                                     |
+| ----------------- | --------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Id                | `String`                    | **No**    | If provided, the cooldown id of the cooldown to be manipulated. If not provided, the cooldown id of the current chain's RootInteraction will be used.                                                                                                                                     |
+| Time              | `Float`<br />(Default: 0.0) | **No**    | The amount to increase the remaining cooldown by. Can be negative. The remaining cooldown time will not be reduced below zero or increased above the maximum cooldown time.                                                                                                               |
+| ChargeTime        | `Float`<br />(Default: 0.0) | **No**    | The amount to increase the remaining time until the next charge is filled by. Can be negative. The remaining charge time cannot be reduced below zero or increased above the maximum cooldown time. **This will not work on abilities that have a maximum of 1 charge, for some reason.** |
+| Charge            | `Integer`<br />(Default: 0) | **No**    | The amount to increase the number of charges by. Can be negative. The number of charges cannot be reduced below 0 or increased above the maximum.                                                                                                                                         |
+| InterruptRecharge | `Boolean`(Default: false)   | **No**    | If true and `Charge` is not 0, will reset the remaining time to the next charge to the maximum value after changing the charge count.                                                                                                                                                     |
+
+### ResetCooldown
+
+This interaction will trigger a cooldown on the User entity with a specified configuration. The charges will be refilled
+but the cooldown will be immediately triggered.  The mechanisms for deciding on the configuration are a little bit complicated.
+You may specify a cooldown configuration via the `Cooldown` field. If you do not include an `Id` field, then the
+interaction chain's RootInteraction will be used for any field not specified in the configuration. If there is an active
+cooldown under the specified `Id` (or under the RootInteraction's cooldown id if none is specified) then the fields
+from that active cooldown will overwrite data in the RootInteraction's cooldown, but not data in your `Cooldown` field.
+
+**ResetCooldown Fields**
+
+| Field Name | Type                  | Required? | Notes                                                        |
+| ---------- | --------------------- | --------- | ------------------------------------------------------------ |
+| Cooldown   | `InteractionCooldown` | **No**    | A cooldown configuration to use for the new, reset cooldown. |
+
+**InteractionCooldown Fields**
+
+| Field Name        | Type                                 | Required? | Notes                                                                                                                                                                                                 |
+| ----------------- | ------------------------------------ | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Id                | `String`                             | **No**    | The cooldown id to use for this cooldown. If not provided, the RootInteraction's cooldown id will be used, if any.                                                                                    |
+| Cooldown          | `Float`<br />(Default: 0.0)          | **No**    | The duration of the cooldown, in seconds.                                                                                                                                                             |
+| Charges           | `Array`<br />(Element Type: `Float`) | **No**    | If provided, a list of how many charges this cooldown can build, and how long each charge takes to build, in seconds.                                                                                 |
+| InterruptRecharge | `Boolean`<br />(Default: false)      | **No**    | If true, the charge time will be reset when the number of charges changes.                                                                                                                            |
+| ClickBypass       | `Boolean`<br />(Default: false)      | **No**    | If true, RootInteractions keyed to this cooldown can still be activated when it is on cooldown provided that the RootInteraction was triggered by a distinct key or mouse button press on the client. |
+
+### TriggerCooldown
+
+This interaction is similar to ResetCooldown, except instead of refilling the cooldown's charges, one charge will be deducted
+as normal.
+
+**TriggerCooldown Fields**
+
+| Field Name | Type                  | Required? | Notes                                                        |
+| ---------- | --------------------- | --------- | ------------------------------------------------------------ |
+| Cooldown   | `InteractionCooldown` | **No**    | A cooldown configuration to use for the new, reset cooldown. |
+
+**InteractionCooldown Fields**
+
+| Field Name        | Type                                 | Required? | Notes                                                                                                                                                                                                 |
+| ----------------- | ------------------------------------ | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Id                | `String`                             | **No**    | The cooldown id to use for this cooldown. If not provided, the RootInteraction's cooldown id will be used, if any.                                                                                    |
+| Cooldown          | `Float`<br />(Default: 0.0)          | **No**    | The duration of the cooldown, in seconds.                                                                                                                                                             |
+| Charges           | `Array`<br />(Element Type: `Float`) | **No**    | If provided, a list of how many charges this cooldown can build, and how long each charge takes to build, in seconds.                                                                                 |
+| InterruptRecharge | `Boolean`<br />(Default: false)      | **No**    | If true, the charge time will be reset when the number of charges changes.                                                                                                                            |
+| ClickBypass       | `Boolean`<br />(Default: false)      | **No**    | If true, RootInteractions keyed to this cooldown can still be activated when it is on cooldown provided that the RootInteraction was triggered by a distinct key or mouse button press on the client. |
+
+## Combo Chains
+
+Hytale additionally comes with a rich "combo chaining" system, which allows several inputs in a row to result in different
+attacks and special moves.  Rather than being attached to the RootInteraction like the cooldown system, these are
+primarily driven by the `Chaining` interaction.
+
+### Chaining
+
+This interaction does not inherit from SimpleInteraction and therefore has no Failed field. Its Next field works differently
+from most interaction types.
+
+Chaining is a type of flow control interaction- each time a Chaining interaction with the same `ChainId` is called, a single
+interaction in the `Next` list is chosen and the others are ignored. The first time the `ChainId` is used, the first
+interaction in the list is chosen, the next time the second, etc. Once the end of the list is reached, the first
+interaction will be chosen again.
+
+Bear in mind: the progress through the Next list is based on the **ChainId**, not the interaction!  That means that two
+different Chaining interactions can share a single combo chain. You could have a pair of daggers that attacks with
+the left when the left mouse button is clicked and with the right when the right mouse button is clicked.  You could give
+both interaction chains a Chaining interaction with the same `ChainId` and three `Next` entries that do a light-light-heavy
+combo.  Each specific hit would occur with either the left or the right knife based on which button you clicked, but
+the combo would be otherwise identical regardless of which you chose.
+
+The Chaining interaction also has a concept called "flags".  It is possible to attach named flags to a `ChainId` by using
+the ChainFlag interaction.  Then, you specify the flag name in Chaining's `Flags` field. If a Flag is active when the
+Chaining interaction is run, the Flag's interaction will be run instead of the appropriate interaction in `Next`.
+Bear in mind: the entity's progress through the `Next` list still advances, the resulting `Next` interaction is just not
+run.  Only one flag can be active at a time.
+
+Lastly, it is possible to cancel the entity's progress through the combo chain and reset them to the first interaction in
+the list. This can be done with the CancelChain interaction, but it will also happen automatically if the player does
+not trigger an interaction with the ChainId for the specified ChainingAllowance.  When either of these happen, all flags will be
+canceled as well.
+
+All of these effects are triggered on the User entity only. Non-players can use the chaining system, but Flags do not currently
+work for non-players.  This interaction has no special failure conditions.
+
+**Chaining Fields**
+
+| Field Name        | Type                                                       | Required? | Notes                                                                                                                                                                                                                       |
+| ----------------- | ---------------------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| ChainId           | `String`                                                   | **No**    | If provided, acts as a key that multiple Chaining interactions can use to share combo chain progress and flags. If not provided, a unique ChainId will be generated for this interaction.                                   |
+| ChainingAllowance | `Double`<br />(Default: 0.0)                               | **No**    | If, at the time this interaction is triggered, it has been this long in seconds since the last time a Chaining interaction with the same ChainId was executed, all state for this ChainId will be cleared before execution. |
+| Next              | `AssetArray`<br />(Element Type: `Interaction`)            | **Yes**   | A list of interactions to cycle between each time this interaction is run.                                                                                                                                                  |
+| Flags             | `Map`<br />(Key Type: `String`, Value Type: `Interaction`) | **No**    | A map of flag names to interactions to run if the flag is active when this interaction executes.                                                                                                                            |
+
+### CancelChain
+
+This interaction resets all progress and flag data on the User entity for the provided `ChainId`.  The next time a Chaining
+interaction is called for the provided `ChainId`, it will begin at the first interaction in the `Next` list. This
+interaction has no special failure conditions.
+
+**CancelChain Fields**
+
+| Field Name | Type     | Required? | Notes                                 |
+| ---------- | -------- | --------- | ------------------------------------- |
+| ChainId    | `String` | **Yes**   | A ChainId whose data should be reset. |
+
+### ChainFlag
+
+This interaction activates a flag on the User entity for the provided `ChainId`, which can be used to change behavior the
+next time a Chaining interaction with this `ChainId` is run. This will overwrite any flag that has
+already been raised. This interaction will have no effect for non-players. This interaction has no special failure
+conditions.
+
+| Field Name | Type     | Required? | Notes                                        |
+| ---------- | -------- | --------- | -------------------------------------------- |
+| ChainId    | `String` | **Yes**   | A ChainId on whom the flag should be raised. |
+| Flag       | `String` | **Yes**   | The name of the flag to raise.               |
+
+## Charging
+
+A unique flow-control interaction that is frequently used is the Charging interaction.  It is a flow-control interaction
+that delays while the input button used to trigger the interaction chain is held.  When it is released (or the interaction
+is forced to end), the interaction chain can continue with a different interaction based on how long the input was held
+for.
+
+These interactions are all related by either being the Charging interaction, or other interaction types that inherit the
+Charging interaction's behavior.
+
+### Charging
+
+This interaction does not inherit from SimpleInteraction and therefore its Next field works different from most interactions.
+This interaction adds its own Failed field which works the same way that SimpleInteraction's does.
+
+This interaction only works properly when its interaction chain was triggered by a client key or button press (or
+NPC-simulated equivalent). This interaction will continue executing for as long as the key or button press is held (with
+some exceptions, covered below) by the User entity.  Like other interactions, it has a `Next` field indicating which interaction to execute
+after this one, but the field is a map from `Float` values to `Interaction` assets. When this interaction ends, either
+due to the input being released or the charge duration completing, this interaction will determine the largest `Float` key that is less
+than the amount of time in seconds that the interaction was executing for.  The Interaction mapped to that key will be
+executed next.
+
+The interaction includes some cancellation conditions that are specific to this interaction. For instance, the interaction
+has a `CancelOnOtherClick` field that matches the field on RootInteraction. If it is active on this interaction but not
+the RootInteraction, then clicking while charging will cancel this interaction (and execute the `Failed` interaction rather
+than any of the `Next` interactions) but otherwise continue the interaction chain.
+
+Another valuable feature Charging has is the `Forks` field.  For input-triggered interactions that are triggered while the
+Charging interaction is executing, you can add an entry for the relevant InteractionType to this field and instead of
+triggering the usual interaction chain based on held item, targeted block, etc. the RootInteraction specified in the
+`Forks` field will be triggered.  This can unlock rich attack modes and behaviors. For instance, having a shield bash attack
+triggered off left click while blocking, or a special attack that triggers when both mouse buttons are pressed at the
+same time.
+
+There are two modes of operation for the Charging interaction. One is to have the ability charge for as long
+as the input is held and only end execution when the entity releases the input.  Bows in the main Hytale game work
+that way.  That is accomplished by setting `AllowIndefiniteHold` to true.  Another mode of operation is to have the
+interaction complete execution when the execution time has surpassed the largest key value in the `Next` field and
+immediately begin executing the Interaction mapped to that key.  Food in the main Hytale game work like this.  It
+is accomplished by setting `AllowIndefiniteHold` to false.
+
+One pitfall to be careful of when setting `AllowIndefiniteHold` to false is the way it interacts with cooldowns.\
+Normally, input-initiated interaction chains start a 0.35s cooldown on the triggered RootInteraction that prevents
+holding the mouse button from immediately spamming a new interaction when the first one completes.  However, if the
+duration of a Charging interaction is longer than 0.35s, then the cooldown will have already completed when the
+interaction chain finishes, which will often result in a new execution beginning immediately before the player can
+stop pressing the mouse button.  One solution for this problem is to add a `Simple` interaction to the end of your
+interaction chain with a `RunTime` of 0.35s to simulate the cooldown.  Alternatively, you can add a longer cooldown
+(the maximum duration of your Charging interaction plus 0.35s) to the RootInteraction. However, the longer cooldown is
+not always desirable, as the interaction may have ended prematurely, resulting in an unusually long lockout between
+executions.
+
+**Charging Fields**
+
+| Field Name                         | Type                                                                    | Required? | Notes                                                                                                                                                                                                                                                                                                                                                                                       |
+| ---------------------------------- | ----------------------------------------------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| FailOnDamage                       | `Boolean`<br />(Default: false)                                         | **No**    | If true, this interaction will fail and end immediately if the User entity takes any damage while it is executing.                                                                                                                                                                                                                                                                          |
+| CancelOnOtherClick                 | `Boolean`<br />(Default: true)                                          | **No**    | If true, this interaction will fail and end immediately if the User entity sends another button or key press while it is executing.                                                                                                                                                                                                                                                         |
+| Forks                              | `Map`<br />(Key Type: `InteractionType`, Value Type: `RootInteraction`) | **No**    | A map of InteractionType to RootInteraction. If entity input triggers the InteractionType while this interaction is executing, the mapped RootInteraction will be forked into its own interaction chain. This will happen instead of the usual handling for that InteractionType.  This fork will occur even if `CancelOnOtherClick` is set to true.                                        |
+| Failed                             | `Asset`<br />(Asset Type: `Interaction`)                                | **No**    | After this Interaction has finished, "Failed" will be executed if this Interaction failed.                                                                                                                                                                                                                                                                                                  |
+| AllowIndefiniteHold                | `Boolean`<br />(Default: false)                                         | **No**    | If true, this interaction will continue executing for as long as the User entity continues to hold the input. If false, execution will end as soon as the execution time in seconds reaches the largest key value in the `Next` map.                                                                                                                                                        |
+| DisplayProgress                    | `Boolean`<br />(Default: true)                                          | **No**    | If true, players executing this interaction will see a progress bar will be displayed below their cursor indicating how close to reaching the highest key value in `Next` they are.                                                                                                                                                                                                         |
+| Next                               | `Map`<br />(Key Type: `Float`, Value Type: `Interaction`)               | **No**    | A map from `Float` to `Interaction`.  When this interaction successfully finishes executing (either because the input was released or because the maximum duration was reached), this interaction will find the `Float` value with the largest duration in seconds that is less than the amount of time this interaction executed for. That key's mapped Interaction will then be executed. |
+| MouseSensitivityAdjustmentTarget   | `Float`<br />(Default: 1.0)                                             | **No**    | While charging, this mouse sensitivity multiplier will gradually be applied.                                                                                                                                                                                                                                                                                                                |
+| MouseSensitivityAdjustmentDuration | `Float`<br />(Default: 1.0)                                             | **No**    | Duration in seconds. After this many seconds, `MouseSensitivityAdjustmentTarget` will be fully applied to the mouse sensitivity.                                                                                                                                                                                                                                                            |
+| Delay                              | `ChargingDelay`                                                         | **No**    | Settings that allow charging progress to be pushed back when the User entity takes damage.                                                                                                                                                                                                                                                                                                  |
+
+**ChargingDelay Fields**
+
+| Field Name    | Type                        | Required? | Notes                                                                                                                                                                                                                                                                     |
+| ------------- | --------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| MinHealth     | `Float`<br />(Default: 0.0) | **No**    | Damage taken as a percentage of entity health (0.0-1.0). If a hit deals less than this much damage, no pushback will be applied.  If a hit deals exactly this much damage, `MinDelay` seconds worth of pushback will be applied.                                          |
+| MaxHealth     | `Float`<br />(Default: 0.0) | **No**    | Damage taken as a percentage of entity health (0.0-1.0). If a hit deals at least this much damage, `MaxDelay` seconds worth of pushback will be applied.                                                                                                                  |
+| MinDelay      | `Float`<br />(Default: 0)   | **No**    | The amount of pushback, in seconds, to apply if the entity takes a hit that deals `MinHealth` damage. The amount of pushback applied by a hit is a gradiant between `MinDelay` and `MaxDelay` based on the amount of damage between `MinHealth` and `MaxHealth`.          |
+| MaxDelay      | `Float`<br />(Default: 0)   | **No**    | The amount of pushback, in seconds, to apply if the entity takes a hit that deals at least `MaxHealth` damage. The amount of pushback applied by a hit is a gradiant between `MinDelay` and `MaxDelay` based on the amount of damage between `MinHealth` and `MaxHealth`. |
+| MaxTotalDelay | `Float`<br />(Deault: 0)    | **No**    | The maximum amount of pushback the entity can receive over the course of a single charge, regardless of how many times they are hit.                                                                                                                                      |
+
+**InteractionType Values**
+
+- `Primary`
+- `Secondary`
+- `Ability1`
+- `Ability2`
+- `Ability3`
+- `Use`
+- `Pick`
+- `Pickup`
+- `CollisionEnter`
+- `CollisionLeave`
+- `Collision`
+- `EntityStatEffect`
+- `SwapTo`
+- `SwapFrom`
+- `Death`
+- `Wielding`
+- `ProjectileSpawn`
+- `ProjectileHit`
+- `ProjectileMiss`
+- `ProjectileBounce`
+- `Held`
+- `HeldOffhand`
+- `Equipped`
+- `Dodge`
+- `GameModeSwap`
+
+### Wielding
+
+This interaction is inherited from Charging rather than SimpleInteraction.  However, its `Failed` and `Next` fields function
+identically to SimpleInteraction.  It does not inherit all fields from Charging, so be sure to pay close attention to
+the field list below.
+
+This interaction drives most blocking behavior in the game. While this interaction is executing, attacks made against
+the Owner entity will (conditionally) trigger effects defined in this interaction.  Unlike the Charging interaction,
+this interaction can always execute indefinitely and will only end when it fails or when the input is released.
+
+One option available in Wielding is `AngledWielding`, which allows damage and knockback modifiers to only be applied
+depending on the direction the attack against the Owner entity is coming from.  The AngledWielding type has a
+field `Angle` which determines which direction the protection points relative to the player (0 is the player's
+front), and `AngleDistance` which determines how wide the cone of protection extends around the player.  Block effects
+from this interaction (such as `BlockedEffects`, `BlockedInteractions`, and `StaminaCost`) will only apply if
+the DamageCause matches `DamageModifiers` OR if the DamageCause matches `AngledWielding.DamageModifiers` and
+the source of the damage matches `Angle` and `AngleDistance`.  It is possible for damage and knockback multipliers
+specified on both this interaction's modifier fields and `AngledWielding`'s modifier fields to stack, if both
+have entries for the same DamageCause.
+
+This interaction will only have an effect on damage taken by one of the DamageCause entries in `DamageModifiers` or
+`AngledWielding.DamageModifiers`.  If a DamageCause is in `DamageModifiers`, then the block effect will be triggered
+and the damage modifier applied regardless of what direction the Owner entity is attacked from.  If a DamageCause is in
+`AngledWielding.DamageModifiers`, then the damage modifier is only applied if the
+
+\*\* Wielding Fields\*\*
+
+| Field Name          | Type                                                                    | Required? | Notes                                                                                                                                                                                                                                                                                                                                                                                                      |
+| ------------------- | ----------------------------------------------------------------------- | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| FailOnDamage        | `Boolean`<br />(Default: false)                                         | **No**    | If true, this interaction will fail and end immediately if the User entity takes any damage while it is executing.                                                                                                                                                                                                                                                                                         |
+| CancelOnOtherClick  | `Boolean`<br />(Default: true)                                          | **No**    | If true, this interaction will fail and end immediately if the User entity sends another button or key press while it is executing.                                                                                                                                                                                                                                                                        |
+| Forks               | `Map`<br />(Key Type: `InteractionType`, Value Type: `RootInteraction`) | **No**    | A map of InteractionType to RootInteraction. If entity input triggers the InteractionType while this interaction is executing, the mapped RootInteraction will be forked into its own interaction chain. This will happen instead of the usual handling for that InteractionType.  This fork will occur even if `CancelOnOtherClick` is set to true (after which this interaction chain will be canceled). |
+| Next                | `Asset`<br />(Asset Type: `Interaction`)                                | **No**    | After this interaction has finished, "Next" will be executed if this interaction did not fail.                                                                                                                                                                                                                                                                                                             |
+| Failed              | `Asset`<br />(Asset Type: `Interaction`)                                | **No**    | After this interaction has finished, "Failed" will be executed if this interaction failed.                                                                                                                                                                                                                                                                                                                 |
+| DamageModifiers     | `Map`<br />(Key Type: `DamageCause`, Value Type: `Float`)               | **No**    | A map from DamageCause to Float, where the Float is multiplied against any damage received from the mapped DamageCause while this interaction is executing.                                                                                                                                                                                                                                                |
+| KnockbackModifiers  | `Map`<br />(Key Type: `DamageCause`, Value Type: `Float`)               | **No**    | A map from DamageCause to Float, where the Float is multiplied against any knockback force received from the mapped DamageCause while this interaction is executing.                                                                                                                                                                                                                                       |
+| AngledWielding      | `AngledWielding`                                                        | **No**    | Configuration to only trigger block effects from certain angles.                                                                                                                                                                                                                                                                                                                                           |
+| StaminaCost         | `StaminaCost`                                                           | **No**    | If the Owner entity receives damage that matches `DamageModifiers` or `AngledWielding` while this interaction is executing, then the entity's stamina will be deducted according to this configuration.                                                                                                                                                                                                    |
+| BlockedEffects      | `DamageEffects`                                                         | **No**    | If the Owner entity receives damage that matches `DamageModifiers` or `AngledWielding` while this interaction is executing, then these effects will be applied to the instance of damage.                                                                                                                                                                                                                  |
+| BlockedInteractions | `Asset`<br />(Asset Type: `RootInteraction`)                            | **No**    | If the Owner entity receives damage that matches `DamageModifiers` or `AngledWielding` while this interaction is executing, then this RootInteraction will be launched as a brand new interaction chain with the Owner entity as both Owner and User, and the attacker as the Target entity.  This new interaction chain is, notably, brand new, **not** forked from the current one.                      |
+
+**AngledWielding Fields**
+
+| Field Name         | Type                                                      | Required? | Notes                                                                                                                                                                                                            |
+| ------------------ | --------------------------------------------------------- | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Angle              | `Float`<br />(Default: 0.0)                               | **No**    | Angle in degrees relative to the Owner entity where the angled protection is centered. 0.0 means pointed towards the front of the Owner entity.                                                                  |
+| AngleDistance      | `Float`<br />(Default: 0.0)                               | **No**    | Angle in degrees indicating how wide the cone of protection is.                                                                                                                                                  |
+| DamageModifiers    | `Map`<br />(Key Type: `DamageCause`, Value Type: `Float`) | **No**    | A map from DamageCause to Float, where the Float is multiplied against any damage received from the mapped DamageCause received from within the cone of protection while this interaction is executing.          |
+| KnockbackModifiers | `Map`<br />(Key Type: `DamageCause`, Value Type: `Float`) | **No**    | A map from DamageCause to Float, where the Float is multiplied against any knockback force received from the mapped DamageCause received from within the cone of protection while this interaction is executing. |
+
+**StaminaCost Fields**
+
+| Field Name | Type                                             | Required? | Notes                                                                                                                                                                                                                                                |
+| ---------- | ------------------------------------------------ | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| CostType   | `CostType`<br />(Default: `MaxHealthPercentage`) | **No**    | How to calculate stamina consumed by blocking from the raw pre-block damage. If `Damage`, then the stamina consumed will be `rawDamage / Value`. If `MaxHealthPercentage`, then the stamina consumed will be `rawDamage / (EntityMaxHealth * Value)` |
+| Value      | `Float`<br />(Default: 0.04)                     | **No**    | The value to use in the `CostType` formula.                                                                                                                                                                                                          |
+
+**DamageEffects Fields**
+
+| Field Name             | Type                                         | Required? | Notes                                                                           |
+| ---------------------- | -------------------------------------------- | --------- | ------------------------------------------------------------------------------- |
+| ModelParticles         | `Array`<br />(Element Type: `ModelParticle`) | **No**    | Particle systems to trigger in the first-person view.                           |
+| WorldParticles         | `Array`<br />(Element Type: `WorldParticle`) | **No**    | Particle systems to trigger in the third-person view.                           |
+| LocalSoundEventId      | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | 2D sound to play locally to the attacking entity if they are a player.          |
+| WorldSoundEventId      | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | Sound to play in the world at the Owner entity's location.                      |
+| PlayerSoundEventId     | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | 2D sound to play locally to the Owner entity if they are a player.              |
+| ViewDistance           | `Double`<br />(Default: 75.0)                | **No**    | Distance at which these effects should play for other players.                  |
+| Knockback              | `Knockback`                                  | **No**    | The properties of the knockback that will be applied.                           |
+| CameraEffect           | `Asset`<br />(Asset Type: `CameraEffect`)    | **No**    | CameraEffect to briefly apply locally to the Owner entity if they are a player. |
+| StaminaDrainMultiplier | `Float`<br />(Default: 1.0)                  | **No**    | This multiplier is applied to the `StaminaCost`, if any.                        |
+
+**Knockback Fields**
+
+| Field Name     | Type                                       | Required? | Notes                                                                                                                      |
+| -------------- | ------------------------------------------ | --------- | -------------------------------------------------------------------------------------------------------------------------- |
+| Type           | `String`                                   | **No**    | If provided, specifies a type of knockback to use. Each knockback type may come with additional fields.                    |
+| Force          | `Double`<br />(Default: 0.0)               | **No**    | The amount of force to apply to the Owner entity.                                                                          |
+| Duration       | `Double`<br />(Default: 0.0)               | **No**    | If 0.0, apply the force as a single impulse.  If more, continuously apply the force over a period of time.                 |
+| VelocityType   | `ChangeVelocityType`<br />(Default: `Add`) | **No**    | How to apply the force, either adding it to the entity's current velocity, or setting the velocity to the knockback force. |
+| VelocityConfig | `VelocityConfig`                           | **No**    | Characteristics of friction as the Owner entity is thrown by this knockback.                                               |
+
+**Knockback Type: Force**
+
+Apply the calculated knockback force along the provided direction.
+
+| Field Name | Type                         | Required? | Notes                                                                                |
+| ---------- | ---------------------------- | --------- | ------------------------------------------------------------------------------------ |
+| Direction  | `Vector3`<br />(Default: Up) | **No**    | Which direction the player should be flung, relative to the direction of the attack. |
+
+**Knockback Type: Point**
+
+Apply the calculated knockback force laterally along the XZ plane, plus provided Y velocity.
+
+| Field Name | Type                        | Required? | Notes                                                                                                   |
+| ---------- | --------------------------- | --------- | ------------------------------------------------------------------------------------------------------- |
+| OffsetX    | `Integer`<br />(Default: 0) | **No**    | Offset the source position of the knockback left or right perpendicular to the direction of the attack. |
+| OffsetZ    | `Integer`<br />(Default: 0) | **No**    | Offset the source position of the knockback, forward or backward along the directon of the attack.      |
+| RotateY    | `Integer`<br />(Default: 0) | **No**    | Rotate the knockback direction around the Y axis, where 0 is the default attack direction.              |
+| VelocityY  | `Float`<br />(Default: 0.0) | **No**    | Add vertical velocity to the knockback force after the direction and force has been calculated.         |
+
+**Knockback Type: Directional**
+
+Apply the calculated knockback force along the attack direction, removing any vertical component and replacing it with a provided Y velocity.
+
+| Field Name | Type                      | Required? | Notes                                                                                                                                            |
+| ---------- | ------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------ |
+| RelativeX  | `Float`<br />(Default: 0) | **No**    | Apply additional force left or right perpendicular to the direction of the attack. The additional force is multiplied by the knockback strength. |
+| RelativeZ  | `Float`<br />(Default: 0) | **No**    | Apply additional force forward or backward along the attack direction. The additional force is multiplied by the knockback strength.             |
+| VelocityY  | `Float`<br />(Default: 0) | **No**    | Replace the vertical velocity of the knockback with this value.  This value is not multiplied by knockback strength.                             |
+
+**VelocityConfig Fields**
+
+| Field Name          | Type                                              | Required? | Notes                                                                                                                                                                                           |
+| ------------------- | ------------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| GroundResistance    | `Float`<br />(Default: 0.82)                      | **No**    | The minimum amount of friction applied when the entity is in contact with the ground.  1.0 = no friction, 0.0 = total friction                                                                  |
+| GroundResistanceMax | `Float`<br />(Default: 0.0)                       | **No**    | The maximum amount of friction applied when the entity is in contact with the ground.  1.0 = no friction, 0.0 = total friction                                                                  |
+| AirResistance       | `Float`<br />(Default: 0.96)                      | **No**    | The minimum amount of friction applied when the entity is in the air. 1.0 = no friction, 0.0 = total friction                                                                                   |
+| AirResistanceMax    | `Float`<br />(Default: 0.0)                       | **No**    | The maximum amount of friction applied when the entity is in the air. 1.0 = no friction, 0.0 = total friction                                                                                   |
+| Threshold           | `Float`<br />(Default: 1.0)                       | **No**    | The speed at which the maximum amount of friction will be applied to the entity. The amount of friction applied will increase from minimum to maximum as the entity moves from 0 to this speed. |
+| Style               | `VelocityThresholdStyle`<br />(Default: `Linear`) | **No**    | The curve that friction follows as the entity's speed increases toward the `Threshold`.                                                                                                         |
+
+**CostType Values**
+
+- `MaxHealthPercentage`
+- `Damage`
+
+**ChangeVelocityType Values**
+
+- `Add`
+- `Set`
+
+**VelocityThresholdStyle Values**
+
+- `Linear`
+- `Exp`
+
+## Blocks
+
+These are interaction types meant to reason about and modify blocks in the world.  The most important concept unique
+to these interactions is the Block Target.  Like the Entity Target, it is mutable and can come from many places.
+However, for interaction chains initiated by the client, the block target will initially be the block that the player's cursor was
+over, if any.
+
+Additionally, for interaction chains initiated by the client, the client will send along which face of the block is targeted,
+which is used by a few block-related interactions.
+It is left up to each interaction type that cares about block faces as to how to handle this behavior for simulated input
+(i.e. NPCs initiating chains that are normally initated by the client).  At the time of this writing, all block-related
+interactions choose the top face where relevant in simulated input.
+
+### BlockCondition
+
+This interaction has a field `Matchers` which specifies certain conditions, such as block type, state, etc.  This
+interaction fails if the current target block does not match all of them.
+
+**BlockCondition Fields**
+
+| Field Name       | Type                                        | Required? | Notes                                                                                                                                                                                                                                                                                                                                   |
+| ---------------- | ------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false)             | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction.                                                                                                                                                                                                       |
+| Matchers         | `Array`<br />(Element Type: `BlockMatcher`) | **Yes**   | A list of conditions that the target block must match or this condition will fail.<br />**Note: This field is technically not required but there is a bug that makes it dangerous to not provide at the time of this writing.**<br />**Note: If no conditions are added to this array, the interaction will fail, counterintuitively.** |
+
+**BlockMatcher Fields**
+
+| Field Name | Type                       | Required? | Notes                                                                          |
+| ---------- | -------------------------- | --------- | ------------------------------------------------------------------------------ |
+| Block      | `BlockIdMatcher`           | **No**    | If provided, requires the block itself match some set of conditions.           |
+| Face       | `BlockFace`                | **No**    | If provided and not 'None', requires a specific block face be targeted.        |
+| StaticFace | `Boolean` (Default: false) | **No**    | If false, the face condition will be adjusted by the block's current rotation. |
+
+**BlockFace Values**
+
+- `Up`
+- `Down`
+- `North`
+- `South`
+- `East`
+- `West`
+- `None`
+
+**BlockIdMatcher Fields**
+
+| Field Name | Type                                   | Required? | Notes                                                                      |
+| ---------- | -------------------------------------- | --------- | -------------------------------------------------------------------------- |
+| Id         | `Asset`<br />(Asset Type: `BlockType`) | **No**    | If provided, the block must match the specified `BlockType`.               |
+| State      | `String`                               | **No**    | If provided, the block's current state must match the provided state name. |
+| Tag        | `String`                               | **No**    | If provided, the block type's asset tags must contain the provided tag.    |
+
+### DestroyCondition
+
+This interaction fails if the current User entity cannot destroy the current target blcok.
+
+**DestroyCondition Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+
+### PlacementCountCondition
+
+This interaction accepts the name of a BlockType that has the TrackedPlacement BlockEntity. The interaction will fail if the number of
+blocks of the provided BlockType in the world do not match the provided condition.
+
+**PlacementCountCondition Fields**
+
+| Field Name | Type                           | Required? | Notes                                                                                                                                                                                                                                                           |
+| ---------- | ------------------------------ | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Block      | `String`                       | **Yes**   | The BlockType to examine. The number of instances of the BlockType in the world will be compared to Value.<br />**Note: The specified BlockType must have the TrackedPlacement BlockEntity. Otherwise, the number of blocks in the world will always be zero.** |
+| Value      | `Integer`<br />(Default: 0)    | **No**    | The value to compare the number of blocks in the world with.                                                                                                                                                                                                    |
+| LessThan   | \`Boolean<br />(Default: true) | **No**    | If true, the interaction will fail if the number of blocks in the world is greater than or equal to Value. If false, the interaction will fail if the number of blocks in the world is less than or equal to Value.                                             |
+
+### BreakBlock
+
+This interaction attempts to break the target block while acting as the User entity. The User entity must be a player. It
+is not guaranteed to work, depending on world settings and the User entity's current state, it may not work.  If it
+fails, it will fail the interaction under some circumstances, but not others.
+
+**Note: In particular, if `Harvest`=false and the player is in Survival mode, the player will simply execute a damage operation
+against the block. Even when the Tool field is specified, the player's currently-held item can impact the results in unintuitive
+ways.**
+
+This interaction will fail if there is no block target, if `Harvest`=true and the
+block is not harvestable, or if the world settings prevent the Harvest/Break operation.
+It will generally not fail otherwise, even if the block was not broken or damaged.
+The block will generally break every time if `Harvest`=true or the player is in
+Creative mode.
+
+**BreakBlock Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                                                                                                                                                                                                  |
+| ---------------- | ------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction.                                                                                                                                                                      |
+| Harvest          | `Boolean` (Default: false)      | **No**    | If true, harvest the block and deposit the drops in the player's inventory. This operation will generally always succeed.  If false, this interaction will effectively perform whatever action would have occurred if the player had left-clicked the block.                                           |
+| Tool             | `String`                        | **No**    | If `Harvest`=true, the player is in Survival mode, and this field is provided, then the break operation will be performed as though with this tool type.<br />**This field mostly doesn't work.  Your held item will be used for most block damage calculations regardless of this field's contents.** |
+| MatchTool        | `Boolean` (Default: false)      | **No**    | If true, `Harvest`=true, the player is in Survival mode, and `Tool` is provided, block breaking will be prevented unless `Tool` is a valid gathering tool for the target block. The interaction will not be failed, even if block breaking is prevented in this manner.                                |
+
+### ChangeBlock
+
+This interaction requires a mapping from one or more current BlockTypes to one or more target BlockTypes.  If the
+target block is one of the key BlockTypes, then it will be changed to the mapped target BlockType.  If the current
+BlockType of the target block does not appear as a key in the Changes field, then this interaction fails.
+
+**ChangeBlock Fields**
+
+| Field Name        | Type                                                        | Required? | Notes                                                                                                                             |
+| ----------------- | ----------------------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget  | `Boolean`<br />(Default: false)                             | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+| Changes           | `Map`<br />(Key Type: `BlockType`, Value Type: `BlockType`) | **No**    | A list of potential block type changes, with each entry having a current and new BlockType id.                                    |
+| WorldSoundEventId | `Asset`<br />(Asset Type: `SoundEvent`)                     | **No**    | If provided, this SoundEvent is played in the world at the position of the block if the block successfully changes.               |
+| RequireNotBroken  | `Boolean`<br />(Default: false)                             | **No**    | If true, this interaction will fail if the player's held item is broken (durability 0), and the block change will not take place. |
+
+### ChangeState
+
+This interaction requires a mapping from one or more current block state names to one or more state names. If the
+target block is in one of the key block states, then it will be changed to the mapped target blocks tate. If the
+current block state of the target block does nto appear as a key in the Changes field, then this interaction fails.
+
+All blocks start out with a null state by default.  This null state can be referenced by the key "default" and the block
+can be returned to that state with the value "default".
+
+**ChangeState Fields**
+
+| Field Name       | Type                                                  | Required? | Notes                                                                                                                                          |
+| ---------------- | ----------------------------------------------------- | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false)                       | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction.              |
+| Changes          | `Map`<br />(Key Type: `String`, Value Type: `String`) | **No**    | A list of potential block state changes, with each entry having a current and new state name.                                                  |
+| UpdateBlockState | `Boolean`<br />(Default: false)                       | **No**    | If true, performs a full refresh of the block's BlockEntity component and notifies nearby players as though a full block type change occurred. |
+
+### CycleBlockGroup
+
+This interaction will attempt to change the target block to the next block type in one of the BlockGroups it belongs to.
+If the block type belongs to multiple BlockGroups, which one is used is effectively arbitrary. The User entity must be
+a player. If the block cannot be changed for any reason (entity not a player, no block target, block does not belong
+to a BlockGroup, etc.). If the block is the only entry in the BlockGroup, this interaction will succeed and the block
+will be considered changed despite nothing happening.  Unlike most other block-changing interactions, this one will
+fail if the world settings prevent players from breaking blocks.
+
+**This interaction always reduces the player's held item's durability by a single 'hit' worth of damage if the block
+changes. There is no way to prevent it. The block type will change and the interaction will succeed even if the player's
+held item is broken, however.**
+
+**CycleBlockGroup Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+
+### DestroyBlock
+
+This interaction destroys the target block without dropping anything.  It will successfully destroy the block if the
+target block exists and this interaction has no failure conditions.
+
+**This interaction has no additional fields.**
+
+### PickBlock
+
+This interaction is effectively equivalent to using the middle mouse button in creative mode. In survival mode, the
+block's item will be moved to the user's current active hotbar slot if it is in the player's inventory.  This
+interaction is performed entirely on the client and cannot be performed by non-players.  It is unclear if this
+interaction has failure conditions.
+
+**PickBlock Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+
+### PlaceBlock
+
+This interaction is effectively identical to a right clicking while holding a block in their hand, with some
+additional options. For one, it can be executed with any LivingEntity as the User entity. For another, it has some
+useful fields.  For the most part, though, it follows the same behaviors and rules as any ordinary block placement
+by a player.
+
+It's not clear under what circumstances this interaction can fail. The server will not fail the interaction under any
+special circumstances (including when there is no target block, or when `BlockTypeToPlace` is not provided and the
+LivingEntity is not holding a block). However, the client is very involved with the function of this interaction and
+its behavior is unknown.
+
+**PlaceBlock Fields**
+
+| Field Name         | Type                                   | Required? | Notes                                                                                                                                                                                                                                                                                                                                                           |
+| ------------------ | -------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| BlockTypeToPlace   | `Asset`<br />(Asset Type: `BlockType`) | **No**    | If provided, the block placed by this interaction will be the specified BlockType. If not provided, the User entity's held item will be used, instead, if it is a block.                                                                                                                                                                                        |
+| RemoveItemInHand   | `Boolean`<br />(Default: True)         | **No**    | If true and the User entity is not a player in Creative mode, the item in the player's hand must match the block being placed and one quantity will be removed for each block placed. If the item does not match, the block cannot be placed.  If false, the player's hand item is ignored entirely.\*\*                                                        |
+| AllowDragPlacement | `Boolean`<br />(Default: True)         | **No**    | If true and the interaction was triggered on the client by a player, then the player can hold the input that was used to activate this interaction chain and move the mouse around in order to execute this interaction repeatedly and place several blocks. The interaction chain will not move onto the next interaction until the player releases the input. |
+
+### RunOnBlockTypes
+
+This interaction retrieves all blocks within a provided radius of the User entity. For each block that matches any of
+the provided BlockSets, a new interaction chain will be forked that uses the matching block as the target block.
+This interaction will continue executing until all forked interaction chains have completed.  The interaction will fail if no
+blocks within the radius match the provided BlockSets or if all of the forked interaction chains fail.
+
+**RunOnBlockTypes Fields**
+
+| Field Name   | Type                                         | Required?        | Notes                                                                                                                                                                                                                                                                                      |
+| ------------ | -------------------------------------------- | ---------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| Range        | `Integer`                                    | **Yes**          | The spherical radius around the User entity to search for blocks. Must be at least 1.                                                                                                                                                                                                      |
+| BlockSets    | `AssetArray`<br />(Element Type: `BlockSet`) | **No**           | A list of BlockSets to match nearby blocks again. Only blocks that match any of the BlockSets will have interaction chains forked for them.                                                                                                                                                |
+| MaxCount     | `Integer`                                    | **Yes**          | The maximum number of blocks that will be located with the search. Further blocks will be ignored. If there are more matching blocks within the radius than this number, the specific set of blocks that will be found is completely arbitrary and may change from execution to execution. |
+| Interactions | `Asset`<br />(Asset Type: `RootInteraction`) | **No, but yes.** | The RootInteraction that will be forked for each matching block.  This interaction will not fail to validate if it is missing, but every execution of this interaction will fail.                                                                                                          |
+
+### UseBlock
+
+If the target block has an interaction for this interaction chain's interaction type, execute it immediately as part of
+this interaction chain. The execution will be wrapped in UseBlockEvent.Pre and UseBlockEvent.Post events, and cancellations
+of the UserBlockEvent.Pre event are respected. The User entity is considered the triggering entity for both events.
+
+If the target block does not have an interaction for this interaction chain's interaction type, this interaction fails.
+
+**This interaction has no additional fields.**
+
+## Items
+
+These are interactions intended to interface with an entity's inventory. There is no concept of an "item target",
+unfortunately, so these generally either interact with the entity's held item or the entity's inventory at a high level.
+
+### AddItem
+
+Adds a specified quantity of a specified item to the User entity's inventory, preferring to add it to the
+entity's hotbar where possible. This interaction will have no effect on User entities that are not LivingEntities.
+This interaction has no failure states.
+
+**Note: This interaction has a bug in its field validators that will cause interactions that reference items declared
+in the same mod to fail validation on startup.  Additionally, this interaction has a bug that will cause it to
+fail and have no effect if the User entity has no block target. Use ModifyInventory instead.**
+
+**AddItem Fields**
+
+| Field Name       | Type                              | Required? | Notes                                                                                                                             |
+| ---------------- | --------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false)   | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+| ItemId           | `Asset`<br />(Asset Type: `Item`) | **Yes**   | The item id of the item to add to the player's inventory.                                                                         |
+| Quantity         | `Integer`<br />(Default: 0)       | **No**    | The quantity of the item to add to the player's inventory.                                                                        |
+
+### CheckUniqueItemUsage
+
+This interaction will check whether it has run once for the User entity with their currently-held item before. If it hasn't,
+it will succeed. If it has, it will fail. It will also fail if the User entity is not a player. The interaction will record
+the item id of the User entity's currently-held item on success, ensuring it cannot be successfully run with that player
+and item id combination again.
+
+**This interaction has no additional fields.**
+
+### ChangeActiveSlot
+
+This interaction does not inherit from SimpleInteraction and therefore has no Next or Failed fields.  The `CancelOnItemChange`
+field is ignored for this interaction and is always treated as false. This interaction will set the User entity's currently-
+active hotbar slot to the specified slot index. If none is specified, the interaction chain's target slot will be used,
+if any. Otherwise, slot 0 will be used.  If a slot is specified and it is already active, then this interaction will
+have no effect, but if no slot is specified and the interaction chain's target slot is already active, the logic in
+the next paragraph will still be executed. This interaction will also have no effect if the User entity is not a
+LivingEntity.
+
+Once the slot has changed, a new SwapTo interaction chain will be forked off for the selected slot.
+If a target slot was specified, then the interaction chain's current target slot will be set to the specified slot, as will
+the forked SwapTo interaction chain. If this interaction chain was initiated by a player swapping an item into or out of
+an occupied active hotbar slot, then the swap will be executed after the slot is changed and before the SwapTo
+interaction is forked. Not running this interaction in the resulting SwapFrom interaction chain is a way for the server
+to cancel players performing these sorts of swap interactions. The default behavior for these swap interactions is that
+the SwapFrom interaction chain will be initiated with the currently-active-slot as the target slot. As a result, the
+target slot will usually not change when this interaction runs, it merely exists as a signal for the server to continue the
+item swap.
+
+**ChangeActiveSlot Fields**
+
+| Field Name | Type      | Required? | Notes                                                                                                                                                                                                     |
+| ---------- | --------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| TargetSlot | `Integer` | **No**    | If not provided, indicates the slot the player's active hotbar slot should be changed to.  Otherwise, the interaction chain's target slot will be used (which is usually the already-active hotbar slot). |
+
+### EquipItem
+
+This interaction will equip the User entity's currently-held item into the appropriate armor slot, if it is armor. The
+interaction will fail if the item is armor but it cannot be equipped for some reason. The interaction will succeed but
+take no action if the User entity cannot equip armor or if the item is not armor.
+
+**This interaction has no additional fields.**
+
+### IncreaseBackpackCapacity
+
+This interaction will increase the User entity's backpack size by the provided amount.  **It will additionally remove one
+quantity from the player's currently-held item. There is no way to prevent this.**  This interaction will have no effect
+if the User entity is not a player.  This interaction has no special failure conditions, even if the User entity
+is not a player, or the player is not currently holding an item.
+
+| Field Name | Type                        | Required? | Notes                                                                                   |
+| ---------- | --------------------------- | --------- | --------------------------------------------------------------------------------------- |
+| Capacity   | `Integer`<br />(Default: 1) | **No**    | The additional backpack capacity to add to the player. **Must be between 1 and 32767.** |
+
+### ModifyInventory
+
+This interaction attempts to perform one or more inventory-modifying actions against the User entity. The User entity must
+be a player. If they are not, no actions will be performed, but the interaction will not fail. Any item removals performed
+by this interaction, either as a result of `ItemToRemove` or `AdjustHeldItemQuantity`, are both atomic (meaning the entire
+quantity must be removed, or none) and required (meaning that the interaction will fail and no further actions taken if
+the removal fails for any reason).  Item additions performed by this interaction, either as a result of `ItemToAdd` or
+`AdjustHeldItemQuantity` will drop excess items on the ground near the player if necesary and continue on.
+
+This interaction first executes the item removal in `ItemToRemove`, if any, then adjusts the held item as specified by
+`AdjustHeldItemQuantity`, if provided, then executes the item addition in `ItemToAdd`, if any, and then finally executes
+the damage/healing of the held item in `AdjustHeldItemDurability`, if provided.
+
+**ModifyDurability Fields**
+
+| Field Name               | Type                            | Required? | Notes                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
+| ------------------------ | ------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| RequiredGameMode         | `GameMode`                      | **No**    | If provided, only execute the inventory-modifying actions if the player is in the provided GameMode. The interaction will not fail if the GameMode doesn't match.                                                                                                                                                                                                                                                                                                                                                                               |
+| ItemToRemove             | `ItemStack`                     | **No**    | If provided, a matching item will be removed in the provided quantity. If there is no matching item in the player inventory in the required quantity, then the interaction will fail and further actions will not be executed.                                                                                                                                                                                                                                                                                                                  |
+| AdjustHeldItemQuantity   | `Integer`<br />(Default: 0)     | **No**    | The player's held item, if any, will have its quantity will be modified by the provided amount- subtracted from if this number is negative or added to if this item is positive.  If the player has no held item, then this field will have no effect regardless of its value and the interaction will NOT fail.  If the player's inventory does not have sufficient quantity of items to support the removal, this interaction will fail and further actions will not be executed. Excess items will be dropped on the ground near the player. |
+| ItemToAdd                | `ItemStack`                     | **No**    | If provided, the ItemStack will be added to the player's inventory. Excess items will be dropped on the ground near the player.                                                                                                                                                                                                                                                                                                                                                                                                                 |
+| AdjustHeldItemDurability | `Double`<br />(Default: 0.0)    | **No**    | The player's held item, if any, will have its durability adjusted by the specified amount.  The durability cannot go below 0 or raise above the item's maximum durability. Invalid durability values in this field will not cause the interaction to fail. Neither will it fail if the player has no held item.                                                                                                                                                                                                                                 |
+| BrokenItem               | `String`                        | **No**    | This field should contain an ItemId, but it is not validated by the server on startup, so be careful.  This field can have the value of "Empty" to specify no item, or an empty hand. If specified and the `AdjustHeldItemDurability` operation reduces the player's held item to 0 durability, the player's held item is changed to this ItemId. If the inventory replacement fails, this interaction will fail.                                                                                                                               |
+| NotifyOnBreak            | `Boolean`<br />(Default: false) | **No**    | If true and the `AdjustHeldItemDurability` operation reduces the player's held item to 0 durability, this interaction will perform the usual audiovisual feedback of a broken tool. It will play the usual tool breaking sound and send the player a text message in chat that their item has broken.                                                                                                                                                                                                                                           |
+| NotifyOnBreakMessage     | `String`                        | **No**    | If provided, and `NotifyOnBreak` is true, when the player is notified of a broken tool by this interaction, the message sent to their chat will instead be the translation key specified by this field. The translation key supports the templating parameter `{itemName}`. See the translation key `server.general.repair.itemBroken_Hoe` for an example.                                                                                                                                                                                      |
+
+**GameMode Values**
+
+- `Creative`: The game is currently in Creative Mode
+- `Adventure`: The game is currently in Adventure Mode
+
+**ItemStack Fields**
+
+| Field Name                   | Type                              | Required? | Notes                                                                                |
+| ---------------------------- | --------------------------------- | --------- | ------------------------------------------------------------------------------------ |
+| Id                           | `Asset`<br />(Asset Type: `Item`) | **Yes**   | The id of the Item asset this stack contains.                                        |
+| Quantity                     | `Integer`<br />(Default: 1)       | **No**    | The number of items in this stack.<br />**Must be greater than 0.**                  |
+| Durability                   | `Double`<br />(Default: 0.0)      | **No**    | The durability of the item stack.<br />**Cannot be negative.**                       |
+| MaxDurability                | `Double`<br />(Default: 0.0)      | **No**    | The maximum durability of the item this stack contains.<br />**Cannot be negative.** |
+| Metadata                     | `Bson Document`                   | **No**    | If provided, applies the bson to the item stack metadata.                            |
+| OverrideDroppedItemAnimation | `Boolean`\*(Default: false)       | **No**    | ???                                                                                  |
+
+### PickupItem
+
+This interaction will attempt to pick up the User entity's current target entity and add it to their inventory. It will
+fail if the User entity is not a player, if they do not have a target entity, or if the target entity is not an item
+located in the world.  It will not fail if the player simply cannot pick up the item.
+
+**This interaction has no additional fields.**
+
+### RefillContainer
+
+This interaction will fail if the User entity is not a player. The interaction will draw a ray from the player's head
+down their look direction until the edge of the player's held item's interaction range or until the first solid block.
+The nearest fluid block of a type listed in this interaction's `States` map will result in the one of the player's
+currently-held items being converted to the fluid's related item state.  If the `States` map indicates a durability
+for the new item state, then the converted item will use that durability. If the item is already in the fluid's related
+item state, then this interaction will fail if the player's held item is already at maximum durability (unless the
+`States` map indicates a durability value greater than the item's maximum, in which case the interaction will succeed
+but the item will not change).  Otherwise, the durability listed for the fluid in the `States` map will be added to the
+item's current durability.
+
+If the interaction has not failed by this point, the fluid block in the world may be transformed to a different type if one is listed
+in the `States` map.
+
+If any part of this process does not proceed for any reason (for instance, if the player is not holding an item),
+then this interaction will fail.
+
+**RefillContainer Fields**
+
+| Field Name | Type                                                       | Required? | Notes                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| ---------- | ---------------------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| States     | `Map`<br />(Key Type: `String`, Value Type: `RefillState`) | **Yes**   | A map from item state names to `RefillState` objects, which contain information such as acceptable fluid block types, durability increases, and what fluid type to convert the targeted fluid block to after refill, if any. If the player targets a fluid block that matches one of the fluid types in the `RefillState`, the item will be converted to the keyed item state and the `RefillState` will be used to decide what happens next. |
+
+**RefillState Fields**
+
+| Field Name     | Type                                  | Required? | Notes                                                                                                                                                                                                                                                                                                                           |
+| -------------- | ------------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| AllowedFluids  | `Array`<br />(Element Type: `String`) | **Yes**   | If any of these fluids are targeted by the player, the player's held item will be converted to the keyed item state and `Durability` and `TransformFluid` will be used.                                                                                                                                                         |
+| Durability     | `Double`<br />(Default: -1.0)         | **No**    | If the player's held item changes item states, this value is the new item's durability, unless it is negative, in which case the item will begin at full durability. If the player's held item is already in the item state, and the item is not already at full durability, this value will be added to the item's durability. |
+| TransformFluid | `String`                              | **No**    | If provided, this field is a fluid id that the targeted fluid block should be transformed to if the player's held item is successfully updated.                                                                                                                                                                                 |
+
+## Entities
+
+### DamageEntity
+
+This interaction does not inherit from SimpleInteraction, but adds its own Next and Failed fields that
+work similarly.
+
+This interaction will cause the User entity to damage the Target entity.  It has the capability to apply different
+damage based on the direction of the attack or what body part was targeted by the User entity, with each possibility
+providing different damage calculations, effects, and Next interaction. If multiple entires match the attack, `TargetedDamage`
+(body part damage) takes highest priority, then the first matching `AngledDamage` in the list, then the default
+damage in the base interaction fields.  It is possible for elements of these different damage priorities to be taken peacemeal if higher-priority
+damage fields do not overwrite lower-priority damage fields. For instance,
+damage calculation could be taken from `TargetedDamage`, the damage effects could be taken from the first matching
+`AngledDamage`, and the Next interaction coming from the default damage field.
+
+If all damage dealt by this interaction is cancelled, then this interaction will fail, and the `Failed` interaction
+will be executed next in the chain. If any damage dealt by this interaction is blocked, then this interaction will
+succeed, but the `Blocked` interaction wil lbe executed next in the chain. Otherwise, the highest-precedent matching
+`Next` interaction that you provide will be executed.  For instance, if you provide `Next` interactions for all
+`TargetedDamage` and `AngledDamage` entries, and one in the interaction's `Next` field, then a headshot could result
+in a unique `Next` interaction being executed, even if there is a matching `AngledDamage` entry. However, if you leave
+the `Next` interaction out of your `TargetedDamage` entries, a special `Next` interaction for backstabs could be
+executed.  Otherwise, the `Next` field in the root of the interaction will be executed instead.
+
+DamageEntity has an unusual relationship with `RunTime`. This interaction always ends immediately after its first tick,
+regardless of the status of `RunTime` or `WaitForAnimationToFinish`.  However, if damage dealt by this interaction is
+calculated as `DamageCalculatorType` `Dps`, then the `RunTime` will be used to determine the precise amount of damage to
+deal. If `RunTime` is 0, then no damage will be dealt.
+
+**DamageEntity Fields**
+
+| Field Name       | Type                                                          | Required?                                                                                                                    | Notes                                                                                                                                                                                                                                                                                                                                                                         |
+| ---------------- | ------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| DamageCalculator | `DamageCalculator`                                            | **No**                                                                                                                       | If provided, describes the damage amounts and types to apply to the Target entity.                                                                                                                                                                                                                                                                                            |
+| DamageEffects    | `DamageEffects`                                               | **No**                                                                                                                       | If provided, describes particles, sounds, knockback, etc. to apply to the target entity on damage.                                                                                                                                                                                                                                                                            |
+| Next             | `Asset`<br />(Asset Type: `Interaction`)                      | **No**  After this interaction has finished, "Next" will be executed if damage was dealt to the target and none was blocked. |                                                                                                                                                                                                                                                                                                                                                                               |
+| AngledDamage     | `Array`<br />(Element Type: `AngledDamage`)                   | **No**                                                                                                                       | If provided, allows alternative `DamageCalculator`, `DamageEffects`, and `Next` entries for attacks that approach the target from certain angles.                                                                                                                                                                                                                             |
+| TargetedDamage   | `Map`<br />(Key Type: `String`, Value Type: `TargetedDamage`) | **Yes**                                                                                                                      | This field must be provided, but is not required to have any entries.  This is a map from body part names to `TargetedDamage` values. Hypixel only uses one body part name: `Head`, and it is not clear whether there are others.  If provided, allows alternative `DamageCalculator`, `DamageEffects`, and `Next` entries for attacks that damage specific enemy body parts. |
+| EntityStatsOnHit | `Array`<br />(Element Type: `EntityStatOnHit`)                | **No**                                                                                                                       | If provided, allows this attack to reduce enemy stats other than health.  Each individual damage application dealt by the same ability will apply stat reductions, at diminishing returns. All damage dealt in interaction chains forked by a Selector interaction will share the number of hits across all targets.                                                          |
+| Failed           | `Asset`<br />(Asset Type: `Interaction`)                      | **No**                                                                                                                       | After this interaction has finished, "Failed" will be executed if no damage hits were applied to the player, or if all damage hits were cancelled.                                                                                                                                                                                                                            |
+| Blocked          | `Asset`<br />(Asset Type: `Interaction`)                      | **No**                                                                                                                       | After this interaction has finished, "Blocked" will be executed if any damage hits were blocked by the target.                                                                                                                                                                                                                                                                |
+
+**DamageCalculator Fields**
+
+| Field Name                | Type                                                      | Required? | Notes                                                                                                                                                                                                                                                 |
+| ------------------------- | --------------------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Type                      | `DamageCalculatorType`<br />(Default: Absolute)           | **No**    | Whether the damage being applied is `Absolute` or \`Dps'.                                                                                                                                                                                             |
+| Class                     | `DamageClass`<br />(Default: Unknown)                     | **No**    | The type of attack producing the damage. Some weapon systems apply equipment modifiers based on this value.                                                                                                                                           |
+| BaseDamage                | `Map`<br />(Key Type: `DamageCause`, Value Type: `Float`) | **No**    | A set of DamageCauses and how much base damage is dealt for each.                                                                                                                                                                                     |
+| SequentialModifierStep    | `Float`<br />(Default: 0.0)                               | **No**    | Value between 0.0-1.0. Each additional hit from a single ability will have its damage reduced by this much as a percentage. All damage dealt in interaction chains forked by a Selector interaction will share the number of hits across all targets. |
+| SequentialModifierMinimum | `Float`<br />(Default: 0.0)                               | **No**    | Value between 0.0-1.0. `SequentialModifierStep` cannot reduce damage below this percentage regardless of the number of hits.                                                                                                                          |
+| RandomPercentageModifier  | `Float`<br />(Default: 0.0)                               | **No**    | A random value between +/- this amount multiplied by the base damage will be added to the base damage.                                                                                                                                                |
+
+**DamageEffects Fields**
+
+| Field Name             | Type                                         | Required? | Notes                                                                                   |
+| ---------------------- | -------------------------------------------- | --------- | --------------------------------------------------------------------------------------- |
+| ModelParticles         | `Array`<br />(Element Type: `ModelParticle`) | **No**    | Particle systems to trigger in the first-person view.                                   |
+| WorldParticles         | `Array`<br />(Element Type: `WorldParticle`) | **No**    | Particle systems to trigger in the third-person view.                                   |
+| LocalSoundEventId      | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | 2D sound to play locally to the attacking entity if they are a player.                  |
+| WorldSoundEventId      | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | Sound to play in the world at the Target entity's location.                             |
+| PlayerSoundEventId     | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | 2D sound to play locally to the Target entity if they are a player.                     |
+| ViewDistance           | `Double`<br />(Default: 75.0)                | **No**    | Distance at which these effects should play for other players.                          |
+| Knockback              | `Knockback`                                  | **No**    | The properties of the knockback that will be applied.                                   |
+| CameraEffect           | `Asset`<br />(Asset Type: `CameraEffect`)    | **No**    | CameraEffect to briefly apply locally to the Target entity if they are a player.        |
+| StaminaDrainMultiplier | `Float`<br />(Default: 1.0)                  | **No**    | This multiplier is applied to the stamina cost incurred by the target blocking, if any. |
+
+**AngledDamage Fields**
+
+| Field Name       | Type                                     | Required? | Notes                                                                                                                                                                                                     |
+| ---------------- | ---------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| AngleDistance    | `Float`<br />(Default: 0)                | **No**    | The width in degrees of the matching arc around the Target entity. If the attack against the Target originates from within the arc, then the properties below will be applied to the attack, if provided. |
+| Angle            | `Float`<br />(Default: 0.0)              | **No**    | The angle in degrees around the Target entity at which the matching arc is centered.                                                                                                                      |
+| DamageCalculator | `DamageCalculator`                       | **No**    | If provided and the attack against the Target entity originates from within the provided arc, this DamageCalculator will override the interaction's `DamageCalculator` field.                             |
+| DamageEffects    | `DamageEffects`                          | **No**    | If provided and the attack against the Target entity originates from within the provided arc, this DamageEffects will override the interaction's `DamageEffects` field.                                   |
+| Next             | `Asset`<br />(Asset Type: `Interaction`) | **No**    | If provided and the attack against the Target entity originates from within the provided arc, this Interaction will override the interaction's `Next` field.                                              |
+
+**TargetedDamage Fields**
+
+| Field Name       | Type                                     | Required? | Notes                                                                                                                                                                                            |
+| ---------------- | ---------------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| DamageCalculator | `DamageCalculator`                       | **No**    | If provided and this TargetedDamage was matched, this DamageCalculator will override the interaction's `DamageCalculator` field and the `DamageCalculator` field of any matching `AngledDamage`. |
+| DamageEffects    | `DamageEffects`                          | **No**    | If provided and this TargetedDamage was matched, this DamageEffects will override the interaction's `DamageEffects` field and the `DamageEffects` field of any matching `AngledDamage`.          |
+| Next             | `Asset`<br />(Asset Type: `Interaction`) | **No**    | If provided and this TargetedDamage was matched, this Interaction will override the interaction's `Next` field and the `Next` field of any matching `AngledDamage`.                              |
+
+**EntityStatOnHit Fields**
+
+| Field Name                  | Type                                                                       | Required? | Notes                                                                                                                                                                                                                                                                                        |
+| --------------------------- | -------------------------------------------------------------------------- | --------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| EntityStatId                | `Asset`<br />(AssetType: `EntityStatType`)                                 | **Yes**   | Which entity stat to affect.                                                                                                                                                                                                                                                                 |
+| Amount                      | `Float`<br />(Default: 0.0)                                                | **No**    | How much of the stat to apply for each damage application. Use negative numbers to reduce stats.                                                                                                                                                                                             |
+| MultipliersPerEntitiesHit   | `Array`<br />(Element Type: `Float`, Default: `[1.0, 0.6, 0.4, 0.2, 0.1]`) | **No**    | The diminishing returns curve to be applied for multiple damage applications by the same ability. Each hit's stat impact will be multiplied by the next value in the list.  If there are more hits than array elements, subsequent hits will be multiplied by `MultiplierPerExtraEntityHit`. |
+| MultiplierPerExtraEntityHit | `Float`<br />(Default: 0.05)                                               | **No**    | If an ability carries out more damage applications than there are elements in the `MultipliersPerEntitiesHit` array, then subsequent stat values will be multiplied by this number.                                                                                                          |
+
+**Knockback Fields**
+
+| Field Name     | Type                                       | Required? | Notes                                                                                                                      |
+| -------------- | ------------------------------------------ | --------- | -------------------------------------------------------------------------------------------------------------------------- |
+| Type           | `String`                                   | **No**    | If provided, specifies a type of knockback to use. Each Target type may come with additional fields.                       |
+| Force          | `Double`<br />(Default: 0.0)               | **No**    | The amount of force to apply to the Owner entity.                                                                          |
+| Duration       | `Double`<br />(Default: 0.0)               | **No**    | If 0.0, apply the force as a single impulse.  If more, continuously apply the force over a period of time.                 |
+| VelocityType   | `ChangeVelocityType`<br />(Default: `Add`) | **No**    | How to apply the force, either adding it to the entity's current velocity, or setting the velocity to the knockback force. |
+| VelocityConfig | `VelocityConfig`                           | **No**    | Characteristics of friction as the Owner entity is thrown by this knockback.                                               |
+
+**Knockback Type: Force**
+
+Apply the calculated knockback force along the provided direction.
+
+| Field Name | Type                         | Required? | Notes                                                                                |
+| ---------- | ---------------------------- | --------- | ------------------------------------------------------------------------------------ |
+| Direction  | `Vector3`<br />(Default: Up) | **No**    | Which direction the entity should be flung, relative to the direction of the attack. |
+
+**Knockback Type: Point**
+
+Apply the calculated knockback force laterally along the XZ plane, plus provided Y velocity.
+
+| Field Name | Type                        | Required? | Notes                                                                                                   |
+| ---------- | --------------------------- | --------- | ------------------------------------------------------------------------------------------------------- |
+| OffsetX    | `Integer`<br />(Default: 0) | **No**    | Offset the source position of the knockback left or right perpendicular to the direction of the attack. |
+| OffsetZ    | `Integer`<br />(Default: 0) | **No**    | Offset the source position of the knockback, forward or backward along the directon of the attack.      |
+| RotateY    | `Integer`<br />(Default: 0) | **No**    | Rotate the knockback direction around the Y axis, where 0 is the default attack direction.              |
+| VelocityY  | `Float`<br />(Default: 0.0) | **No**    | Add vertical velocity to the knockback force after the direction and force has been calculated.         |
+
+**Knockback Type: Directional**
+
+Apply the calculated knockback force along the attack direction, removing any vertical component and replacing it with a provided Y velocity.
+
+| Field Name | Type                      | Required? | Notes                                                                                                                                            |
+| ---------- | ------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------ |
+| RelativeX  | `Float`<br />(Default: 0) | **No**    | Apply additional force left or right perpendicular to the direction of the attack. The additional force is multiplied by the knockback strength. |
+| RelativeZ  | `Float`<br />(Default: 0) | **No**    | Apply additional force forward or backward along the attack direction. The additional force is multiplied by the knockback strength.             |
+| VelocityY  | `Float`<br />(Default: 0) | **No**    | Replace the vertical velocity of the knockback with this value.  This value is not multiplied by knockback strength.                             |
+
+**VelocityConfig Fields**
+
+| Field Name          | Type                                              | Required? | Notes                                                                                                                                                                                           |
+| ------------------- | ------------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| GroundResistance    | `Float`<br />(Default: 0.82)                      | **No**    | The minimum amount of friction applied when the entity is in contact with the ground.  1.0 = no friction, 0.0 = total friction                                                                  |
+| GroundResistanceMax | `Float`<br />(Default: 0.0)                       | **No**    | The maximum amount of friction applied when the entity is in contact with the ground.  1.0 = no friction, 0.0 = total friction                                                                  |
+| AirResistance       | `Float`<br />(Default: 0.96)                      | **No**    | The minimum amount of friction applied when the entity is in the air. 1.0 = no friction, 0.0 = total friction                                                                                   |
+| AirResistanceMax    | `Float`<br />(Default: 0.0)                       | **No**    | The maximum amount of friction applied when the entity is in the air. 1.0 = no friction, 0.0 = total friction                                                                                   |
+| Threshold           | `Float`<br />(Default: 1.0)                       | **No**    | The speed at which the maximum amount of friction will be applied to the entity. The amount of friction applied will increase from minimum to maximum as the entity moves from 0 to this speed. |
+| Style               | `VelocityThresholdStyle`<br />(Default: `Linear`) | **No**    | The curve that friction follows as the entity's speed increases toward the `Threshold`.                                                                                                         |
+
+**DamageCalculatorType Values**
+
+- `Absolute`
+- `Dps`
+
+**DamageClass Values**
+
+- `Unknown`
+- `Light`
+- `Charged`
+- `Signature`
+
+**ChangeVelocityType Values**
+
+- `Add`
+- `Set`
+
+**VelocityThresholdStyle Values**
+
+- `Linear`
+- `Exp`
+
+### LaunchProjectile
+
+This is just a worse version of Projectile and is slated to be removed.  Use Projectile.
+
+### Projectile
+
+This interaction will spawn a new projectile at the User entity's eye position that will travel in its look direction.
+
+| Field Name | Type                                          | Required? | Notes                                                  |
+| ---------- | --------------------------------------------- | --------- | ------------------------------------------------------ |
+| Config     | `Asset`<br />(Asset Type: `ProjectileConfig`) | **No**    | Configuration describing the projectile to be spawned. |
+
+### RemoveEntity
+
+Despawns the specified entity from the world. This interaction will have no effect if the specified entity is a player. This
+interaction has no special failure conditions.
+
+| Field Name | Type                                     | Required? | Notes                  |
+| ---------- | ---------------------------------------- | --------- | ---------------------- |
+| Entity     | `InteractionTarget`<br />(Default: User) | **No**    | The entity to despawn. |
+
+**InteractionTarget Values**
+
+- `User` - The user of this interaction chain. The entity whose actions caused this interaction chain to be executed. This is usually the same as the Owner.
+- `Owner` - The owner of this interaction chain. The entity upon whom this interaction chain is executing.
+- `Target` - The entity target of this interaction chain, if any.  This value is mutable (and can therefore come from many places) but most commonly, it is an entity the User was targeting when this interaction chain began executing.
+
+### SendMessage
+
+This interaction sends a message to the Owner entity if that entity can receive messages.  Otherwise, the message
+is written to the server logs.  If the entity is a player, the message will appear in the player's chat window.
+
+\*\*SendMessage
+
+| Field Name | Type     | Required? | Notes                                                                                                                 |
+| ---------- | -------- | --------- | --------------------------------------------------------------------------------------------------------------------- |
+| Message    | `String` | **No**    | A text message to be sent to the Owner entity.  If this field is not provided, `Key` is used instead.                 |
+| Key        | `String` | **No**    | A translation key for a message to be sent to the Owner entity. If `Message` is provided, then this field is ignored. |
+
+### UseEntity
+
+This interaction is not in use by Hypixel and has some unusual qualities that mean it probably won't do what you want it
+to.  Do not use it.
+
+This interaction will retrieve the entity currently targeted by the client (NOT the interaction chain's current Target
+entity) and execute that entity's RootInteraction for this interaction chain's current interaction type. The
+RootInteraction will be executed as part of this current interaction chain. None of the properties of this interaction
+chain will be modified.
+
+This interaction will fail if the client is not currently targeting an entity, or if no interaction for the current
+interaction type exists on the entity.
+
+## Stats
+
+Hytale's resource system has been written about fairly extensively.  You can use these interactions to modify stats in
+response to actions or use stats as a cost for abilities.
+
+### ChangeStat
+
+This interaction applies a set of raw stat changes to the User entity. It has no special failure conditions.
+
+| Field Name    | Type                                                         | Required? | Notes                                                                                                                                                                                                                      |
+| ------------- | ------------------------------------------------------------ | --------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| StatModifiers | `Map`<br />(Key Type: `EntityStatType`, Value Type: `Float`) | **Yes**   | A set of stats to modify and what value to apply to them.                                                                                                                                                                  |
+| ValueType     | `ValueType`<br />(Default: Absolute)                         | **No**    | Whether the values in the `StatModifiers` map represent flat values to apply to the stat total, or percentages (0.0-100.0). Percentage values are percentage of the difference between the maximum and minimum stat value. |
+| Behaviour     | `ChangeStatBehavior`<br />(Default: Add)                     | **No**    | Whether the values in the `StatModifiers` map represent deltas to add into the User entity's current stat values, or fixed values to set the entity's stats to.                                                            |
+
+**ValueType Values**
+
+- `Absolute`
+- `Percent`
+
+**ChangeStatBehaviour Values**
+
+- `Add`
+- `Set`
+
+### ChangeStatWithModifier
+
+This interaction is like ChangeStat, except an armor stat modifier can be chosen which will apply bonuses and penalties
+to a stat from the User entity's equipped armor before it is applied.
+
+| Field Name            | Type                                                         | Required? | Notes                                                                                                                                                                                                                      |
+| --------------------- | ------------------------------------------------------------ | --------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| StatModifiers         | `Map`<br />(Key Type: `EntityStatType`, Value Type: `Float`) | **Yes**   | A set of stats to modify and what value to apply to them.                                                                                                                                                                  |
+| ValueType             | `ValueType`<br />(Default: Absolute)                         | **No**    | Whether the values in the `StatModifiers` map represent flat values to apply to the stat total, or percentages (0.0-100.0). Percentage values are percentage of the difference between the maximum and minimum stat value. |
+| Behaviour             | `ChangeStatBehavior`<br />(Default: Add)                     | **No**    | Whether the values in the `StatModifiers` map represent deltas to add into the User entity's current stat values, or fixed values to set the entity's stats to.                                                            |
+| InteractionModifierId | `InteractionModifierId`                                      | **Yes**   | The armor interaction modifier to apply bonuses and penalties for.                                                                                                                                                         |
+
+**ValueType Values**
+
+- `Absolute`
+- `Percent`
+
+**ChangeStatBehaviour Values**
+
+- `Add`
+- `Set`
+
+**InteractionModifierId Values**
+
+- `Dodge`
+
+### StatsCondition
+
+This interaction will fail if the User entity cannot afford the specified stats costs, or if it does not have the
+requested stats.
+
+| Field Name | Type                                                         | Required? | Notes                                                                                                                                                                                    |
+| ---------- | ------------------------------------------------------------ | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Costs      | `Map`<br />(Key Type:` EntityStatType`, Value Type: `Float`) | **Yes**   | A set of costs that the User entity needs to be able to afford for this interaction to succeed.                                                                                          |
+| ValueType  | `ValueType`<br />(Default: Absolute)                         | **No**    | Whether the values in the `Costs` map represetn flat values or percentages (0.0-100.0).  Percentage values are percentage of the difference between the maximum and minimum value.       |
+| LessThan   | `Boolean`<br />(Default: false)                              | **No**    | If true, this interaction will fail unless the User entity's current stat values are at or **below** the specified levels.  If false, they must be at or **above** the specified levels. |
+| Lenient    | `Boolean`<br />(Default: false)                              | **No**    | If true and `LessThan` is true, and a player's minimum stat value is below zero, then the player can afford a stat cost if the current value of a stat if above 0.                       |
+
+**ValueType Values**
+
+- `Absolute`
+- `Percent`
+
+### StatsConditionWithModifier
+
+This interaction is like StatsCondition, except an armor stat modifier can be chosen which will apply bonuses and penalties
+to a stat's cost from the User entity's equipped armor before it is compared.
+
+| Field Name            | Type                                                         | Required? | Notes                                                                                                                                                                                    |
+| --------------------- | ------------------------------------------------------------ | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Costs                 | `Map`<br />(Key Type:` EntityStatType`, Value Type: `Float`) | **Yes**   | A set of costs that the User entity needs to be able to afford for this interaction to succeed.                                                                                          |
+| ValueType             | `ValueType`<br />(Default: Absolute)                         | **No**    | Whether the values in the `Costs` map represetn flat values or percentages (0.0-100.0).  Percentage values are percentage of the difference between the maximum and minimum value.       |
+| LessThan              | `Boolean`<br />(Default: false)                              | **No**    | If true, this interaction will fail unless the User entity's current stat values are at or **below** the specified levels.  If false, they must be at or **above** the specified levels. |
+| Lenient               | `Boolean`<br />(Default: false)                              | **No**    | If true and `LessThan` is true, and a player's minimum stat value is below zero, then the player can afford a stat cost if the current value of a stat if above 0.                       |
+| InteractionModifierId | `InteractionModifierId`                                      | **Yes**   | The armor interaction modifier to apply bonuses and penalties for.                                                                                                                       |
+
+**ValueType Values**
+
+- `Absolute`
+- `Percent`
+
+**InteractionModifierId Values**
+
+- `Dodge`
+
+## EntityEffects
+
+EntityEffects are buff or debuff effects that can be applied to a LivingEntity.  These can have a variety of effects from
+movement speed changes to periodic damage.
+
+### EffectCondition
+
+This interaction will fail if the specified entity's EntityEffects do not match the provided conditions.
+
+**EffectCondition Fields**
+
+| Field Name      | Type                                             | Required? | Notes                                                                                                                                                                                                             |
+| --------------- | ------------------------------------------------ | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Entity          | `InteractionTarget`<br />(Default: User)         | **Yes**   | The entity to examine for EntityEffects. This field can indicate the Owner, User, or Target of this interaction chain.                                                                                            |
+| Match           | `Match`<br />(Default: All)                      | **No**    | If `All`, then this interaction will fail if any EntityEffect in the `EntityEffectIds` is not on the specified entity. If `None`, then this interaction will fail if any EntityEffect IS on the specified entity. |
+| EntityEffectIds | `AssetArray`<br />(Element Type: `EntityEffect`) | **Yes**   | The set of EntityEffects to check against the specified entity and `Match`.                                                                                                                                       |
+
+**InteractionTarget Values**
+
+- `User` - The user of this interaction chain. The entity whose actions caused this interaction chain to be executed. This is usually the same as the Owner.
+- `Owner` - The owner of this interaction chain. The entity upon whom this interaction chain is executing.
+- `Target` - The entity target of this interaction chain, if any.  This value is mutable (and can therefore come from many places) but most commonly, it is an entity the User was targeting when this interaction chain began executing.
+
+**Match Values**
+
+- `All` - All EntityEffects must be on the specified entity for this interaction to succeed.
+- `None` - None of the EntityEffects must be on the specified entity for this interaction to succeed.
+
+### ApplyEffect
+
+This interaction will apply the specified EntityEffect to the specified Entity.  It has no special failure conditions.
+
+**ApplyEffect Fields**
+
+| Field Name | Type                                      | Required? | Notes                                                                                                                  |
+| ---------- | ----------------------------------------- | --------- | ---------------------------------------------------------------------------------------------------------------------- |
+| Entity     | `InteractionTarget`<br />(Default: User)  | **Yes**   | The entity to apply the EntityEffect to. This field can indicate the Owner, User, or Target of this interaction chain. |
+| EffectId   | `Asset`<br />(Asset Type: `EntityEffect`) | **Yes**   | The effect to apply.                                                                                                   |
+
+**InteractionTarget Values**
+
+- `User` - The user of this interaction chain. The entity whose actions caused this interaction chain to be executed. This is usually the same as the Owner.
+- `Owner` - The owner of this interaction chain. The entity upon whom this interaction chain is executing.
+- `Target` - The entity target of this interaction chain, if any.  This value is mutable (and can therefore come from many places) but most commonly, it is an entity the User was targeting when this interaction chain began executing.
+
+### ClearEntityEffect
+
+This interaction will remove the specified EntityEffect from the specified Entity. It has no special failure conditions.
+It will not fail if the Entity does not have the EntityEffect.
+
+**ClearEntityEffect Fields**
+
+| Field Name | Type                                      | Required? | Notes                                                                                                                     |
+| ---------- | ----------------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------- |
+| Entity     | `InteractionTarget`<br />(Default: User)  | **Yes**   | The entity to remove the EntityEffect from. This field can indicate the Owner, User, or Target of this interaction chain. |
+| EffectId   | `Asset`<br />(Asset Type: `EntityEffect`) | **Yes**   | The effect to remove.                                                                                                     |
+
+**InteractionTarget Values**
+
+- `User` - The user of this interaction chain. The entity whose actions caused this interaction chain to be executed. This is usually the same as the Owner.
+- `Owner` - The owner of this interaction chain. The entity upon whom this interaction chain is executing.
+- `Target` - The entity target of this interaction chain, if any.  This value is mutable (and can therefore come from many places) but most commonly, it is an entity the User was targeting when this interaction chain began executing.
+
+## Farming
+
+These are interaction types built to support the in-game farming system in Hytale. They are mostly block-related interactions
+with a few exceptions.
+
+### ChangeFarmingStage
+
+If the target block is a farming block, this interaction will attempt to modify the current farming stage in one of
+three ways.  The interaction can optionally specify which StageSet to use for the new stage. If it is not specified,
+the current StageSet will be used. If any part of the the process of changing the growth stage fails, this interaction
+will fail, with the one exception that attempting to set the stage to the crop's existing stage will have no effect but
+still succeed.
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                                                                                                                                                                          |
+| ---------------- | ------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction.                                                                                                                                              |
+| StageSet         | `String`                        | **No**    | If provided, set the block's current stage to one in the provided StageSet. Otherwise, use the crop's current StageSet.                                                                                                                                                        |
+| Increase         | `Integer`                       | **No**    | If provided, increase the current stage by the specified amount. If the specified stage does not exist, the block will be set to the closest extant stage.                                                                                                                     |
+| Decrease         | `Integer`                       | **No**    | If provided and `Increase` is not provided, decrease the current stage by the specified amount. If the specified stage does not exist, the block will be set to the closest extant stage.                                                                                      |
+| Stage            | `Integer`<br />(Default: -1)    | **No**    | If provided and `Increase`/`Decrease` are not provided, set the current stage to the specified stage. If this value is less than 0, set the current stage to the final growth stage. If the specified stage does not exist, the block will be set to the closest extant stage. |
+
+### FertilizeSoil
+
+If the target block is unfertilized tilled soil or a farming block on top of unfertilized tilled soil, fertilizes the soil.
+The interaction will fail otherwise.
+
+**FertilizeSoil Fields**
+
+| Field Name       | Type                                  | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false)       | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+| RefreshModifiers | `Array`<br />(Element Type: `String`) | **No**    | Does nothing.                                                                                                                     |
+
+### HarvestCrop
+
+This interaction will attempt to execute the harvest action on the current block target and add the crop's drops to the User entity's
+inventory.  The block will either be destroyed or set to its post-harvest growth stage, depending on the farming
+configuration of the block.  This will happen (and the player will receive the full harvest drops) regardless of the
+block's current growth stage. This interaction has no special failure conditions, even if the block target isn't a
+farming block or gathering isn't permitted in the current world, but nothing will occur in those cases.
+
+**HarvestCrop Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+
+### UseWateringCan
+
+If the target block is tilled soil or a farming block on top of tilled soil, waters the soil for the specified duration.
+The interaction will fail otherwise.
+
+**UseWateringCan Fields**
+
+| Field Name       | Type                                  | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false)       | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+| Duration         | `Integer`<br />(Default: 0)           | **No**    | The duration in seconds to water the soil for.                                                                                    |
+| RefreshModifiers | `Array`<br />(Element Type: `String`) | **No**    | Does nothing.                                                                                                                     |
diff --git a/content/docs/vi-VN/contributing/pr-guidelines.mdx b/content/docs/vi-VN/contributing/pr-guidelines.mdx
index 7a251032..c226da04 100644
--- a/content/docs/vi-VN/contributing/pr-guidelines.mdx
+++ b/content/docs/vi-VN/contributing/pr-guidelines.mdx
@@ -19,6 +19,8 @@ To ensure a smooth and efficient review process, both contributors and reviewers
 4. **Code Quality**
    - Ensure your code follows the project's coding standards and best practices.
    - Include comments where necessary to explain complex logic.
+   - Always test your changes locally before submitting the PR to catch any issues early.
+   - Format your code using `bun format` to maintain consistency across the codebase.
 5. **Testing**
    - Test your changes thoroughly before submitting the PR.
    - If applicable, include unit tests or integration tests to verify your changes.
diff --git a/content/docs/vi-VN/contributing/translate.mdx b/content/docs/vi-VN/contributing/translate.mdx
new file mode 100644
index 00000000..c62ffdde
--- /dev/null
+++ b/content/docs/vi-VN/contributing/translate.mdx
@@ -0,0 +1,74 @@
+---
+title: Translate
+description: How to translate HytaleModding to your language
+---
+
+# Translating HytaleModding
+
+HytaleModding is translated with the help of the community using **Crowdin**. If you want to help translate or improve existing translations, this is the right place.
+
+## Steps to Translate
+
+All translations are managed **via Crowdin**.
+
+1. Visit [our Crowdin project](https://crowdin.com/project/hytalemodding) and log in if required.
+2. Click on your language.
+3. Click on the file/article you wish to translate. We recommend starting with Official Documentation, and then Server Plugin Documentation.
+4. Start translating!
+5. Approved translations will appear on the website.
+
+### Video Guide
+
+<iframe src="https://www.youtube.com/embed/NHiG1rDRgks" allowFullScreen />
+
+## How to discuss
+
+You can always report issues or discuss specific topics directly on Crowdin, but we recommend using Discord instead of the Crowdin comment system to keep everything organized in one place.
+
+1. Join [our Discord](https://discord.gg/hytalemodding)
+2. Open `#translations` channel. Here you can discuss or ask questions that are not related to a specific language.
+3. If you want to join a thread, you are required to run `/translator <your-language>` command here. The bot will add you to the thread for your language.
+
+## Translation Guidelines
+
+- You need to be confident in what you are translating. You should be able to read the text you just translated and understand the meaning of it very easily.
+- It should use the simplest form of language possible. Use English words if the translation is unknown to the majority in your country.
+- Use your imagination, trust yourself. Feel free to change any context as you wish as long as it can still get the same point across and is understandable.
+- These guidelines are more important than language-specific guidelines, but less important than Hytale terminology and rules.
+
+## What not to translate
+
+We request you all to not translate these specific sections of the website:
+
+### Callout types
+
+Callouts are the boxes that contain important information. We request you to not translate the types as they only work in English.
+
+**Example:**
+
+```mdx
+<Callout type="warning" title="Translate this title!">
+Translate the text inside the callout!
+</Callout>
+```
+
+In this example, please don't translate the word warning, the rest you can translate.
+
+### Icons
+
+Icon names must not be translated.
+They are technical identifiers mapped directly to existing icons. Translating them will break the icon rendering.
+
+```mdx
+icon: Globe
+```
+
+---
+
+{/* 
+For translators who will edit this page:
+
+- You are required to translate the Guidelines as they change.
+- General guidelines should be translated but not edited.
+- Learn how to use Markdown from writing_guides.mdx
+*/}
diff --git a/content/docs/vi-VN/established-information/server/content-categories/art-assets.mdx b/content/docs/vi-VN/established-information/server/content-categories/art-assets.mdx
index 39c2ed37..1e926874 100644
--- a/content/docs/vi-VN/established-information/server/content-categories/art-assets.mdx
+++ b/content/docs/vi-VN/established-information/server/content-categories/art-assets.mdx
@@ -14,7 +14,7 @@ Hytale provides comprehensive support for 3D modeling and texture art creation,
 Hytale uses **Blockbench** as the primary tool for 3D modeling and animation:
 
 * **Official support**: Used for "creating Hytale models, textures, and animations"
-* **Special plugin**: Hytale will have a dedicated Blockbench plugin, to be released ASAP
+* **Special plugin**: Hytale has a dedicated [Blockbench Plugin](https://www.blockbench.net/plugins/hytale_plugin).
 * **Direct compatibility**: The plugin allows creators to "create Hytale-compatible models, textures, and animations directly in Blockbench"
 * **Replaces legacy tools**: Fully replaces the old Hytale Model Maker to better support established creative workflows in the community
 * **Safety features**: Only allows you to add things compatible with the engine, so no need to worry about breaking anything
diff --git a/content/docs/vi-VN/guides/ecs/block-components.mdx b/content/docs/vi-VN/guides/ecs/block-components.mdx
new file mode 100644
index 00000000..ca68b38a
--- /dev/null
+++ b/content/docs/vi-VN/guides/ecs/block-components.mdx
@@ -0,0 +1,247 @@
+---
+title: Block Components
+description: Learn how to use the block components.
+authors:
+  - name: Bird
+    link: https://discord.com/users/495709580068651009
+  - name: oskarscot
+    link: https://oskar.scot
+---
+
+# Overview
+
+In this guide, you'll learn how to use block components to create a ticking block.
+
+<Callout>
+  For a more complete reference, you may also want to review FarmingSystems.Ticking, as much of the underlying logic is based on its implementation.
+</Callout>
+
+## Steps
+
+### 1. ExampleBlock - holds block behavior
+
+```java
+public class ExampleBlock implements Component<ChunkStore> {
+
+    public static final BuilderCodec CODEC = BuilderCodec.builder(ExampleBlock.class, ExampleBlock::new).build();
+
+    // Components usually require a copy constructor as well but since we don't actually hold any data in this component this is not neccessary
+    public ExampleBlock() { }
+
+    public static ComponentType getComponentType() {
+        return ExamplePlugin.get().getExampleBlockComponentType();
+    }
+
+    @Nullable
+    public Component<ChunkStore> clone() {
+        return new ExampleBlock();
+    }
+}
+```
+
+ExampleBlock is a custom component that stores the behavior and data for your ticking block. Here, it simply places an Ice Block at x + 1 relative to its current position when it ticks.
+
+---
+
+### 2. ExampleInitializer - marks blocks as ticking when placed
+
+```java
+public class ExampleInitializer extends RefSystem {
+
+    @Override
+    public void onEntityAdded(@Nonnull Ref ref, @Nonnull AddReason reason, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+        BlockModule.BlockStateInfo info = (BlockModule.BlockStateInfo) commandBuffer.getComponent(ref, BlockModule.BlockStateInfo.getComponentType());
+        if (info == null) return;
+
+        ExampleBlock generator = (ExampleBlock) commandBuffer.getComponent(ref, ExamplePlugin.get().getExampleBlockComponentType());
+        if (generator != null) {
+            int x = ChunkUtil.xFromBlockInColumn(info.getIndex());
+            int y = ChunkUtil.yFromBlockInColumn(info.getIndex());
+            int z = ChunkUtil.zFromBlockInColumn(info.getIndex());
+
+            WorldChunk worldChunk = (WorldChunk) commandBuffer.getComponent(info.getChunkRef(), WorldChunk.getComponentType());
+            if (worldChunk != null) {
+				worldChunk.setTicking(x, y, z, true);
+            }
+        }
+    }
+
+    @Override
+    public void onEntityRemove(@Nonnull Ref ref, @Nonnull RemoveReason reason, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+    }
+
+    @Override
+    public Query getQuery() {
+        return Query.and(BlockModule.BlockStateInfo.getComponentType(), ExamplePlugin.get().getExampleBlockComponentType());
+    }
+}
+```
+
+ExampleInitializer is a RefSystem that reacts when block entities with the ExampleBlock component are added or removed. This is crucial for marking blocks as ticking when they're first placed.
+
+**Key Points:**
+
+- Tells the game that this block should tick, allowing `ExampleSystem` to process it.
+
+```java
+worldChunk.setTicking(x, y, z, true);
+```
+
+---
+
+### 3. ExampleSystem - handles ticking
+
+```java
+public class ExampleSystem extends EntityTickingSystem {
+
+    public void tick(float dt, int index, @Nonnull ArchetypeChunk archetypeChunk, @Nonnull Store store, @Nonnull CommandBuffer commandBuffer) {
+        BlockSection blocks = (BlockSection) archetypeChunk.getComponent(index, BlockSection.getComponentType());
+
+        assert blocks != null;
+
+        if (blocks.getTickingBlocksCountCopy() != 0) {
+            ChunkSection section = (ChunkSection) archetypeChunk.getComponent(index, ChunkSection.getComponentType());
+
+            assert section != null;
+
+            BlockComponentChunk blockComponentChunk = (BlockComponentChunk) commandBuffer.getComponent(section.getChunkColumnReference(), BlockComponentChunk.getComponentType());
+
+            assert blockComponentChunk != null;
+
+            blocks.forEachTicking(blockComponentChunk, commandBuffer, section.getY(), (blockComponentChunk1, commandBuffer1, localX, localY, localZ, blockId) -> {
+                Ref<ChunkStore> blockRef = blockComponentChunk.getEntityReference(ChunkUtil.indexBlockInColumn(localX, localY, localZ));
+                if (blockRef == null) {
+                    return BlockTickStrategy.IGNORED;
+                } else {
+                    ExampleBlock exampleBlock = (ExampleBlock) commandBuffer1.getComponent(blockRef, ExampleBlock.getComponentType());
+                    if (exampleBlock != null) {
+                        WorldChunk worldChunk = (WorldChunk) commandBuffer.getComponent(section.getChunkColumnReference(), WorldChunk.getComponentType());
+                        World world = worldChunk.getWorld();
+
+                        int globalX = localX + (worldChunk.getX() * 32);
+                        int globalZ = localZ + (worldChunk.getZ() * 32);
+
+                        // We need to execute setBlock on the world thread as you cannot call store functions from a system
+                        // This is because of the architecture of the server, depending on your needs you can also use the CommandBuffer
+                        world.execute(() -> {
+                            world.setBlock(globalX + 1, localY, globalZ, "Rock_Ice");
+                        });
+
+                        return BlockTickStrategy.CONTINUE;
+
+                    } else {
+                        return BlockTickStrategy.IGNORED;
+                    }
+                }
+            });
+        }
+    }
+
+    @Nullable
+    public Query getQuery() {
+        return Query.and(BlockSection.getComponentType(), ChunkSection.getComponentType());;
+    }
+}
+```
+
+ExampleSystem is an EntityTickingSystem that runs every tick to execute the logic for all ticking blocks with the ExampleBlock component.
+
+**Key Points:**
+
+- **Get the block component**
+
+```java
+ExampleBlock exampleBlock = (ExampleBlock) commandBuffer.getComponent(blockRef, ExampleBlock.getComponentType());
+```
+
+- **Convert local chunk coordinates to world coordinates**
+
+```java
+int globalX = localX + (worldChunk.getX() * 32);
+int globalZ = localZ + (worldChunk.getZ() * 32);
+```
+
+- **Run the block logic**
+
+```java
+exampleBlock.runBlockAction(globalX, localY, globalZ, worldChunk.getWorld());
+```
+
+- **Keep the block ticking in the next tick**
+
+```java
+return BlockTickStrategy.CONTINUE;
+```
+
+---
+
+### 4. ExamplePlugin - registers components and systems
+
+```java
+public class ExamplePlugin extends JavaPlugin {
+    protected static ExamplePlugin instance;
+    private static final HytaleLogger LOGGER = HytaleLogger.forEnclosingClass();
+    private ComponentType exampleBlockComponentType;
+
+    public static ExamplePlugin get() {
+        return instance;
+    }
+
+    public ExamplePlugin(@Nonnull JavaPluginInit init) {
+        super(init);
+        LOGGER.atInfo().log("Hello from " + this.getName() + " version " + this.getManifest().getVersion().toString());
+    }
+
+    @Override
+    protected void setup() {
+        instance = this;
+        LOGGER.atInfo().log("Setting up plugin " + this.getName());
+        this.exampleBlockComponentType = this.getChunkStoreRegistry().registerComponent(ExampleBlock.class, "ExampleBlock", ExampleBlock.CODEC);
+    }
+	
+	@Override
+	protected void start() {
+		this.getChunkStoreRegistry().registerSystem(new ExampleSystem());
+		this.getChunkStoreRegistry().registerSystem(new ExampleInitializer());
+	}
+
+    public ComponentType getExampleBlockComponentType() {
+        return this.exampleBlockComponentType;
+    }
+}
+```
+
+---
+
+### 5. Configure In-Game
+
+![block-component-1](/assets/guides/block-component-1.png)
+
+![block-component-2](/assets/guides/block-component-2.png)
+
+With this logic, the block will now continuously place an Ice Block at the coordinates x + 1 relative to its current position every time it ticks.
+
+---
+
+## Common Issues
+
+### NullPointerException on Startup
+
+**Error message:**
+
+```java
+java.lang.NullPointerException: Cannot invoke "com.hypixel.hytale.component.query.Query.validateRegistry(com.hypixel.hytale.component.ComponentRegistry)" because "query" is null
+```
+
+**Cause:**
+This error occurs when your module is loaded **before** the required Hytale modules.
+
+**Fix:**
+Add `EntityModule` and `BlockModule` as dependencies in your `manifest.json` to ensure proper load order.
+
+```json
+"Dependencies": {
+  "Hytale:EntityModule": "*",
+  "Hytale:BlockModule": "*"
+}
+```
diff --git a/content/docs/vi-VN/guides/ecs/hytale-ecs-theory.mdx b/content/docs/vi-VN/guides/ecs/hytale-ecs-theory.mdx
index 20c3a94d..52d8b1f5 100644
--- a/content/docs/vi-VN/guides/ecs/hytale-ecs-theory.mdx
+++ b/content/docs/vi-VN/guides/ecs/hytale-ecs-theory.mdx
@@ -29,7 +29,7 @@ for now this is the basic understanding for the `ChunkStore`. You can use it to
 
 ## Holder
 
-A Holder is essentially a blueprint for an entity. Before an entity exists in the Store (and thus in the world), is exists as a `Holder`. It collects and holds all the necessary components (data). You can compare it analogous to shopping cart. You grab all components you need and once you have everything, check out at the store which will take your cart and create a valid entity ID and hand you back a receipt (a Ref).
+A Holder is essentially a blueprint for an entity. Before an entity exists in the Store (and thus in the world), it exists as a `Holder`. It collects and holds all the necessary components (data). You can compare it analogous to shopping cart. You grab all components you need and once you have everything, check out at the store which will take your cart and create a valid entity ID and hand you back a receipt (a Ref).
 
 Let's take a look at an example: initializing players. In `Universe`, the `addPlayer` method demonstrates it perfectly.
 When a player connects, we don't immediately throw them into the ECS. We first construct their data in a Holder.
@@ -167,7 +167,7 @@ MyComponent comp = commandBuffer.getComponent(ref, componentType);
 
 Codecs handle serialization and deserialization of components. Hytale uses them to save and load entity data to and from disk as well as sending component data over the network. When creating a custom component, you must also create a corresponding Codec.
 
-There are mutliple Codec types already implemented in the default Codec Interface:
+There are multiple Codec types already implemented in the default Codec Interface:
 
 - Codec.STRING
 - Codec.BOOLEAN
@@ -215,7 +215,7 @@ This might seem tedious at first but it ensures that your component can be corre
   KeyedCodec<Integer> exampleInt = new KeyedCodec<Integer>("ExampleIntIdForCodec", Codec.INTEGER);
   ```
 
-- **Setter Function**: This is a lambda function that takes an instance of your component and returns the value of the field you want to serialize. For example, if you have a field called `myCustomField` in your custom component, your getter function would look like this:
+- **Setter Function**: This is a lambda function that takes an instance of your component + the value to set and sets the field value on the component. For example, if you have a field called `myCustomField` in your custom component, your setter function would look like this:
   ```java
   (data, value) -> data.myCustomField = value
   ```
@@ -276,7 +276,7 @@ public class PoisonComponent implements Component<EntityStore> {
 
 You can also add validators to your Codec fields to ensure that the data being serialized/deserialized meets certain criteria. For example, if you want to ensure that the `damagePerTick` field is always non-negative or the poison name is never null, you can add a validator like this:
 
-````java
+```java
 .append(
     new KeyedCodec<Float>("DamagePerTick", Codec.FLOAT),
     (data, value) -> data.damagePerTick = value,
@@ -292,14 +292,15 @@ You can also add validators to your Codec fields to ensure that the data being s
 )
 .addValidator(Validators.nonNull())
 .add()
+```
 
 ### Complex Codec Examples
 
-If you want to have a map inside your component, you can use the MapCodec class to build a KeyedCoded for it. Here's an example of how to create a Codec for a Map field:
+If you want to have a map inside your component, you can use the MapCodec class to build a KeyedCodec for it. Here's an example of how to create a Codec for a Map field:
 
 ```java
 var damagePerTick = new KeyedCodec<>("DamagePerTick", new MapCodec<>(Codec.FLOAT, HashMap<String, Float>::new));
-````
+```
 
 <Callout type="info">
   This also works with custom Objects as long as you have a Codec defined for the Object type.
diff --git a/content/docs/vi-VN/guides/java-basics/00-introduction.mdx b/content/docs/vi-VN/guides/java-basics/00-introduction.mdx
index a03ad638..b0130d74 100644
--- a/content/docs/vi-VN/guides/java-basics/00-introduction.mdx
+++ b/content/docs/vi-VN/guides/java-basics/00-introduction.mdx
@@ -7,7 +7,7 @@ Welcome to your journey into Java Programming! This guide is designed to introdu
 
 ## What is Java?
 
-Java is a powerful, object-oriented programming language created in 1995. It's one of the most popular programming languages in the world and is used for everything from mobile apps to enterprise software. Most importantly for us, it's the language Hytale uses for it's servers & modding API.
+Java is a powerful, object-oriented programming language created in 1995. It's one of the most popular programming languages in the world and is used for everything from mobile apps to enterprise software. Most importantly for us, it's the language Hytale uses for its servers & modding API.
 
 ## What You'll Learn
 
diff --git a/content/docs/vi-VN/guides/java-basics/02-operators.mdx b/content/docs/vi-VN/guides/java-basics/02-operators.mdx
index a132b1c0..18634665 100644
--- a/content/docs/vi-VN/guides/java-basics/02-operators.mdx
+++ b/content/docs/vi-VN/guides/java-basics/02-operators.mdx
@@ -119,7 +119,7 @@ String greetingWithName = "Hello, " + name + "!"; // "Hello, Alice!"
 
 ## Operator Precedence
 
-Operator Precendence means which operator gets evaluated first in an line of code. Think of it like BODMAS/PEMDAS in math!
+Operator Precedence means which operator gets evaluated first in an line of code. Think of it like BODMAS/PEMDAS in math!
 
 ```java
 int result = 10 + 5 * 2; // result is 20, not 30
diff --git a/content/docs/vi-VN/guides/java-basics/03-control-flow-if.mdx b/content/docs/vi-VN/guides/java-basics/03-control-flow-if.mdx
index b9d6c479..af2d1c22 100644
--- a/content/docs/vi-VN/guides/java-basics/03-control-flow-if.mdx
+++ b/content/docs/vi-VN/guides/java-basics/03-control-flow-if.mdx
@@ -7,7 +7,7 @@ Programs need to make decisions. If statements let your code choose different pa
 
 ## Basic If Statement
 
-The simplest form checks one condition;
+The simplest form checks one condition:
 
 ```java
 int health = 20;
diff --git a/content/docs/vi-VN/guides/java-basics/08-access-modifiers.mdx b/content/docs/vi-VN/guides/java-basics/08-access-modifiers.mdx
index af560932..da2bf33b 100644
--- a/content/docs/vi-VN/guides/java-basics/08-access-modifiers.mdx
+++ b/content/docs/vi-VN/guides/java-basics/08-access-modifiers.mdx
@@ -484,7 +484,7 @@ class Data {
     // Static member:
     // cannot access to non-static variables
     public static void bar() {
-        x = 100; // Error: non-static variable x cannot be renference from a static context
+        x = 100; // Error: non-static variable x cannot be referenced from a static context
         y = 100; // OK
     }
 }
@@ -504,7 +504,7 @@ Data.x = 1000; // Error: cannot access instanced variables in a static context
 
 ### Static Fields
 
-A static field represents a data member owned by the class type rather then the object. Static fields are also stored in a specific memory location that's been shared between all the object instances that are created.
+A static field represents a data member owned by the class type rather than the object. Static fields are also stored in a specific memory location that's been shared between all the object instances that are created.
 
 It is declared as following:
 
diff --git a/content/docs/vi-VN/guides/plugin/animated-block-textures.mdx b/content/docs/vi-VN/guides/plugin/animated-block-textures.mdx
new file mode 100644
index 00000000..42bfa51f
--- /dev/null
+++ b/content/docs/vi-VN/guides/plugin/animated-block-textures.mdx
@@ -0,0 +1,101 @@
+---
+title: Animated Block Textures
+description: Learn how to attach a .blockyanim to a block
+authors:
+  - name: Burkino
+---
+
+import { File, Folder, Files } from 'fumadocs-ui/components/files';
+
+So, you want to make your blocks feel more alive through animations, do you?\
+Now for the most part this is the exact same as [Creating custom blocks](./creating-block).
+![blue fire gif](/assets/guides/blue_fire.gif)
+
+## Prerequisites
+
+This is NOT a guide on animating or texturing or even using BlockBench, why? Because I don't know how to do that.\
+The only thing we will be doing is taking the fire texture, changing the color, and applying it to our new fire block.
+
+## Setup
+
+To start, you're obviously going to want to grab the `Common/VFX/Fire/Fire.png` file. How you do it is up to you, in the Asset Editor you'll need to switch to the Common tab.\
+I'll assume you know how colorize or change the hue of an image, so go ahead and do that now and save it as `Blue_Fire.png`.
+
+The other assets used in this guide are `Common/VFX/Fire/Fire.blockymodel` and `Common/Blocks/Animations/Fire/Fire_Burn.blockyanim` (both renamed to `Blue_Fire`) but since we won't be changing them it's probably fine to leave them. I will reference the `Blue_Fire` versions as a way to point out what should be custom assets.\
+I will also duplicate `Server/Item/Item/Deco/Deco_Fire.json` and call it `Deco_Blue_Fire.json`.
+
+## Applying the changes
+
+The `Deco_Blue_Fire` block is actually just a particle emitter, however we will not be using particles, so lets start by removing them in `Block > Particles`.\
+Next we want to set the Block Model (called `CustomModel` in JSON) to `VFX/Blue_Fire/Blue_Fire.blockymodel` and Block Model Textures (`CustomModelTexture` in JSON) to
+
+```json
+[
+    {
+        "Texture": "VFX/Blue_Fire/Blue_Fire.png",
+        "Weight": 1
+    }
+]
+```
+
+Finally, we will apply the .blockyanim to our model, this is done through the Block Model Animation property (`CustomModelAnimation` in JSON) and the value should be `Blocks/Animations/Blue_Fire/Blue_Fire_Burn.blockyanim`.
+
+## Final Code
+
+With that your new blue fire should be done. Here is the minimal JSON for our blue fire.\
+There is an additional `Looping` and `RequiresAlphaBlending` property that I have not gone over, however I hope it is self-explanatory.
+
+```json
+{
+  "BlockType": {
+    "DrawType": "Model",
+    "CustomModel": "VFX/Blue_Fire/Blue_Fire.blockymodel",
+    "CustomModelAnimation": "Blocks/Animations/Blue_Fire/Blue_Fire_Burn.blockyanim",
+    "CustomModelTexture": [
+      {
+        "Texture": "VFX/Blue_Fire/Blue_Fire.png",
+        "Weight": 1
+      }
+    ],
+    "Looping": true,
+    "RequiresAlphaBlending": false
+  },
+  "PlayerAnimationsId": "Block"
+}
+```
+
+<Files>
+  <Folder name="resources" defaultOpen>
+    <Folder name="Server" defaultOpen>
+      <Folder name="Item" defaultOpen>
+        <Folder name="Items" defaultOpen>
+          <Folder name="Deco" defaultOpen>
+            <File name="Deco_Blue_Fire.json" />
+          </Folder>
+        </Folder>
+      </Folder>
+    </Folder>
+
+    <Folder name="Common" defaultOpen>
+      <Folder name="Blocks" defaultOpen>
+        <Folder name="Animations" defaultOpen>
+          <Folder name="Blue_Fire" defaultOpen>
+            <File name="Blue_Fire_Burn.blockyanim" />
+          </Folder>
+        </Folder>
+      </Folder>
+
+      <Folder name="VFX" defaultOpen>
+        <Folder name="Blue_Fire" defaultOpen>
+          <File name="Blue_Fire.blockymodel" />
+
+          <File name="Blue_Fire.png" />
+        </Folder>
+      </Folder>
+    </Folder>
+  </Folder>
+</Files>
+
+## Next steps
+
+Now that you know how to attach an animation to a block, try adding it to a block state.
diff --git a/content/docs/vi-VN/guides/plugin/build-and-test.mdx b/content/docs/vi-VN/guides/plugin/build-and-test.mdx
index 0e7fe7eb..f37534c3 100644
--- a/content/docs/vi-VN/guides/plugin/build-and-test.mdx
+++ b/content/docs/vi-VN/guides/plugin/build-and-test.mdx
@@ -9,18 +9,18 @@ If you followed along with the [Setting Up Your Development Environment](./setti
 
 ## Building Your Mod
 
-In our case, we've **Maven** as the build system. Maven is a powerful build automation tool that manages dependencies, compiles your code, and packages everything into a distributable JAR file.
+In our case, we've **Gradle** as the build system. Gradle is a powerful build automation tool that manages dependencies, compiles your code, and packages everything into a distributable JAR file.
 
-### Understanding Maven
+### Understanding Gradle
 
-Maven uses a `pom.xml` file (Project Object Model) to define your project's configuration, dependencies, and build settings. You can learn more about Maven at the [official Apache Maven website](https://maven.apache.org/).
+Gradle can use a `build.gradle.kts` file (Kotlin DSL) to define your project's configuration, dependencies, and build settings. You can learn more about Gradle at the [official Gradle website](https://gradle.org/).
 
-### Building with Maven
+### Building with Gradle
 
 To build your mod, open a terminal in your project directory and run:
 
 ```bash
-mvn package
+./gradlew build
 ```
 
 This command will:
@@ -29,16 +29,35 @@ This command will:
 2. Run any tests (if present)
 3. Package everything into a JAR file
 
+<Callout type="info">
+  If you are using the plugin template from the [Setting Up Your Development Environment](./setting-up-env) guide, then the build script is already set up for you. It includes paths to your Hytale game library and handles the packaging of your mod, managing hytale dependencies and manifest changes.
+
+  If you have a different path to your Hytale installation, you may receive the following error:
+
+  ```bash
+  FAILURE: Build failed with an exception.
+
+  * What went wrong:
+  Failed to find Hytale at the expected location. Please make sure you have installed the game. The expected location can be changed using the hytale.home_path property. Currently looking in 'C:\Path\To\Hytale'
+  ```
+
+  You can change the path by adding a property to your `gradle.properties` file (if it doesn't exist, create it in the root of your project):
+
+  ```properties
+  hytale.home_path=C:\Correct\Path\To\Hytale
+  ```
+</Callout>
+
 ### Build Output
 
-Once the build completes successfully, your mod will be located in the `target` directory and named:
+Once the build completes successfully, your mod will be located in the `build/libs` directory and named:
 
 ```
-ExamplePlugin-1.0-SNAPSHOT.jar
+ExamplePlugin-1.0.jar
 ```
 
 <Callout type="info">
-  The exact name may vary depending on what you configured in your `pom.xml` file. Check the `artifactId` and `version` fields to see what your JAR will be named.
+  The exact name may vary depending on what you configured in your `build.gradle.kts` and `settings.gradle.kts` file. Check the `rootProject.name` and `version` fields to see what your JAR will be named.
 </Callout>
 
 ## Testing Your Mod
@@ -49,11 +68,11 @@ Now that you've built your mod, it's time to test it in Hytale!
 
 First, you need to find Hytale's mods directory:
 
-1. Press **Win + R** on your keyboard
-2. Type `%appdata%` and press Enter
-3. Navigate to: `Hytale\UserData\Mods`
+1. Go to your Hytale installation directory (The default location is usually in your AppData folder)
+   > On Windows, you can access it by clicking `windows + R` and typing `%appdata%`.
+2. Navigate to: `/UserData/Mods`
 
-The full path should look like:
+The default path would look like:
 
 ```
 C:\Users\YourUsername\AppData\Roaming\Hytale\UserData\Mods
@@ -65,7 +84,7 @@ C:\Users\YourUsername\AppData\Roaming\Hytale\UserData\Mods
 
 ### 2. Copy Your Mod
 
-Copy the `ExamplePlugin-1.0-SNAPSHOT.jar` file from your project's `target` directory into the `Mods` folder you just located.
+Copy the `ExamplePlugin-1.0.jar` file from your project's `build/libs` directory into the `Mods` folder you just located.
 
 ### 3. Launch Hytale and Verify
 
@@ -84,7 +103,7 @@ If your mod doesn't appear in the mods list:
 - Make sure the JAR file is in the correct `Mods` folder
 - Check that your `manifest.json` file is properly configured
 - Look for any error messages in the Hytale logs
-- Verify that you're using the correct version of Java and Maven
+- Verify that you're using the correct version of Java and Gradle
 
 ## Next Steps
 
diff --git a/content/docs/vi-VN/guides/plugin/creating-commands.mdx b/content/docs/vi-VN/guides/plugin/creating-commands.mdx
index d33597f3..08572f16 100644
--- a/content/docs/vi-VN/guides/plugin/creating-commands.mdx
+++ b/content/docs/vi-VN/guides/plugin/creating-commands.mdx
@@ -8,6 +8,8 @@ authors:
     url: https://oskar.scot
   - name: jacobwojoski
     url: https://github.com/jacobwojoski
+  - name: Marcel-TO
+    url: https://marcel-to.net
 ---
 
 In this guide, you will learn how to create custom commands for your Hytale mod.
@@ -36,7 +38,7 @@ The most basic command is an `AbstractAsyncCommand`. It has very minimal data av
   `AbstractAsyncCommand` runs on its own background thread. This means its execute is not tied to any world instance and because of this it can not edit any **Stores** or **Refs** without getting the desired world first. To access this data any of the other command types would be preferred and are likely what you will want to use instead.
 </Callout>
 
-The main purpose for a command like this would be for something that can happen everywhere and is not tied to a specific world. For example a `serverRules` command to tell the user thats running the command in chat what the servers rules are nomatter what world they are in.
+The main purpose for a command like this would be for something that can happen everywhere and is not tied to a specific world. For example a `serverRules` command to tell the user that's running the command in chat what the server's rules are no matter what world they are in.
 
 ```java
 // Command that can be run that lists the server rules in chat to the player
@@ -49,7 +51,7 @@ public class ServerRulesCommand extends AbstractAsyncCommand {
     }
 
     // Run the command
-    // conetext - info about who ran the command. Server console?, Some player?
+    // context - info about who ran the command. Server console?, Some player?
     @Override
     protected CompletableFuture<Void> executeAsync(@Nonnull CommandContext context) {
         context.sendMessage(Message.raw("The only rule is there are no rules."));
@@ -134,7 +136,7 @@ Uses a Ray to see what the player is looking at and tries to run the command on
 
 ## Adding Arguments
 
-Arguments are additional fields that the user can input when running a command. The different types of arguments along with small snipits and a large example can be seen below.
+Arguments are additional fields that the user can input when running a command. The different types of arguments along with small snippets and a large example can be seen below.
 
 ### Command Argument Types
 
@@ -163,14 +165,14 @@ this.messageArg = this.withOptionalArg("message", "Message to print while healin
 
 ### Default Arguments
 
-Adding a default argument has two additional arguemnt for the default value and default value description. You need to use `withDefaultArg` method.
+Adding a default argument has two additional argument for the default value and default value description. You need to use `withDefaultArg` method.
 
 ```java
 // args <Command String> <Description> <Default Value> <Desc of default value>
 this.healthArg = this.withDefaultArg("health", "Amount to heal player", ArgTypes.FLOAT, (float)100, "Desc of Default: 100");
 ```
 
-### Flag Arguemnts
+### Flag Arguments
 
 Similar as above but the flags return is either true if it exists or false if it does not. You need to use `withFlagArg` method.
 
@@ -181,20 +183,13 @@ this.debugArg = this.withFlagArg("debug", "Add debug logs");
 
 ### ArgTypes
 
-The following ArgTypes are available (only lists common types):
-
-- `ArgTypes.STRING`
-- `ArgTypes.INTEGER`
-- `ArgTypes.BOOLEAN`
-- `ArgTypes.FLOAT`
-- `ArgTypes.DOUBLE`
-- `ArgTypes.UUID`
+You can find all the available argument types on the [ArgTypes](../../argtypes) page.
 
 ### Example Command Arg Types
 
-Shows all Command arguemnt types with different various input types.
+Shows all Command argument types with different various input types.
 
-**NOTE:** When getting the value of an argument during execute you need to pass the context with `someArg.get(commandContext)`. Where `commandContext` is the first variable in the execute funtion.
+**NOTE:** When getting the value of an argument during execute you need to pass the context with `someArg.get(commandContext)`. Where `commandContext` is the first variable in the execute function.
 
 ```java
 // Example usage: /healplayer --health 50 --message "Feels Good" --debug
@@ -204,7 +199,7 @@ public class HealPlayerCommand extends AbstractTargetPlayerCommand {
     private final FlagArg debugArg;
 
     public HealPlayerCommand() {
-        super("healplayer", "Healing a player for an <input> ammount of HP (default: 100)");
+        super("healplayer", "Healing a player for an <input> amount of HP (default: 100)");
 
         // Abstract TargetPlayerCommand passes the player that ran the command by default and implements
         // the use of `--player <value>` to specify someone else
@@ -213,10 +208,10 @@ public class HealPlayerCommand extends AbstractTargetPlayerCommand {
         this.healthArg = this.withDefaultArg("health", "Amount to heal player", ArgTypes.FLOAT, (float)100, "Desc of Default: 100");
 
         // Or you could do the following making the health value required instead of with a default.
-        //    You would need to change the decleration to RequiredArg<Float>
+        //    You would need to change the declaration to RequiredArg<Float>
         // this.healthArg = this.withRequiredArg("health", "Amount to heal player", ArgTypes.FLOAT);
 
-        // Optional args reguare the user the input `--<key> <value>` so the following would require `--message "Good Luck"`
+// Optional args require the user the input `--<key> <value>` so the following would require `--message "Good Luck"`
         this.messageArg = this.withOptionalArg("message", "Message to print while healing", ArgTypes.STRING);
 
         // No type needed due to being a bool
@@ -230,7 +225,7 @@ public class HealPlayerCommand extends AbstractTargetPlayerCommand {
             commandContext.sendMessage(Message.raw("We are debugging"));
         }
 
-        // Health is stored in a generic stat map to allowing mods/future contect to easily add more stats if desired.
+        // Health is stored in a generic stat map to allowing mods/future content to easily add more stats if desired.
         EntityStatMap stats = store.getComponent(ref, EntityStatMap.getComponentType());
         int healthIdx = DefaultEntityStatTypes.getHealth();
         EntityStatValue health = stats.get(healthIdx);
@@ -252,7 +247,7 @@ public class HealPlayerCommand extends AbstractTargetPlayerCommand {
 
 ## Argument Validators
 
-Argument validators are a way to check the command before the command gets executed. They are added with the `addValidator` method on an argument when calling `withXxxArg`. They provide a nice output to the user when an input value is invalid.
+Argument validators are a way to check the command before the command gets executed. They are added with the `addValidator` method on an argument when calling `withXxxArg`. They provide a nice output to the user when an input value is invalid. There are some common validators provided in the `Validators` class such as `greaterThan`, `lessThan`, and `or`, `max`, `range`, etc.
 
 ```java
 ...
@@ -260,18 +255,59 @@ Argument validators are a way to check the command before the command gets execu
     OptionalArg<Integer> healAmount = withOptionalArg("amount", "Heal Amount", ArgTypes.INTEGER)
         .addValidator(Validators.greaterThan(0))
         .addValidator(Validators.lessThan(1000));
-
-    // Custom check example
-    OptionalArg<Integer> healAmount = withOptionalArg("amount", "Heal Amount", ArgTypes.INTEGER)
-            .addValidator( value -> {
-                if (value != null && value <= 0) {
-                    return ValidationResult.error("ammount argument must be a positive number");
-                }
-                return ValidationResult.success();
-            });
 ...
 ```
 
+### Custom Validators
+
+You can also create custom validators by implementing the `com.hypixel.hytale.codec.validation.Validator` interface. The interfaces forces you to implement the `accept` and `updateSchema` method. The `accept` method takes in the argument value and validates it. If the validation fails, you can use the `fail` method of the `com.hypixel.hytale.codec.validation.ValidationResults` class to return an error message.
+The `updateSchema` method is used to update the schema of the command argument. This is used for commands that have dynamic schemas based on the input value. For example, if you have a command that takes in a player name as an argument, you can use the `updateSchema` method to update the schema to include a list of online players for validation.
+
+Here is an example of a custom validator that checks if a string value is equal to a banned word. In this example, the banned word is "badword". If the input value is "badword", the validator will fail and return an error message.
+
+```java
+import com.hypixel.hytale.codec.schema.SchemaContext;
+import com.hypixel.hytale.codec.schema.config.Schema;
+import com.hypixel.hytale.codec.validation.ValidationResults;
+import com.hypixel.hytale.codec.validation.Validator;
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+
+public class MyCustomValidator implements Validator<String> {
+    @Nonnull
+    private final String value;
+
+    public MyCustomValidator(@Nonnull String value) {
+        this.value = value;
+    }
+
+    @Override
+    public void accept(@Nullable String input, @Nonnull ValidationResults results) {
+        if (this.value.equalsIgnoreCase(input)) {
+            results.fail("The given role has been banned.");
+        }
+    }
+
+    @Override
+    public void updateSchema(SchemaContext context, @Nonnull Schema target) {
+        // This method can be used to update the schema of the command argument. This is useful for commands that have dynamic schemas based on the input value. For example, if you have a command that takes in a player name as an argument, you can use the `updateSchema` method to update the schema to include a list of online players for validation.
+        throw new UnsupportedOperationException("Not implemented yet.");
+    }
+}
+```
+
+After the custom validator is created, you can add it to an argument like the following example. In this example, we add the `MyCustomValidator` to a string argument called "role". If the user inputs "badword" as the role, the command will fail and return the error message defined in the `MyCustomValidator`.
+
+```java
+    ...
+    // Custom validator example
+    String bannedRole = "badword";
+
+    OptionalArg<String> roleArg = withOptionalArg("role", "Role to assign", ArgTypes.STRING)
+        .addValidator(new MyCustomValidator(bannedRole));
+    ...
+```
+
 ---
 
 ## Permissions
@@ -312,7 +348,7 @@ This allows the server to control who has access to specific commands. You add t
 
 If you want variants of the same command without doing argument parsing you can instead use `addUsageVariant(new OtherCommandClass())` in the original commands constructor.
 
-The only difference is in the `OtherCommandClass()` constrcutor you don't pass the command name to the super class.
+The only difference is in the `OtherCommandClass()` constructor you don't pass the command name to the super class.
 
 <Callout type="info">
   You can also use `addAliases("some_alias", "some_other_alias")` as a way to add shorthand or other ways to write the same command.
@@ -387,7 +423,7 @@ public class AdminCommand extends AbstractCommandCollection {
     public AdminCommand () {
         super("admin", "Admin commands");
         addSubCommand(new UserCommandCollection());
-        addSybCommand(new ServerCommandCollection);
+        addSubCommand(new ServerCommandCollection);
     }
 }
 ```
@@ -417,5 +453,5 @@ public class MyPlugin extends JavaPlugin {
 
 ## Video Link
 
-_Special Thanks to [TroubleDev](https://www.youtube.com/@TroubleDEV) for his excelent video guide on all of these features._
+_Special Thanks to [TroubleDev](https://www.youtube.com/@TroubleDEV) for his excellent video guide on all of these features._
 _Video Link: [TroubleDev - Hytale's Command API Explained](https://www.youtube.com/watch?v=KnmhG9MDMgo)_
diff --git a/content/docs/vi-VN/guides/plugin/creating-events.mdx b/content/docs/vi-VN/guides/plugin/creating-events.mdx
index 95863990..d3f0925d 100644
--- a/content/docs/vi-VN/guides/plugin/creating-events.mdx
+++ b/content/docs/vi-VN/guides/plugin/creating-events.mdx
@@ -1,6 +1,6 @@
 ---
-title: Creating Events
-description: Learn how to create custom events for your Hytale mod.
+title: Creating Events Listeners
+description: Learn how to create event listeners for your Hytale mod.
 authors:
   - name: Neil Revin
     url: https://itsneil.dev
@@ -10,7 +10,7 @@ authors:
 
 ## Event Class
 
-You can import a Event class and create a function with the Event as a argument. [Click here](../../server/events) to look at all available events.
+You can import an Event class and create a function with the Event as an argument. [Click here](../../server/events) to look at all available events.
 
 Example plugin when a player is ready (joins a server):
 
diff --git a/content/docs/vi-VN/guides/plugin/item-registry.mdx b/content/docs/vi-VN/guides/plugin/item-registry.mdx
new file mode 100644
index 00000000..9a0fd53a
--- /dev/null
+++ b/content/docs/vi-VN/guides/plugin/item-registry.mdx
@@ -0,0 +1,95 @@
+---
+title: Working with the Item Registry
+description: Learn how to access and query the game's item registry to list all items, check if items exist, and retrieve item properties.
+authors:
+  - name: Denis
+---
+
+In this guide, you'll learn how to work with Hytale's Item Registry system. This is useful when you need to programmatically list all available items, validate item IDs, or retrieve item properties at runtime.
+
+## Prerequisites
+
+Before diving in, you should be familiar with:
+
+- [Setting up your development environment](./setting-up-env)
+- [Creating commands](./creating-commands) (optional, for testing)
+
+## Required Imports
+
+To work with the Item Registry, you'll need the following imports:
+
+```java
+import com.hypixel.hytale.assetstore.map.DefaultAssetMap;
+import com.hypixel.hytale.server.core.asset.type.item.config.Item;
+```
+
+## Getting the Item Registry
+
+The Item Registry is accessed through the `Item.getAssetMap()` method, which returns a `DefaultAssetMap<String, Item>` containing all registered items in the game:
+
+```java
+DefaultAssetMap<String, Item> itemMap = Item.getAssetMap();
+```
+
+## Listing All Items
+
+To iterate through all items in the registry, you can get the underlying map and loop through its entries:
+
+```java
+DefaultAssetMap<String, Item> itemMap = Item.getAssetMap();
+var map = itemMap.getAssetMap();
+
+for (var entry : map.entrySet()) {
+    String itemId = String.valueOf(entry.getKey());
+    Item item = entry.getValue();
+    
+    // Do something with the item
+    LOGGER.atInfo().log("Item ID: " + itemId);
+}
+```
+
+You can also get the total count of registered items:
+
+```java
+int totalItems = map.size();
+```
+
+## Checking if an Item Exists
+
+To check if a specific item exists in the registry, use `getAsset()` and verify the result:
+
+```java
+public boolean itemExists(String itemId) {
+    var assetMap = Item.getAssetMap();
+    if (assetMap != null) {
+        Item item = assetMap.getAsset(itemId);
+        return item != null && item != Item.UNKNOWN;
+    }
+    return false;
+}
+```
+
+<Callout type="info">
+  The `Item.UNKNOWN` constant represents an invalid or unrecognized item. Always check for both `null` and `Item.UNKNOWN` when validating items.
+</Callout>
+
+## Accessing Item Properties
+
+Once you have an `Item` instance, you can access various properties:
+
+```java
+var assetMap = Item.getAssetMap();
+Item item = assetMap.getAsset("Soil_Grass");
+
+if (item != null && item != Item.UNKNOWN) {
+    String id = item.getId(); // Soil_Grass
+    int maxStack = item.getMaxStack(); // 100
+    boolean isBlock = item.hasBlockType(); // true
+    boolean isConsumable = item.isConsumable(); // false
+}
+```
+
+## Related Guides
+
+- [Inventory Management](./inventory-management) - Learn how to add and remove items from player inventories
+- [Create Custom Item and Interaction](./item-interaction) - Learn how to create your own custom items
diff --git a/content/docs/vi-VN/guides/plugin/permission-management.mdx b/content/docs/vi-VN/guides/plugin/permission-management.mdx
index 6b7cfd46..55f06101 100644
--- a/content/docs/vi-VN/guides/plugin/permission-management.mdx
+++ b/content/docs/vi-VN/guides/plugin/permission-management.mdx
@@ -10,132 +10,569 @@ authors:
     link: https://discord.com/users/292656109939064833
   - name: Ivan
     link: https://discord.com/users/505770451218333717
+  - name: ZenithDevHQ
+    link: https://github.com/ZenithDevHQ
 ---
 
-In this guide, you'll learn how to manage permission nodes and groups in your Hytale plugin.
+In this guide, you'll learn how to manage permission nodes and groups in your Hytale plugin. Permissions control what actions players can perform on your server, from basic commands to advanced administrative functions.
 
-## The `PermissionsModule` class
+## What Are Permissions?
 
-The `PermissionsModule` class is responsible for managing permission nodes and groups in your plugin. It provides methods to check, grant and revoke permissions and groups for players. It allows the following operations
+Permissions are string identifiers that control access to features and commands. When a player tries to perform an action (like using a command), the server checks if they have the required permission.
 
-- Add permissions to user
-- Remove permissions from user
-- Add permissions to group (this also creates the group if it doesn't exist)
-- Remove permissions from group
-- Add user to group
-- Remove user from group
-- List all groups for a user
-- Check if a user has a permission (it checks both user and group permissions for the given player UUID)
+**Example permission nodes:**
 
-With this class you cannot:
+- `hytale.command.gamemode` - Permission to use the gamemode command
+- `hytale.editor.brush.use` - Permission to use brush tools
+- `myplugin.teleport.home` - A custom permission for your plugin
 
-- List all defined groups
-- Remove a group
+Permissions follow a hierarchical naming pattern: `namespace.category.action`
 
-### Adding Permission Nodes
+## Key Concepts
 
-You need a `Set<String>` containing all the permission nodes you want to add, these are added on top of the already existing permission nodes the user may have, it is not a replacement.
+Before diving into code, let's understand the core concepts:
+
+| Concept             | Description                                                                |
+| ------------------- | -------------------------------------------------------------------------- |
+| **Permission Node** | A string like `myplugin.feature.use` that represents a specific permission |
+| **Group**           | A named collection of permissions (e.g., "Admin", "VIP", "Default")        |
+| **Provider**        | The backend that stores and retrieves permissions                          |
+| **Wildcard**        | A pattern like `*` or `myplugin.*` that matches multiple permissions       |
+
+### How Permissions Are Checked
+
+When checking if a player has a permission, Hytale follows this order:
+
+1. **User's direct permissions** - Permissions granted directly to the player
+2. **Group permissions** - Permissions from groups the player belongs to
+3. **Virtual groups** - Game-mode-based permissions (e.g., Creative mode grants builder tools)
+4. **Default value** - Falls back to `false` if no match found
+
+<Callout type="info">
+  The first definitive match wins. If a player has a permission granted at the user level, group permissions won't override it.
+</Callout>
+
+---
+
+## The `PermissionsModule` Class
+
+The `PermissionsModule` class is the central hub for managing permissions. Access it using the singleton pattern:
 
 ```java
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.addUserPermission(playerUUID, permissions);
 ```
 
-### Removing Permission Nodes
+### Available Operations
+
+The module supports these operations:
+
+| Operation                     | Method                                          |
+| ----------------------------- | ----------------------------------------------- |
+| Add permissions to user       | `addUserPermission(uuid, permissions)`          |
+| Remove permissions from user  | `removeUserPermission(uuid, permissions)`       |
+| Add permissions to group      | `addGroupPermission(groupName, permissions)`    |
+| Remove permissions from group | `removeGroupPermission(groupName, permissions)` |
+| Add user to group             | `addUserToGroup(uuid, groupName)`               |
+| Remove user from group        | `removeUserFromGroup(uuid, groupName)`          |
+| Get user's groups             | `getGroupsForUser(uuid)`                        |
+| Check permission              | `hasPermission(uuid, permissionNode)`           |
+
+<Callout type="warning">
+  The module does **not** support:
+
+  - Listing all defined groups
+  - Deleting a group entirely
+
+  Groups are implicitly created when you first add permissions to them.
+</Callout>
+
+---
 
-Same as above, we just use the `removeUserPermission` method instead to remove permission nodes.
+## Checking Permissions
+
+The most common operation is checking if a player has a permission.
+
+### Basic Permission Check
+
+```java
+// Returns true if player has the permission, false otherwise
+boolean canUse = PermissionsModule.get().hasPermission(playerUUID, "myplugin.feature.use");
+
+if (canUse) {
+    // Player has permission, allow the action
+} else {
+    // Player lacks permission, deny or show error
+}
+```
+
+### Permission Check with Default Value
+
+You can specify what to return when no permission is explicitly set:
+
+```java
+// Returns true by default if no explicit permission is found
+boolean canUse = PermissionsModule.get().hasPermission(playerUUID, "myplugin.feature.use", true);
+```
+
+This is useful for features that should be enabled by default but can be revoked.
+
+### Using PermissionHolder Interface
+
+Players and command senders implement `PermissionHolder`, allowing direct checks:
+
+```java
+// In a command or event handler where you have access to the player
+if (player.hasPermission("myplugin.admin.manage")) {
+    // Player has admin permission
+}
+```
+
+---
+
+## Managing User Permissions
+
+### Adding Permissions to a User
+
+Permissions are additive - new permissions are added on top of existing ones, not replaced.
+
+```java
+PermissionsModule perms = PermissionsModule.get();
+
+// Add a single permission
+perms.addUserPermission(playerUUID, Set.of("myplugin.vip.chat"));
+
+// Add multiple permissions at once
+Set<String> newPerms = Set.of(
+    "myplugin.vip.chat",
+    "myplugin.vip.fly",
+    "myplugin.vip.kit"
+);
+perms.addUserPermission(playerUUID, newPerms);
+```
+
+### Removing Permissions from a User
 
 ```java
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.removeUserPermission(playerUUID, permissions);
+
+// Remove specific permissions
+Set<String> toRemove = Set.of("myplugin.vip.fly");
+perms.removeUserPermission(playerUUID, toRemove);
 ```
 
-### Add permissions to group
+---
+
+## Managing Groups
+
+Groups let you assign a collection of permissions to multiple players. This is more manageable than assigning permissions individually.
+
+### Adding Permissions to a Group
+
+If the group doesn't exist, it will be created automatically.
 
 ```java
-String groupName = "testGroup";
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.addGroupPermission(groupName, permissions);
+
+// Create/update the "VIP" group with permissions
+Set<String> vipPerms = Set.of(
+    "myplugin.vip.chat",
+    "myplugin.vip.fly",
+    "myplugin.vip.kit"
+);
+perms.addGroupPermission("VIP", vipPerms);
 ```
 
-### Remove permissions from group
+### Removing Permissions from a Group
 
 ```java
-String groupName = "testGroup";
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.removeGroupPermission(groupName, permissions);
+
+// Remove specific permissions from the group
+Set<String> toRemove = Set.of("myplugin.vip.fly");
+perms.removeGroupPermission("VIP", toRemove);
 ```
 
-### Add user to group
+### Adding a User to a Group
 
 ```java
-String groupName = "testGroup";
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.addUserToGroup(playerUUID, groupName);
+
+// Add player to the VIP group - they now have all VIP permissions
+perms.addUserToGroup(playerUUID, "VIP");
 ```
 
-### Remove user from group
+### Removing a User from a Group
 
 ```java
-String groupName = "testGroup";
-Set<String> permissions = new HashSet<>();
 PermissionsModule perms = PermissionsModule.get();
-perms.removeUserFromGroup(playerUUID, groupName);
+
+// Remove player from VIP group
+perms.removeUserFromGroup(playerUUID, "VIP");
 ```
 
-### List all groups for a user
+### Getting a User's Groups
 
 ```java
 PermissionsModule perms = PermissionsModule.get();
-perms.getGroupsForUser(playerUUID);
+
+// Get all groups the player belongs to
+Set<String> groups = perms.getGroupsForUser(playerUUID);
+
+for (String group : groups) {
+    System.out.println("Player is in group: " + group);
+}
 ```
 
-### Check Permission Nodes
+---
+
+## Built-in Groups
+
+Hytale includes two default groups:
+
+| Group     | Default Permissions   | Purpose                           |
+| --------- | --------------------- | --------------------------------- |
+| `OP`      | `*` (all permissions) | Server operators with full access |
+| `Default` | None                  | Base group for all players        |
+
+Players without any explicit group assignment are automatically part of the `Default` group.
 
-To check if a player has a specific permission node, you can use the `hasPermission` method.
+---
+
+## Wildcards
+
+Wildcards let you grant or deny multiple permissions with a single pattern.
+
+### Wildcard Patterns
+
+| Pattern             | Meaning                                          |
+| ------------------- | ------------------------------------------------ |
+| `*`                 | Grants **all** permissions                       |
+| `myplugin.*`        | Grants all permissions starting with `myplugin.` |
+| `-*`                | Denies **all** permissions                       |
+| `-myplugin.admin.*` | Denies all admin permissions in your plugin      |
+
+### Example: Admin Group with Wildcards
 
 ```java
-boolean hasPermission = PermissionsModule.hasPermission(playerUUID, "permission.node");
+// Grant all permissions to admins
+perms.addGroupPermission("Admin", Set.of("*"));
+
+// Grant all plugin permissions to moderators
+perms.addGroupPermission("Moderator", Set.of("myplugin.*"));
+
+// Grant all permissions except admin commands
+perms.addGroupPermission("Helper", Set.of(
+    "*",
+    "-myplugin.admin.*"  // Deny admin permissions
+));
 ```
 
-## Additional: Defining your own provider for permissions and groups
+<Callout type="warning">
+  Negation permissions (starting with `-`) take precedence at each level. Use them carefully to avoid accidentally blocking permissions.
+</Callout>
+
+---
+
+## Built-in Permission Nodes
+
+Hytale provides constants for common permissions in the `HytalePermissions` class:
+
+### Command Permissions
+
+```java
+// Generate permission for a command
+String perm = HytalePermissions.fromCommand("gamemode");
+// Result: "hytale.command.gamemode"
+
+// Generate permission for a subcommand
+String perm = HytalePermissions.fromCommand("gamemode", "creative");
+// Result: "hytale.command.gamemode.creative"
+```
+
+### Common Permission Nodes
+
+| Permission                    | Description                  |
+| ----------------------------- | ---------------------------- |
+| `hytale.command.op.add`       | Add players to OP group      |
+| `hytale.command.op.remove`    | Remove players from OP group |
+| `hytale.editor.brush.use`     | Use brush tools              |
+| `hytale.editor.prefab.use`    | Use prefabs                  |
+| `hytale.editor.selection.use` | Use selection tools          |
+| `hytale.editor.history`       | Undo/redo operations         |
+| `hytale.camera.flycam`        | Use fly camera mode          |
+
+---
+
+## Listening to Permission Events
+
+You can react to permission changes using Hytale's event system.
+
+### Available Events
+
+| Event                                            | Triggered When                   |
+| ------------------------------------------------ | -------------------------------- |
+| `PlayerPermissionChangeEvent.PermissionsAdded`   | Permissions added to a user      |
+| `PlayerPermissionChangeEvent.PermissionsRemoved` | Permissions removed from a user  |
+| `PlayerGroupEvent.Added`                         | User added to a group            |
+| `PlayerGroupEvent.Removed`                       | User removed from a group        |
+| `GroupPermissionChangeEvent.Added`               | Permissions added to a group     |
+| `GroupPermissionChangeEvent.Removed`             | Permissions removed from a group |
 
-The PermissionsModule also enables us to define our own PermissionProvider's, this can be useful for:
+### Example: Reacting to Permission Changes
 
-- Cross server permission systems
-- Implementing features missing in the `HytalePermissionsProvider` like permission expiry
+```java
+public class PermissionListener {
+
+    public static void onPermissionsAdded(PlayerPermissionChangeEvent.PermissionsAdded event) {
+        UUID playerUUID = event.getPlayerUuid();
+        Set<String> added = event.getAddedPermissions();
+
+        System.out.println("Permissions added to " + playerUUID + ": " + added);
 
-To implement our PermissionProvider, first we need to define a provider class that implements PermissionProvider:
+        // Maybe notify the player or update cached data
+    }
+
+    public static void onGroupAdded(PlayerGroupEvent.Added event) {
+        UUID playerUUID = event.getPlayerUuid();
+        String groupName = event.getGroupName();
+
+        System.out.println("Player " + playerUUID + " joined group: " + groupName);
+    }
+}
+```
+
+### Registering the Events
 
 ```java
-public class DatabasePermissionProvider implements PermissionProvider
+public class MyPlugin extends JavaPlugin {
+
+    @Override
+    public void setup() {
+        EventRegistry events = this.getEventRegistry();
+
+        events.registerGlobal(
+            PlayerPermissionChangeEvent.PermissionsAdded.class,
+            PermissionListener::onPermissionsAdded
+        );
+
+        events.registerGlobal(
+            PlayerGroupEvent.Added.class,
+            PermissionListener::onGroupAdded
+        );
+    }
+}
 ```
 
-Then we just implement the required methods using a database implementation.
+---
+
+## Creating a Custom Permission Provider
+
+For advanced use cases, you can create your own permission provider. This is useful for:
+
+- Database-backed permissions (MySQL, MongoDB, etc.)
+- Cross-server permission synchronization
+- Custom features like permission expiry or contexts
+
+### Implementing PermissionProvider
+
+```java
+public class DatabasePermissionProvider implements PermissionProvider {
+
+    @Nonnull
+    @Override
+    public String getName() {
+        return "DatabasePermissionProvider";
+    }
+
+    // User permission methods
+    @Override
+    public void addUserPermissions(@Nonnull UUID uuid, @Nonnull Set<String> permissions) {
+        // Save to your database
+    }
+
+    @Override
+    public void removeUserPermissions(@Nonnull UUID uuid, @Nonnull Set<String> permissions) {
+        // Remove from your database
+    }
+
+    @Override
+    public Set<String> getUserPermissions(@Nonnull UUID uuid) {
+        // Query your database
+        return Set.of();
+    }
+
+    // Group permission methods
+    @Override
+    public void addGroupPermissions(@Nonnull String group, @Nonnull Set<String> permissions) {
+        // Save to your database
+    }
+
+    @Override
+    public void removeGroupPermissions(@Nonnull String group, @Nonnull Set<String> permissions) {
+        // Remove from your database
+    }
+
+    @Override
+    public Set<String> getGroupPermissions(@Nonnull String group) {
+        // Query your database
+        return Set.of();
+    }
+
+    // User-group membership methods
+    @Override
+    public void addUserToGroup(@Nonnull UUID uuid, @Nonnull String group) {
+        // Save to your database
+    }
+
+    @Override
+    public void removeUserFromGroup(@Nonnull UUID uuid, @Nonnull String group) {
+        // Remove from your database
+    }
+
+    @Override
+    public Set<String> getGroupsForUser(@Nonnull UUID uuid) {
+        // Query your database
+        return Set.of("Default");
+    }
+}
+```
 
 <Callout type="warning">
-  Hytale will try to use the first available permissions provider to add/remove gamemode groups (i.e. `Creative`, `Adventure`).
+  Hytale automatically assigns players to game-mode groups (like `Creative` or `Adventure`) using the first available provider.
+
+  If your provider throws an error when the group doesn't exist, the player will be disconnected! Always handle missing groups gracefully.
+</Callout>
+
+### Registering Your Provider
 
-  If your provider throws an error (for instance, if the group does not exist) when the server is preparing the player, the player will be disconnected.
+```java
+public class MyPlugin extends JavaPlugin {
+
+    @Override
+    public void setup() {
+        // Add your provider alongside the default one
+        PermissionsModule.get().addProvider(new DatabasePermissionProvider());
+    }
+}
+```
+
+The `PermissionsModule` aggregates permissions from all registered providers. This means:
+
+- Permission checks query all providers
+- Write operations (add/remove) use the **first** provider
+
+### Replacing the Default Provider
+
+If you want full control, you can remove the default provider:
+
+```java
+public class MyPlugin extends JavaPlugin {
+
+    @Override
+    public void setup() {
+        PermissionsModule perms = PermissionsModule.get();
+
+        // Remove the default provider FIRST
+        perms.removeProvider(perms.getFirstPermissionProvider());
+
+        // Then add your provider
+        perms.addProvider(new DatabasePermissionProvider());
+    }
+}
+```
+
+<Callout type="info">
+  When you remove the default provider, the `/op self` command will stop working since it checks for provider tampering.
 </Callout>
 
-We can then register the provider using the built-in permission module:
+---
+
+## Best Practices
+
+### Permission Naming Conventions
+
+Follow the pattern: `namespace.category.action`
 
 ```java
-PermissionsModule.get().addProvider(new DatabasePermissionProvider());
+// Good - clear hierarchy
+"myplugin.admin.ban"
+"myplugin.user.teleport.home"
+"myplugin.vip.chat.color"
+
+// Bad - unclear structure
+"myplugin_ban"
+"teleport"
+"vipChatColor"
 ```
 
-Please note that the `HytalePermissionsProvider` will still be enabled alongside your provider.
-The `PermissionsModule` will aggregate groups and permissions from all available providers.
+### Use Constants for Permissions
 
-If you want to disable the default `HytalePermissionsProvider`, you can use:
+Define your permissions as constants to avoid typos:
 
 ```java
-// put this **before** you add your provider
-PermissionsModule.get().removeProvider(PermissionsModule.get().getFirstPermissionProvider());
+public final class MyPermissions {
+    public static final String ADMIN_BAN = "myplugin.admin.ban";
+    public static final String ADMIN_KICK = "myplugin.admin.kick";
+    public static final String USER_HOME = "myplugin.user.home";
+    public static final String VIP_FLY = "myplugin.vip.fly";
+}
+
+// Usage
+if (player.hasPermission(MyPermissions.ADMIN_BAN)) {
+    // ...
+}
 ```
+
+### Don't Over-Permission
+
+Only create permissions for actions that genuinely need access control. Not everything needs a permission check.
+
+### Thread Safety
+
+If you create a custom provider, ensure it's thread-safe. Permission checks can occur from multiple threads simultaneously. Use `ReadWriteLock` or `ConcurrentHashMap` for your data structures.
+
+---
+
+## In-Game Commands
+
+Hytale provides built-in commands for managing permissions:
+
+### `/op` Command
+
+| Command               | Description                                                        |
+| --------------------- | ------------------------------------------------------------------ |
+| `/op self`            | Toggle your own OP status (singleplayer or with `--allow-op` flag) |
+| `/op add <player>`    | Add a player to the OP group                                       |
+| `/op remove <player>` | Remove a player from the OP group                                  |
+
+### `/perm` Command
+
+Use `/perm --help` in-game for full usage. Common operations:
+
+| Command                                  | Description                   |
+| ---------------------------------------- | ----------------------------- |
+| `/perm user list <uuid>`                 | List user's permissions       |
+| `/perm user add <uuid> <perm>`           | Add permission to user        |
+| `/perm user remove <uuid> <perm>`        | Remove permission from user   |
+| `/perm user group list <uuid>`           | List user's groups            |
+| `/perm user group add <uuid> <group>`    | Add user to group             |
+| `/perm user group remove <uuid> <group>` | Remove user from group        |
+| `/perm group list <group>`               | List group's permissions      |
+| `/perm group add <group> <perm>`         | Add permission to group       |
+| `/perm group remove <group> <perm>`      | Remove permission from group  |
+| `/perm test <perm>`                      | Test if you have a permission |
+
+---
+
+## Summary
+
+You've learned how to:
+
+- **Check permissions** using `PermissionsModule.hasPermission()`
+- **Manage user permissions** with `addUserPermission()` and `removeUserPermission()`
+- **Work with groups** using `addGroupPermission()`, `addUserToGroup()`, etc.
+- **Use wildcards** like `*` and `myplugin.*` for bulk permissions
+- **Listen to events** for permission changes
+- **Create custom providers** for database-backed permissions
+
+For more advanced permission systems with features like inheritance, expiry, and contexts, we're looking into expanding this guide with advanced permission management techniques in the future.
diff --git a/content/docs/vi-VN/guides/plugin/setting-up-env.mdx b/content/docs/vi-VN/guides/plugin/setting-up-env.mdx
index d2718098..5be5e9e0 100644
--- a/content/docs/vi-VN/guides/plugin/setting-up-env.mdx
+++ b/content/docs/vi-VN/guides/plugin/setting-up-env.mdx
@@ -4,6 +4,10 @@ description: Learn how to set up your development environment for modding Hytale
 authors:
   - name: Neil Revin
     link: https://itsneil.dev
+  - name: Marcel-TO
+    url: https://marcel-to.net
+  - name: Ádám Liszkai
+    link: https://adaliszk.dev
 ---
 
 This guide will walk you through setting up a complete development environment for Hytale modding, including all necessary tools and dependencies.
@@ -19,24 +23,73 @@ Before we begin, make sure you have:
 
 ## Required Software
 
-### 1. Java Development Kit (JDK)
+### Integrated Development Environment (IDE)
 
+We recommend IntelliJ IDEA Community Edition for Hytale modding. If you use IntelliJ IDEA, **almost everything is built-in**. You can clone a template, open a new project, and start working right away!
+
+1. Download from [JetBrains website](https://www.jetbrains.com/idea/download/)
+2. Install with default settings
+3. Launch and complete the initial setup wizard
+
+When opening a project, wait for indexing to finish, then start coding.
+Now, IDEA may say "No JDK configured" at the top of the source file you have.
+In that case, you can click Download JDK and choose JetBrains JDK 25.
+
+<Callout type="success">
+  If IDEA opened the project without errors, your environment is ready.
+</Callout>
+
+More details by [JetBrains](https://www.jetbrains.com/help/idea/2026.1/run-for-the-first-time.html)
+help page, where we recommend that you also check the
+[SDK configuration](https://www.jetbrains.com/help/idea/2026.1/sdk.html) guide.
+
+<Callout type="info">
+  We recommened following
+  [TheNullicorn's](https://gist.github.com/TheNullicorn/90a619796c40f20ae1fcf13094c1a57d) guide to ensure
+  you are using the correct `Nonnull` in your projects.
+</Callout>
+
+#### What the IDE Does for You
+
+When opened in IntelliJ IDEA, the project automatically:
+
+- Detects and configures Gradle or Maven
+- Downloads all dependencies
+- Sets up project structure and classpaths
+- Configures run/build tasks
+
+You do **not** need to manually install or configure Maven or Gradle if you stay inside the IDE.
+
+Skip to the [Setting Up Your Workspace](#setting-up-your-workspace).
+
+### Manual Setup: Java Development Kit (JDK)
+
+For any other setup, you will need to install and configure your system to have and load Java.
 Hytale modding requires Java 25 or later. We recommend using OpenJDK.
 
-#### Windows
+#### Windows via Installer
 
 1. Download OpenJDK 25 from [Adoptium](https://adoptium.net/)
 2. Run the installer with default settings
+   - Optionally enable feature `Set or Override JAVA_HOME variable` to resolve version related build issues with your project.
 3. Verify installation by opening Command Prompt and running:
 
+#### Windows via Scoop
+
+1. Install Scoop via PowerShell using [scoop.sh](https://scoop.sh/)
+2. Install OpenJDK 25:
+
 ```bash
-java -version
+scoop bucket add java
+scoop install java/openjdk25
 ```
 
 #### macOS
 
+1. Install Brew via Terminal using [brew.sh](https://brew.sh)
+2. Install JDK via Homebrew:
+
 ```bash
-# Using Homebrew
 brew install openjdk@25
 ```
 
@@ -51,22 +104,41 @@ brew install openjdk@25
 
 #### Linux (Ubuntu/Debian)
 
+1. Install JDK via the built-in package repository:
+
 ```bash
 sudo apt update
 sudo apt install openjdk-25-jdk
 ```
 
-### 2. Integrated Development Environment (IDE)
+### Verify installation:
 
-We recommend IntelliJ IDEA Community Edition for Hytale modding.
+Run the following command to see what version of Java you have:
 
-1. Download from [JetBrains website](https://www.jetbrains.com/idea/download/)
-2. Install with default settings
-3. Launch and complete the initial setup wizard
+```bash
+java -version
+```
+
+### Java Build Tool (Optional)
+
+We recommend using a Gradle Wrapper for managing dependencies and building your Hytale plugins. It provides benefits by eliminating the need for a system-wide Gradle installation and ensuring consistent Gradle versions across different environments. (Alternatively you can use Maven, but this guide focuses on Gradle since it is the default for our plugin template.)
+
+The plugin template in the following sections includes a Gradle Wrapper, so you can skip this step if you plan to use the template.
+
+#### Choosing Gradle (if not using the template)
+
+If you prefer to install Gradle manually, follow these steps:
 
-### 3) Java Build Tool
+1. Visit the official website: https://gradle.org/releases/
+2. Download the newest gradle binary: `gradle-9.3.1-bin.zip` (Binary zip archive)
+3. Unzip it
+4. Add the `gradle-9.3.1/bin/` folder to your PATH
+
+You can now try the command `gradle -version` to verify Gradle is installed correctly. Make sure to do this in a fresh new terminal instead of one you had opened from before!
+
+#### Choosing Maven (if not using the template)
 
-We recommend using Apache Maven for managing dependencies and building your Hytale plugins. (Alternatively you can use Gradle, but this guide focuses on Maven.)
+If you prefer to use Maven instead of Gradle, follow these steps to install Maven:
 
 1. Visit the official website: https://maven.apache.org/download.cgi
 2. Download this file: `apache-maven-3.9.12-bin.zip` (Binary zip archive)
@@ -89,22 +161,61 @@ cd MyFirstMod
 
 If you don't have Git installed, you can download the ZIP file from the repository page and extract it to a folder named `MyFirstMod`.
 
-### 2. Open Plugin in your IDEA
+### 2. Open Plugin in your IDE
 
-1. Open IntelliJ IDEA
+1. Open Your IDE (e.g., IntelliJ IDEA)
 2. Click "Open" and navigate to your `MyFirstMod` directory
-3. IntelliJ will automatically detect it as a Maven project
+3. Most IDEs like IntelliJ will automatically detect it as a Gradle project
 4. Wait for the project to index and dependencies to download
 
-<Callout type="info">
-  We recommened following [this](https://gist.github.com/TheNullicorn/90a619796c40f20ae1fcf13094c1a57d) guide to ensure you are using the correct `Nonnull` in your projects.
-</Callout>
+## Alternate Approach: Hytale Dependency
+
+If you prefer to set up your project from scratch without using the template and importing the hytale dependencies manually, ensure your build configuration includes the Hytale repositories and dependencies:
+
+For Gradle, add the following to your `build.gradle.kts`:
+
+```kotlin
+repositories {
+    mavenCentral()
+    maven {
+        name = "hytale"
+        url = uri("https://maven.hytale.com/release") // Or "hytale-pre-release" for pre-release versions
+    }
+}
+dependencies {
+    // + here means the latest version, but you can hard-wire any known version!
+    implementation("com.hypixel.hytale:Server:+")
+}
+```
+
+For Maven, add the following to your `pom.xml`:
+
+```xml
+<project>
+    <repositories>
+        <repository>
+            <id>hytale-release</id> <!-- Or "hytale-pre-release" for pre-release versions -->
+            <url>https://maven.hytale.com/release</url> <!-- Or "https://maven.hytale.com/pre-release" -->
+        </repository>
+    </repositories>
+
+    <dependencies>
+        <dependency>
+            <groupId>com.hypixel.hytale</groupId>
+            <artifactId>Server</artifactId>
+            <!-- Replace with latest version, Hytale provides jars for the last five releases -->
+            <version>LATEST_VERSION_HERE</version>
+            <scope>provided</scope>
+        </dependency>
+    </dependencies>
+</project>
+```
 
 ## Next Steps
 
 Now that you have your development environment set up with the plugin template:
 
-1. **Customize the template** - Edit the `pom.xml` and `manifest.json` file to change your mod's name and details
+1. **Customize the template** - Edit the `settings.gradle.kts`, `build.gradle.kts` and `manifest.json` file to change your mod's name and details
 2. **Explore the code structure** - Familiarize yourself with the template's organization
 3. **Start modding** - Begin writing your first Hytale plugin!
 
diff --git a/content/docs/vi-VN/guides/plugin/spawning-entities.mdx b/content/docs/vi-VN/guides/plugin/spawning-entities.mdx
index e12c0aea..15be2fb3 100644
--- a/content/docs/vi-VN/guides/plugin/spawning-entities.mdx
+++ b/content/docs/vi-VN/guides/plugin/spawning-entities.mdx
@@ -36,7 +36,7 @@ Store<EntityStore> store = world.getEntityStore().getStore();
 
 ## Creating Entities
 
-Once you have the `EntityStore` instance, you can start to create a entity and give it components. Entities are just instances of `Holder<EntityStore>` with several components attached to them.
+Once you have the `EntityStore` instance, you can start to create an entity and give it components. Entities are just instances of `Holder<EntityStore>` with several components attached to them.
 
 <Callout type="warning">
   To interact with the `World` instance, some methods require you to run the code inside the world's execution context.
@@ -118,3 +118,48 @@ Finally, we can add the entity to the world by calling the `addEntity` method on
 ```java
 store.addEntity(holder, AddReason.SPAWN);
 ```
+
+## Making the entity persist
+
+Hytale automatically saves all entities, but the `NetworkId` component (required for players to be able to see the entity) needs to be manually added every time the entity is loaded.
+
+### Using a system
+
+If you have a component that is unique to your entities, this can be done by creating and registering a custom system as follows:
+
+```java
+public class AddNetworkIdToMyEntitySystem extends HolderSystem<EntityStore> {
+    private final ComponentType<EntityStore, MyEntityComponent> myEntityComponentType = MyEntityComponent.getComponentType();
+    private final ComponentType<EntityStore, NetworkId> networkIdComponentType = NetworkId.getComponentType();
+    private final Query<EntityStore> query = Query.and(this.myEntityComponentType, Query.not(this.networkIdComponentType));
+
+    @Override
+    public void onEntityAdd(@NotNull Holder<EntityStore> holder, @NotNull AddReason reason, @NotNull Store<EntityStore> store) {
+        if (!holder.getArchetype().contains(NetworkId.getComponentType())) {
+            holder.addComponent(NetworkId.getComponentType(), new NetworkId(store.getExternalData().takeNextNetworkId()));
+        }
+    }
+
+    @Override
+    public void onEntityRemoved(@NotNull Holder<EntityStore> holder, @NotNull RemoveReason reason, @NotNull Store<EntityStore> store) {}
+
+    @Override
+    public @Nullable Query<EntityStore> getQuery() {
+        return query;
+    }
+}
+```
+
+In your plugin's `setup()` function
+
+```java
+this.getEntityStoreRegistry().registerSystem(new AddNetworkIdToMyEntitySystem())
+```
+
+### Using PropComponent
+
+Alternatively you can add `PropComponent` to your entity. Hytale adds `PropComponent` to entities spawned with the Entity Tool, and such entities automatically get `NetworkId` and `PrefabCopyableComponent` (which makes the entity work with prefabs).
+
+<Callout type="warning">
+  There is no guarantee, that Hytale will not add some other behavior to this component in the future, which may break your entity, so be careful if you decide to rely on it.
+</Callout>
diff --git a/content/docs/vi-VN/guides/plugin/store-persistent-data.mdx b/content/docs/vi-VN/guides/plugin/store-persistent-data.mdx
new file mode 100644
index 00000000..1071dff3
--- /dev/null
+++ b/content/docs/vi-VN/guides/plugin/store-persistent-data.mdx
@@ -0,0 +1,171 @@
+---
+title: Storing Persistent Data on the Player
+description: Learn how to save and load persistent data using Components
+authors:
+  - name: Neil Revin
+    url: https://itsneil.dev/
+  - name: ArcticDev
+    url: https://github.com/ArcticRaven
+  - name: oskarscot
+    url: https://oskar.scot
+  - name: JammingEng
+    url: https://github.com/JammingEnd
+---
+
+Here is how to store persistent data using a custom component on a Player.
+
+## Build your Component Class
+
+Creating a custom component class leverages the Component system made with the ECS architecture in mind. For more information on Components, check out the [ECS Guide](../ecs/hytale-ecs-theory#components).
+
+Start by creating your custom component class. This will be extremely similar to how regular components are created, however we'll setup a custom Codec so the server can translate this data to BSON, or the server's internal json encoder.
+
+<Callout type="info">
+  Each variable you want to store in your component must have its own Codec field defined in the BuilderCodec.
+  For more information on how to create custom Codecs, check out the [ECS Codec Guide](../ecs/hytale-ecs-theory#codec).
+</Callout>
+
+```java
+public class YourPlayerData implements Component<EntityStore> {
+
+    // define some vars!
+    private int someInteger;
+    private String someString;
+    private Map<String, String> someMap;
+
+    public static final BuilderCodec<YourPlayerData> CODEC =
+            BuilderCodec.builder(YourPlayerData.class, YourPlayerData::new)
+            .append(new KeyedCodec<>("SomeInteger", Codec.INTEGER),
+                    (data, value) -> data.someInteger = value, // setter
+                    data -> data.someInteger) // getter
+            .addValidator(Validators.nonNull())
+            .add()
+            .append(new KeyedCodec<>("SomeString", Codec.STRING),
+                    (data, value) -> data.someString = value, // setter
+                    data -> data.someString) // getter
+            .add()
+            .append(new KeyedCodec<>("SomeMap",
+                            new MapCodec<>(Codec.STRING, HashMap::new, false)),
+                    (data, value) -> data.someMap = value, // setter
+                    data -> data.someMap) // getter
+            .add()
+            .build();
+
+
+
+    // Getters and Setters are for the purpose of this example omitted.
+
+    // constructor
+    public YourPlayerData() {
+        this.someInteger = 0;
+        this.someString = "";
+        this.someMap = new HashMap<>();
+    }
+
+    // copy constructor for cloning
+    public YourPlayerData(YourPlayerData clone) {
+        this.someInteger = clone.someInteger;
+        this.someString = clone.someString;
+        this.someMap = clone.someMap;
+    }
+
+    @Nonnull
+    @Override
+    public Component<EntityStore> clone() {
+        return new YourPlayerData(this);
+    }
+}
+```
+
+## Register your Component
+
+Inside your main class's `setup()` method, register your new Component.
+
+```java
+public class YourPlugin extends JavaPlugin {
+
+    private ComponentType<EntityStore, YourPlayerData> yourPlayerDataComponent;
+
+    public YourPlugin(@Nonnull JavaPluginInit init) {
+        super(init);
+    }
+
+    @Override
+    protected void setup(){
+        this.yourPlayerDataComponent = this.getEntityStoreRegistry().registerComponent(
+            YourPlayerData.class,
+            "YourPlayerDataComponent",
+            YourPlayerData.CODEC
+        );
+    }
+
+    public ComponentType<EntityStore, YourPlayerData> getYourPlayerDataComponent() {
+        return this.yourPlayerDataComponent;
+    }
+}
+```
+
+## Using your Component
+
+To use your newly created component, you can add the Component to a player using the `addComponent` method, although this only adds it temporarily, meaning when the player/entity leaves the world, the component is removed. You can use `putComponent` to ensure the component persists between sessions.
+
+```java
+// You will need the Ref and Store to apply components
+private void someEntryMethod(@Nonnull Ref<EntityStore> ref, @Nonnull Store<EntityStore> store)
+{
+       // Any entity will work, for now we will use the player
+      Player player = (Player) store.getComponent(ref, Player.getComponentType());
+
+      // since we're using putComponent, it could be useful to check if it already exists on the player in case we want to update it
+     if(store.getComponent(ref, YourPlugin.instance().getYourPlayerDataComponent()) != null)
+     {
+          // here we implement logic that updates the component
+         var comp = store.getComponent(ref, YourPlugin.instance().getYourPlayerDataComponent())
+         // declare public fields or methods in the component class
+         comp.SomeString = "An Updated Field";
+     } else {
+          // Here we put the component
+          var myCustomComp = new CustomComponent();
+          // declare public fields or methods in the component class
+          myCustomComp.SomeString = "Edited String";
+
+          // putComponent allows you to insert declared objects
+          store.putComponent(ref, YourPlugin.instance().getYourPlayerDataComponent(), myCustomComp);
+     }
+}
+```
+
+## Using your Data
+
+Your component will be stored within the `Store<EntityStore>` when added to the player. In the provided example,
+we'll fetch this data off the player using the `ensureAndGetComponent()` method, which will add the component to
+the player if it does not exist with the default values.
+
+```java
+public class IncompleteCustomCommand extends AbstractPlayerCommand {
+
+    public IncompleteCustomCommand() {
+        super("nope", "don't use this command");
+    }
+
+    @Override
+    protected void execute(
+        @NonNullDecl CommandContext commandContext,
+        @NonNullDecl Store<EntityStore> store,
+        @NonNullDecl Ref<EntityStore> ref,
+        @NonNullDecl PlayerRef playerRef,
+        @NonNullDecl World world
+    ) {
+        YourPlayerData customData = store.ensureAndGetComponent(ref, YourPlugin.instance().getYourPlayerDataComponent());
+        // ensureAndGetComponent adds the component to the ref, with the default values defined inside your component.
+ 		// use your data
+    }
+}
+```
+
+And that's it! Your data will now be saved and loaded automatically with the player.
+
+Using custom components to store persistent data on players is a powerful way to maintain state across sessions.
+By following the steps outlined above, you can easily create, register, and utilize your own data structures within the Hytale ECS framework.
+This approach ensures that your data is seamlessly integrated with the game's existing systems.
+For more information about Hytale's Entity Component System visit the [Hytale ECS Theory](https://hytalemodding.dev/en/docs/guides/ecs/hytale-ecs-theory) guide.
diff --git a/content/docs/vi-VN/guides/plugin/teleporting-players.mdx b/content/docs/vi-VN/guides/plugin/teleporting-players.mdx
index 57cee77f..32ce0435 100644
--- a/content/docs/vi-VN/guides/plugin/teleporting-players.mdx
+++ b/content/docs/vi-VN/guides/plugin/teleporting-players.mdx
@@ -1,26 +1,32 @@
 ---
 title: Teleporting the player
 description: Learn how to teleport the player.
+authors:
+  - name: oskarscot
+    url: https://oskar.scot
 ---
 
-To teleport players in Hytale, you will need to get a `World` object so we can safely run the teleport on the world thread. The world thread manages all entity updates, so modifying entities off-thread can crash the server or cause inconsistent state.
-Next, we get the entity store and make a `Teleport` object.
-We add a `Teleport` component to the player’s entity reference in the entity store. This triggers the teleportation logic for that player.
+Teleporting players in Hytale works by simply attaching a `Teleport` component to a player with the desired world and transform.
+You can only trigger teleports from a world where the player is currently present.
+Teleport itself is a component but it also provides factory methods to configure the Teleport. Just as with any entity component, an EntityStore and a Ref to the EntityStore is required
+
+We can create a simple teleport utility like this:
 
 ```java
-public static void teleportPlayer(Player player, int x, int y, int z) {
-        World world = player.getWorld();
-        if (world == null) return;
-        world.execute(() -> {
-            if (player.getReference() == null) return;
-            Store<EntityStore> store = player.getReference().getStore();
-            Teleport teleport = Teleport.createForPlayer(world,
-                new Vector3d(x ,y, z), // Target position
-                new Vector3f(0, 0, 0)  // Target rotation (pitch, yaw, roll)
-            );
+public static void teleportPlayer(Ref<EntityStore> ref, Store<EntityStore> store, World targetWorld, double x, double y, double z) {                                                                                       
+    Transform transform = new Transform(x, y, z);                                                                                                                           
+    Teleport teleport = Teleport.createForPlayer(targetWorld, transform);                                                                                                   
+    store.addComponent(ref, Teleport.getComponentType(), teleport);                                                                                                         
+}  
+```
 
-            store.addComponent(player.getReference(), Teleport.getComponentType(), teleport);
-        });
+A `Transform` is a representation of a position Vector3d and rotation Vector3f which works in the following way:
 
-}
+```java
+Transform transform = new Transform(
+    new Vector3d(x, y, z),      // Position
+    new Rotation(yaw, pitch, 0) // Rotation, last value seems to always be 0
+);
+Teleport teleport = Teleport.createForPlayer(targetWorld, transform);
+store.addComponent(ref, Teleport.getComponentType(), teleport);
 ```
diff --git a/content/docs/vi-VN/guides/plugin/tracking-mod-analytics-with-hstats.mdx b/content/docs/vi-VN/guides/plugin/tracking-mod-analytics-with-hstats.mdx
new file mode 100644
index 00000000..45c022e0
--- /dev/null
+++ b/content/docs/vi-VN/guides/plugin/tracking-mod-analytics-with-hstats.mdx
@@ -0,0 +1,65 @@
+---
+title: Tracking Mod Analytics with HStats
+description: Learn how you can track Analytics for your Hytale Mod for Free using hstats.dev
+authors:
+  - name: Al3x
+    url: https://hstats.dev
+---
+
+In this guide, you will learn how to integrate HStats into your Plugin/Mod which will allow you to track how many Servers are using it along with other stats.
+
+<Callout type="info">
+  HStats is a third-party tool and is not affiliated with HytaleModding or Hypixel Studios
+</Callout>
+
+# Step 1: Register your Mod to HStats
+
+Before you touch any code, you will need to add your mod to the HStats website which will give you a UUID for your mod.
+
+- Create or Login to an Account on https://hstats.dev
+- Navigate to the dashboard page (https://hstats.dev/dashboard)
+- On the left, type in your mod's name and click "Add Mod"
+- Keep note of the UUID generated for later.
+
+# Step 2: Add the HStats Class to Your Project
+
+To keep things simple, HStats uses a single Java class file that handles everything for you.
+
+- Download / Copy the File from the GitHub page (https://github.com/hstats-dev/HStatsExamplePlugin/blob/main/src/main/java/com/al3x/HStats.java)
+- Paste into your Project. You should now have a HStats.java file somewhere in your projects directory.
+- Update the package name from com.al3x to whatever fits your project.
+
+# Step 3: Initialize HStats in your code
+
+You only need to add one line of code to your mod's setup method in your main class to start tracking.
+
+`new HStats("YOUR-MOD-UUID", "1.0.0");`
+
+Replace `YOUR-MOD-UUID` with the Mod UUID we made note of earlier and change the `1.0.0` version to whatever version your mod is currently on.
+
+Your setup method should now look something like this:
+
+```java
+@Override
+protected void setup() {
+  super.setup();
+  new HStats("c34a2b2a-afd8-4d6a-821e-7a63e12c5ea6", "1.0.0");
+}
+```
+
+# Extras
+
+Your done! Your mod should now be listed under the Mods page (https://hstats.dev/mods) as well as under your dashboard.
+
+Servers using your mod should now post updates about every minute to HStats which you can view in the Dashboard.
+
+### Embeds
+
+HStats allows you to generate an Embed Card that you can place on your CurseForge or GitHub page. This is useful for server owners to be able to see how many other servers are using your mod.
+
+- In your dashboard, scroll down to the Embed Card section.
+- Customize the appearance (Light/Dark mode, layout, etc).
+- Copy the generated URL to display your "Active Servers" and "Players Online" live on your mod's description page
+
+Heres an example of what they look like:
+![HStats Example](https://api.hstats.dev/api/embed/d52fa672-6966-47b2-b501-1a11bddebac3/card.svg?theme=light\&layout=compact\&size=md\&show_id=true\&dark=false)
diff --git a/content/docs/vi-VN/guides/plugin/world-gen.mdx b/content/docs/vi-VN/guides/plugin/world-gen.mdx
index 4c23b0c9..7b193ffd 100644
--- a/content/docs/vi-VN/guides/plugin/world-gen.mdx
+++ b/content/docs/vi-VN/guides/plugin/world-gen.mdx
@@ -100,7 +100,7 @@ Biome biome = biomeGen.generateBiomeAt(zoneResult, seed, x, z);
 
 ### Zone & Cave Integration
 
-Each zone defines it's own cave patterns:
+Each zone defines its own cave patterns:
 
 ```java
 Zone zone = /* ... */;
diff --git a/content/docs/vi-VN/guides/prefabs.mdx b/content/docs/vi-VN/guides/prefabs.mdx
index 08404b30..b1a55109 100644
--- a/content/docs/vi-VN/guides/prefabs.mdx
+++ b/content/docs/vi-VN/guides/prefabs.mdx
@@ -14,7 +14,7 @@ Prefabs are Hytale's way of creating reusable structures.
 There are a few fundamental concepts to understand about prefabs:
 
 - Users interact with prefabs via a prefab editing world.
-- Prefabs the physical structures in the game world, and are saved as JSON files.
+- Prefabs are the physical structures in the game world, and are saved as JSON files.
 
 ## How to Create a Prefab
 
diff --git a/content/docs/vi-VN/official-documentation/custom-ui/common-styling.mdx b/content/docs/vi-VN/official-documentation/custom-ui/common-styling.mdx
new file mode 100644
index 00000000..c36e3e3a
--- /dev/null
+++ b/content/docs/vi-VN/official-documentation/custom-ui/common-styling.mdx
@@ -0,0 +1,50 @@
+---
+title: Common Styling
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# Common Styling
+
+## Common UI Styling Library
+
+This document describes the shared UI components and styles defined in `Common.ui`.
+
+---
+
+### Styles
+
+We are providing some styles that can be re-used in any custom UI that, provide a cohesive UI experience with the core game UI. These styles are available in the `Common.ui` file.
+
+You can find a list of all the styles defined with live examples by running the `/ui-gallery` command ingame.
+
+<Callout type="warning">
+  This command is not available yet, but will be in a future patch.
+</Callout>
+
+![Gallery](/assets/official-documentation/ui/gallery.png)
+
+### Importing
+
+To use these styles in your UI file:
+
+```
+$Common = "Common.ui";
+
+// Then reference styles and components:
+$Common.@TextButton { @Text = "My Button"; }
+$Common.@Container { ... }
+```
+
+<Callout type="info">
+  The `Common.ui` file is at `Common/UI/Custom/Common.ui` within the Hytale pack. If your custom ui document is in a subfolder of `Common/UI/Custom/`, reference it via relative path traversal:
+
+  ```
+  $Common = "../Common.ui";
+  ```
+
+  You can find more info about paths [here](markup#path).
+</Callout>
diff --git a/content/docs/vi-VN/official-documentation/custom-ui/index.mdx b/content/docs/vi-VN/official-documentation/custom-ui/index.mdx
new file mode 100644
index 00000000..f94c4e88
--- /dev/null
+++ b/content/docs/vi-VN/official-documentation/custom-ui/index.mdx
@@ -0,0 +1,125 @@
+---
+title: Custom UI
+icon: LayoutDashboard
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# Custom UI
+
+## What is Custom UI?
+
+Custom UI is Hytale's framework for creating **custom user interfaces** controlled by the game server. Unlike the built-in Client UI (which is part of the game client and cannot be modified), Server UI allows you to create interactive screens and HUD overlays through Java plugins and asset packs.
+
+As a modder, Custom UI gives you the power to:
+
+- **Create custom interactive pages** - Shop interfaces, quest dialogs, server settings menus, admin panels
+- **Add custom HUD overlays** - Quest trackers, status displays, custom health bars, server information
+- **Design with markup** - Use `.ui` files to define reusable UI templates
+- **Handle user interactions** - Respond to button clicks, form submissions, and other events
+- **Localize your UI** - Support multiple languages using the game's translation system
+
+## How Custom UI Fits Into Hytale's UI
+
+Hytale's user interface is divided into two main categories:
+
+### Client UI (Not Moddable)
+
+Built-in interfaces controlled by the C# game client:
+
+- Main menu and settings
+- Character creation
+- Built-in HUD (health, hotbar, chat)
+- Inventory and crafting screens
+- Development tools
+
+**You cannot modify these** - they are part of the core game client.
+
+### In-Game UI (Moddable via Server)
+
+Server-controlled interfaces that you can create and customize:
+
+#### Custom Pages
+
+Full-screen interactive overlays that appear during gameplay:
+
+- Can be dismissed by the player (ESC key)
+- Capture all input (keyboard and mouse)
+- Support loading states while waiting for server responses
+- Perfect for: shops, dialogs, menus, configuration screens
+
+#### Custom HUDs
+
+Persistent overlay elements drawn on top of the game world:
+
+- Display-only (no user interaction)
+- Always visible during gameplay
+- Lightweight and non-intrusive
+- Perfect for: quest objectives, status indicators, server info panels
+
+## Architecture Overview
+
+Server UI uses a **command-based architecture**:
+
+```
+┌─────────────────────┐         ┌──────────────────────┐
+│   Java Server       │         │    C# Client         │
+│   (Your Plugin)     │         │    (Game)            │
+├─────────────────────┤         ├──────────────────────┤
+│                     │         │                      │
+│ InteractiveCustomUI │         │   CustomPage or      │
+│ Page                │         │   CustomHud          │
+│   ↓ build()         ├────────→│     ↓ Apply          │
+│ UICommandBuilder    │         │   Element Tree       │
+│   - append()        │         │     ↓ Layout         │
+│   - set()           │         │   Rendered UI        │
+│   - clear()         │         │                      │
+│                     │         │                      │
+│ ↓ handleDataEvent() │← Events │   User Interaction   │
+│   Process input     │         │   (click, type, etc) │
+│   sendUpdate()      │         │                      │
+└─────────────────────┘         └──────────────────────┘
+```
+
+**The flow:**
+
+1. Your Java code builds UI using `UICommandBuilder`
+2. Commands are sent to the client as data
+3. Client parses `.ui` markup files and creates visual elements
+4. User interacts with the UI
+5. Events are sent back to your Java code
+6. You process events and send updates back
+
+## Key Principles
+
+### Declarative, Not Imperative
+
+You don't create UI objects directly. Instead, you send **commands** that describe what you want:
+
+- "Append this button template to that container"
+- "Set this label's text to 'Hello World'"
+- "Clear all children from this list"
+
+### Asset-Driven
+
+UI structure is defined in `.ui` markup files (assets), not hardcoded in Java. This enables:
+
+- Designers to modify layouts without touching code
+- Reusable UI components
+- Consistent visual language
+
+### Event-Driven
+
+User interactions trigger events that flow back to your server code. You register event bindings and handle them in `handleDataEvent()`.
+
+### Selector-Based
+
+You target specific UI elements using **selectors:**
+
+- `#MyButton` - Element with ID "MyButton"
+- `#List[0]` - First child of element "List"
+- `#List[0] #Title` - Element with ID "Title" in the first child of element "List"
+- `#Label.TextColor` - The TextColor property of element "Label"
diff --git a/content/docs/vi-VN/official-documentation/custom-ui/layout.mdx b/content/docs/vi-VN/official-documentation/custom-ui/layout.mdx
new file mode 100644
index 00000000..0a24ca09
--- /dev/null
+++ b/content/docs/vi-VN/official-documentation/custom-ui/layout.mdx
@@ -0,0 +1,492 @@
+---
+title: Layout
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# Layout
+
+The layout system determines how UI elements are positioned and sized on screen. Understanding layout is crucial for creating well-structured, responsive interfaces.
+
+## Layout Fundamentals
+
+Every UI element has:
+
+- **Container Rectangle** - The space allocated by the parent
+- **Anchor** - How the element positions/sizes itself within the container
+- **Padding** - Inner spacing that affects child layout
+- **LayoutMode** - How the element arranges its children (if it's a container)
+
+```
+┌─────────────────────────────────────┐
+│  Container Rectangle (from parent)  │
+│  ┌───────────────────────────────┐  │
+│  │  Anchored Rectangle           │  │
+│  │  ┌─────────────────────────┐  │  │
+│  │  │ Padding                 │  │  │
+│  │  │  ┌───────────────────┐  │  │  │
+│  │  │  │  Content Area     │  │  │  │
+│  │  │  └───────────────────┘  │  │  │
+│  │  └─────────────────────────┘  │  │
+│  └───────────────────────────────┘  │
+└─────────────────────────────────────┘
+```
+
+## Anchor
+
+`Anchor` controls how an element positions and sizes itself within its container rectangle.
+
+### Fixed Size
+
+```
+Button {
+    Anchor: (Width: 200, Height: 40);
+}
+```
+
+Creates a 200×40 pixel button.
+
+### Positioning
+
+```
+Label {
+    Anchor: (Top: 10, Left: 20, Width: 100, Height: 30);
+}
+```
+
+- **Top**: 10 pixels from container's top edge
+- **Left**: 20 pixels from container's left edge
+- **Width**: 100 pixels wide
+- **Height**: 30 pixels tall
+
+### Anchoring to Edges
+
+```
+Button {
+    Anchor: (Bottom: 10, Right: 10, Width: 100, Height: 30);
+}
+```
+
+Anchors the button to the bottom-right corner, 10 pixels from each edge.
+
+### Stretching
+
+```
+Group {
+    Anchor: (Top: 0, Bottom: 0, Left: 0, Right: 0);
+}
+```
+
+Stretches to fill the entire container (all edges at 0 pixels).
+
+**Shorthand:**
+
+```
+Group {
+    Anchor: (Full: 0);
+}
+```
+
+### Mixed Anchoring
+
+```
+Panel {
+    Anchor: (Top: 10, Bottom: 10, Left: 20, Width: 300);
+}
+```
+
+- Fixed width of 300 pixels
+- Stretches vertically between top and bottom edges
+- 10 pixels from top and bottom
+- 20 pixels from left
+
+## Padding
+
+`Padding` creates inner spacing, affecting where children are positioned.
+
+### Uniform Padding
+
+```
+Group {
+    Padding: (Full: 20);
+}
+```
+
+20 pixels of padding on all sides.
+
+### Directional Padding
+
+```
+Group {
+    Padding: (Top: 10, Bottom: 20, Left: 15, Right: 15);
+}
+```
+
+Different padding per edge.
+
+### Shorthand
+
+```
+// Horizontal and vertical
+Group {
+    Padding: (Horizontal: 20, Vertical: 10);
+}
+
+// Equivalent to:
+// Top: 10, Bottom: 10, Left: 20, Right: 20
+```
+
+### Effect on Children
+
+```
+Group {
+    Anchor: (Width: 200, Height: 100);
+    Padding: (Full: 10);
+
+    Label {
+        Anchor: (Full: 0);
+    }
+}
+```
+
+The label fills the group, but there's a 10-pixel gap on all sides due to padding.
+
+```
+┌──────────────────────┐
+│ Group (200×100)      │
+│  ┌────────────────┐  │
+│  │ Label          │  │ ← 10px padding all around
+│  │                │  │
+│  └────────────────┘  │
+└──────────────────────┘
+```
+
+## LayoutMode
+
+`LayoutMode` determines how a container arranges its children.
+
+### Top (Vertical Stack)
+
+```
+Group {
+    LayoutMode: Top;
+
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+}
+```
+
+Children stack vertically from top to bottom:
+
+```
+┌──────────┐
+│ Button 1 │
+├──────────┤
+│ Button 2 │
+├──────────┤
+│ Button 3 │
+└──────────┘
+
+
+```
+
+Each child's `Anchor.Bottom` adds spacing between elements:
+
+```
+Button { Anchor: (Height: 30, Bottom: 10); }  // 10px gap after this button
+```
+
+### Bottom (Vertical Stack)
+
+```
+Group {
+    LayoutMode: Bottom;
+
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+}
+```
+
+Children stack vertically from top to bottom but aligned to the bottom edge of the parent:
+
+```
+
+
+
+┌──────────┐
+│ Button 1 │
+├──────────┤
+│ Button 2 │
+├──────────┤
+│ Button 3 │
+└──────────┘
+```
+
+### Left (Horizontal Stack)
+
+```
+Group {
+    LayoutMode: Left;
+
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+}
+```
+
+Children arrange horizontally from left to right:
+
+```
+┌────────┬────────┬────────┐
+│ Button │ Button │ Button │
+│   1    │   2    │   3    │
+└────────┴────────┴────────┘
+```
+
+Use `Anchor.Right` for spacing between elements.
+
+### Right (Horizontal Stack)
+
+```
+Group {
+    LayoutMode: Right;
+
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+}
+```
+
+Children arrange horizontally from left to right but aligned to the right side of the parent:
+
+```
+                                                                 ┌────────┬────────┬────────┐
+                                                                 │ Button │ Button │ Button │
+                                                                 │   1    │   2    │   3    │
+                                                                 └────────┴────────┴────────┘
+```
+
+### Center
+
+```
+Group {
+    LayoutMode: Center;
+
+    Group #Dialog {
+        Anchor: (Width: 400, Height: 300);
+    }
+}
+```
+
+Centers the children horizontally.
+
+### Middle
+
+```
+Group {
+    LayoutMode: Middle;
+
+    Group #Dialog {
+        Anchor: (Width: 400, Height: 300);
+    }
+}
+```
+
+Centers the children vertically.
+
+### CenterMiddle (Horizontal Stack, Fully Centered)
+
+```
+Group {
+    LayoutMode: CenterMiddle;
+
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+    Button { Anchor: (Width: 80); }
+}
+```
+
+Children stack horizontally from left to right, centered both horizontally and vertically within the parent:
+
+```
+┌────────────────────────────────────────────┐
+│                                            │
+│                                            │
+│         ┌──────┐ ┌──────┐ ┌──────┐         │
+│         │  B1  │ │  B2  │ │  B3  │         │
+│         └──────┘ └──────┘ └──────┘         │
+│                                            │
+│                                            │
+└────────────────────────────────────────────┘
+```
+
+---
+
+### MiddleCenter (Vertical Stack, Fully Centered)
+
+```
+Group {
+    LayoutMode: MiddleCenter;
+
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+    Button { Anchor: (Height: 30); }
+}
+```
+
+Children stack vertically from top to bottom, centered both horizontally and vertically within the parent:
+
+```
+┌────────────────────────────────────────────┐
+│                                            │
+│              ┌──────────┐                  │
+│              │ Button 1 │                  │
+│              ├──────────┤                  │
+│              │ Button 2 │                  │
+│              ├──────────┤                  │
+│              │ Button 3 │                  │
+│              └──────────┘                  │
+│                                            │
+└────────────────────────────────────────────┘
+```
+
+---
+
+### Full
+
+```
+Group {
+    LayoutMode: Full;
+
+    Label {
+        Anchor: (Top: 20, Left: 20, Width: 100, Height: 30);
+    }
+}
+```
+
+Children use absolute positioning via their `Anchor` properties.
+
+### TopScrolling
+
+```
+Group {
+    LayoutMode: TopScrolling;
+    ScrollbarStyle: $Common.@DefaultScrollbar;
+
+    // ... many children
+}
+```
+
+Like `Top`, but adds a scrollbar if content exceeds container height.
+
+Or use `BottomScrolling` for bottom-aligned content.
+
+### LeftScrolling
+
+```
+Group {
+    LayoutMode: LeftScrolling;
+    ScrollbarStyle: $Common.@DefaultScrollbar;
+
+    // ... many children
+}
+```
+
+Like `Left`, but adds a scrollbar for horizontal scrolling.
+
+Or use `RightScrolling` for right-aligned content.
+
+### LeftCenterWrap (Wrapping Horizontal Stack, Horizontally Centered)
+
+```
+Group {
+    LayoutMode: LeftCenterWrap;
+
+    Button { Anchor: (Width: 80, Height: 30); }
+    Button { Anchor: (Width: 80, Height: 30); }
+    Button { Anchor: (Width: 80, Height: 30); }
+    Button { Anchor: (Width: 80, Height: 30); }
+    Button { Anchor: (Width: 80, Height: 30); }
+}
+```
+
+Children flow left to right. When there's no more horizontal space, they wrap to the next row. Each row is horizontally centered within the parent:
+
+```
+┌────────────────────────────────────────────┐
+│                                            │
+│       ┌──────┐ ┌──────┐ ┌──────┐           │
+│       │  B1  │ │  B2  │ │  B3  │           │
+│       └──────┘ └──────┘ └──────┘           │
+│            ┌──────┐ ┌──────┐               │
+│            │  B4  │ │  B5  │               │
+│            └──────┘ └──────┘               │
+│                                            │
+└────────────────────────────────────────────┘
+```
+
+## FlexWeight
+
+`FlexWeight` distributes remaining space among children.
+
+```
+Group {
+    LayoutMode: Left;
+    Anchor: (Width: 400);
+
+    Button {
+        Anchor: (Width: 100);
+    }
+
+    Group {
+        FlexWeight: 1;  // Takes all remaining space
+    }
+
+    Button {
+        Anchor: (Width: 100);
+    }
+}
+```
+
+Result:
+
+- First button: 100px
+- Middle group: 200px (400 - 100 - 100 = 200)
+- Last button: 100px
+
+### Multiple FlexWeights
+
+```
+Group {
+    LayoutMode: Left;
+    Anchor: (Width: 600);
+
+    Group { FlexWeight: 1; }
+    Group { FlexWeight: 2; }
+    Group { FlexWeight: 1; }
+}
+```
+
+Remaining space (600px) is split:
+
+- First group: 600 × (1/4) = 150px
+- Second group: 600 × (2/4) = 300px
+- Third group: 600 × (1/4) = 150px
+
+## Visibility
+
+```
+Button #HiddenButton {
+    Visible: false;
+}
+```
+
+**Effect:**
+
+- Element and its children are not displayed
+- Element is **not included in layout** (doesn't take up space)
diff --git a/content/docs/vi-VN/official-documentation/custom-ui/markup.mdx b/content/docs/vi-VN/official-documentation/custom-ui/markup.mdx
new file mode 100644
index 00000000..564110ed
--- /dev/null
+++ b/content/docs/vi-VN/official-documentation/custom-ui/markup.mdx
@@ -0,0 +1,226 @@
+---
+title: Markup
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# Markup
+
+## Markup
+
+An element is the basic building block of a user interface. There are various types of elements with different properties, which are documented below.
+
+Here's what the syntax looks like:
+
+```
+// Basic declaration of an element
+// with its Anchor property set to attach on all sides of its parent
+// with 10 pixels of margin
+Group { Anchor: (Left: 10, Top: 10, Right: 10, Bottom: 10); }
+
+Group { Anchor: (Full: 10); } // More concise version
+
+// Declaration of a Label with a name
+// (can be used to access the element from game code)
+Label #MyLabel {
+  Style: LabelStyle(FontSize: 16); // or just Style: (FontSize: 16), type can be inferred.
+  Text: "Hi! I am text.";
+}
+
+// Declaration of a Group containing 2 children
+// You can use FlexWeight to distribute any left-over space after explicit widths/heights have been subtracted
+Group {
+  LayoutMode: Left;
+  Label { Text: "Child 1"; FlexWeight: 2; }
+  Label { Text: "Child 2"; FlexWeight: 1; }
+}
+```
+
+### Documents
+
+A UI document (_.ui_ file) contains trees of elements. There can be multiple root elements.
+
+### Named Expressions
+
+Named expressions can be declared at any level of a document (including at the root) and will be scoped to that subtree, though they need to be declared at the top of the block.
+
+```
+// Example of named expressions, declared and used with @ prefix
+@Title = "Hytale";
+@ExtraSpacing = 5;
+
+Label {
+  Text: @Title;
+  Style: (LetterSpacing: 2 + @ExtraSpacing);
+}
+```
+
+You can use the spread operator `...` to reuse a named expression while overriding some of its fields:
+
+```
+@MyBaseStyle = LabelStyle(FontSize: 24, LetterSpacing: 2);
+
+Label {
+  Style: (...@MyBaseStyle, FontSize: 36);
+}
+```
+
+You can even layer multiple named expressions like so:
+
+```
+@TitleStyle = LabelStyle(FontSize: 24, HorizontalAlignment: Center);
+@SpacedTextStyle = LabelStyle(LetterSpacing: 2);
+
+Label {
+  Style: (...@BigTextStyle, ...@SpacedTextStyle);
+}
+```
+
+#### Document references
+
+A document can reference another document and access its named expressions.
+
+```
+// Document references are defined with $ prefix
+$Common = "../Common.ui";
+
+TextButton {
+  Style: $Common.@DefaultButtonStyle;
+}
+```
+
+### Templates
+
+You can declare a reusable bit of interface as a named expression and then instantiate it as many times as you want in the tree while customizing it.
+
+You can override local named expressions as well as insert additional children at any point in the template tree. However, local named expressions must be defined at the very top of the block, before properties and child elements.
+
+```
+// This is the template
+@Row = Group {
+  Anchor: (Height: 50);
+  Label #Label { Anchor: (Left: 0, Width: 100); Text: @LabelText; }
+  Group #Content { Anchor: (Left: 100); }
+};
+
+// Here we'll be using it twice in the document tree
+Group #Rows {
+  LayoutMode: TopScrolling;
+
+  @Row #MyFirstRow {
+    @LabelText = "First row";
+    #Content { TextInput {} }
+  }
+
+  @Row #MySecondRow {
+    @LabelText = "Second row";
+  }
+}
+```
+
+### Property Types
+
+#### Basic Types
+
+- **Boolean**
+  - `Visible: false;`
+  - `Visible: true;`
+- **Int**
+  - `Height: 20;`
+- **Float, Double, Decimal**
+  - `Min: 0.2;`
+- **String**
+  - `Text: "Hi!";`
+- **Char**
+  - `PasswordChar: "*";`
+  - _Note: The syntax is the same as a string, however a value of this type cannot contain more than one character!_
+- **Color**
+  - `Background: #ffffff;`&#x20;
+- **Objects**
+  - `Style: (Background: #ffffff)`
+- **Array**&#x20;
+  - `TextSpans: [(Text: "Hi", IsBold: true)]`
+
+#### Translations
+
+Translation keys can be referenced anywhere in markup where you can provide a string, and they are then converted to a string when an element gets instantiated.
+
+**Example:**
+
+```
+Label {
+  Text: %ui.general.cancel;
+}
+```
+
+#### Colors
+
+A color literal can be written as follows:
+
+- `#rrggbb`: 6-digit hexadecimal representation for red, green, blue (fully opaque)
+- `#rrggbb(a.a)`: 6-digit hexadecimal representation for red, green, blue with alpha between 0 and 1
+- `#rrggbbaa`: 8-digit hexadecimal representation for red, green, blue and alpha
+
+```
+Group {
+  Background: #000000(0.3);
+}
+```
+
+<Callout>
+  The `#rrggbb(a.a)` format is prefered over the `#rrggbbaa` format for
+  readability reasons.
+</Callout>
+
+#### Font Name
+
+Font names can be referenced directly by their string ID. Internally this is using a custom type called `UIFontName`, however strings will be converted automatically to this type in markup.
+
+```
+Label {
+  Text: "Hi";
+  Style: (FontName: "Secondary");
+}
+```
+
+**Available Font Names**
+
+- _Default_ - This is the default font that is used for most text and is always used unless a different option has been specified
+- _Secondary_ - This font is mostly used for headlines or elements that are supposed to stick out
+- _Mono_ - This is only used for development; For things such as profiling or error overlays.
+
+#### Path
+
+We can reference other UI assets with the `UIPath` type. Similar to `UIFontName`_,_ Strings are automatically converted to a `UIPath`. Paths are always relative to the file where they have been declared in. Looking up _MyButton.png_ in _Menu/MyAwesomeMenu.ui_ will result in _Menu/MyButton.png_. If you want to reference a file that is in a parent folder you can go back one directory by writing two dots (_../MyButton.png_).
+
+The markup syntax of a `UIPath` is the same as a String. (e.g. `Path: "Test.png"`)
+
+Here are some more examples:
+
+| UIPath             | .ui File                              | Resulting Path    |
+| ------------------ | ------------------------------------- | ----------------- |
+| MyButton.png       | Menu/MyAwesomeMenu.ui                 | Menu/MyButton.png |
+| ../MyButton.png    | Menu/MyAwesomeMenu.ui                 | MyButton.png      |
+| ../../MyButton.png | Menu/Popup/Templates/MyAwesomeMenu.ui | Menu/MyButton.png |
+
+#### Objects
+
+Objects contain a set of properties. In this example we are assigning an Anchor object to the _Anchor_ property:
+
+```
+Group {
+  Anchor: (
+   Height: 10,
+   Width: 20
+ );
+}
+```
+
+You can find all objects that can be used in markup [here](type-documentation#elements).
+
+## Visual Studio Code Extension
+
+There is an official extension for Visual Studio Code which adds syntax highlighting for .ui files. You can find it [here](https://marketplace.visualstudio.com/items?itemName=HypixelStudiosCanadaInc.vscode-hytaleui).
diff --git a/content/docs/vi-VN/official-documentation/custom-ui/type-documentation/index.mdx b/content/docs/vi-VN/official-documentation/custom-ui/type-documentation/index.mdx
new file mode 100644
index 00000000..69cea406
--- /dev/null
+++ b/content/docs/vi-VN/official-documentation/custom-ui/type-documentation/index.mdx
@@ -0,0 +1,127 @@
+---
+title: Type Documentation
+authors:
+  - name: Hypixel Studios Canada Inc.
+    url: https://hytale.com
+---
+
+<OfficialDocumentationNotice />
+
+# Type Documentation
+
+This is a generated list of UI elements accessible by markup. More information about the User Interface framework can be found in the main documentation.
+
+## Elements
+
+- [ActionButton](type-documentation/elements/actionbutton)
+- [AssetImage](type-documentation/elements/assetimage)
+- [BackButton](type-documentation/elements/backbutton)
+- [BlockSelector](type-documentation/elements/blockselector)
+- [Button](type-documentation/elements/button)
+- [CharacterPreviewComponent](type-documentation/elements/characterpreviewcomponent)
+- [CheckBox](type-documentation/elements/checkbox)
+- [CheckBoxContainer](type-documentation/elements/checkboxcontainer)
+- [CircularProgressBar](type-documentation/elements/circularprogressbar)
+- [CodeEditor](type-documentation/elements/codeeditor)
+- [ColorOptionGrid](type-documentation/elements/coloroptiongrid)
+- [ColorPicker](type-documentation/lements/colorpicker)
+- [ColorPickerDropdownBox](type-documentation/elements/colorpickerdropdownbox)
+- [CompactTextField](type-documentation/elements/compacttextfield)
+- [DropdownBox](type-documentation/elements/dropdownbox)
+- [DropdownEntry](type-documentation/elements/dropdownentry)
+- [DynamicPane](type-documentation/elements/dynamicpane)
+- [DynamicPaneContainer](type-documentation/elements/dynamicpanecontainer)
+- [FloatSlider](type-documentation/elements/floatslider)
+- [FloatSliderNumberField](type-documentation/elements/floatslidernumberfield)
+- [Group](type-documentation/elements/group)
+- [HotkeyLabel](type-documentation/elements/hotkeylabel)
+- [ItemGrid](type-documentation/elements/itemgrid)
+- [ItemIcon](type-documentation/elements/itemicon)
+- [ItemPreviewComponent](type-documentation/elements/itempreviewcomponent)
+- [ItemSlot](type-documentation/elements/itemslot)
+- [ItemSlotButton](type-documentation/elements/itemslotbutton)
+- [Label](type-documentation/elements/label)
+- [LabeledCheckBox](type-documentation/elements/labeledcheckbox)
+- [MenuItem](type-documentation/elements/menuitem)
+- [MultilineTextField](type-documentation/elements/multilinetextfield)
+- [NumberField](type-documentation/elements/numberfield)
+- [Panel](type-documentation/elements/panel)
+- [ProgressBar](type-documentation/elements/progressbar)
+- [ReorderableList](type-documentation/elements/reorderablelist)
+- [ReorderableListGrip](type-documentation/elements/reorderablelistgrip)
+- [SceneBlur](type-documentation/elements/sceneblur)
+- [Slider](type-documentation/elements/slider)
+- [SliderNumberField](type-documentation/elements/slidernumberfield)
+- [Sprite](type-documentation/elements/sprite)
+- [TabButton](type-documentation/elements/tabbutton)
+- [TabNavigation](type-documentation/elements/tabnavigation)
+- [TextButton](type-documentation/elements/textbutton)
+- [TextField](type-documentation/elements/textfield)
+- [TimerLabel](type-documentation/elements/timerlabel)
+- [ToggleButton](type-documentation/elements/togglebutton)
+
+## Property Types
+
+- [Anchor](type-documentation/property-types/anchor)
+- [BlockSelectorStyle](type-documentation/property-types/blockselectorstyle)
+- [ButtonSounds](type-documentation/property-types/buttonsounds)
+- [ButtonStyle](type-documentation/property-types/buttonstyle)
+- [ButtonStyleState](type-documentation/property-types/buttonstylestate)
+- [CheckBoxStyle](type-documentation/property-types/checkboxstyle)
+- [CheckBoxStyleState](type-documentation/property-types/checkboxstylestate)
+- [ClientItemStack](type-documentation/property-types/clientitemstack)
+- [ColorOptionGridStyle](type-documentation/property-types/coloroptiongridstyle)
+- [ColorPickerDropdownBoxStateBackground](type-documentation/property-types/colorpickerdropdownboxstatebackground)
+- [ColorPickerDropdownBoxStyle](type-documentation/property-types/colorpickerdropdownboxstyle)
+- [ColorPickerStyle](type-documentation/property-types/colorpickerstyle)
+- [DropdownBoxSearchInputStyle](type-documentation/property-types/dropdownboxsearchinputstyle)
+- [DropdownBoxSounds](type-documentation/property-types/dropdownboxsounds)
+- [DropdownBoxStyle](type-documentation/property-types/dropdownboxstyle)
+- [InputFieldButtonStyle](type-documentation/property-types/inputfieldbuttonstyle)
+- [InputFieldDecorationStyle](type-documentation/property-types/inputfielddecorationstyle)
+- [InputFieldDecorationStyleState](type-documentation/property-types/inputfielddecorationstylestate)
+- [InputFieldIcon](type-documentation/property-types/inputfieldicon)
+- [InputFieldStyle](type-documentation/property-types/inputfieldstyle)
+- [ItemGridSlot](type-documentation/property-types/itemgridslot)
+- [ItemGridStyle](type-documentation/property-types/itemgridstyle)
+- [LabeledCheckBoxStyle](type-documentation/property-types/labeledcheckboxstyle)
+- [LabeledCheckBoxStyleState](type-documentation/property-types/labeledcheckboxstylestate)
+- [LabelSpan](type-documentation/property-types/labelspan)
+- [LabelStyle](type-documentation/property-types/labelstyle)
+- [NumberFieldFormat](type-documentation/property-types/numberfieldformat)
+- [Padding](type-documentation/property-types/padding)
+- [PatchStyle](type-documentation/property-types/patchstyle)
+- [PopupStyle](type-documentation/property-types/popupstyle)
+- [ScrollbarStyle](type-documentation/property-types/scrollbarstyle)
+- [SliderStyle](type-documentation/property-types/sliderstyle)
+- [SoundStyle](type-documentation/property-types/soundstyle)
+- [SpriteFrame](type-documentation/property-types/spriteframe)
+- [SubMenuItemStyle](type-documentation/property-types/submenuitemstyle)
+- [SubMenuItemStyleState](type-documentation/property-types/submenuitemstylestate)
+- [Tab](type-documentation/property-types/tab)
+- [TabNavigationStyle](type-documentation/property-types/tabnavigationstyle)
+- [TabStyle](type-documentation/property-types/tabstyle)
+- [TabStyleState](type-documentation/property-types/tabstylestate)
+- [TextButtonStyle](type-documentation/property-types/textbuttonstyle)
+- [TextButtonStyleState](type-documentation/property-types/textbuttonstylestate)
+- [TextTooltipStyle](type-documentation/property-types/texttooltipstyle)
+- [ToggleButtonStyle](type-documentation/property-types/togglebuttonstyle)
+- [ToggleButtonStyleState](type-documentation/property-types/togglebuttonstylestate)
+
+## Enums
+
+- [ActionButtonAlignment](type-documentation/enums/actionbuttonalignment)
+- [CodeEditorLanguage](type-documentation/enums/codeeditorlanguage)
+- [ColorFormat](type-documentation/enums/colorformat)
+- [DropdownBoxAlign](type-documentation/enums/dropdownboxalign)
+- [InputFieldButtonSide](type-documentation/enums/inputfieldbuttonside)
+- [InputFieldIconSide](type-documentation/enums/inputfieldiconside)
+- [ItemGridInfoDisplayMode](type-documentation/enums/itemgridinfodisplaymode)
+- [LabelAlignment](type-documentation/enums/labelalignment)
+- [LayoutMode](type-documentation/enums/layoutmode)
+- [MouseWheelScrollBehaviourType](type-documentation/enums/mousewheelscrollbehaviourtype)
+- [ProgressBarAlignment](type-documentation/enums/progressbaralignment)
+- [ProgressBarDirection](type-documentation/enums/progressbardirection)
+- [ResizeType](type-documentation/enums/resizetype)
+- [TimerDirection](type-documentation/enums/timerdirection)
+- [TooltipAlignment](type-documentation/enums/tooltipalignment)
diff --git a/content/docs/vi-VN/official-documentation/npc/2-getting-started-with-templates.mdx b/content/docs/vi-VN/official-documentation/npc/2-getting-started-with-templates.mdx
index 91081ca1..99d078e0 100644
--- a/content/docs/vi-VN/official-documentation/npc/2-getting-started-with-templates.mdx
+++ b/content/docs/vi-VN/official-documentation/npc/2-getting-started-with-templates.mdx
@@ -9,7 +9,7 @@ authors:
 
 There are no hard and fast rules for making a start on a template. I like to duplicate **BlankTemplate** and start from there because it already provides the basic structure of the file.
 
-This leaves me with the following template (`Template_Goblin_Ogre.json`): (note: the file could be looking different in the current version of the game)
+This leaves me with the following template (`Template_Goblin_Ogre.json`): (**note: the file could be looking different in the current version of the game**)
 
 ```json
 {
@@ -33,7 +33,7 @@ This leaves me with the following template (`Template_Goblin_Ogre.json`): (note:
     }
   },
   "Appearance": { "Compute": "Appearance" },
-  "DropList": { "Compute": "Droplist" },
+  "DropList": { "Compute": "DropList" },
   "MaxHealth": { "Compute": "MaxHealth" },
   "MotionControllerList": [
     {
@@ -65,10 +65,10 @@ And the following variant (`Goblin_Ogre.json`) next to the template. There's a t
   "Type": "Variant",
   "Reference": "Template_Goblin_Ogre",
   "Modify": {
-    "Appearance": "Goblin_Ogre",
+    "Appearance": "Goblin",
     "MaxHealth": 124
   }
 }
 ```
 
-Our artists have defined the `Goblin_Ogre` appearance already so I'm going to use that.
+Our artists have not yet finished animations for the `Goblin_Ogre`, for that sake of the tutorial I am going to use appearance `Goblin`, because it offers a more complete set of animations that we will need.
diff --git a/content/docs/vi-VN/official-documentation/worldgen/pack-tutorial/asset-packs.mdx b/content/docs/vi-VN/official-documentation/worldgen/pack-tutorial/asset-packs.mdx
index 38809fad..dcf1f3b9 100644
--- a/content/docs/vi-VN/official-documentation/worldgen/pack-tutorial/asset-packs.mdx
+++ b/content/docs/vi-VN/official-documentation/worldgen/pack-tutorial/asset-packs.mdx
@@ -9,13 +9,13 @@ authors:
 
 <OfficialDocumentationNotice />
 
-# How to modify Hytale
+# How to modify Hytale?
 
-## What's an Asset Pack
+## What's an Asset Pack?
 
-Hytales gameplay is driven by assets in the game that can be modified by creators. Asset Packs are our solution to let you override or add features to the base game with your own work. These can in the form of zip files of folders, which contain a custom set of assets. This is not the only way for a creator to change Hytale but this is the most accessible form.;
+Hytales gameplay is driven by assets in the game that can be modified by creators. Asset Packs are our solution to let you override or add features to the base game with your own work. These can be the form of zip files of folders, which contain a custom set of assets. This is not the only way for a creator to change Hytale but this is the most accessible form.;
 
-### How do I make an Asset Pack
+### How do I make an Asset Pack?
 
 <video controls className="my-6 aspect-video w-full rounded-lg border">
   <source src="https://cdn.internal.hytalemodding.dev/guides/official/how-to-asset-pack.mp4" type="video/mp4" />
@@ -48,7 +48,7 @@ An asset pack is typically a zip or folder, with a `manifest.json` inside. This
 }
 ```
 
-### Where are they stored
+### Where are they stored?
 
 Asset Packs are stored with other mods in the Mods folder.
 
@@ -76,7 +76,7 @@ C:\Users\<user>\AppData\Roaming\Hytale\UserData\Saves\New World 5\mods
 
 When you have Asset Packs or Mods installed, these will appear in the New World menu under the Options menu.;
 
-### How do I change an existing asset
+### How do I change an existing asset?
 
 <video controls className="my-6 aspect-video w-full rounded-lg border">
   <source src="https://cdn.internal.hytalemodding.dev/guides/official/how-to-asset.mp4" type="video/mp4" />
diff --git a/content/docs/vi-VN/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx b/content/docs/vi-VN/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx
index 44528376..24e628b5 100644
--- a/content/docs/vi-VN/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx
+++ b/content/docs/vi-VN/official-documentation/worldgen/technical-hytale-generator/material-providers.mdx
@@ -106,7 +106,7 @@ If a BaseHeight is provided, the TopY and BottomY values are relative to the Bas
 
 Applies a Material Provider slot on a set of horizontal stripes of blocks of varying thickness and position. Below is an example image of basalt stripes into a stone cliff.
 
-{/* ![](https://540086904-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F7KAmBkOg6d13nZCkf9ku%2Fuploads%2FbcxO9LpArn8gPCaBwFg5%2Funknown.png?alt=media&token=1c72b67a-8253-4d03-8c64-1ad5f6830050) */}
+![Example of basalt stripes](/assets/official-documentation/worldgen/technical-hytale-generator/material-providers/basalt-stripes-example.png)
 
 #### Parameters:
 
diff --git a/content/docs/vi-VN/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx b/content/docs/vi-VN/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx
index 5e34acd4..a4418473 100644
--- a/content/docs/vi-VN/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx
+++ b/content/docs/vi-VN/official-documentation/worldgen/technical-hytale-generator/positions-provider.mdx
@@ -294,7 +294,7 @@ Combines all the positions into a single Positioins field.
 
 ---
 
-### SimpleHoritontal
+### SimpleHorizontal
 
 Keeps only the positions that are within the provided range.
 
diff --git a/content/docs/vi-VN/official-documentation/worldgen/worldgen-tutorial/README.mdx b/content/docs/vi-VN/official-documentation/worldgen/worldgen-tutorial/README.mdx
new file mode 100644
index 00000000..5f66d245
--- /dev/null
+++ b/content/docs/vi-VN/official-documentation/worldgen/worldgen-tutorial/README.mdx
@@ -0,0 +1,166 @@
+---
+title: How to edit and create Biomes
+description: Explores where world generation assets can be found and how to edit them.
+---
+
+### Where are the Assets
+
+World generation assets are kept in the HytaleGenerator directory within the assets.
+
+```
+/Server/HytaleGenerator/
+```
+
+<div className="flex flex-row rounded-lg border p-4">
+  <div className="flex-1/2 border-r pr-4">
+    ```
+    /Biomes
+    ```
+
+    Biome assets, with content configurations.
+  </div>
+
+  <div className="flex-1/2 pl-4">
+    ```
+    /WorldStructure
+    ```
+
+    Generator files that define which biomes spawn together.
+  </div>
+</div>
+
+<div className="flex flex-row rounded-lg border p-4">
+  <div className="flex-1/2 border-r pr-4">
+    ```
+    /Density
+    ```
+
+    Density assets that can be referenced by any other assets.
+  </div>
+
+  <div className="flex-1/2 pl-4">
+    ```
+    /Assignments
+    ```
+
+    Prop assets that can be referenced by any Biome assets.
+  </div>
+</div>
+
+***
+
+An example of this structure can be found bellow, packed in an asset pack with the instance configuration.
+
+[https://drive.google.com/file/d/1sIz_CluANIIe3n8vNiOi-4PQdeqCO0qY/view?usp=drive_link](https://drive.google.com/file/d/1sIz_CluANIIe3n8vNiOi-4PQdeqCO0qY/view?usp=drive_link)
+
+<Callout>
+  Ensure you place your asset pack in the correct directory, under Mods.
+</Callout>
+
+### How to visit our worlds
+
+https://drive.google.com/file/d/1BJurxyj-taE-PXWm04bk7Dl6X7ZHTH92/view?usp=sharing
+
+#### Requirements
+
+- You must be an **Operator** in the world.
+  - To do this, run <mark style="color:$danger;">`/op self`</mark>
+- You must be in **Creative mode**.
+  - Press the <mark style="color:$danger;">`O`</mark> key, O for Orange.&#x20;
+
+The generation assets define a set of generators but on their own you cannot visit these. Currently you require an Instance with a generator that will allow you to visit your work.
+
+```
+/Server/Instances/
+```
+
+Instances are separate worlds that players can join using the `/instances` command. Each instance has an `Instance.bson` configuration asset that specifies which generator to use, among other worldly settings.
+
+```json
+{
+  "WorldGen": {
+    "Type": "HytaleGenerator",
+    "WorldStructure": "Basic",
+    "playerSpawn" : {
+      "X" : 123,
+      "Y" : 480,
+      "Z" : 10000,
+      "Pitch" : 0,
+      "Yaw" : 0,
+      "Roll" : 0
+    }
+  }
+}
+```
+
+<Callout>
+  You can create custom instances for different world structures and biomes as you need them.
+</Callout>
+
+### How to edit Biomes
+
+<video>
+  <source src="https://cdn.internal.hytalemodding.dev/guides/official/How-to-edit-Biomes.mp4" type="video/mp4" />
+</video>
+
+We currently use the Hytale Node Editor when editing world generation assets. This can be accessed while in-game from the Content Creation menu when pressing B. The node editor is then found under the asset editor dropdown on the upper left.&#x20;
+
+![Node Editor 1](/assets/official-documentation/worldgen/worldgen-tutorial/biomes/node-editor-1.png)
+
+Once you have the Hytale Node Editor open, through the file menu you can open Biomes by navigating to the Biomes directory and selecting one from your pack.&#x20;
+
+```
+/Server/HytaleGenerator/Biomes/
+```
+
+### Biome Asset Structure
+
+Every Biome has a root Biome node, this node splits into 5 structures. This is covered briefly but more information on each field can be found on the World Generation Concepts page.
+
+![Node Editor 2](/assets/official-documentation/worldgen/worldgen-tutorial/biomes/node-editor-2.png)
+
+<Callout>
+  Each biome is for the most part self contained, meaning it has control over what appears with the biome. The only exception to this are Base Heights.
+</Callout>
+
+<Tabs>
+  <Tab value="Terrain">
+    Mathematical function nodes that calculate the physical shape of the Biome's terrain.
+  </Tab>
+
+  <Tab value="Materials">
+    Logical nodes that determine what materials (blocks) make up a Biome's terrain.
+  </Tab>
+
+  <Tab value="Props">
+    Function nodes that add objects like prefabs and decorations to the terrain.
+  </Tab>
+
+  <Tab value="Environments">
+    Logical nodes that determine the environment asset at a given coordinate within the biome. This asset determines things like weather, NPC spawns, and sounds.
+  </Tab>
+
+  <Tab value="Tints">
+    Logical function nodes that determine a colour code that can be used by certain blocks in the world. Typically this will be grasses and soils.
+  </Tab>
+</Tabs>
+
+### How to preview your work
+
+[https://drive.google.com/file/d/1mNcHn9LhFnWDF0DzWFH6_YllmKAUvUry/view?t=6](https://drive.google.com/file/d/1mNcHn9LhFnWDF0DzWFH6_YllmKAUvUry/view?t=6)
+
+Once you are in an Instance world with the Hytale Generator active you will only be able to see your work by generating new chunks. There are a few ways to do this.
+
+The viewport command selects an area around the Player that will live reload as you make changes to the generator.&#x20;
+
+```
+/viewport --radius 5 
+```
+
+You can also create a new world to show your changes.&#x20;
+
+```
+/instances spawn <instance> 
+```
+
+The last option is to simply fly south, new chunks will generate with the changes made.
diff --git a/content/docs/vi-VN/quick-start.mdx b/content/docs/vi-VN/quick-start.mdx
index 653644f4..249d803a 100644
--- a/content/docs/vi-VN/quick-start.mdx
+++ b/content/docs/vi-VN/quick-start.mdx
@@ -9,3 +9,8 @@ Welcome to the Hytale modding documentation! Here you'll find everything you nee
 * [Setting up your dev environment](./guides/plugin/setting-up-env)
 * [Entity Component System (ECS)](./guides/ecs/entity-component-system)
 * [Publishing your mod](./publishing)
+
+### Useful Links
+
+* [Kaupenjoe's Modding Videos](https://www.youtube.com/@ModdingByKaupenjoe)
+* [TroubleDEV's Modding Videos](https://www.youtube.com/@TroubleDEV)
diff --git a/content/docs/vi-VN/server/argtypes.mdx b/content/docs/vi-VN/server/argtypes.mdx
new file mode 100644
index 00000000..e54a442e
--- /dev/null
+++ b/content/docs/vi-VN/server/argtypes.mdx
@@ -0,0 +1,61 @@
+---
+title: ArgTypes
+description: Available ArgTypes
+icon: List
+full: true
+authors:
+  - name: Valeena
+---
+
+| Name                        | Target Class                           | Description                                                                                                                               |   |
+| :-------------------------- | :------------------------------------- | :---------------------------------------------------------------------------------------------------------------------------------------- | - |
+| Boolean                     | java.lang.Boolean                      | A 'true' or 'false' input                                                                                                                 |   |
+| Integer                     | java.lang.Integer                      | A whole number                                                                                                                            |   |
+| String                      | java.lang.String                       | Words, text, numbers, letters. To input more than one word at a time, you may need to wrap it with double quotes (`"my fancy sentence"`). |   |
+| Float                       | java.lang.Float                        | A floating-pointer number                                                                                                                 |   |
+| Double                      | java.lang.Double                       | A decimal number                                                                                                                          |   |
+| UUID                        | java.util.UUID                         | A UUID (Universally Unique IDentifier)                                                                                                    |   |
+| Player_UUID                 | java.util.UUID                         | A UUID or an online player username                                                                                                       |   |
+| Game_Profile_Lookup_Async   | ProfileServiceClient.PublicGameProfile | A player UUID or username. If not found locally, performs a remote lookup via the Profile Service.                                        |   |
+| Relative_Double_Coord       | Coord                                  | An x, y, or z coordinate as a decimal, optionally relative by specifying a tilde (~) in front of the number                               |   |
+| Relative_Int_Coord          | IntCoord                               | An x, y, or z coordinate as a whole number, optionally relative by specifying a tilde (~) in front of the number                          |   |
+| Relative_Integer            | RelativeInteger                        | A tilde to mark an integer relative to a base                                                                                             |   |
+| Relative_Float              | RelativeFloat                          | A tilde to mark a float relative to a base                                                                                                |   |
+| Player_Ref                  | PlayerRef                              | A UUID or an online player's username                                                                                                     |   |
+| World                       | World                                  | A world folder name                                                                                                                       |   |
+| Model_Asset                 | ModelAsset                             | A reference to an Asset of type Model                                                                                                     |   |
+| Weather_Asset               | Weather                                | A reference to an Asset of type Weather                                                                                                   |   |
+| Interaction_Asset           | Interaction                            | A reference to an Asset of type Interaction                                                                                               |   |
+| Root_Interaction_Asset      | RootInteraction                        | A reference to an Asset of type Root Interaction                                                                                          |   |
+| Effect_Asset                | EntityEffect                           | A refernece to an Asset of type EntityEffect                                                                                              |   |
+| Environment_Asset           | Environment                            | A reference to an Asset of type Environment                                                                                               |   |
+| Item_Asset                  | Item                                   | A reference to an Asset of type Item                                                                                                      |   |
+| Block_Type_Asset            | BlockType                              | A reference to an Asset of type BlockType                                                                                                 |   |
+| Particle_System             | ParticleSystem                         | A reference to an Asset of type ParticleSystem                                                                                            |   |
+| Hitbox_Collision_Config     | HitboxCollisionConfig                  | A reference to an Asset of type HitboxCollisionConfig                                                                                     |   |
+| Repulsion_Config            | RepulsionConfig                        | A reference to an Asset of type RepulsionConfig                                                                                           |   |
+| Sound_Event_Asset           | SoundEvent                             | A reference to an Asset of type SoundEvent                                                                                                |   |
+| Ambiance_Fx_Asset           | AmbianceFX                             | A reference to an Asset of type AmbianceFX                                                                                                |   |
+| Sound_Category              | SoundCategory                          | A sound category (sfx, music, ambient, ui)                                                                                                |   |
+| Entity_ID                   | `ArgWrapper<EntityWrappedArg, UUID>`   | A UUID representing an entity id                                                                                                          |   |
+| Integer_Comparison_Operator | IntegerComparisonOperator              | A mathematical sign for integer comparison                                                                                                |   |
+| Integer_Operation           | IntegerOperation                       | A mathematical sign for performing an operation                                                                                           |   |
+| Int_Range                   | `Pair<Integer, Integer>`               | Two integers representing a minimum and maximum of a range                                                                                |   |
+| Relative_Int_Range          | RelativeIntRange                       | Two integers representing a minimum and maximum of a range                                                                                |   |
+| Vector2I                    | Vector2i                               | Two integers, generally corresponding to x/z axis                                                                                         |   |
+| Vector3I                    | Vector3i                               | Three integers, generally corresponding to x/y/z axis                                                                                     |   |
+| Relative_Vector3I           | RelativeVector3i                       | Three optionally relative integers, generally corresponding to x/y/z axis                                                                 |   |
+| Relative_Block_Position     | RelativeIntPosition                    | A position with three integer coordinates, representing a block's location in world space.                                                |   |
+| Relative_Position           | Relative                               | A position with three decimal coordinates, representing a location in world space.                                                        |   |
+| Relative_Chunk_Position     | RealtiveChunkPosition                  | A position with two integer coordinates (x, z), representing a chunk's location.                                                          |   |
+| Rotation                    | Vector3f                               | A rotation with three coordinates, representing the pitch, yaw, and roll respectively                                                     |   |
+| Block_Type_Key              | String                                 | A block type                                                                                                                              |   |
+| Block_ID                    | Integer                                | A block type, converted to an int id                                                                                                      |   |
+| Color                       | Integer                                | A color value in hex format, hex integer, or decimal integer                                                                              |   |
+| Weighted_Block_Type         | `Pair<Integer, String>`                | A weight corresponding to a blocktype                                                                                                     |   |
+| Weighted_Block_Entry        | String                                 | A block with optional weight prefix                                                                                                       |   |
+| Block_Pattern               | BlockPattern                           | A list of blocks with optional weights                                                                                                    |   |
+| Individual_Block_Mask       | BlockMask                              | Create a block mask using symbols and block names                                                                                         |   |
+| Block_Mask                  | BlockMask                              | A tick rate value (e.g., 30tps, 33ms, or 30)                                                                                              |   |
+| Tick_Rate                   | Integer                                | A list of block masks that combine together                                                                                               |   |
+| Game_Mode                   | GameMode                               | GameMode                                                                                                                                  |   |
diff --git a/content/docs/vi-VN/server/interaction-reference.mdx b/content/docs/vi-VN/server/interaction-reference.mdx
new file mode 100644
index 00000000..6c0d01b3
--- /dev/null
+++ b/content/docs/vi-VN/server/interaction-reference.mdx
@@ -0,0 +1,1586 @@
+---
+title: Interactions
+description: A list of most Interaction types provided by Hypixel, along with the meaning of their fields, and how they fit together.
+icon: List
+authors:
+  - name: Stephen Baynham
+    url: https://github.com/cannibalvox
+---
+
+### The Interaction Base Type
+
+All interactions of every type below are inherited from Interaction and have these fields.
+
+**Interaction Fields**
+
+| Field Name                | Type                                                                 | Required? | Notes                                                                                                                                                                                                                       |
+| ------------------------- | -------------------------------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| ViewDistance              | `Double`<br />(Default: 96.0)                                        | **No**    | Distance in blocks at which other players can see the effects from this interaction.                                                                                                                                        |
+| Effects                   | `InteractionEffects`                                                 | **No**    | Sound, animations, and particle effects that should trigger when this interaction begins executing.                                                                                                                         |
+| HorizontalSpeedMultiplier | `Float`<br />(Default: 1.0)                                          | **No**    | Multiplier applied to the User entity's movement speed while this interaction is executing                                                                                                                                  |
+| RunTime                   | `Float`                                                              | **No**    | If provided, this interaction will continue executing for at least this long before the interaction chain moves onto the next interaction.                                                                                  |
+| CancelOnItemChange        | `Boolean`<br />(Default: true)                                       | **No**    | If true, this interaction will be cancelled if the User entity's held item changes during execution. This can happen either due to the selected hotbar slot changing or the contents of the item's inventory slot changing. |
+| Rules                     | `InteractionRules`                                                   | **Yes**   | If provided, adds additional limitations and cancellation conditions to this interaction.                                                                                                                                   |
+| Settings                  | `Map`<br />(Key Type: `GameMode`, Value Type: `InteractionSettings`) | **No**    | If provided, adds additional per-GameMode settings to the interaction.                                                                                                                                                      |
+| Camera                    | `InteractionCameraSettings`                                          | **No**    | Arrays of camera motion keyframes for cutscenes and reveals.                                                                                                                                                                |
+
+**GameMode Values**
+
+- `Creative`: The game is currently in Creative Mode
+- `Adventure`: The game is currently in Adventure Mode
+
+**InteractionEffects Fields**
+
+| Field Name               | Type                                              | Required? | Notes                                                                                                                                                 |
+| ------------------------ | ------------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Particles                | `Array`<br />(Element Type: `ModelParticle`)      | **No**    | Particle systems to activate when this interaction begins if the player is in third-person mode.                                                      |
+| FirstPersonParticles     | `Array`<br />(Element Type: `ModelParticle`)      | **No**    | Particle systems to activate when this interaction begins if the player is in first-person mode.                                                      |
+| WorldSoundEventId        | `Asset`<br />(Asset Type: `SoundEvent`)           | **No**    | A sound to play in the world at the User entity's location when this interaction begins.<br />**The SoundEvent must be single-channel (mono) sound.** |
+| LocalSoundEventId        | `Asset`<br />(Asset Type: `SoundEvent`)           | **No**    | A 2D sound to play for the User entity when this interaction begins. Ignored if the User entity is not a player.                                      |
+| Trails                   | `Array`<br />(Element Type: `ModelTrail`)         | **No**    | Trail effects to activate on the User entity when this interaction begins.                                                                            |
+| WaitForAnimationToFinish | `Boolean`<br />(Default: false)                   | **No**    | If true, this interaction will continue executing for at least the length of any animations in this InteractionEffects object.                        |
+| ItemPlayerAnimationsId   | `Asset`<br />(Asset Type: `ItemPlayerAnimations`) | **No**    | If provided, the User entity will use this ItemPlayerAnimations set while this interaction is executing.                                              |
+| ItemAnimationId          | `String`                                          | **No**    | Id of an animation to trigger when this interaction begins executing.<br />**This animation id is not validated on server start.**                    |
+| ClearAnimationOnFinish   | `Boolean`<br />(Default: false)                   | **No**    | If true, animations triggered by this interaction will be halted when the interaction completes.                                                      |
+| ClearSoundEventOnFinish  | `Boolean`<br />(Default: false)                   | **No**    | If true, sounds triggered by this interaction will be halted when the interaction completes.                                                          |
+| CameraEffect             | `Asset`<br />(Asset Type: `CameraEffect` )        | **No**    | If provided, the CameraEffect will be applied while this interaction is executing.                                                                    |
+| MovementEffects          | `MovementEffects`                                 | **No**    | If provided, apply the movement effects to the User entity while this interaction is executing.                                                       |
+| StartDelay               | `Float`<br />(Default: 0.0f)                      | **No**    | The interaction will wait this many seconds before triggering the effects in this object.                                                             |
+
+**InteractionRules Fields**
+
+| Field Name          | Type                                                                                                | Required? | Notes                                                                                                                                                                                                                                     |
+| ------------------- | --------------------------------------------------------------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| BlockedBy           | `Array`<br />(Element Type: `InteractionType`)<br />(Default: Based on the chain's InteractionType) | **No**    | If provided, this RootInteraction cannot be executed while interaction chains of the provided types are executing.<br />**This field only functions for rules attached to a RootInteraction. It has no effect on an Interaction.**        |
+| Blocking            | `Array`<br />(Element Type: `InteractionType`)                                                      | **No**    | If provided, interaction chains with the specified InteractionTypes cannot be executed while this interaction is executing.                                                                                                               |
+| InterruptedBy       | `Array`<br />(Element Type: `InteractionType`)                                                      | **No**    | If provided, interaction chains with the specified InteractionTypes will cancel this interaction chain when they execute.<br />**This field only functions for rules attached to a RootInteraction. It has no effect on an Interaction.** |
+| Interrupting        | `Array`<br />(Element Type: `InteractionType`)                                                      | **No**    | If provided, interaction chains with the specified InteractionTypes will be canceled when this interaction begins.                                                                                                                        |
+| BlockedByBypass     | `String`                                                                                            | **No**    | If provided, this RootInteraction cannot be blocked by interaction chains whose RootInteraction has this value as an asset tag.                                                                                                           |
+| BlockingBypass      | `String`                                                                                            | **No**    | If provided, this interaction will not block RootInteractions that have the this value as an asset tag.                                                                                                                                   |
+| InterruptedByBypass | `String`                                                                                            | **No**    | If provided, this RootInteraction cannot be canceled by RootInteractions that have this value as an asset tag.                                                                                                                            |
+| InterruptingBypass  | `String`                                                                                            | **No**    | If provided, this interaction will not cancel interaction chains whose RootInteraction has this value as an asset tag.                                                                                                                    |
+
+**InteractionType Values**
+
+- `Primary`
+- `Secondary`
+- `Ability1`
+- `Ability2`
+- `Ability3`
+- `Use`
+- `Pick`
+- `Pickup`
+- `CollisionEnter`
+- `CollisionLeave`
+- `Collision`
+- `EntityStatEffect`
+- `SwapTo`
+- `SwapFrom`
+- `Death`
+- `Wielding`
+- `ProjectileSpawn`
+- `ProjectileHit`
+- `ProjectileMiss`
+- `ProjectileBounce`
+- `Held`
+- `HeldOffhand`
+- `Equipped`
+- `Dodge`
+- `GameModeSwap`
+
+**InteractionSettings Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                        |
+| ---------------- | ------------------------------- | --------- | -------------------------------------------------------------------------------------------- |
+| AllowSkipOnClick | `Boolean`<br />(Default: false) | **No**    | If true, the user will be able to skip this interaction by clicking shortly after it starts. |
+
+**InteractionCameraSettings Fields**
+
+| Field Name  | Type                                             | Required? | Notes                                                                                                                                                           |
+| ----------- | ------------------------------------------------ | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| FirstPerson | `Array`<br />(Element Type: `InteractionCamera`) | **No**    | A list of camera keyframes to be played if the player is in first-person.<br />**The time of each keyframe must be after the keyframe before it in the array.** |
+| ThirdPerson | `Array`<br />(Element Type: `InteractionCamera`) | **No**    | A list of camera keyframes to be played if the player is in third-person.<br />**The time of each keyframe must be after the keyframe before it in the array.** |
+
+**InteractionCamera Fields**
+
+| Field Name | Type                         | Required? | Notes                                                                                                                                       |
+| ---------- | ---------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------- |
+| Time       | `Float`<br />(Default: 0.1f) | **No**    | How long after the interaction begins executing that the camera should arrive at this keyframe.<br />**Cannot be less than or equal to 0.** |
+| Position   | `Vector3`                    | **Yes**   | Where the camera should be located when it arrives at this keyframe.                                                                        |
+| Rotation   | `Direction`                  | **Yes**   | Where the camera should be pointing when it arrives at this keyframe.                                                                       |
+
+### SimpleInteraction
+
+Most interaction types below are inherited from SimpleInteraction and have these
+fields.  If a type does not have these fields, the documentation will mention it.
+
+The purpose of SimpleInteraction is to facilitate Interaction chaining by taking different paths
+based on whether the Interaction succeeded or failed.  The circumstances under which
+a given Interaction fails are generally type-specific (and described in the documentation
+below), but all interactions will be marked failed if they are cancelled via one of the
+many, many mechanisms for doing so.
+
+It is valid to create an interaction asset of type "Simple", which can be valuable when you want to use the
+interaction fields with no additional functionality.
+
+**SimpleInteraction Fields**
+
+| Field Name | Type                                     | Required? | Notes                                                                                          |
+| ---------- | ---------------------------------------- | --------- | ---------------------------------------------------------------------------------------------- |
+| Next       | `Asset`<br />(Asset Type: `Interaction`) | **No**    | After this Interaction has finished, "Next" will be executed if this Interaction did not fail. |
+| Failed     | `Asset`<br />(Asset Type: `Interaction`) | **No**    | After this Interaction has finished, "Failed" will be executed if this Interaction failed.     |
+
+## Flow Control
+
+These are interaction types used to control the flow of an interaction chain and allow interactions
+to be composed into more complex behaviors.  These interaction types generally do not pertain to
+the game and instead pertain to the interaction system itself.
+
+### Condition
+
+This interaction will fail if one of the fields is provided but does not match the current state.
+
+**Condition Fields**
+
+| Field Name       | Type       | Required? | Notes                                                                                                                                                                                    |
+| ---------------- | ---------- | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| RequiredGameMode | `GameMode` | **No**    | If provided, the interaction will fail if the current GameMode does not match the provided value.                                                                                        |
+| Jumping          | `Boolean`  | **No**    | If provided, the interaction will fail if the player's Jumping state does not match the provided value. (i.e. if True, the player must be jumping, if False, the player must not be)     |
+| Swimming         | `Boolean`  | **No**    | If provided, the interaction will fail if the player's Swimming state does not match the provided value. (i.e. if True, the player must be swimming, if False, the player must not be)   |
+| Crouching        | `Boolean`  | **No**    | If provided, the interaction will fail if the player's Crouching state does not match the provided value. (i.e. if True, the player must be crouching, if False, the player must not be) |
+| Running          | `Boolean`  | **No**    | If provided, the interaction will fail if the player's Running state does not match the provided value. (i.e. if True, the player must be running, if False, the player must not be)     |
+| Flying           | `Boolean`  | **No**    | If provided, the interaction will fail if the player's Flying state does not match the provided value. (i.e. if True, the player must be flying, if False, the player must not be)       |
+
+**GameMode Values**
+
+- `Creative`: The game is currently in Creative Mode
+- `Adventure`: The game is currently in Adventure Mode
+
+### FirstClick
+
+This interaction does not inherit from SimpleInteraction and therefore has no Next or Failed fields.
+
+This interaction has two fields that each contain a reference to an Interaction: Click and Hold.  If the root interaction
+of the chain was initiated by a client button/key press (or simulated NPC input) and the input was a tap, then
+the Click interaction is run. if it was a longer press, then the Hold interaction is run.
+
+As a minor implementation detail, this interaction is internally marked as failed when the Hold path is followed.
+This generally shouldn't matter.  If the interaction was not initiated by a key press at all, the Click path will be followed,
+but it seems risky to rely on that behavior.
+
+**FirstClick Fields**
+
+| Field Name | Type                                     | Required? | Notes                                                                                                                                                    |
+| ---------- | ---------------------------------------- | --------- | -------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Click      | `Asset`<br />(Asset Type: `Interaction`) | **No**    | If provided and the root interaction of the chain was initiated by button/key press, this interaction is executed next if the press was a quick tap.     |
+| Hold       | `Asset`<br />(Asset Type: `Interaction`) | **No**    | If provided and the root interaction of the chain was initiated by a button/key press, this interaction is executed next if the press was a longer hold. |
+
+### Interrupt
+
+This interaction can be used to cancel one or more running interaction chains on an entity and **all forked interaction
+chains those chains have spawned that are still currently running**.  All interaction chains canceled in this manner will be marked as
+Failed, which may have additional implications if the canceled chains are themselves forked from
+other chains that are still running.
+
+**Interrupt Fields**
+
+| Field Name     | Type                                           | Required? | Notes                                                                                                                                                                                               |
+| -------------- | ---------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Entity         | `InteractionTarget`<br />(Default: User)       | **Yes**   | The entity that is the owner of the target interaction chains.  This field can indicate the Owner, User, or Target of this interaction chain.                                                       |
+| InterruptTypes | `Array`<br />(Element Type: `InteractionType`) | **No**    | A set of InteractionTypes that are to be interrupted. Only interactions of these types are affected. If null, all types will be interrupted.<br />**(Note: An empty set will interrupt NO TYPES.)** |
+| RequiredTag    | `String`                                       | **No**    | An asset tag that, if provided, the RootInteraction of the interaction chain must have in order to be canceled.                                                                                     |
+| ExcludedTag    | `String`                                       | **No**    | An asset tag that, if provided, the RootInteraction of the interaction chain must not have in order to be canceled.                                                                                 |
+
+**InteractionTarget Values**
+
+- `User` - The user of this interaction chain. The entity whose actions caused this interaction chain to be executed. This is usually the same as the Owner.
+- `Owner` - The owner of this interaction chain. The entity upon whom this interaction chain is executing.
+- `Target` - The entity target of this interaction chain, if any.  This value is mutable (and can therefore come from many places) but most commonly, it is an entity the User was targeting when this interaction chain began executing.
+
+**InteractionType Values**
+
+- `Primary`
+- `Secondary`
+- `Ability1`
+- `Ability2`
+- `Ability3`
+- `Use`
+- `Pick`
+- `Pickup`
+- `CollisionEnter`
+- `CollisionLeave`
+- `Collision`
+- `EntityStatEffect`
+- `SwapTo`
+- `SwapFrom`
+- `Death`
+- `Wielding`
+- `ProjectileSpawn`
+- `ProjectileHit`
+- `ProjectileMiss`
+- `ProjectileBounce`
+- `Held`
+- `HeldOffhand`
+- `Equipped`
+- `Dodge`
+- `GameModeSwap`
+
+### Parallel
+
+This interaction does not inherit from SimpleInteraction and therefore has no Next or Failed fields.
+
+This interaction has a field `Interactions` that is an array of RootInteraction assets. The list must contain at least
+two RootInteractions.  This interaction will fork all of its children except for the first into their
+own interaction chains and immediately complete. After this interaction completes, this interaction chain will
+execute the first RootInteraction in the `Interactions` list.
+
+This interaction does not have any failure conditions and is indifferent to the fate of the forked interaction chains.
+
+**Parallel Fields**
+
+| Field Name   | Type                                                | Required? | Notes                                                         |
+| ------------ | --------------------------------------------------- | --------- | ------------------------------------------------------------- |
+| Interactions | `AssetArray`<br />(Element Type: `RootInteraction`) | **Yes**   | An array of RootInteractions that will be forked or executed. |
+
+### Repeat
+
+This interaction has a field `ForkInteractions` that is an asset of type RootInteraction. This interaction will fork that
+RootInteraction into its own interaction chain and then wait for it to complete. If the RootInteraction fails, this
+interaction will complete immediately and be marked failed. Otherwise, the RootInteraction will be forked and run again,
+up to a specified total number of times.
+
+**Repeat Fields**
+
+| Field Name       | Type                                                                                   | Required? | Notes                                                                                                                                                                                                              |
+| ---------------- | -------------------------------------------------------------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| ForkInteractions | `Asset`<br />(Asset Type: `RootInteraction`)                                           | **Yes**   | A RootInteraction that will be forked.                                                                                                                                                                             |
+| Repeat           | `Integer`<br />(Default: 1)<br />**Must be -1 or a positive integer. 0 is not valid.** | **No**    | The total number of times to fork ForkInteractions. If -1 is provided, ForkInteractions will continue being forked and executed indefinitely, until this interaction is cancelled or until ForkInteractions fails. |
+
+### Replace
+
+This interaction does not inherit from SimpleInteraction and therefore has no Next or Failed fields.
+
+This interaction uses the InteractionVars system that is avaiable for items. InteractionVars are RootInteractions that
+can be attached to an Item asset with a name.
+
+This interaction specifies a var name, and if this interaction chain was executed through
+an item and that item has an InteractionVar of the same name, then this interaction will immediately execute
+the RootInteraction on the var.  Otherwise, it will execute the default RootInteraction specified in this interaction.
+If no default is specified, then this interaction will be marked as failed.
+
+**Replace Fields**
+
+| Field Name   | Type                                         | Required? | Notes                                                                                                                                                                                                           |
+| ------------ | -------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Var          | `String`                                     | **Yes**   | The name of the InteractionVar to execute.                                                                                                                                                                      |
+| DefaultValue | `Asset`<br />(Asset Type: `RootInteraction`) | **No**    | The RootInteraction to execute if the owning item does not have an InteractionVar by the specified name. If not provided, the interaction will be marked as failed instead.                                     |
+| DefaultOk    | `Boolean`<br />(Default: false)              | **No**    | If false, then an angry message will be printed to the server logs if the owning item does not have an InteractionVar by the specified name.  The functioning of this interaction will be otherwise unaffected. |
+
+### RunRootInteraction
+
+This interaction immediately executes the provided RootInteraction as part of this interaction chain. This interaction
+does not have any failure conditions.
+
+**RunRootInteraction Fields**
+
+| Field Name      | Type                                         | Required? | Notes                           |
+| --------------- | -------------------------------------------- | --------- | ------------------------------- |
+| RootInteraction | `Asset`<br />(Asset Type: `RootInteraction`) | **Yes**   | The RootInteraction to execute. |
+
+### Selector
+
+This interaction will execute a Selector to find entities and/or blocks (depending on the Selector) and fork off an
+interaction chain for each located entity or block. This interaction will not wait for those interaction chains
+to complete and is indifferent to their fate. The forked interaction chains will use the located entity/block as
+their target entity/target block. Each entity or block will only fork one interaction chain over the life of this
+interaction.  The Selector is guaranteed to run once for each execution of this interaction, but some Selectors
+are intended to be run over a period of time and sweep across an area to locate targets. In order to use those Selectors
+properly, you will need to extend the execution time of this interaction using `RunTime` or `WaitForAnimationToFinish`.
+The Selector will be executed repeatedly over the lifetime of the interaction.
+
+If the Selector is configured to locate entities, you can add additional sets of entity matching rules. If a located entity
+matches one of the rules, the matching RootInteraction will be forked instead of the standard `HitEntity` RootInteraction.
+
+Entities located by the Selector will be ignored if they do not have a NetworkId, if they are dead, or if they are invulnerable.
+The only exception to this rule is that players in Creative Mode that are marked to receive hits will not be ignored.
+
+This interaction's failure conditions are configurable via the `FailOn` field. You can configure this interaction to never
+fail, to fail if the Selector does not locate any blocks before this interaction finishes executing, to fail if the
+Selector does not locate any entities before this interaction finishes executing, or to fail in either case.
+
+**Selector Fields**
+
+| Field Name     | Type                                         | Required? | Notes                                                                                                                                                                                                                                     |
+| -------------- | -------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Selector       | `Selector`                                   | **Yes**   | The Selector is executed at least once and may be executed repeatedly to locate blocks and/or entities in an area.                                                                                                                        |
+| HitEntity      | `Asset`<br />(Asset Type: `RootInteraction`) | **No**    | If included and the `Selector` locates an entity that does not match any `HitEntityRules`, this RootInteraction will be forked into a new interaction chain with the located entity as the target entity.                                 |
+| HitEntityRules | `Array`<br />(Element Type: `HitEntity`)     | **No**    | If included, these rules will be matched against any entity located by the `Selector`. If an entity matches a set of rules, the RootInteraction associated with the rules will be forked instead of the standard `HitEntity` interaction. |
+| HitBlock       | `Asset`<br />(Asset Type: `RootInteraction`) | **No**    | If included and the `Selector` locates a block, this RootInteraction will be forked into a new interaction chain with the located block as the block target.                                                                              |
+| FailOn         | `FailOnType`<br />(Default: `Neither`)       | **No**    | Defines under what circumstances this interaction will fail.  It can be marked to fail when it completes without locating any blocks, it can be marked to fail when it completes without locating any entities, both, or neither.         |
+| IgnoreOwner    | `Boolean`<br />(Default: true)               | **No**    | If true, the Selector will not locate the User entity of this interaction.                                                                                                                                                                |
+
+**HitEntity Fields**
+
+| Field Name | Type                                         | Required? | Notes                                                                                                 |
+| ---------- | -------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------- |
+| Matchers   | `Array`<br />(Element Type: `EntityMatcher`) | **Yes**   | A set of rules that an entity must match. An entity must successful match all rules to be considered. |
+| Next       | `Asset`<br />(Asset Type: `RootInteraction`) | **Yes**   | The RootInteraction to fork if an entity matches all rules.                                           |
+
+**EntityMatcher Fields**
+
+| Field Name | Type                            | Required? | Notes                                                                                                     |
+| ---------- | ------------------------------- | --------- | --------------------------------------------------------------------------------------------------------- |
+| Type       | `String`                        | **Yes**   | If provided, specifies a type of EntityMatcher to use. Each matcher type may come with additional fields. |
+| Invert     | `Boolean`<br />(Default: false) | **No**    | If true, an entity must fail this rule for it to be marked as succeeded.                                  |
+
+**EntityMatcher Type: Player**
+
+This EntityMatcher will succesfully match the entity only if they are a player.
+
+**EntityMatcher Type: Vulnerable**
+
+This Entitymatcher will successfully match the entity only if they are not marked as invulnerable.
+
+**FailOnType Values**
+
+- `Neither`
+- `Entity`
+- `Block`
+- `Either`
+
+### Serial
+
+This interaction does not inherit from SimpleInteraction and therefore has no Next or Failed fields.
+
+This interaction has a field `Interactions` which is a list of Interaction assets. This interaction immediately
+completes and the interaction chain continues by executing the interactions in the list one at a time. This
+interaction does not have any failure conditions.
+
+**Serial Fields**
+
+| Field Name   | Type                                            | Required? | Notes                                      |
+| ------------ | ----------------------------------------------- | --------- | ------------------------------------------ |
+| Interactions | `AssetArray`<br />(Element Type: `Interaction`) | **Yes**   | An array of Interaction assets to execute. |
+
+## Cooldowns
+
+RootInteractions interface with a complex cooldown system that can be used for a variety of purposes. Aside from simply
+adding an important aspect of resource management to your game design, cooldowns can be used to ensure that click-activated
+interaction chains don't repeatedly spam if the player holds down the input.
+
+By default, every RootInteraction has a cooldown timer that is keyed to the RootInteraction name, and by default, it
+will launch a cooldown of 0.35 seconds when activated by client input.  Otherwise, no cooldown will be activated.  However,
+by configuring your RootInteraction, you can change the key for the cooldown (so that multiple RootInteractions can share
+a single cooldown), set the cooldown timer to whatever you like, and configure multiple charges that can build up over time
+to allow the entity to activate the RootInteraction multiple times before being forced to pause.
+
+One important concept to keep in mind is the difference between **cooldown** and **charge time**.  The cooldown, if any,
+is activated each time a RootInteraction triggers, even if the player has more available charges. If the RootInteraction
+is configured to use charges, then they will gradually build up over time. In order for a RootInteraction to be activated,
+the cooldown (if any) must be expired, and the RootInteraction must have at least one charge (if it has been
+configured to use charges).
+
+Bear in mind that the entire Cooldown configuration is shared between different RootInteractions with the same cooldown id.
+If you activate an ability with 5 charges and a short cooldown and then another ability with a much longer cooldown and no
+charges, the second ability will use the cooldown properties of the first ability until/unless the first ability finishes
+charging and is cleared from the system.  You should generally only have multiple RootInteractions share a cooldown id
+if they have the same configuration.
+
+The interactions below interact with the cooldown system to allow you to manipulate cooldowns via the interaction system. By
+using these interactions, you can have several interaction chains with different cooldown configurations share cooldowns
+that are checked and activated as part of the interaction chain itself, or have some components of an interaction change
+use a second cooldown separate from the main one.
+
+### CooldownCondition
+
+**CooldownCondition Fields**
+
+This interaction will fail if the specified cooldown id is on cooldown for the User entity.  This interaction will only
+function for players- the interaction will always succeed for NPCs.  In order for this interaction to succeed, the
+cooldown, if any, must have expired and at least one charge, if any, must have filled.
+
+| Field Name | Type     | Required? | Notes                     |
+| ---------- | -------- | --------- | ------------------------- |
+| Id         | `String` | **Yes**   | The cooldown id to check. |
+
+### IncrementCooldown
+
+**IncrementCooldown Fields**
+
+This interaction will modify a cooldown that is currently active on the User entity, allowing charges and remaining
+cooldown to be modified.
+Despite its name, this interaction can be used to reduce a cooldown as well as increase it. If the cooldown is not
+currently active, this interaction will have no effect. The interaction has no special failure conditions.
+
+| Field Name        | Type                        | Required? | Notes                                                                                                                                                                                                                                                                                     |
+| ----------------- | --------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Id                | `String`                    | **No**    | If provided, the cooldown id of the cooldown to be manipulated. If not provided, the cooldown id of the current chain's RootInteraction will be used.                                                                                                                                     |
+| Time              | `Float`<br />(Default: 0.0) | **No**    | The amount to increase the remaining cooldown by. Can be negative. The remaining cooldown time will not be reduced below zero or increased above the maximum cooldown time.                                                                                                               |
+| ChargeTime        | `Float`<br />(Default: 0.0) | **No**    | The amount to increase the remaining time until the next charge is filled by. Can be negative. The remaining charge time cannot be reduced below zero or increased above the maximum cooldown time. **This will not work on abilities that have a maximum of 1 charge, for some reason.** |
+| Charge            | `Integer`<br />(Default: 0) | **No**    | The amount to increase the number of charges by. Can be negative. The number of charges cannot be reduced below 0 or increased above the maximum.                                                                                                                                         |
+| InterruptRecharge | `Boolean`(Default: false)   | **No**    | If true and `Charge` is not 0, will reset the remaining time to the next charge to the maximum value after changing the charge count.                                                                                                                                                     |
+
+### ResetCooldown
+
+This interaction will trigger a cooldown on the User entity with a specified configuration. The charges will be refilled
+but the cooldown will be immediately triggered.  The mechanisms for deciding on the configuration are a little bit complicated.
+You may specify a cooldown configuration via the `Cooldown` field. If you do not include an `Id` field, then the
+interaction chain's RootInteraction will be used for any field not specified in the configuration. If there is an active
+cooldown under the specified `Id` (or under the RootInteraction's cooldown id if none is specified) then the fields
+from that active cooldown will overwrite data in the RootInteraction's cooldown, but not data in your `Cooldown` field.
+
+**ResetCooldown Fields**
+
+| Field Name | Type                  | Required? | Notes                                                        |
+| ---------- | --------------------- | --------- | ------------------------------------------------------------ |
+| Cooldown   | `InteractionCooldown` | **No**    | A cooldown configuration to use for the new, reset cooldown. |
+
+**InteractionCooldown Fields**
+
+| Field Name        | Type                                 | Required? | Notes                                                                                                                                                                                                 |
+| ----------------- | ------------------------------------ | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Id                | `String`                             | **No**    | The cooldown id to use for this cooldown. If not provided, the RootInteraction's cooldown id will be used, if any.                                                                                    |
+| Cooldown          | `Float`<br />(Default: 0.0)          | **No**    | The duration of the cooldown, in seconds.                                                                                                                                                             |
+| Charges           | `Array`<br />(Element Type: `Float`) | **No**    | If provided, a list of how many charges this cooldown can build, and how long each charge takes to build, in seconds.                                                                                 |
+| InterruptRecharge | `Boolean`<br />(Default: false)      | **No**    | If true, the charge time will be reset when the number of charges changes.                                                                                                                            |
+| ClickBypass       | `Boolean`<br />(Default: false)      | **No**    | If true, RootInteractions keyed to this cooldown can still be activated when it is on cooldown provided that the RootInteraction was triggered by a distinct key or mouse button press on the client. |
+
+### TriggerCooldown
+
+This interaction is similar to ResetCooldown, except instead of refilling the cooldown's charges, one charge will be deducted
+as normal.
+
+**TriggerCooldown Fields**
+
+| Field Name | Type                  | Required? | Notes                                                        |
+| ---------- | --------------------- | --------- | ------------------------------------------------------------ |
+| Cooldown   | `InteractionCooldown` | **No**    | A cooldown configuration to use for the new, reset cooldown. |
+
+**InteractionCooldown Fields**
+
+| Field Name        | Type                                 | Required? | Notes                                                                                                                                                                                                 |
+| ----------------- | ------------------------------------ | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Id                | `String`                             | **No**    | The cooldown id to use for this cooldown. If not provided, the RootInteraction's cooldown id will be used, if any.                                                                                    |
+| Cooldown          | `Float`<br />(Default: 0.0)          | **No**    | The duration of the cooldown, in seconds.                                                                                                                                                             |
+| Charges           | `Array`<br />(Element Type: `Float`) | **No**    | If provided, a list of how many charges this cooldown can build, and how long each charge takes to build, in seconds.                                                                                 |
+| InterruptRecharge | `Boolean`<br />(Default: false)      | **No**    | If true, the charge time will be reset when the number of charges changes.                                                                                                                            |
+| ClickBypass       | `Boolean`<br />(Default: false)      | **No**    | If true, RootInteractions keyed to this cooldown can still be activated when it is on cooldown provided that the RootInteraction was triggered by a distinct key or mouse button press on the client. |
+
+## Combo Chains
+
+Hytale additionally comes with a rich "combo chaining" system, which allows several inputs in a row to result in different
+attacks and special moves.  Rather than being attached to the RootInteraction like the cooldown system, these are
+primarily driven by the `Chaining` interaction.
+
+### Chaining
+
+This interaction does not inherit from SimpleInteraction and therefore has no Failed field. Its Next field works differently
+from most interaction types.
+
+Chaining is a type of flow control interaction- each time a Chaining interaction with the same `ChainId` is called, a single
+interaction in the `Next` list is chosen and the others are ignored. The first time the `ChainId` is used, the first
+interaction in the list is chosen, the next time the second, etc. Once the end of the list is reached, the first
+interaction will be chosen again.
+
+Bear in mind: the progress through the Next list is based on the **ChainId**, not the interaction!  That means that two
+different Chaining interactions can share a single combo chain. You could have a pair of daggers that attacks with
+the left when the left mouse button is clicked and with the right when the right mouse button is clicked.  You could give
+both interaction chains a Chaining interaction with the same `ChainId` and three `Next` entries that do a light-light-heavy
+combo.  Each specific hit would occur with either the left or the right knife based on which button you clicked, but
+the combo would be otherwise identical regardless of which you chose.
+
+The Chaining interaction also has a concept called "flags".  It is possible to attach named flags to a `ChainId` by using
+the ChainFlag interaction.  Then, you specify the flag name in Chaining's `Flags` field. If a Flag is active when the
+Chaining interaction is run, the Flag's interaction will be run instead of the appropriate interaction in `Next`.
+Bear in mind: the entity's progress through the `Next` list still advances, the resulting `Next` interaction is just not
+run.  Only one flag can be active at a time.
+
+Lastly, it is possible to cancel the entity's progress through the combo chain and reset them to the first interaction in
+the list. This can be done with the CancelChain interaction, but it will also happen automatically if the player does
+not trigger an interaction with the ChainId for the specified ChainingAllowance.  When either of these happen, all flags will be
+canceled as well.
+
+All of these effects are triggered on the User entity only. Non-players can use the chaining system, but Flags do not currently
+work for non-players.  This interaction has no special failure conditions.
+
+**Chaining Fields**
+
+| Field Name        | Type                                                       | Required? | Notes                                                                                                                                                                                                                       |
+| ----------------- | ---------------------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| ChainId           | `String`                                                   | **No**    | If provided, acts as a key that multiple Chaining interactions can use to share combo chain progress and flags. If not provided, a unique ChainId will be generated for this interaction.                                   |
+| ChainingAllowance | `Double`<br />(Default: 0.0)                               | **No**    | If, at the time this interaction is triggered, it has been this long in seconds since the last time a Chaining interaction with the same ChainId was executed, all state for this ChainId will be cleared before execution. |
+| Next              | `AssetArray`<br />(Element Type: `Interaction`)            | **Yes**   | A list of interactions to cycle between each time this interaction is run.                                                                                                                                                  |
+| Flags             | `Map`<br />(Key Type: `String`, Value Type: `Interaction`) | **No**    | A map of flag names to interactions to run if the flag is active when this interaction executes.                                                                                                                            |
+
+### CancelChain
+
+This interaction resets all progress and flag data on the User entity for the provided `ChainId`.  The next time a Chaining
+interaction is called for the provided `ChainId`, it will begin at the first interaction in the `Next` list. This
+interaction has no special failure conditions.
+
+**CancelChain Fields**
+
+| Field Name | Type     | Required? | Notes                                 |
+| ---------- | -------- | --------- | ------------------------------------- |
+| ChainId    | `String` | **Yes**   | A ChainId whose data should be reset. |
+
+### ChainFlag
+
+This interaction activates a flag on the User entity for the provided `ChainId`, which can be used to change behavior the
+next time a Chaining interaction with this `ChainId` is run. This will overwrite any flag that has
+already been raised. This interaction will have no effect for non-players. This interaction has no special failure
+conditions.
+
+| Field Name | Type     | Required? | Notes                                        |
+| ---------- | -------- | --------- | -------------------------------------------- |
+| ChainId    | `String` | **Yes**   | A ChainId on whom the flag should be raised. |
+| Flag       | `String` | **Yes**   | The name of the flag to raise.               |
+
+## Charging
+
+A unique flow-control interaction that is frequently used is the Charging interaction.  It is a flow-control interaction
+that delays while the input button used to trigger the interaction chain is held.  When it is released (or the interaction
+is forced to end), the interaction chain can continue with a different interaction based on how long the input was held
+for.
+
+These interactions are all related by either being the Charging interaction, or other interaction types that inherit the
+Charging interaction's behavior.
+
+### Charging
+
+This interaction does not inherit from SimpleInteraction and therefore its Next field works different from most interactions.
+This interaction adds its own Failed field which works the same way that SimpleInteraction's does.
+
+This interaction only works properly when its interaction chain was triggered by a client key or button press (or
+NPC-simulated equivalent). This interaction will continue executing for as long as the key or button press is held (with
+some exceptions, covered below) by the User entity.  Like other interactions, it has a `Next` field indicating which interaction to execute
+after this one, but the field is a map from `Float` values to `Interaction` assets. When this interaction ends, either
+due to the input being released or the charge duration completing, this interaction will determine the largest `Float` key that is less
+than the amount of time in seconds that the interaction was executing for.  The Interaction mapped to that key will be
+executed next.
+
+The interaction includes some cancellation conditions that are specific to this interaction. For instance, the interaction
+has a `CancelOnOtherClick` field that matches the field on RootInteraction. If it is active on this interaction but not
+the RootInteraction, then clicking while charging will cancel this interaction (and execute the `Failed` interaction rather
+than any of the `Next` interactions) but otherwise continue the interaction chain.
+
+Another valuable feature Charging has is the `Forks` field.  For input-triggered interactions that are triggered while the
+Charging interaction is executing, you can add an entry for the relevant InteractionType to this field and instead of
+triggering the usual interaction chain based on held item, targeted block, etc. the RootInteraction specified in the
+`Forks` field will be triggered.  This can unlock rich attack modes and behaviors. For instance, having a shield bash attack
+triggered off left click while blocking, or a special attack that triggers when both mouse buttons are pressed at the
+same time.
+
+There are two modes of operation for the Charging interaction. One is to have the ability charge for as long
+as the input is held and only end execution when the entity releases the input.  Bows in the main Hytale game work
+that way.  That is accomplished by setting `AllowIndefiniteHold` to true.  Another mode of operation is to have the
+interaction complete execution when the execution time has surpassed the largest key value in the `Next` field and
+immediately begin executing the Interaction mapped to that key.  Food in the main Hytale game work like this.  It
+is accomplished by setting `AllowIndefiniteHold` to false.
+
+One pitfall to be careful of when setting `AllowIndefiniteHold` to false is the way it interacts with cooldowns.\
+Normally, input-initiated interaction chains start a 0.35s cooldown on the triggered RootInteraction that prevents
+holding the mouse button from immediately spamming a new interaction when the first one completes.  However, if the
+duration of a Charging interaction is longer than 0.35s, then the cooldown will have already completed when the
+interaction chain finishes, which will often result in a new execution beginning immediately before the player can
+stop pressing the mouse button.  One solution for this problem is to add a `Simple` interaction to the end of your
+interaction chain with a `RunTime` of 0.35s to simulate the cooldown.  Alternatively, you can add a longer cooldown
+(the maximum duration of your Charging interaction plus 0.35s) to the RootInteraction. However, the longer cooldown is
+not always desirable, as the interaction may have ended prematurely, resulting in an unusually long lockout between
+executions.
+
+**Charging Fields**
+
+| Field Name                         | Type                                                                    | Required? | Notes                                                                                                                                                                                                                                                                                                                                                                                       |
+| ---------------------------------- | ----------------------------------------------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| FailOnDamage                       | `Boolean`<br />(Default: false)                                         | **No**    | If true, this interaction will fail and end immediately if the User entity takes any damage while it is executing.                                                                                                                                                                                                                                                                          |
+| CancelOnOtherClick                 | `Boolean`<br />(Default: true)                                          | **No**    | If true, this interaction will fail and end immediately if the User entity sends another button or key press while it is executing.                                                                                                                                                                                                                                                         |
+| Forks                              | `Map`<br />(Key Type: `InteractionType`, Value Type: `RootInteraction`) | **No**    | A map of InteractionType to RootInteraction. If entity input triggers the InteractionType while this interaction is executing, the mapped RootInteraction will be forked into its own interaction chain. This will happen instead of the usual handling for that InteractionType.  This fork will occur even if `CancelOnOtherClick` is set to true.                                        |
+| Failed                             | `Asset`<br />(Asset Type: `Interaction`)                                | **No**    | After this Interaction has finished, "Failed" will be executed if this Interaction failed.                                                                                                                                                                                                                                                                                                  |
+| AllowIndefiniteHold                | `Boolean`<br />(Default: false)                                         | **No**    | If true, this interaction will continue executing for as long as the User entity continues to hold the input. If false, execution will end as soon as the execution time in seconds reaches the largest key value in the `Next` map.                                                                                                                                                        |
+| DisplayProgress                    | `Boolean`<br />(Default: true)                                          | **No**    | If true, players executing this interaction will see a progress bar will be displayed below their cursor indicating how close to reaching the highest key value in `Next` they are.                                                                                                                                                                                                         |
+| Next                               | `Map`<br />(Key Type: `Float`, Value Type: `Interaction`)               | **No**    | A map from `Float` to `Interaction`.  When this interaction successfully finishes executing (either because the input was released or because the maximum duration was reached), this interaction will find the `Float` value with the largest duration in seconds that is less than the amount of time this interaction executed for. That key's mapped Interaction will then be executed. |
+| MouseSensitivityAdjustmentTarget   | `Float`<br />(Default: 1.0)                                             | **No**    | While charging, this mouse sensitivity multiplier will gradually be applied.                                                                                                                                                                                                                                                                                                                |
+| MouseSensitivityAdjustmentDuration | `Float`<br />(Default: 1.0)                                             | **No**    | Duration in seconds. After this many seconds, `MouseSensitivityAdjustmentTarget` will be fully applied to the mouse sensitivity.                                                                                                                                                                                                                                                            |
+| Delay                              | `ChargingDelay`                                                         | **No**    | Settings that allow charging progress to be pushed back when the User entity takes damage.                                                                                                                                                                                                                                                                                                  |
+
+**ChargingDelay Fields**
+
+| Field Name    | Type                        | Required? | Notes                                                                                                                                                                                                                                                                     |
+| ------------- | --------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| MinHealth     | `Float`<br />(Default: 0.0) | **No**    | Damage taken as a percentage of entity health (0.0-1.0). If a hit deals less than this much damage, no pushback will be applied.  If a hit deals exactly this much damage, `MinDelay` seconds worth of pushback will be applied.                                          |
+| MaxHealth     | `Float`<br />(Default: 0.0) | **No**    | Damage taken as a percentage of entity health (0.0-1.0). If a hit deals at least this much damage, `MaxDelay` seconds worth of pushback will be applied.                                                                                                                  |
+| MinDelay      | `Float`<br />(Default: 0)   | **No**    | The amount of pushback, in seconds, to apply if the entity takes a hit that deals `MinHealth` damage. The amount of pushback applied by a hit is a gradiant between `MinDelay` and `MaxDelay` based on the amount of damage between `MinHealth` and `MaxHealth`.          |
+| MaxDelay      | `Float`<br />(Default: 0)   | **No**    | The amount of pushback, in seconds, to apply if the entity takes a hit that deals at least `MaxHealth` damage. The amount of pushback applied by a hit is a gradiant between `MinDelay` and `MaxDelay` based on the amount of damage between `MinHealth` and `MaxHealth`. |
+| MaxTotalDelay | `Float`<br />(Deault: 0)    | **No**    | The maximum amount of pushback the entity can receive over the course of a single charge, regardless of how many times they are hit.                                                                                                                                      |
+
+**InteractionType Values**
+
+- `Primary`
+- `Secondary`
+- `Ability1`
+- `Ability2`
+- `Ability3`
+- `Use`
+- `Pick`
+- `Pickup`
+- `CollisionEnter`
+- `CollisionLeave`
+- `Collision`
+- `EntityStatEffect`
+- `SwapTo`
+- `SwapFrom`
+- `Death`
+- `Wielding`
+- `ProjectileSpawn`
+- `ProjectileHit`
+- `ProjectileMiss`
+- `ProjectileBounce`
+- `Held`
+- `HeldOffhand`
+- `Equipped`
+- `Dodge`
+- `GameModeSwap`
+
+### Wielding
+
+This interaction is inherited from Charging rather than SimpleInteraction.  However, its `Failed` and `Next` fields function
+identically to SimpleInteraction.  It does not inherit all fields from Charging, so be sure to pay close attention to
+the field list below.
+
+This interaction drives most blocking behavior in the game. While this interaction is executing, attacks made against
+the Owner entity will (conditionally) trigger effects defined in this interaction.  Unlike the Charging interaction,
+this interaction can always execute indefinitely and will only end when it fails or when the input is released.
+
+One option available in Wielding is `AngledWielding`, which allows damage and knockback modifiers to only be applied
+depending on the direction the attack against the Owner entity is coming from.  The AngledWielding type has a
+field `Angle` which determines which direction the protection points relative to the player (0 is the player's
+front), and `AngleDistance` which determines how wide the cone of protection extends around the player.  Block effects
+from this interaction (such as `BlockedEffects`, `BlockedInteractions`, and `StaminaCost`) will only apply if
+the DamageCause matches `DamageModifiers` OR if the DamageCause matches `AngledWielding.DamageModifiers` and
+the source of the damage matches `Angle` and `AngleDistance`.  It is possible for damage and knockback multipliers
+specified on both this interaction's modifier fields and `AngledWielding`'s modifier fields to stack, if both
+have entries for the same DamageCause.
+
+This interaction will only have an effect on damage taken by one of the DamageCause entries in `DamageModifiers` or
+`AngledWielding.DamageModifiers`.  If a DamageCause is in `DamageModifiers`, then the block effect will be triggered
+and the damage modifier applied regardless of what direction the Owner entity is attacked from.  If a DamageCause is in
+`AngledWielding.DamageModifiers`, then the damage modifier is only applied if the
+
+\*\* Wielding Fields\*\*
+
+| Field Name          | Type                                                                    | Required? | Notes                                                                                                                                                                                                                                                                                                                                                                                                      |
+| ------------------- | ----------------------------------------------------------------------- | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| FailOnDamage        | `Boolean`<br />(Default: false)                                         | **No**    | If true, this interaction will fail and end immediately if the User entity takes any damage while it is executing.                                                                                                                                                                                                                                                                                         |
+| CancelOnOtherClick  | `Boolean`<br />(Default: true)                                          | **No**    | If true, this interaction will fail and end immediately if the User entity sends another button or key press while it is executing.                                                                                                                                                                                                                                                                        |
+| Forks               | `Map`<br />(Key Type: `InteractionType`, Value Type: `RootInteraction`) | **No**    | A map of InteractionType to RootInteraction. If entity input triggers the InteractionType while this interaction is executing, the mapped RootInteraction will be forked into its own interaction chain. This will happen instead of the usual handling for that InteractionType.  This fork will occur even if `CancelOnOtherClick` is set to true (after which this interaction chain will be canceled). |
+| Next                | `Asset`<br />(Asset Type: `Interaction`)                                | **No**    | After this interaction has finished, "Next" will be executed if this interaction did not fail.                                                                                                                                                                                                                                                                                                             |
+| Failed              | `Asset`<br />(Asset Type: `Interaction`)                                | **No**    | After this interaction has finished, "Failed" will be executed if this interaction failed.                                                                                                                                                                                                                                                                                                                 |
+| DamageModifiers     | `Map`<br />(Key Type: `DamageCause`, Value Type: `Float`)               | **No**    | A map from DamageCause to Float, where the Float is multiplied against any damage received from the mapped DamageCause while this interaction is executing.                                                                                                                                                                                                                                                |
+| KnockbackModifiers  | `Map`<br />(Key Type: `DamageCause`, Value Type: `Float`)               | **No**    | A map from DamageCause to Float, where the Float is multiplied against any knockback force received from the mapped DamageCause while this interaction is executing.                                                                                                                                                                                                                                       |
+| AngledWielding      | `AngledWielding`                                                        | **No**    | Configuration to only trigger block effects from certain angles.                                                                                                                                                                                                                                                                                                                                           |
+| StaminaCost         | `StaminaCost`                                                           | **No**    | If the Owner entity receives damage that matches `DamageModifiers` or `AngledWielding` while this interaction is executing, then the entity's stamina will be deducted according to this configuration.                                                                                                                                                                                                    |
+| BlockedEffects      | `DamageEffects`                                                         | **No**    | If the Owner entity receives damage that matches `DamageModifiers` or `AngledWielding` while this interaction is executing, then these effects will be applied to the instance of damage.                                                                                                                                                                                                                  |
+| BlockedInteractions | `Asset`<br />(Asset Type: `RootInteraction`)                            | **No**    | If the Owner entity receives damage that matches `DamageModifiers` or `AngledWielding` while this interaction is executing, then this RootInteraction will be launched as a brand new interaction chain with the Owner entity as both Owner and User, and the attacker as the Target entity.  This new interaction chain is, notably, brand new, **not** forked from the current one.                      |
+
+**AngledWielding Fields**
+
+| Field Name         | Type                                                      | Required? | Notes                                                                                                                                                                                                            |
+| ------------------ | --------------------------------------------------------- | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Angle              | `Float`<br />(Default: 0.0)                               | **No**    | Angle in degrees relative to the Owner entity where the angled protection is centered. 0.0 means pointed towards the front of the Owner entity.                                                                  |
+| AngleDistance      | `Float`<br />(Default: 0.0)                               | **No**    | Angle in degrees indicating how wide the cone of protection is.                                                                                                                                                  |
+| DamageModifiers    | `Map`<br />(Key Type: `DamageCause`, Value Type: `Float`) | **No**    | A map from DamageCause to Float, where the Float is multiplied against any damage received from the mapped DamageCause received from within the cone of protection while this interaction is executing.          |
+| KnockbackModifiers | `Map`<br />(Key Type: `DamageCause`, Value Type: `Float`) | **No**    | A map from DamageCause to Float, where the Float is multiplied against any knockback force received from the mapped DamageCause received from within the cone of protection while this interaction is executing. |
+
+**StaminaCost Fields**
+
+| Field Name | Type                                             | Required? | Notes                                                                                                                                                                                                                                                |
+| ---------- | ------------------------------------------------ | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| CostType   | `CostType`<br />(Default: `MaxHealthPercentage`) | **No**    | How to calculate stamina consumed by blocking from the raw pre-block damage. If `Damage`, then the stamina consumed will be `rawDamage / Value`. If `MaxHealthPercentage`, then the stamina consumed will be `rawDamage / (EntityMaxHealth * Value)` |
+| Value      | `Float`<br />(Default: 0.04)                     | **No**    | The value to use in the `CostType` formula.                                                                                                                                                                                                          |
+
+**DamageEffects Fields**
+
+| Field Name             | Type                                         | Required? | Notes                                                                           |
+| ---------------------- | -------------------------------------------- | --------- | ------------------------------------------------------------------------------- |
+| ModelParticles         | `Array`<br />(Element Type: `ModelParticle`) | **No**    | Particle systems to trigger in the first-person view.                           |
+| WorldParticles         | `Array`<br />(Element Type: `WorldParticle`) | **No**    | Particle systems to trigger in the third-person view.                           |
+| LocalSoundEventId      | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | 2D sound to play locally to the attacking entity if they are a player.          |
+| WorldSoundEventId      | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | Sound to play in the world at the Owner entity's location.                      |
+| PlayerSoundEventId     | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | 2D sound to play locally to the Owner entity if they are a player.              |
+| ViewDistance           | `Double`<br />(Default: 75.0)                | **No**    | Distance at which these effects should play for other players.                  |
+| Knockback              | `Knockback`                                  | **No**    | The properties of the knockback that will be applied.                           |
+| CameraEffect           | `Asset`<br />(Asset Type: `CameraEffect`)    | **No**    | CameraEffect to briefly apply locally to the Owner entity if they are a player. |
+| StaminaDrainMultiplier | `Float`<br />(Default: 1.0)                  | **No**    | This multiplier is applied to the `StaminaCost`, if any.                        |
+
+**Knockback Fields**
+
+| Field Name     | Type                                       | Required? | Notes                                                                                                                      |
+| -------------- | ------------------------------------------ | --------- | -------------------------------------------------------------------------------------------------------------------------- |
+| Type           | `String`                                   | **No**    | If provided, specifies a type of knockback to use. Each knockback type may come with additional fields.                    |
+| Force          | `Double`<br />(Default: 0.0)               | **No**    | The amount of force to apply to the Owner entity.                                                                          |
+| Duration       | `Double`<br />(Default: 0.0)               | **No**    | If 0.0, apply the force as a single impulse.  If more, continuously apply the force over a period of time.                 |
+| VelocityType   | `ChangeVelocityType`<br />(Default: `Add`) | **No**    | How to apply the force, either adding it to the entity's current velocity, or setting the velocity to the knockback force. |
+| VelocityConfig | `VelocityConfig`                           | **No**    | Characteristics of friction as the Owner entity is thrown by this knockback.                                               |
+
+**Knockback Type: Force**
+
+Apply the calculated knockback force along the provided direction.
+
+| Field Name | Type                         | Required? | Notes                                                                                |
+| ---------- | ---------------------------- | --------- | ------------------------------------------------------------------------------------ |
+| Direction  | `Vector3`<br />(Default: Up) | **No**    | Which direction the player should be flung, relative to the direction of the attack. |
+
+**Knockback Type: Point**
+
+Apply the calculated knockback force laterally along the XZ plane, plus provided Y velocity.
+
+| Field Name | Type                        | Required? | Notes                                                                                                   |
+| ---------- | --------------------------- | --------- | ------------------------------------------------------------------------------------------------------- |
+| OffsetX    | `Integer`<br />(Default: 0) | **No**    | Offset the source position of the knockback left or right perpendicular to the direction of the attack. |
+| OffsetZ    | `Integer`<br />(Default: 0) | **No**    | Offset the source position of the knockback, forward or backward along the directon of the attack.      |
+| RotateY    | `Integer`<br />(Default: 0) | **No**    | Rotate the knockback direction around the Y axis, where 0 is the default attack direction.              |
+| VelocityY  | `Float`<br />(Default: 0.0) | **No**    | Add vertical velocity to the knockback force after the direction and force has been calculated.         |
+
+**Knockback Type: Directional**
+
+Apply the calculated knockback force along the attack direction, removing any vertical component and replacing it with a provided Y velocity.
+
+| Field Name | Type                      | Required? | Notes                                                                                                                                            |
+| ---------- | ------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------ |
+| RelativeX  | `Float`<br />(Default: 0) | **No**    | Apply additional force left or right perpendicular to the direction of the attack. The additional force is multiplied by the knockback strength. |
+| RelativeZ  | `Float`<br />(Default: 0) | **No**    | Apply additional force forward or backward along the attack direction. The additional force is multiplied by the knockback strength.             |
+| VelocityY  | `Float`<br />(Default: 0) | **No**    | Replace the vertical velocity of the knockback with this value.  This value is not multiplied by knockback strength.                             |
+
+**VelocityConfig Fields**
+
+| Field Name          | Type                                              | Required? | Notes                                                                                                                                                                                           |
+| ------------------- | ------------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| GroundResistance    | `Float`<br />(Default: 0.82)                      | **No**    | The minimum amount of friction applied when the entity is in contact with the ground.  1.0 = no friction, 0.0 = total friction                                                                  |
+| GroundResistanceMax | `Float`<br />(Default: 0.0)                       | **No**    | The maximum amount of friction applied when the entity is in contact with the ground.  1.0 = no friction, 0.0 = total friction                                                                  |
+| AirResistance       | `Float`<br />(Default: 0.96)                      | **No**    | The minimum amount of friction applied when the entity is in the air. 1.0 = no friction, 0.0 = total friction                                                                                   |
+| AirResistanceMax    | `Float`<br />(Default: 0.0)                       | **No**    | The maximum amount of friction applied when the entity is in the air. 1.0 = no friction, 0.0 = total friction                                                                                   |
+| Threshold           | `Float`<br />(Default: 1.0)                       | **No**    | The speed at which the maximum amount of friction will be applied to the entity. The amount of friction applied will increase from minimum to maximum as the entity moves from 0 to this speed. |
+| Style               | `VelocityThresholdStyle`<br />(Default: `Linear`) | **No**    | The curve that friction follows as the entity's speed increases toward the `Threshold`.                                                                                                         |
+
+**CostType Values**
+
+- `MaxHealthPercentage`
+- `Damage`
+
+**ChangeVelocityType Values**
+
+- `Add`
+- `Set`
+
+**VelocityThresholdStyle Values**
+
+- `Linear`
+- `Exp`
+
+## Blocks
+
+These are interaction types meant to reason about and modify blocks in the world.  The most important concept unique
+to these interactions is the Block Target.  Like the Entity Target, it is mutable and can come from many places.
+However, for interaction chains initiated by the client, the block target will initially be the block that the player's cursor was
+over, if any.
+
+Additionally, for interaction chains initiated by the client, the client will send along which face of the block is targeted,
+which is used by a few block-related interactions.
+It is left up to each interaction type that cares about block faces as to how to handle this behavior for simulated input
+(i.e. NPCs initiating chains that are normally initated by the client).  At the time of this writing, all block-related
+interactions choose the top face where relevant in simulated input.
+
+### BlockCondition
+
+This interaction has a field `Matchers` which specifies certain conditions, such as block type, state, etc.  This
+interaction fails if the current target block does not match all of them.
+
+**BlockCondition Fields**
+
+| Field Name       | Type                                        | Required? | Notes                                                                                                                                                                                                                                                                                                                                   |
+| ---------------- | ------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false)             | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction.                                                                                                                                                                                                       |
+| Matchers         | `Array`<br />(Element Type: `BlockMatcher`) | **Yes**   | A list of conditions that the target block must match or this condition will fail.<br />**Note: This field is technically not required but there is a bug that makes it dangerous to not provide at the time of this writing.**<br />**Note: If no conditions are added to this array, the interaction will fail, counterintuitively.** |
+
+**BlockMatcher Fields**
+
+| Field Name | Type                       | Required? | Notes                                                                          |
+| ---------- | -------------------------- | --------- | ------------------------------------------------------------------------------ |
+| Block      | `BlockIdMatcher`           | **No**    | If provided, requires the block itself match some set of conditions.           |
+| Face       | `BlockFace`                | **No**    | If provided and not 'None', requires a specific block face be targeted.        |
+| StaticFace | `Boolean` (Default: false) | **No**    | If false, the face condition will be adjusted by the block's current rotation. |
+
+**BlockFace Values**
+
+- `Up`
+- `Down`
+- `North`
+- `South`
+- `East`
+- `West`
+- `None`
+
+**BlockIdMatcher Fields**
+
+| Field Name | Type                                   | Required? | Notes                                                                      |
+| ---------- | -------------------------------------- | --------- | -------------------------------------------------------------------------- |
+| Id         | `Asset`<br />(Asset Type: `BlockType`) | **No**    | If provided, the block must match the specified `BlockType`.               |
+| State      | `String`                               | **No**    | If provided, the block's current state must match the provided state name. |
+| Tag        | `String`                               | **No**    | If provided, the block type's asset tags must contain the provided tag.    |
+
+### DestroyCondition
+
+This interaction fails if the current User entity cannot destroy the current target blcok.
+
+**DestroyCondition Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+
+### PlacementCountCondition
+
+This interaction accepts the name of a BlockType that has the TrackedPlacement BlockEntity. The interaction will fail if the number of
+blocks of the provided BlockType in the world do not match the provided condition.
+
+**PlacementCountCondition Fields**
+
+| Field Name | Type                           | Required? | Notes                                                                                                                                                                                                                                                           |
+| ---------- | ------------------------------ | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Block      | `String`                       | **Yes**   | The BlockType to examine. The number of instances of the BlockType in the world will be compared to Value.<br />**Note: The specified BlockType must have the TrackedPlacement BlockEntity. Otherwise, the number of blocks in the world will always be zero.** |
+| Value      | `Integer`<br />(Default: 0)    | **No**    | The value to compare the number of blocks in the world with.                                                                                                                                                                                                    |
+| LessThan   | \`Boolean<br />(Default: true) | **No**    | If true, the interaction will fail if the number of blocks in the world is greater than or equal to Value. If false, the interaction will fail if the number of blocks in the world is less than or equal to Value.                                             |
+
+### BreakBlock
+
+This interaction attempts to break the target block while acting as the User entity. The User entity must be a player. It
+is not guaranteed to work, depending on world settings and the User entity's current state, it may not work.  If it
+fails, it will fail the interaction under some circumstances, but not others.
+
+**Note: In particular, if `Harvest`=false and the player is in Survival mode, the player will simply execute a damage operation
+against the block. Even when the Tool field is specified, the player's currently-held item can impact the results in unintuitive
+ways.**
+
+This interaction will fail if there is no block target, if `Harvest`=true and the
+block is not harvestable, or if the world settings prevent the Harvest/Break operation.
+It will generally not fail otherwise, even if the block was not broken or damaged.
+The block will generally break every time if `Harvest`=true or the player is in
+Creative mode.
+
+**BreakBlock Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                                                                                                                                                                                                  |
+| ---------------- | ------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction.                                                                                                                                                                      |
+| Harvest          | `Boolean` (Default: false)      | **No**    | If true, harvest the block and deposit the drops in the player's inventory. This operation will generally always succeed.  If false, this interaction will effectively perform whatever action would have occurred if the player had left-clicked the block.                                           |
+| Tool             | `String`                        | **No**    | If `Harvest`=true, the player is in Survival mode, and this field is provided, then the break operation will be performed as though with this tool type.<br />**This field mostly doesn't work.  Your held item will be used for most block damage calculations regardless of this field's contents.** |
+| MatchTool        | `Boolean` (Default: false)      | **No**    | If true, `Harvest`=true, the player is in Survival mode, and `Tool` is provided, block breaking will be prevented unless `Tool` is a valid gathering tool for the target block. The interaction will not be failed, even if block breaking is prevented in this manner.                                |
+
+### ChangeBlock
+
+This interaction requires a mapping from one or more current BlockTypes to one or more target BlockTypes.  If the
+target block is one of the key BlockTypes, then it will be changed to the mapped target BlockType.  If the current
+BlockType of the target block does not appear as a key in the Changes field, then this interaction fails.
+
+**ChangeBlock Fields**
+
+| Field Name        | Type                                                        | Required? | Notes                                                                                                                             |
+| ----------------- | ----------------------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget  | `Boolean`<br />(Default: false)                             | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+| Changes           | `Map`<br />(Key Type: `BlockType`, Value Type: `BlockType`) | **No**    | A list of potential block type changes, with each entry having a current and new BlockType id.                                    |
+| WorldSoundEventId | `Asset`<br />(Asset Type: `SoundEvent`)                     | **No**    | If provided, this SoundEvent is played in the world at the position of the block if the block successfully changes.               |
+| RequireNotBroken  | `Boolean`<br />(Default: false)                             | **No**    | If true, this interaction will fail if the player's held item is broken (durability 0), and the block change will not take place. |
+
+### ChangeState
+
+This interaction requires a mapping from one or more current block state names to one or more state names. If the
+target block is in one of the key block states, then it will be changed to the mapped target blocks tate. If the
+current block state of the target block does nto appear as a key in the Changes field, then this interaction fails.
+
+All blocks start out with a null state by default.  This null state can be referenced by the key "default" and the block
+can be returned to that state with the value "default".
+
+**ChangeState Fields**
+
+| Field Name       | Type                                                  | Required? | Notes                                                                                                                                          |
+| ---------------- | ----------------------------------------------------- | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false)                       | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction.              |
+| Changes          | `Map`<br />(Key Type: `String`, Value Type: `String`) | **No**    | A list of potential block state changes, with each entry having a current and new state name.                                                  |
+| UpdateBlockState | `Boolean`<br />(Default: false)                       | **No**    | If true, performs a full refresh of the block's BlockEntity component and notifies nearby players as though a full block type change occurred. |
+
+### CycleBlockGroup
+
+This interaction will attempt to change the target block to the next block type in one of the BlockGroups it belongs to.
+If the block type belongs to multiple BlockGroups, which one is used is effectively arbitrary. The User entity must be
+a player. If the block cannot be changed for any reason (entity not a player, no block target, block does not belong
+to a BlockGroup, etc.). If the block is the only entry in the BlockGroup, this interaction will succeed and the block
+will be considered changed despite nothing happening.  Unlike most other block-changing interactions, this one will
+fail if the world settings prevent players from breaking blocks.
+
+**This interaction always reduces the player's held item's durability by a single 'hit' worth of damage if the block
+changes. There is no way to prevent it. The block type will change and the interaction will succeed even if the player's
+held item is broken, however.**
+
+**CycleBlockGroup Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+
+### DestroyBlock
+
+This interaction destroys the target block without dropping anything.  It will successfully destroy the block if the
+target block exists and this interaction has no failure conditions.
+
+**This interaction has no additional fields.**
+
+### PickBlock
+
+This interaction is effectively equivalent to using the middle mouse button in creative mode. In survival mode, the
+block's item will be moved to the user's current active hotbar slot if it is in the player's inventory.  This
+interaction is performed entirely on the client and cannot be performed by non-players.  It is unclear if this
+interaction has failure conditions.
+
+**PickBlock Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+
+### PlaceBlock
+
+This interaction is effectively identical to a right clicking while holding a block in their hand, with some
+additional options. For one, it can be executed with any LivingEntity as the User entity. For another, it has some
+useful fields.  For the most part, though, it follows the same behaviors and rules as any ordinary block placement
+by a player.
+
+It's not clear under what circumstances this interaction can fail. The server will not fail the interaction under any
+special circumstances (including when there is no target block, or when `BlockTypeToPlace` is not provided and the
+LivingEntity is not holding a block). However, the client is very involved with the function of this interaction and
+its behavior is unknown.
+
+**PlaceBlock Fields**
+
+| Field Name         | Type                                   | Required? | Notes                                                                                                                                                                                                                                                                                                                                                           |
+| ------------------ | -------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| BlockTypeToPlace   | `Asset`<br />(Asset Type: `BlockType`) | **No**    | If provided, the block placed by this interaction will be the specified BlockType. If not provided, the User entity's held item will be used, instead, if it is a block.                                                                                                                                                                                        |
+| RemoveItemInHand   | `Boolean`<br />(Default: True)         | **No**    | If true and the User entity is not a player in Creative mode, the item in the player's hand must match the block being placed and one quantity will be removed for each block placed. If the item does not match, the block cannot be placed.  If false, the player's hand item is ignored entirely.\*\*                                                        |
+| AllowDragPlacement | `Boolean`<br />(Default: True)         | **No**    | If true and the interaction was triggered on the client by a player, then the player can hold the input that was used to activate this interaction chain and move the mouse around in order to execute this interaction repeatedly and place several blocks. The interaction chain will not move onto the next interaction until the player releases the input. |
+
+### RunOnBlockTypes
+
+This interaction retrieves all blocks within a provided radius of the User entity. For each block that matches any of
+the provided BlockSets, a new interaction chain will be forked that uses the matching block as the target block.
+This interaction will continue executing until all forked interaction chains have completed.  The interaction will fail if no
+blocks within the radius match the provided BlockSets or if all of the forked interaction chains fail.
+
+**RunOnBlockTypes Fields**
+
+| Field Name   | Type                                         | Required?        | Notes                                                                                                                                                                                                                                                                                      |
+| ------------ | -------------------------------------------- | ---------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| Range        | `Integer`                                    | **Yes**          | The spherical radius around the User entity to search for blocks. Must be at least 1.                                                                                                                                                                                                      |
+| BlockSets    | `AssetArray`<br />(Element Type: `BlockSet`) | **No**           | A list of BlockSets to match nearby blocks again. Only blocks that match any of the BlockSets will have interaction chains forked for them.                                                                                                                                                |
+| MaxCount     | `Integer`                                    | **Yes**          | The maximum number of blocks that will be located with the search. Further blocks will be ignored. If there are more matching blocks within the radius than this number, the specific set of blocks that will be found is completely arbitrary and may change from execution to execution. |
+| Interactions | `Asset`<br />(Asset Type: `RootInteraction`) | **No, but yes.** | The RootInteraction that will be forked for each matching block.  This interaction will not fail to validate if it is missing, but every execution of this interaction will fail.                                                                                                          |
+
+### UseBlock
+
+If the target block has an interaction for this interaction chain's interaction type, execute it immediately as part of
+this interaction chain. The execution will be wrapped in UseBlockEvent.Pre and UseBlockEvent.Post events, and cancellations
+of the UserBlockEvent.Pre event are respected. The User entity is considered the triggering entity for both events.
+
+If the target block does not have an interaction for this interaction chain's interaction type, this interaction fails.
+
+**This interaction has no additional fields.**
+
+## Items
+
+These are interactions intended to interface with an entity's inventory. There is no concept of an "item target",
+unfortunately, so these generally either interact with the entity's held item or the entity's inventory at a high level.
+
+### AddItem
+
+Adds a specified quantity of a specified item to the User entity's inventory, preferring to add it to the
+entity's hotbar where possible. This interaction will have no effect on User entities that are not LivingEntities.
+This interaction has no failure states.
+
+**Note: This interaction has a bug in its field validators that will cause interactions that reference items declared
+in the same mod to fail validation on startup.  Additionally, this interaction has a bug that will cause it to
+fail and have no effect if the User entity has no block target. Use ModifyInventory instead.**
+
+**AddItem Fields**
+
+| Field Name       | Type                              | Required? | Notes                                                                                                                             |
+| ---------------- | --------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false)   | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+| ItemId           | `Asset`<br />(Asset Type: `Item`) | **Yes**   | The item id of the item to add to the player's inventory.                                                                         |
+| Quantity         | `Integer`<br />(Default: 0)       | **No**    | The quantity of the item to add to the player's inventory.                                                                        |
+
+### CheckUniqueItemUsage
+
+This interaction will check whether it has run once for the User entity with their currently-held item before. If it hasn't,
+it will succeed. If it has, it will fail. It will also fail if the User entity is not a player. The interaction will record
+the item id of the User entity's currently-held item on success, ensuring it cannot be successfully run with that player
+and item id combination again.
+
+**This interaction has no additional fields.**
+
+### ChangeActiveSlot
+
+This interaction does not inherit from SimpleInteraction and therefore has no Next or Failed fields.  The `CancelOnItemChange`
+field is ignored for this interaction and is always treated as false. This interaction will set the User entity's currently-
+active hotbar slot to the specified slot index. If none is specified, the interaction chain's target slot will be used,
+if any. Otherwise, slot 0 will be used.  If a slot is specified and it is already active, then this interaction will
+have no effect, but if no slot is specified and the interaction chain's target slot is already active, the logic in
+the next paragraph will still be executed. This interaction will also have no effect if the User entity is not a
+LivingEntity.
+
+Once the slot has changed, a new SwapTo interaction chain will be forked off for the selected slot.
+If a target slot was specified, then the interaction chain's current target slot will be set to the specified slot, as will
+the forked SwapTo interaction chain. If this interaction chain was initiated by a player swapping an item into or out of
+an occupied active hotbar slot, then the swap will be executed after the slot is changed and before the SwapTo
+interaction is forked. Not running this interaction in the resulting SwapFrom interaction chain is a way for the server
+to cancel players performing these sorts of swap interactions. The default behavior for these swap interactions is that
+the SwapFrom interaction chain will be initiated with the currently-active-slot as the target slot. As a result, the
+target slot will usually not change when this interaction runs, it merely exists as a signal for the server to continue the
+item swap.
+
+**ChangeActiveSlot Fields**
+
+| Field Name | Type      | Required? | Notes                                                                                                                                                                                                     |
+| ---------- | --------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| TargetSlot | `Integer` | **No**    | If not provided, indicates the slot the player's active hotbar slot should be changed to.  Otherwise, the interaction chain's target slot will be used (which is usually the already-active hotbar slot). |
+
+### EquipItem
+
+This interaction will equip the User entity's currently-held item into the appropriate armor slot, if it is armor. The
+interaction will fail if the item is armor but it cannot be equipped for some reason. The interaction will succeed but
+take no action if the User entity cannot equip armor or if the item is not armor.
+
+**This interaction has no additional fields.**
+
+### IncreaseBackpackCapacity
+
+This interaction will increase the User entity's backpack size by the provided amount.  **It will additionally remove one
+quantity from the player's currently-held item. There is no way to prevent this.**  This interaction will have no effect
+if the User entity is not a player.  This interaction has no special failure conditions, even if the User entity
+is not a player, or the player is not currently holding an item.
+
+| Field Name | Type                        | Required? | Notes                                                                                   |
+| ---------- | --------------------------- | --------- | --------------------------------------------------------------------------------------- |
+| Capacity   | `Integer`<br />(Default: 1) | **No**    | The additional backpack capacity to add to the player. **Must be between 1 and 32767.** |
+
+### ModifyInventory
+
+This interaction attempts to perform one or more inventory-modifying actions against the User entity. The User entity must
+be a player. If they are not, no actions will be performed, but the interaction will not fail. Any item removals performed
+by this interaction, either as a result of `ItemToRemove` or `AdjustHeldItemQuantity`, are both atomic (meaning the entire
+quantity must be removed, or none) and required (meaning that the interaction will fail and no further actions taken if
+the removal fails for any reason).  Item additions performed by this interaction, either as a result of `ItemToAdd` or
+`AdjustHeldItemQuantity` will drop excess items on the ground near the player if necesary and continue on.
+
+This interaction first executes the item removal in `ItemToRemove`, if any, then adjusts the held item as specified by
+`AdjustHeldItemQuantity`, if provided, then executes the item addition in `ItemToAdd`, if any, and then finally executes
+the damage/healing of the held item in `AdjustHeldItemDurability`, if provided.
+
+**ModifyDurability Fields**
+
+| Field Name               | Type                            | Required? | Notes                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
+| ------------------------ | ------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| RequiredGameMode         | `GameMode`                      | **No**    | If provided, only execute the inventory-modifying actions if the player is in the provided GameMode. The interaction will not fail if the GameMode doesn't match.                                                                                                                                                                                                                                                                                                                                                                               |
+| ItemToRemove             | `ItemStack`                     | **No**    | If provided, a matching item will be removed in the provided quantity. If there is no matching item in the player inventory in the required quantity, then the interaction will fail and further actions will not be executed.                                                                                                                                                                                                                                                                                                                  |
+| AdjustHeldItemQuantity   | `Integer`<br />(Default: 0)     | **No**    | The player's held item, if any, will have its quantity will be modified by the provided amount- subtracted from if this number is negative or added to if this item is positive.  If the player has no held item, then this field will have no effect regardless of its value and the interaction will NOT fail.  If the player's inventory does not have sufficient quantity of items to support the removal, this interaction will fail and further actions will not be executed. Excess items will be dropped on the ground near the player. |
+| ItemToAdd                | `ItemStack`                     | **No**    | If provided, the ItemStack will be added to the player's inventory. Excess items will be dropped on the ground near the player.                                                                                                                                                                                                                                                                                                                                                                                                                 |
+| AdjustHeldItemDurability | `Double`<br />(Default: 0.0)    | **No**    | The player's held item, if any, will have its durability adjusted by the specified amount.  The durability cannot go below 0 or raise above the item's maximum durability. Invalid durability values in this field will not cause the interaction to fail. Neither will it fail if the player has no held item.                                                                                                                                                                                                                                 |
+| BrokenItem               | `String`                        | **No**    | This field should contain an ItemId, but it is not validated by the server on startup, so be careful.  This field can have the value of "Empty" to specify no item, or an empty hand. If specified and the `AdjustHeldItemDurability` operation reduces the player's held item to 0 durability, the player's held item is changed to this ItemId. If the inventory replacement fails, this interaction will fail.                                                                                                                               |
+| NotifyOnBreak            | `Boolean`<br />(Default: false) | **No**    | If true and the `AdjustHeldItemDurability` operation reduces the player's held item to 0 durability, this interaction will perform the usual audiovisual feedback of a broken tool. It will play the usual tool breaking sound and send the player a text message in chat that their item has broken.                                                                                                                                                                                                                                           |
+| NotifyOnBreakMessage     | `String`                        | **No**    | If provided, and `NotifyOnBreak` is true, when the player is notified of a broken tool by this interaction, the message sent to their chat will instead be the translation key specified by this field. The translation key supports the templating parameter `{itemName}`. See the translation key `server.general.repair.itemBroken_Hoe` for an example.                                                                                                                                                                                      |
+
+**GameMode Values**
+
+- `Creative`: The game is currently in Creative Mode
+- `Adventure`: The game is currently in Adventure Mode
+
+**ItemStack Fields**
+
+| Field Name                   | Type                              | Required? | Notes                                                                                |
+| ---------------------------- | --------------------------------- | --------- | ------------------------------------------------------------------------------------ |
+| Id                           | `Asset`<br />(Asset Type: `Item`) | **Yes**   | The id of the Item asset this stack contains.                                        |
+| Quantity                     | `Integer`<br />(Default: 1)       | **No**    | The number of items in this stack.<br />**Must be greater than 0.**                  |
+| Durability                   | `Double`<br />(Default: 0.0)      | **No**    | The durability of the item stack.<br />**Cannot be negative.**                       |
+| MaxDurability                | `Double`<br />(Default: 0.0)      | **No**    | The maximum durability of the item this stack contains.<br />**Cannot be negative.** |
+| Metadata                     | `Bson Document`                   | **No**    | If provided, applies the bson to the item stack metadata.                            |
+| OverrideDroppedItemAnimation | `Boolean`\*(Default: false)       | **No**    | ???                                                                                  |
+
+### PickupItem
+
+This interaction will attempt to pick up the User entity's current target entity and add it to their inventory. It will
+fail if the User entity is not a player, if they do not have a target entity, or if the target entity is not an item
+located in the world.  It will not fail if the player simply cannot pick up the item.
+
+**This interaction has no additional fields.**
+
+### RefillContainer
+
+This interaction will fail if the User entity is not a player. The interaction will draw a ray from the player's head
+down their look direction until the edge of the player's held item's interaction range or until the first solid block.
+The nearest fluid block of a type listed in this interaction's `States` map will result in the one of the player's
+currently-held items being converted to the fluid's related item state.  If the `States` map indicates a durability
+for the new item state, then the converted item will use that durability. If the item is already in the fluid's related
+item state, then this interaction will fail if the player's held item is already at maximum durability (unless the
+`States` map indicates a durability value greater than the item's maximum, in which case the interaction will succeed
+but the item will not change).  Otherwise, the durability listed for the fluid in the `States` map will be added to the
+item's current durability.
+
+If the interaction has not failed by this point, the fluid block in the world may be transformed to a different type if one is listed
+in the `States` map.
+
+If any part of this process does not proceed for any reason (for instance, if the player is not holding an item),
+then this interaction will fail.
+
+**RefillContainer Fields**
+
+| Field Name | Type                                                       | Required? | Notes                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| ---------- | ---------------------------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| States     | `Map`<br />(Key Type: `String`, Value Type: `RefillState`) | **Yes**   | A map from item state names to `RefillState` objects, which contain information such as acceptable fluid block types, durability increases, and what fluid type to convert the targeted fluid block to after refill, if any. If the player targets a fluid block that matches one of the fluid types in the `RefillState`, the item will be converted to the keyed item state and the `RefillState` will be used to decide what happens next. |
+
+**RefillState Fields**
+
+| Field Name     | Type                                  | Required? | Notes                                                                                                                                                                                                                                                                                                                           |
+| -------------- | ------------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| AllowedFluids  | `Array`<br />(Element Type: `String`) | **Yes**   | If any of these fluids are targeted by the player, the player's held item will be converted to the keyed item state and `Durability` and `TransformFluid` will be used.                                                                                                                                                         |
+| Durability     | `Double`<br />(Default: -1.0)         | **No**    | If the player's held item changes item states, this value is the new item's durability, unless it is negative, in which case the item will begin at full durability. If the player's held item is already in the item state, and the item is not already at full durability, this value will be added to the item's durability. |
+| TransformFluid | `String`                              | **No**    | If provided, this field is a fluid id that the targeted fluid block should be transformed to if the player's held item is successfully updated.                                                                                                                                                                                 |
+
+## Entities
+
+### DamageEntity
+
+This interaction does not inherit from SimpleInteraction, but adds its own Next and Failed fields that
+work similarly.
+
+This interaction will cause the User entity to damage the Target entity.  It has the capability to apply different
+damage based on the direction of the attack or what body part was targeted by the User entity, with each possibility
+providing different damage calculations, effects, and Next interaction. If multiple entires match the attack, `TargetedDamage`
+(body part damage) takes highest priority, then the first matching `AngledDamage` in the list, then the default
+damage in the base interaction fields.  It is possible for elements of these different damage priorities to be taken peacemeal if higher-priority
+damage fields do not overwrite lower-priority damage fields. For instance,
+damage calculation could be taken from `TargetedDamage`, the damage effects could be taken from the first matching
+`AngledDamage`, and the Next interaction coming from the default damage field.
+
+If all damage dealt by this interaction is cancelled, then this interaction will fail, and the `Failed` interaction
+will be executed next in the chain. If any damage dealt by this interaction is blocked, then this interaction will
+succeed, but the `Blocked` interaction wil lbe executed next in the chain. Otherwise, the highest-precedent matching
+`Next` interaction that you provide will be executed.  For instance, if you provide `Next` interactions for all
+`TargetedDamage` and `AngledDamage` entries, and one in the interaction's `Next` field, then a headshot could result
+in a unique `Next` interaction being executed, even if there is a matching `AngledDamage` entry. However, if you leave
+the `Next` interaction out of your `TargetedDamage` entries, a special `Next` interaction for backstabs could be
+executed.  Otherwise, the `Next` field in the root of the interaction will be executed instead.
+
+DamageEntity has an unusual relationship with `RunTime`. This interaction always ends immediately after its first tick,
+regardless of the status of `RunTime` or `WaitForAnimationToFinish`.  However, if damage dealt by this interaction is
+calculated as `DamageCalculatorType` `Dps`, then the `RunTime` will be used to determine the precise amount of damage to
+deal. If `RunTime` is 0, then no damage will be dealt.
+
+**DamageEntity Fields**
+
+| Field Name       | Type                                                          | Required?                                                                                                                    | Notes                                                                                                                                                                                                                                                                                                                                                                         |
+| ---------------- | ------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| DamageCalculator | `DamageCalculator`                                            | **No**                                                                                                                       | If provided, describes the damage amounts and types to apply to the Target entity.                                                                                                                                                                                                                                                                                            |
+| DamageEffects    | `DamageEffects`                                               | **No**                                                                                                                       | If provided, describes particles, sounds, knockback, etc. to apply to the target entity on damage.                                                                                                                                                                                                                                                                            |
+| Next             | `Asset`<br />(Asset Type: `Interaction`)                      | **No**  After this interaction has finished, "Next" will be executed if damage was dealt to the target and none was blocked. |                                                                                                                                                                                                                                                                                                                                                                               |
+| AngledDamage     | `Array`<br />(Element Type: `AngledDamage`)                   | **No**                                                                                                                       | If provided, allows alternative `DamageCalculator`, `DamageEffects`, and `Next` entries for attacks that approach the target from certain angles.                                                                                                                                                                                                                             |
+| TargetedDamage   | `Map`<br />(Key Type: `String`, Value Type: `TargetedDamage`) | **Yes**                                                                                                                      | This field must be provided, but is not required to have any entries.  This is a map from body part names to `TargetedDamage` values. Hypixel only uses one body part name: `Head`, and it is not clear whether there are others.  If provided, allows alternative `DamageCalculator`, `DamageEffects`, and `Next` entries for attacks that damage specific enemy body parts. |
+| EntityStatsOnHit | `Array`<br />(Element Type: `EntityStatOnHit`)                | **No**                                                                                                                       | If provided, allows this attack to reduce enemy stats other than health.  Each individual damage application dealt by the same ability will apply stat reductions, at diminishing returns. All damage dealt in interaction chains forked by a Selector interaction will share the number of hits across all targets.                                                          |
+| Failed           | `Asset`<br />(Asset Type: `Interaction`)                      | **No**                                                                                                                       | After this interaction has finished, "Failed" will be executed if no damage hits were applied to the player, or if all damage hits were cancelled.                                                                                                                                                                                                                            |
+| Blocked          | `Asset`<br />(Asset Type: `Interaction`)                      | **No**                                                                                                                       | After this interaction has finished, "Blocked" will be executed if any damage hits were blocked by the target.                                                                                                                                                                                                                                                                |
+
+**DamageCalculator Fields**
+
+| Field Name                | Type                                                      | Required? | Notes                                                                                                                                                                                                                                                 |
+| ------------------------- | --------------------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Type                      | `DamageCalculatorType`<br />(Default: Absolute)           | **No**    | Whether the damage being applied is `Absolute` or \`Dps'.                                                                                                                                                                                             |
+| Class                     | `DamageClass`<br />(Default: Unknown)                     | **No**    | The type of attack producing the damage. Some weapon systems apply equipment modifiers based on this value.                                                                                                                                           |
+| BaseDamage                | `Map`<br />(Key Type: `DamageCause`, Value Type: `Float`) | **No**    | A set of DamageCauses and how much base damage is dealt for each.                                                                                                                                                                                     |
+| SequentialModifierStep    | `Float`<br />(Default: 0.0)                               | **No**    | Value between 0.0-1.0. Each additional hit from a single ability will have its damage reduced by this much as a percentage. All damage dealt in interaction chains forked by a Selector interaction will share the number of hits across all targets. |
+| SequentialModifierMinimum | `Float`<br />(Default: 0.0)                               | **No**    | Value between 0.0-1.0. `SequentialModifierStep` cannot reduce damage below this percentage regardless of the number of hits.                                                                                                                          |
+| RandomPercentageModifier  | `Float`<br />(Default: 0.0)                               | **No**    | A random value between +/- this amount multiplied by the base damage will be added to the base damage.                                                                                                                                                |
+
+**DamageEffects Fields**
+
+| Field Name             | Type                                         | Required? | Notes                                                                                   |
+| ---------------------- | -------------------------------------------- | --------- | --------------------------------------------------------------------------------------- |
+| ModelParticles         | `Array`<br />(Element Type: `ModelParticle`) | **No**    | Particle systems to trigger in the first-person view.                                   |
+| WorldParticles         | `Array`<br />(Element Type: `WorldParticle`) | **No**    | Particle systems to trigger in the third-person view.                                   |
+| LocalSoundEventId      | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | 2D sound to play locally to the attacking entity if they are a player.                  |
+| WorldSoundEventId      | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | Sound to play in the world at the Target entity's location.                             |
+| PlayerSoundEventId     | `Asset`<br />(Asset Type: `SoundEvent`)      | **No**    | 2D sound to play locally to the Target entity if they are a player.                     |
+| ViewDistance           | `Double`<br />(Default: 75.0)                | **No**    | Distance at which these effects should play for other players.                          |
+| Knockback              | `Knockback`                                  | **No**    | The properties of the knockback that will be applied.                                   |
+| CameraEffect           | `Asset`<br />(Asset Type: `CameraEffect`)    | **No**    | CameraEffect to briefly apply locally to the Target entity if they are a player.        |
+| StaminaDrainMultiplier | `Float`<br />(Default: 1.0)                  | **No**    | This multiplier is applied to the stamina cost incurred by the target blocking, if any. |
+
+**AngledDamage Fields**
+
+| Field Name       | Type                                     | Required? | Notes                                                                                                                                                                                                     |
+| ---------------- | ---------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| AngleDistance    | `Float`<br />(Default: 0)                | **No**    | The width in degrees of the matching arc around the Target entity. If the attack against the Target originates from within the arc, then the properties below will be applied to the attack, if provided. |
+| Angle            | `Float`<br />(Default: 0.0)              | **No**    | The angle in degrees around the Target entity at which the matching arc is centered.                                                                                                                      |
+| DamageCalculator | `DamageCalculator`                       | **No**    | If provided and the attack against the Target entity originates from within the provided arc, this DamageCalculator will override the interaction's `DamageCalculator` field.                             |
+| DamageEffects    | `DamageEffects`                          | **No**    | If provided and the attack against the Target entity originates from within the provided arc, this DamageEffects will override the interaction's `DamageEffects` field.                                   |
+| Next             | `Asset`<br />(Asset Type: `Interaction`) | **No**    | If provided and the attack against the Target entity originates from within the provided arc, this Interaction will override the interaction's `Next` field.                                              |
+
+**TargetedDamage Fields**
+
+| Field Name       | Type                                     | Required? | Notes                                                                                                                                                                                            |
+| ---------------- | ---------------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| DamageCalculator | `DamageCalculator`                       | **No**    | If provided and this TargetedDamage was matched, this DamageCalculator will override the interaction's `DamageCalculator` field and the `DamageCalculator` field of any matching `AngledDamage`. |
+| DamageEffects    | `DamageEffects`                          | **No**    | If provided and this TargetedDamage was matched, this DamageEffects will override the interaction's `DamageEffects` field and the `DamageEffects` field of any matching `AngledDamage`.          |
+| Next             | `Asset`<br />(Asset Type: `Interaction`) | **No**    | If provided and this TargetedDamage was matched, this Interaction will override the interaction's `Next` field and the `Next` field of any matching `AngledDamage`.                              |
+
+**EntityStatOnHit Fields**
+
+| Field Name                  | Type                                                                       | Required? | Notes                                                                                                                                                                                                                                                                                        |
+| --------------------------- | -------------------------------------------------------------------------- | --------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| EntityStatId                | `Asset`<br />(AssetType: `EntityStatType`)                                 | **Yes**   | Which entity stat to affect.                                                                                                                                                                                                                                                                 |
+| Amount                      | `Float`<br />(Default: 0.0)                                                | **No**    | How much of the stat to apply for each damage application. Use negative numbers to reduce stats.                                                                                                                                                                                             |
+| MultipliersPerEntitiesHit   | `Array`<br />(Element Type: `Float`, Default: `[1.0, 0.6, 0.4, 0.2, 0.1]`) | **No**    | The diminishing returns curve to be applied for multiple damage applications by the same ability. Each hit's stat impact will be multiplied by the next value in the list.  If there are more hits than array elements, subsequent hits will be multiplied by `MultiplierPerExtraEntityHit`. |
+| MultiplierPerExtraEntityHit | `Float`<br />(Default: 0.05)                                               | **No**    | If an ability carries out more damage applications than there are elements in the `MultipliersPerEntitiesHit` array, then subsequent stat values will be multiplied by this number.                                                                                                          |
+
+**Knockback Fields**
+
+| Field Name     | Type                                       | Required? | Notes                                                                                                                      |
+| -------------- | ------------------------------------------ | --------- | -------------------------------------------------------------------------------------------------------------------------- |
+| Type           | `String`                                   | **No**    | If provided, specifies a type of knockback to use. Each Target type may come with additional fields.                       |
+| Force          | `Double`<br />(Default: 0.0)               | **No**    | The amount of force to apply to the Owner entity.                                                                          |
+| Duration       | `Double`<br />(Default: 0.0)               | **No**    | If 0.0, apply the force as a single impulse.  If more, continuously apply the force over a period of time.                 |
+| VelocityType   | `ChangeVelocityType`<br />(Default: `Add`) | **No**    | How to apply the force, either adding it to the entity's current velocity, or setting the velocity to the knockback force. |
+| VelocityConfig | `VelocityConfig`                           | **No**    | Characteristics of friction as the Owner entity is thrown by this knockback.                                               |
+
+**Knockback Type: Force**
+
+Apply the calculated knockback force along the provided direction.
+
+| Field Name | Type                         | Required? | Notes                                                                                |
+| ---------- | ---------------------------- | --------- | ------------------------------------------------------------------------------------ |
+| Direction  | `Vector3`<br />(Default: Up) | **No**    | Which direction the entity should be flung, relative to the direction of the attack. |
+
+**Knockback Type: Point**
+
+Apply the calculated knockback force laterally along the XZ plane, plus provided Y velocity.
+
+| Field Name | Type                        | Required? | Notes                                                                                                   |
+| ---------- | --------------------------- | --------- | ------------------------------------------------------------------------------------------------------- |
+| OffsetX    | `Integer`<br />(Default: 0) | **No**    | Offset the source position of the knockback left or right perpendicular to the direction of the attack. |
+| OffsetZ    | `Integer`<br />(Default: 0) | **No**    | Offset the source position of the knockback, forward or backward along the directon of the attack.      |
+| RotateY    | `Integer`<br />(Default: 0) | **No**    | Rotate the knockback direction around the Y axis, where 0 is the default attack direction.              |
+| VelocityY  | `Float`<br />(Default: 0.0) | **No**    | Add vertical velocity to the knockback force after the direction and force has been calculated.         |
+
+**Knockback Type: Directional**
+
+Apply the calculated knockback force along the attack direction, removing any vertical component and replacing it with a provided Y velocity.
+
+| Field Name | Type                      | Required? | Notes                                                                                                                                            |
+| ---------- | ------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------ |
+| RelativeX  | `Float`<br />(Default: 0) | **No**    | Apply additional force left or right perpendicular to the direction of the attack. The additional force is multiplied by the knockback strength. |
+| RelativeZ  | `Float`<br />(Default: 0) | **No**    | Apply additional force forward or backward along the attack direction. The additional force is multiplied by the knockback strength.             |
+| VelocityY  | `Float`<br />(Default: 0) | **No**    | Replace the vertical velocity of the knockback with this value.  This value is not multiplied by knockback strength.                             |
+
+**VelocityConfig Fields**
+
+| Field Name          | Type                                              | Required? | Notes                                                                                                                                                                                           |
+| ------------------- | ------------------------------------------------- | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| GroundResistance    | `Float`<br />(Default: 0.82)                      | **No**    | The minimum amount of friction applied when the entity is in contact with the ground.  1.0 = no friction, 0.0 = total friction                                                                  |
+| GroundResistanceMax | `Float`<br />(Default: 0.0)                       | **No**    | The maximum amount of friction applied when the entity is in contact with the ground.  1.0 = no friction, 0.0 = total friction                                                                  |
+| AirResistance       | `Float`<br />(Default: 0.96)                      | **No**    | The minimum amount of friction applied when the entity is in the air. 1.0 = no friction, 0.0 = total friction                                                                                   |
+| AirResistanceMax    | `Float`<br />(Default: 0.0)                       | **No**    | The maximum amount of friction applied when the entity is in the air. 1.0 = no friction, 0.0 = total friction                                                                                   |
+| Threshold           | `Float`<br />(Default: 1.0)                       | **No**    | The speed at which the maximum amount of friction will be applied to the entity. The amount of friction applied will increase from minimum to maximum as the entity moves from 0 to this speed. |
+| Style               | `VelocityThresholdStyle`<br />(Default: `Linear`) | **No**    | The curve that friction follows as the entity's speed increases toward the `Threshold`.                                                                                                         |
+
+**DamageCalculatorType Values**
+
+- `Absolute`
+- `Dps`
+
+**DamageClass Values**
+
+- `Unknown`
+- `Light`
+- `Charged`
+- `Signature`
+
+**ChangeVelocityType Values**
+
+- `Add`
+- `Set`
+
+**VelocityThresholdStyle Values**
+
+- `Linear`
+- `Exp`
+
+### LaunchProjectile
+
+This is just a worse version of Projectile and is slated to be removed.  Use Projectile.
+
+### Projectile
+
+This interaction will spawn a new projectile at the User entity's eye position that will travel in its look direction.
+
+| Field Name | Type                                          | Required? | Notes                                                  |
+| ---------- | --------------------------------------------- | --------- | ------------------------------------------------------ |
+| Config     | `Asset`<br />(Asset Type: `ProjectileConfig`) | **No**    | Configuration describing the projectile to be spawned. |
+
+### RemoveEntity
+
+Despawns the specified entity from the world. This interaction will have no effect if the specified entity is a player. This
+interaction has no special failure conditions.
+
+| Field Name | Type                                     | Required? | Notes                  |
+| ---------- | ---------------------------------------- | --------- | ---------------------- |
+| Entity     | `InteractionTarget`<br />(Default: User) | **No**    | The entity to despawn. |
+
+**InteractionTarget Values**
+
+- `User` - The user of this interaction chain. The entity whose actions caused this interaction chain to be executed. This is usually the same as the Owner.
+- `Owner` - The owner of this interaction chain. The entity upon whom this interaction chain is executing.
+- `Target` - The entity target of this interaction chain, if any.  This value is mutable (and can therefore come from many places) but most commonly, it is an entity the User was targeting when this interaction chain began executing.
+
+### SendMessage
+
+This interaction sends a message to the Owner entity if that entity can receive messages.  Otherwise, the message
+is written to the server logs.  If the entity is a player, the message will appear in the player's chat window.
+
+\*\*SendMessage
+
+| Field Name | Type     | Required? | Notes                                                                                                                 |
+| ---------- | -------- | --------- | --------------------------------------------------------------------------------------------------------------------- |
+| Message    | `String` | **No**    | A text message to be sent to the Owner entity.  If this field is not provided, `Key` is used instead.                 |
+| Key        | `String` | **No**    | A translation key for a message to be sent to the Owner entity. If `Message` is provided, then this field is ignored. |
+
+### UseEntity
+
+This interaction is not in use by Hypixel and has some unusual qualities that mean it probably won't do what you want it
+to.  Do not use it.
+
+This interaction will retrieve the entity currently targeted by the client (NOT the interaction chain's current Target
+entity) and execute that entity's RootInteraction for this interaction chain's current interaction type. The
+RootInteraction will be executed as part of this current interaction chain. None of the properties of this interaction
+chain will be modified.
+
+This interaction will fail if the client is not currently targeting an entity, or if no interaction for the current
+interaction type exists on the entity.
+
+## Stats
+
+Hytale's resource system has been written about fairly extensively.  You can use these interactions to modify stats in
+response to actions or use stats as a cost for abilities.
+
+### ChangeStat
+
+This interaction applies a set of raw stat changes to the User entity. It has no special failure conditions.
+
+| Field Name    | Type                                                         | Required? | Notes                                                                                                                                                                                                                      |
+| ------------- | ------------------------------------------------------------ | --------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| StatModifiers | `Map`<br />(Key Type: `EntityStatType`, Value Type: `Float`) | **Yes**   | A set of stats to modify and what value to apply to them.                                                                                                                                                                  |
+| ValueType     | `ValueType`<br />(Default: Absolute)                         | **No**    | Whether the values in the `StatModifiers` map represent flat values to apply to the stat total, or percentages (0.0-100.0). Percentage values are percentage of the difference between the maximum and minimum stat value. |
+| Behaviour     | `ChangeStatBehavior`<br />(Default: Add)                     | **No**    | Whether the values in the `StatModifiers` map represent deltas to add into the User entity's current stat values, or fixed values to set the entity's stats to.                                                            |
+
+**ValueType Values**
+
+- `Absolute`
+- `Percent`
+
+**ChangeStatBehaviour Values**
+
+- `Add`
+- `Set`
+
+### ChangeStatWithModifier
+
+This interaction is like ChangeStat, except an armor stat modifier can be chosen which will apply bonuses and penalties
+to a stat from the User entity's equipped armor before it is applied.
+
+| Field Name            | Type                                                         | Required? | Notes                                                                                                                                                                                                                      |
+| --------------------- | ------------------------------------------------------------ | --------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| StatModifiers         | `Map`<br />(Key Type: `EntityStatType`, Value Type: `Float`) | **Yes**   | A set of stats to modify and what value to apply to them.                                                                                                                                                                  |
+| ValueType             | `ValueType`<br />(Default: Absolute)                         | **No**    | Whether the values in the `StatModifiers` map represent flat values to apply to the stat total, or percentages (0.0-100.0). Percentage values are percentage of the difference between the maximum and minimum stat value. |
+| Behaviour             | `ChangeStatBehavior`<br />(Default: Add)                     | **No**    | Whether the values in the `StatModifiers` map represent deltas to add into the User entity's current stat values, or fixed values to set the entity's stats to.                                                            |
+| InteractionModifierId | `InteractionModifierId`                                      | **Yes**   | The armor interaction modifier to apply bonuses and penalties for.                                                                                                                                                         |
+
+**ValueType Values**
+
+- `Absolute`
+- `Percent`
+
+**ChangeStatBehaviour Values**
+
+- `Add`
+- `Set`
+
+**InteractionModifierId Values**
+
+- `Dodge`
+
+### StatsCondition
+
+This interaction will fail if the User entity cannot afford the specified stats costs, or if it does not have the
+requested stats.
+
+| Field Name | Type                                                         | Required? | Notes                                                                                                                                                                                    |
+| ---------- | ------------------------------------------------------------ | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Costs      | `Map`<br />(Key Type:` EntityStatType`, Value Type: `Float`) | **Yes**   | A set of costs that the User entity needs to be able to afford for this interaction to succeed.                                                                                          |
+| ValueType  | `ValueType`<br />(Default: Absolute)                         | **No**    | Whether the values in the `Costs` map represetn flat values or percentages (0.0-100.0).  Percentage values are percentage of the difference between the maximum and minimum value.       |
+| LessThan   | `Boolean`<br />(Default: false)                              | **No**    | If true, this interaction will fail unless the User entity's current stat values are at or **below** the specified levels.  If false, they must be at or **above** the specified levels. |
+| Lenient    | `Boolean`<br />(Default: false)                              | **No**    | If true and `LessThan` is true, and a player's minimum stat value is below zero, then the player can afford a stat cost if the current value of a stat if above 0.                       |
+
+**ValueType Values**
+
+- `Absolute`
+- `Percent`
+
+### StatsConditionWithModifier
+
+This interaction is like StatsCondition, except an armor stat modifier can be chosen which will apply bonuses and penalties
+to a stat's cost from the User entity's equipped armor before it is compared.
+
+| Field Name            | Type                                                         | Required? | Notes                                                                                                                                                                                    |
+| --------------------- | ------------------------------------------------------------ | --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Costs                 | `Map`<br />(Key Type:` EntityStatType`, Value Type: `Float`) | **Yes**   | A set of costs that the User entity needs to be able to afford for this interaction to succeed.                                                                                          |
+| ValueType             | `ValueType`<br />(Default: Absolute)                         | **No**    | Whether the values in the `Costs` map represetn flat values or percentages (0.0-100.0).  Percentage values are percentage of the difference between the maximum and minimum value.       |
+| LessThan              | `Boolean`<br />(Default: false)                              | **No**    | If true, this interaction will fail unless the User entity's current stat values are at or **below** the specified levels.  If false, they must be at or **above** the specified levels. |
+| Lenient               | `Boolean`<br />(Default: false)                              | **No**    | If true and `LessThan` is true, and a player's minimum stat value is below zero, then the player can afford a stat cost if the current value of a stat if above 0.                       |
+| InteractionModifierId | `InteractionModifierId`                                      | **Yes**   | The armor interaction modifier to apply bonuses and penalties for.                                                                                                                       |
+
+**ValueType Values**
+
+- `Absolute`
+- `Percent`
+
+**InteractionModifierId Values**
+
+- `Dodge`
+
+## EntityEffects
+
+EntityEffects are buff or debuff effects that can be applied to a LivingEntity.  These can have a variety of effects from
+movement speed changes to periodic damage.
+
+### EffectCondition
+
+This interaction will fail if the specified entity's EntityEffects do not match the provided conditions.
+
+**EffectCondition Fields**
+
+| Field Name      | Type                                             | Required? | Notes                                                                                                                                                                                                             |
+| --------------- | ------------------------------------------------ | --------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Entity          | `InteractionTarget`<br />(Default: User)         | **Yes**   | The entity to examine for EntityEffects. This field can indicate the Owner, User, or Target of this interaction chain.                                                                                            |
+| Match           | `Match`<br />(Default: All)                      | **No**    | If `All`, then this interaction will fail if any EntityEffect in the `EntityEffectIds` is not on the specified entity. If `None`, then this interaction will fail if any EntityEffect IS on the specified entity. |
+| EntityEffectIds | `AssetArray`<br />(Element Type: `EntityEffect`) | **Yes**   | The set of EntityEffects to check against the specified entity and `Match`.                                                                                                                                       |
+
+**InteractionTarget Values**
+
+- `User` - The user of this interaction chain. The entity whose actions caused this interaction chain to be executed. This is usually the same as the Owner.
+- `Owner` - The owner of this interaction chain. The entity upon whom this interaction chain is executing.
+- `Target` - The entity target of this interaction chain, if any.  This value is mutable (and can therefore come from many places) but most commonly, it is an entity the User was targeting when this interaction chain began executing.
+
+**Match Values**
+
+- `All` - All EntityEffects must be on the specified entity for this interaction to succeed.
+- `None` - None of the EntityEffects must be on the specified entity for this interaction to succeed.
+
+### ApplyEffect
+
+This interaction will apply the specified EntityEffect to the specified Entity.  It has no special failure conditions.
+
+**ApplyEffect Fields**
+
+| Field Name | Type                                      | Required? | Notes                                                                                                                  |
+| ---------- | ----------------------------------------- | --------- | ---------------------------------------------------------------------------------------------------------------------- |
+| Entity     | `InteractionTarget`<br />(Default: User)  | **Yes**   | The entity to apply the EntityEffect to. This field can indicate the Owner, User, or Target of this interaction chain. |
+| EffectId   | `Asset`<br />(Asset Type: `EntityEffect`) | **Yes**   | The effect to apply.                                                                                                   |
+
+**InteractionTarget Values**
+
+- `User` - The user of this interaction chain. The entity whose actions caused this interaction chain to be executed. This is usually the same as the Owner.
+- `Owner` - The owner of this interaction chain. The entity upon whom this interaction chain is executing.
+- `Target` - The entity target of this interaction chain, if any.  This value is mutable (and can therefore come from many places) but most commonly, it is an entity the User was targeting when this interaction chain began executing.
+
+### ClearEntityEffect
+
+This interaction will remove the specified EntityEffect from the specified Entity. It has no special failure conditions.
+It will not fail if the Entity does not have the EntityEffect.
+
+**ClearEntityEffect Fields**
+
+| Field Name | Type                                      | Required? | Notes                                                                                                                     |
+| ---------- | ----------------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------- |
+| Entity     | `InteractionTarget`<br />(Default: User)  | **Yes**   | The entity to remove the EntityEffect from. This field can indicate the Owner, User, or Target of this interaction chain. |
+| EffectId   | `Asset`<br />(Asset Type: `EntityEffect`) | **Yes**   | The effect to remove.                                                                                                     |
+
+**InteractionTarget Values**
+
+- `User` - The user of this interaction chain. The entity whose actions caused this interaction chain to be executed. This is usually the same as the Owner.
+- `Owner` - The owner of this interaction chain. The entity upon whom this interaction chain is executing.
+- `Target` - The entity target of this interaction chain, if any.  This value is mutable (and can therefore come from many places) but most commonly, it is an entity the User was targeting when this interaction chain began executing.
+
+## Farming
+
+These are interaction types built to support the in-game farming system in Hytale. They are mostly block-related interactions
+with a few exceptions.
+
+### ChangeFarmingStage
+
+If the target block is a farming block, this interaction will attempt to modify the current farming stage in one of
+three ways.  The interaction can optionally specify which StageSet to use for the new stage. If it is not specified,
+the current StageSet will be used. If any part of the the process of changing the growth stage fails, this interaction
+will fail, with the one exception that attempting to set the stage to the crop's existing stage will have no effect but
+still succeed.
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                                                                                                                                                                          |
+| ---------------- | ------------------------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction.                                                                                                                                              |
+| StageSet         | `String`                        | **No**    | If provided, set the block's current stage to one in the provided StageSet. Otherwise, use the crop's current StageSet.                                                                                                                                                        |
+| Increase         | `Integer`                       | **No**    | If provided, increase the current stage by the specified amount. If the specified stage does not exist, the block will be set to the closest extant stage.                                                                                                                     |
+| Decrease         | `Integer`                       | **No**    | If provided and `Increase` is not provided, decrease the current stage by the specified amount. If the specified stage does not exist, the block will be set to the closest extant stage.                                                                                      |
+| Stage            | `Integer`<br />(Default: -1)    | **No**    | If provided and `Increase`/`Decrease` are not provided, set the current stage to the specified stage. If this value is less than 0, set the current stage to the final growth stage. If the specified stage does not exist, the block will be set to the closest extant stage. |
+
+### FertilizeSoil
+
+If the target block is unfertilized tilled soil or a farming block on top of unfertilized tilled soil, fertilizes the soil.
+The interaction will fail otherwise.
+
+**FertilizeSoil Fields**
+
+| Field Name       | Type                                  | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false)       | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+| RefreshModifiers | `Array`<br />(Element Type: `String`) | **No**    | Does nothing.                                                                                                                     |
+
+### HarvestCrop
+
+This interaction will attempt to execute the harvest action on the current block target and add the crop's drops to the User entity's
+inventory.  The block will either be destroyed or set to its post-harvest growth stage, depending on the farming
+configuration of the block.  This will happen (and the player will receive the full harvest drops) regardless of the
+block's current growth stage. This interaction has no special failure conditions, even if the block target isn't a
+farming block or gathering isn't permitted in the current world, but nothing will occur in those cases.
+
+**HarvestCrop Fields**
+
+| Field Name       | Type                            | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false) | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+
+### UseWateringCan
+
+If the target block is tilled soil or a farming block on top of tilled soil, waters the soil for the specified duration.
+The interaction will fail otherwise.
+
+**UseWateringCan Fields**
+
+| Field Name       | Type                                  | Required? | Notes                                                                                                                             |
+| ---------------- | ------------------------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------- |
+| UserLatestTarget | `Boolean`<br />(Default: false)       | **No**    | If true, update this interaction chain's target block from the client's current cursor position before executing the interaction. |
+| Duration         | `Integer`<br />(Default: 0)           | **No**    | The duration in seconds to water the soil for.                                                                                    |
+| RefreshModifiers | `Array`<br />(Element Type: `String`) | **No**    | Does nothing.                                                                                                                     |
diff --git a/messages/bg-BG.json b/messages/bg-BG.json
new file mode 100644
index 00000000..320e91dd
--- /dev/null
+++ b/messages/bg-BG.json
@@ -0,0 +1,93 @@
+{
+  "displayName": "English",
+  "nav": {
+    "title": "Hytale Modding",
+    "documentation": "Documentation",
+    "sponsors": "Sponsors",
+    "search": "Search"
+  },
+  "home": {
+    "title": "#1 Resource for Hytale Modding {flipwords}",
+    "flipwords": [
+      "Guides",
+      "Documentation",
+      "Tools",
+      "Tutorials"
+    ],
+    "description": "The number one community resource for modding Hytale, featuring\ncomprehensive guides, detailed documentation, and essential tools to\nkickstart your modding journey.",
+    "documentation": "Docs",
+    "forum": "Forum",
+    "discord": "Join the community!",
+    "memberCount": "{count} Members",
+    "countdown": "Hytale releases in {countdown}",
+    "countdownUnits": {
+      "hours": "h",
+      "minutes": "m",
+      "seconds": "s"
+    },
+    "hytaleReleased": "Hytale is out!"
+  },
+  "sponsors": {
+    "title": "Support Us",
+    "description": "HytaleModding is an open-source community project, and part of managing the community involves paying for services, servers and infrastructure, like hosting this website. If you would like to support the project, consider becoming a sponsor! We use OpenCollective so you can see how funds are being used to support the community.",
+    "ourSponsors": "Our Sponsors"
+  },
+  "misc": {
+    "loading": "Loading...",
+    "failedToLoad": "Failed to load.",
+    "gitInfoUnavailable": "Git info not available",
+    "credit": "Written by",
+    "supportUs": "Support Us",
+    "officialDocumentationNotice": {
+      "title": "Official Hytale Documentation",
+      "description": "All content on this section is provided by **Hypixel Studios Canada Inc.** and is presented without any substantial changes, aside from visual design adjustments by the HytaleModding Team."
+    }
+  },
+  "meta": {
+    "established_information": {
+      "title": "Established Information",
+      "separator": "Specific Categories",
+      "server": {
+        "title": "Server",
+        "content_categories": {
+          "title": "Content Categories"
+        },
+        "interface": {
+          "title": "Interface"
+        }
+      },
+      "client": {
+        "title": "Client"
+      },
+      "gameplay": {
+        "title": "Gameplay"
+      },
+      "misc": {
+        "title": "Miscellaneous"
+      }
+    },
+    "guides": {
+      "title": "Guides",
+      "java_basics": {
+        "title": "Java Basics"
+      }
+    },
+    "official_documentation": {
+      "worldgen": {
+        "title": "World Generation",
+        "pack_tutorial": {
+          "title": "Worldgen Pack Tutorial"
+        },
+        "technical_hytale_generator": {
+          "title": "Technical Hytale Generator"
+        },
+        "worldgen_tutorial": {
+          "title": "Worldgen Tutorial"
+        }
+      }
+    },
+    "community_projects": {
+      "title": "Community Projects"
+    }
+  }
+}
diff --git a/messages/fr-FR.json b/messages/fr-FR.json
index 5028bd16..3d7121cf 100644
--- a/messages/fr-FR.json
+++ b/messages/fr-FR.json
@@ -39,8 +39,8 @@
     "credit": "Écrit par",
     "supportUs": "Soutenez-nous",
     "officialDocumentationNotice": {
-      "title": "Official Hytale Documentation",
-      "description": "All content on this section is provided by **Hypixel Studios Canada Inc.** and is presented without any substantial changes, aside from visual design adjustments by the HytaleModding Team."
+      "title": "Documentation officielle de Hytale",
+      "description": "Tout le contenu de cette section est fourni par **Hypixel Studios Canada Inc. * et est présenté sans aucun changement substantiel, en dehors des ajustements de design visuel par l'équipe HytaleModding."
     }
   },
   "meta": {
@@ -74,15 +74,15 @@
     },
     "official_documentation": {
       "worldgen": {
-        "title": "World Generation",
+        "title": "Génération de monde",
         "pack_tutorial": {
-          "title": "Worldgen Pack Tutorial"
+          "title": "Tutoriel du pack de génération de monde"
         },
         "technical_hytale_generator": {
-          "title": "Technical Hytale Generator"
+          "title": "Générateur technique de Hytale"
         },
         "worldgen_tutorial": {
-          "title": "Worldgen Tutorial"
+          "title": "Tutoriel de génération de monde"
         }
       }
     },
diff --git a/messages/ja-JP.json b/messages/ja-JP.json
index ce395a8e..3d4e8af9 100644
--- a/messages/ja-JP.json
+++ b/messages/ja-JP.json
@@ -39,8 +39,8 @@
     "credit": "著者",
     "supportUs": "支援する",
     "officialDocumentationNotice": {
-      "title": "Official Hytale Documentation",
-      "description": "All content on this section is provided by **Hypixel Studios Canada Inc.** and is presented without any substantial changes, aside from visual design adjustments by the HytaleModding Team."
+      "title": "公式 Hytale ドキュメント",
+      "description": "このセクション内の全てのコンテンツは、 **Hypixel Studios Canada Inc.** によって提供されており、 HytaleModding Team による視覚的なデザインの調整以外に大幅な変更なしで提示されます。 (訳注: 元々のドキュメントに日本語版は無いので、翻訳は公式ではなくこのサイトの翻訳者によるものです。)"
     }
   },
   "meta": {
@@ -74,15 +74,15 @@
     },
     "official_documentation": {
       "worldgen": {
-        "title": "World Generation",
+        "title": "ワールド生成",
         "pack_tutorial": {
-          "title": "Worldgen Pack Tutorial"
+          "title": "ワールド生成パックのチュートリアル"
         },
         "technical_hytale_generator": {
-          "title": "Technical Hytale Generator"
+          "title": "ワールド生成器の技術面"
         },
         "worldgen_tutorial": {
-          "title": "Worldgen Tutorial"
+          "title": "ワールド生成のチュートリアル"
         }
       }
     },
diff --git a/messages/uk-UA.json b/messages/uk-UA.json
index 9edb1415..e96cdb95 100644
--- a/messages/uk-UA.json
+++ b/messages/uk-UA.json
@@ -3,18 +3,18 @@
   "nav": {
     "title": "Hytale Modding",
     "documentation": "Документація",
-    "sponsors": "Спонсори",
+    "sponsors": "Меценати",
     "search": "Пошук"
   },
   "home": {
-    "title": "#1 ресурс для {flipwords} Hytale модингу",
+    "title": "#1 ресурс для {flipwords} модифікування Hytale ",
     "flipwords": [
       "Інструкцій",
       "Документацій",
       "Інструментів",
       "Підручників"
     ],
-    "description": "Ресурс спільноти #1 для Hytale модингу, з \nкомплексними інструкціями, детальними документаціями та корисними інструментами для початку вашої подорожі у світі модингу.",
+    "description": "Ресурс спільноти #1 для модифікування  Hytale, зі \nзмістовними інструкціями, детальними документаціями та корисними інструментами для початку вашої подорожі у світі модингу.",
     "documentation": "Документація",
     "forum": "Форум",
     "discord": "Приєднуйтеся до спільноти!",
@@ -29,8 +29,8 @@
   },
   "sponsors": {
     "title": "Підтримати нас",
-    "description": "HytaleModding — це спільнотний проєкт із відкритим кодом, і частиною управління спільнотою є оплата послуг, серверів та інфраструктури, як-от хостинг цього веб-сайту. Якщо ви хочете підтримати проєкт, подумайте про те, щоб стати спонсором! Ми ​​використовуємо OpenCollective, щоб ви могли бачити, як кошти використовуються для підтримки спільноти.",
-    "ourSponsors": "Наші спонсори"
+    "description": "HytaleModding — це проєкт спільноти із відкритим кодом, і частиною управління спільнотою є оплата послуг, серверів та інфраструктури, як-от хостинг цього веб-сайту. Якщо ви хочете підтримати проєкт, подумайте про те, щоб стати меценатом! Ми ​​використовуємо OpenCollective, щоб ви могли бачити, як кошти використовуються для підтримки спільноти.",
+    "ourSponsors": "Наші меценати"
   },
   "misc": {
     "loading": "Завантаження...",
@@ -39,8 +39,8 @@
     "credit": "Написана",
     "supportUs": "Підтримати нас",
     "officialDocumentationNotice": {
-      "title": "Official Hytale Documentation",
-      "description": "All content on this section is provided by **Hypixel Studios Canada Inc.** and is presented without any substantial changes, aside from visual design adjustments by the HytaleModding Team."
+      "title": "Офіційна документація Hytale",
+      "description": "Увесь контент у цьому розділі надається **Hypixel Studios Canada Inc.** та представляється без будь-яких суттєвих змін, окрім налаштувань візуального оформлення командою HytaleModing."
     }
   },
   "meta": {
@@ -50,7 +50,7 @@
       "server": {
         "title": "Сервер",
         "content_categories": {
-          "title": "Категорії контенту"
+          "title": "Категорії вмісту"
         },
         "interface": {
           "title": "Інтерфейс"
@@ -74,15 +74,15 @@
     },
     "official_documentation": {
       "worldgen": {
-        "title": "World Generation",
+        "title": "Генерація світу",
         "pack_tutorial": {
-          "title": "Worldgen Pack Tutorial"
+          "title": "Посібник з використання пакета Worldgen"
         },
         "technical_hytale_generator": {
-          "title": "Technical Hytale Generator"
+          "title": "Technical Hytale генератор"
         },
         "worldgen_tutorial": {
-          "title": "Worldgen Tutorial"
+          "title": "Підручник з Worldgen"
         }
       }
     },